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 mobile = 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 or >= 1.4.0 */
    if (ma >= 1 && mi >= 4)
        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;
}


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

char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);

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

    if (cmdline && stristr (cmdline, "--mobile"))
        mobile = 1;

    set_default_kserver ();

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

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