trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2005 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
 */

#include <windows.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"

HINSTANCE glob_hinst; /* global instance for the dialogs */
HWND glob_hwnd; /* global window handle for the dialogs */
HWND activ_hwnd;
LOCK mo_file;
int scard_support = 0;
int debug = 0;
int gpg_read_only = 0;
char gpgver[3];


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


static char *
get_gettext_lang (void)
{    
    char * fname;
    fname = get_reg_entry_mo ();
    if (!fname)
        return NULL;
    return fname;
} /* get_gettext_lang */


static void
load_gettext (void)
{
    char * nls = NULL;
    char * file = NULL;

    nls = get_gettext_lang ();
    if (nls) {
        set_gettext_file ("winpt", nls);
        file = make_filename (nls, "winpt", "mo");
        if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {
            msg_box (NULL, _("Could not initizalize file lock.\n"
                             "Native Language Support"),
                     _("WinPT Error"), MB_ERR);
        }
        free_if_alloc (nls);
        free_if_alloc (file);
    }
} /* load_gettext */


/* 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 (gpgme_keycache_t kc)
{
    gpgme_key_t key;
    gpgme_error_t err = GPGME_No_Error;
    char * defkey;

    defkey = get_gnupg_default_key ();
    if (defkey)
        err = gpgme_keycache_find_key (kc, defkey, 0, &key);
    free_if_alloc (defkey);
    return err? -1 : 0;
} /* check_default_key */


/* Return the WinPT program file name (with full pathname). */
static const char *
get_prog_part (const char * fname, int use_cwd)
{
    static char program[1024];
    char currdir[256], * 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, 255);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;          
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
} /* get_prog_part */


static int
check_crypto_engine (void)
{
    int ma=1, mi=2, pa=4; /* GPG 1.2.4 */
    int rc;

    rc = check_gnupg_engine (&ma, &mi, &pa);
    if (rc == -1) {
        msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);
        return rc;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("Sorry, you need a newer GPG version.\n"
                   "GPG version %d.%d.%d requred GPG version 1.2.4"),
                   ma, mi, pa);
        return rc;
    }
    /* We enable smartcard support for GPG: 1.9.x and >= 1.3.90 */
    if (ma > 1 || mi >= 9 || mi > 3)
        scard_support = 1;

    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return rc;
} /* check_crypto_engine */


static int
load_keyserver_conf (int quiet)
{
    const char * t;
    int rc;

    if (reg_prefs.kserv_conf)
        t = reg_prefs.kserv_conf;
    else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
        t = get_prog_part ("keyserver.conf", 0);
    else 
        t = "keyserver.conf";
    rc = kserver_load_conf (t);
    if (rc && !quiet)
        msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
    return rc;
}


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;
    int rc, ec, created = 0, use_cwd = 0, nfiles = 0;
    int first_start = 0, start_gpgprefs = 0;
    const char * s;
    MSG msg;
    HWND hwnd;

    glob_hinst = hinst;
    
    gpgme_lib_init ();
    #ifdef _DEBUG
    gpgme_set_debug_mode (1);
    #endif
    gpgme_set_pgm_string ("WinPT "PGM_VERSION);

    s = PTD_get_version ();
    if (strcmp (s, "0.8.0")) {
        log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,
                 _("Please update your PTD.dll to the newest version, "
                   "the version (%s) you use is too old."), s);
        return 0;
    }

    if (gpg_md_selftest ()) {
        msg_box (NULL, _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    set_default_kserver ();
    regist_inst_gnupg (1);
    regist_inst_winpt (1, &created);
    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 ();
    }

    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));
        const char * s = get_filename_dlg (GetActiveWindow (), FILE_OPEN,
                                           _("Select GPG Public Keyring"),
                                           _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
                                           NULL);
        if (s && !file_exist_check (s))
        {
            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 (!first_start)
    {
        rc = gpg_check_permissions (1);
        if (rc && rc == 2)
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }

    load_gettext ();
    init_gnupg_table ();

    nfiles = fm_parse_command_line (cmdline);
    if (nfiles > 0)
        return 0;

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
                            _("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"))) {
        update_keycache (GetDesktopWindow ());
        if (stristr (cmdline, "keymanager"))
            dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
                            GetDesktopWindow(), keymanager_dlg_proc, NULL,
                            _("Key Manager"), IDS_WINPT_KEYMISC);
        else {
            gpgme_card_t crd = smartcard_init ();
            if (crd)
                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
                                  GetDesktopWindow(), card_edit_dlg_proc,
                                  (LPARAM)crd, _("Card Manager"),
                                  IDS_WINPT_CARD_EDIT);
            gpgme_card_release (crd);
        }
        keycache_release ();
        free_gnupg_table ();
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS) {
        free_gnupg_table ();
        return 0;
    }

    /*if (file_exist_check ("loadimage.exe"))
        PTD_create_loadimage (NULL);*/
        
    if (cmdline && stristr (cmdline, "--enable-debug")) {
        gpgme_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 (1);
        gnupg_backup_options (0);
        
        rc = check_crypto_engine ();
        if (rc) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }

    if (start_gpgprefs) 
    {
        char *ring;
        size_t size = 0;
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, NULL);
        ring = get_gnupg_keyring (0, !NO_STRICT);
        if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
            first_start = 1; /* The keyring is empty! */
        free_if_alloc (ring);
    }

    if (first_start) {
        struct key_wizard_s c, dummy;
start:
        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,
                        first_run_dlg_proc, (LPARAM)&dummy);
        switch (dummy.interactive) 
        {
        case SETUP_KEYGEN:
            c.interactive = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 hwnd, 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_EXISTING:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                            gpgprefs_dlg_proc, NULL);
            break;

        case -1:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        check_crypto_engine ();
    }
    else {
        gpgme_keycache_t c;
        update_keycache (hwnd);
        c = keycache_get_ctx (1);
        if (!c || !gpgme_keycache_count (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, NULL);
                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, NULL);
    }

    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;
} /* WinMain */
1	twoaday	2	/* WinPT.cpp - Windows Privacy Tray (WinPT)
2			* Copyright (C) 2000-2005 Timo Schulz
3			*
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
21			#include <windows.h>
22
23			#include "../resource.h"
24			#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
38			HINSTANCE glob_hinst; /* global instance for the dialogs */
39			HWND glob_hwnd; /* global window handle for the dialogs */
40			HWND activ_hwnd;
41			LOCK mo_file;
42			int scard_support = 0;
43			int debug = 0;
44			int gpg_read_only = 0;
45			char gpgver[3];
46
47
48			static void
49			update_keycache (HWND hwnd)
50			{
51			refresh_cache_s rcs = {0};
52			rcs.kr_reload = 0;
53			rcs.kr_update = 1;
54			rcs.tr_update = 1;
55			DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
56			keycache_dlg_proc, (LPARAM)&rcs);
57			} /* update_keycache */
58
59
60			static char *
61			get_gettext_lang (void)
62			{
63			char * fname;
64			fname = get_reg_entry_mo ();
65			if (!fname)
66			return NULL;
67			return fname;
68			} /* get_gettext_lang */
69
70
71			static void
72			load_gettext (void)
73			{
74			char * nls = NULL;
75			char * file = NULL;
76
77			nls = get_gettext_lang ();
78			if (nls) {
79			set_gettext_file ("winpt", nls);
80			file = make_filename (nls, "winpt", "mo");
81			if (!file_exist_check (nls) && init_file_lock (&mo_file, file)) {
82			msg_box (NULL, _("Could not initizalize file lock.\n"
83			"Native Language Support"),
84			_("WinPT Error"), MB_ERR);
85			}
86			free_if_alloc (nls);
87			free_if_alloc (file);
88			}
89			} /* load_gettext */
90
91
92			/* check if the default key from the gpg.conf file is available in the
93			keyring. if not, bail out because encryption won't work properly then. */
94			static int
95			check_default_key (gpgme_keycache_t kc)
96			{
97			gpgme_key_t key;
98			gpgme_error_t err = GPGME_No_Error;
99			char * defkey;
100
101			defkey = get_gnupg_default_key ();
102			if (defkey)
103			err = gpgme_keycache_find_key (kc, defkey, 0, &key);
104			free_if_alloc (defkey);
105			return err? -1 : 0;
106			} /* check_default_key */
107
108
109			/* Return the WinPT program file name (with full pathname). */
110			static const char *
111			get_prog_part (const char * fname, int use_cwd)
112			{
113			static char program[1024];
114			char currdir[256], * cmd = NULL;
115			int j;
116
117			memset (currdir, 0, DIM (currdir));
118			memset (program, 0, DIM (program));
119
120			if (use_cwd) {
121			GetCurrentDirectory (DIM (currdir)-1, currdir);
122			_snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
123			}
124			else {
125			cmd = GetCommandLine ();
126			if (cmd == NULL)
127			return NULL;
128			strncpy (currdir, cmd, 255);
129			j = strlen (currdir);
130	twoaday	4	while (j--) {
131	twoaday	2	if (currdir[j] == '\\')
132			break;
133			}
134			currdir[j] = 0;
135			_snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
136			}
137			return program;
138			} /* get_prog_part */
139
140
141			static int
142			check_crypto_engine (void)
143			{
144			int ma=1, mi=2, pa=4; /* GPG 1.2.4 */
145			int rc;
146
147			rc = check_gnupg_engine (&ma, &mi, &pa);
148			if (rc == -1) {
149			msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);
150			return rc;
151			}
152			else if (rc) {
153			log_box (_("WinPT Error"), MB_ERR,
154			_("Sorry, you need a newer GPG version.\n"
155			"GPG version %d.%d.%d requred GPG version 1.2.4"),
156			ma, mi, pa);
157			return rc;
158			}
159			/* We enable smartcard support for GPG: 1.9.x and >= 1.3.90 */
160			if (ma > 1 \|\| mi >= 9 \|\| mi > 3)
161			scard_support = 1;
162
163			gpgver[0] = ma;
164			gpgver[1] = mi;
165			gpgver[2] = pa;
166			return rc;
167			} /* check_crypto_engine */
168
169
170			static int
171			load_keyserver_conf (int quiet)
172			{
173			const char * t;
174			int rc;
175
176			if (reg_prefs.kserv_conf)
177			t = reg_prefs.kserv_conf;
178			else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
179			t = get_prog_part ("keyserver.conf", 0);
180			else
181			t = "keyserver.conf";
182			rc = kserver_load_conf (t);
183			if (rc && !quiet)
184			msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
185			return rc;
186			}
187
188
189			int WINAPI
190			WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
191			{
192			WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
193			HACCEL accel_tab;
194			int rc, ec, created = 0, use_cwd = 0, nfiles = 0;
195			int first_start = 0, start_gpgprefs = 0;
196			const char * s;
197			MSG msg;
198			HWND hwnd;
199
200			glob_hinst = hinst;
201
202			gpgme_lib_init ();
203			#ifdef _DEBUG
204			gpgme_set_debug_mode (1);
205			#endif
206			gpgme_set_pgm_string ("WinPT "PGM_VERSION);
207
208			s = PTD_get_version ();
209	twoaday	5	if (strcmp (s, "0.8.0")) {
210	twoaday	2	log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,
211			_("Please update your PTD.dll to the newest version, "
212			"the version (%s) you use is too old."), s);
213			return 0;
214			}
215
216	twoaday	5	if (gpg_md_selftest ()) {
217	twoaday	2	msg_box (NULL, _("Cryptographic selftest failed."),
218			_("WinPT Error"), MB_ERR);
219			return 0;
220			}
221
222			set_default_kserver ();
223			regist_inst_gnupg (1);
224			regist_inst_winpt (1, &created);
225	twoaday	5	if (!created) {
226	twoaday	2	memset (&reg_prefs, 0, sizeof (reg_prefs));
227			reg_prefs.use_tmpfiles = 1; /* default */
228	twoaday	5	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
229	twoaday	2	get_reg_winpt_prefs (&reg_prefs);
230			if (!reg_prefs.no_hotkeys)
231			hotkeys_modify ();
232			}
233
234			rc = gnupg_check_homedir ();
235	twoaday	5	if (rc) {
236	twoaday	2	log_box (_("WinPT Error"), MB_ERR,
237			_("GPG home directory is not set correctly.\n"
238			"Please check the GPG registry settings:\n%s."),
239			winpt_strerror (rc));
240			const char * s = get_filename_dlg (GetActiveWindow (), FILE_OPEN,
241			_("Select GPG Public Keyring"),
242			_("GPG Keyrings (.gpg)\0.gpg\0\0"),
243			NULL);
244			if (s && !file_exist_check (s))
245			{
246			size_t n;
247			char * p = strrchr (s, '\\');
248			if (!p)
249			BUG (0);
250			n = p - s;
251			if (n)
252			{
253			char * file = new char[n+1];
254			if (!file)
255			BUG (NULL);
256			memset (file, 0, n);
257			memcpy (file, s, n);
258			file[n] = '\0';
259			set_reg_entry_gpg ("HomeDir", file);
260			free_if_alloc (file);
261			gnupg_check_homedir (); /* change gpgProgram if needed */
262			}
263			}
264	twoaday	5	else {
265	twoaday	2	msg_box (NULL, _("GPG home directory could not be determited."),
266			_("WinPT Error"), MB_ERR);
267			goto start;
268			}
269			}
270
271			rc = check_gnupg_prog ();
272	twoaday	5	if (rc) {
273	twoaday	2	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
274			"Do you want to start the GPG preferences to "
275			"correct this problem?"), _("WinPT Error"),
276			MB_INFO\|MB_YESNO) == IDYES)
277			start_gpgprefs = 1;
278			else
279			{
280			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
281			return 0;
282			}
283			}
284
285			rc = gnupg_access_files ();
286			if (!start_gpgprefs && rc)
287			{
288			if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS)
289			{
290			ec = msg_box (NULL,
291			_("Could not access and/or find the public and secret keyring.\n"
292			"If this is an accident, quit the program and fix it.\n\n"
293			"Continue if you want that WinPT offers you more choices.\n"),
294			"WinPT", MB_INFO\|MB_YESNO);
295			if (ec == IDYES)
296			first_start = 1;
297			}
298			if (!first_start)
299			{
300			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
301			return 0;
302			}
303			}
304
305			if (!first_start)
306			{
307			rc = gpg_check_permissions (1);
308			if (rc && rc == 2)
309			gpg_read_only = 1;
310			else if (rc)
311			return 0;
312			}
313
314			load_gettext ();
315			init_gnupg_table ();
316
317			nfiles = fm_parse_command_line (cmdline);
318			if (nfiles > 0)
319			return 0;
320
321			if (cmdline && stristr (cmdline, "--wipe-freespace")) {
322			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
323			GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
324			_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
325			free_gnupg_table ();
326			return 0;
327			}
328
329			load_keyserver_conf (cmdline? 1 : 0);
330			if (cmdline && (stristr (cmdline, "--keymanager")
331			\|\| stristr (cmdline, "--cardmanager"))) {
332			update_keycache (GetDesktopWindow ());
333			if (stristr (cmdline, "keymanager"))
334			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
335			GetDesktopWindow(), keymanager_dlg_proc, NULL,
336			_("Key Manager"), IDS_WINPT_KEYMISC);
337			else {
338			gpgme_card_t crd = smartcard_init ();
339			if (crd)
340			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
341			GetDesktopWindow(), card_edit_dlg_proc,
342			(LPARAM)crd, _("Card Manager"),
343			IDS_WINPT_CARD_EDIT);
344			gpgme_card_release (crd);
345			}
346			keycache_release ();
347			free_gnupg_table ();
348			return 0;
349			}
350
351			CreateMutex (NULL, TRUE, PGM_NAME);
352			if (GetLastError () == ERROR_ALREADY_EXISTS) {
353			free_gnupg_table ();
354			return 0;
355			}
356
357			/*if (file_exist_check ("loadimage.exe"))
358			PTD_create_loadimage (NULL);*/
359
360			if (cmdline && stristr (cmdline, "--enable-debug")) {
361			gpgme_set_debug_mode (1);
362			winpt_debug_msg ();
363			debug = 1;
364			}
365
366			wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
367			rc = RegisterClass (&wc);
368			if (rc == FALSE) {
369			msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);
370			free_gnupg_table ();
371			return 0;
372			}
373
374			hwnd = CreateWindow (PGM_NAME,
375			PGM_NAME,
376			0, 0, 0, 0, 0,
377			NULL,
378			NULL,
379			hinst,
380			NULL);
381			if (hwnd == NULL) {
382			msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
383			free_gnupg_table ();
384			return 0;
385			}
386			glob_hwnd = hwnd;
387			UpdateWindow (hwnd);
388
389			if (!first_start && !start_gpgprefs) {
390			gnupg_backup_options (1);
391			gnupg_backup_options (0);
392
393			rc = check_crypto_engine ();
394			if (rc) {
395			DestroyWindow (hwnd);
396			free_gnupg_table ();
397			return 0;
398			}
399			}
400
401			if (start_gpgprefs)
402			{
403			char *ring;
404			size_t size = 0;
405			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
406			gpgprefs_dlg_proc, NULL);
407			ring = get_gnupg_keyring (0, !NO_STRICT);
408			if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
409			first_start = 1; /* The keyring is empty! */
410			free_if_alloc (ring);
411			}
412
413			if (first_start) {
414			struct key_wizard_s c, dummy;
415			start:
416			DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,
417			first_run_dlg_proc, (LPARAM)&dummy);
418			switch (dummy.interactive)
419			{
420			case SETUP_KEYGEN:
421			c.interactive = 1;
422			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
423			hwnd, keygen_wizard_dlg_proc, (LPARAM)&c);
424			if (!rc)
425			goto start;
426			break;
427
428			case SETUP_IMPORT:
429			rc = gnupg_copy_keyrings ();
430			if (rc) {
431			msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
432			goto start;
433			}
434			break;
435
436			case SETUP_EXISTING:
437	twoaday	4	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
438			gpgprefs_dlg_proc, NULL);
439			break;
440	twoaday	2
441			case -1:
442			DestroyWindow (hwnd);
443			free_gnupg_table ();
444			return 0;
445			}
446	twoaday	4	update_keycache (hwnd);
447			check_crypto_engine ();
448	twoaday	2	}
449			else {
450			gpgme_keycache_t c;
451			update_keycache (hwnd);
452			c = keycache_get_ctx (1);
453			if (!c \|\| !gpgme_keycache_count (c)) {
454			gnupg_display_error ();
455			msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
456			"Please check your GPG config (keyrings, pathes...)"),
457			_("WinPT Error"), MB_ERR);
458			ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
459			"Do you want to start the GPG preferences dialog?"),
460			"WinPT", MB_INFO\|MB_YESNO);
461			if (ec == IDYES) {
462			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
463			gpgprefs_dlg_proc, NULL);
464			update_keycache (hwnd);
465			}
466			else {
467			DestroyWindow (hwnd);
468			free_gnupg_table ();
469			return 0;
470			}
471			}
472			if (check_default_key (c)) {
473			char * p = get_gnupg_default_key ();
474			log_box (_("WinPT Error"), MB_ERR,
475			_("Default key from the GPG options file could not be found.\n"
476			"Please check your gpg.conf (options) to correct this:\n\n"
477			"%s: public key not found."), p? p : "[null]");
478			free_if_alloc (p);
479			DestroyWindow (hwnd);
480			free_gnupg_table ();
481			return 0;
482			}
483			if (count_insecure_elgkeys ())
484			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
485			elgamal_warn_dlg_proc, NULL);
486			}
487
488			accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
489			keyring_check_last_access (); /* init */
490			while (GetMessage (&msg, hwnd, 0, 0)) {
491			if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
492			TranslateMessage (&msg);
493			DispatchMessage (&msg);
494			}
495			}
496
497			return 0;
498			} /* WinMain */