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


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 >= 9 \|\| 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
207	int WINAPI
208	WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
209	{
210	WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
211	HACCEL accel_tab;
212	int rc, ec, created = 0, use_cwd = 0, nfiles = 0;
213	int first_start = 0, start_gpgprefs = 0;
214	const char * s;
215	MSG msg;
216	HWND hwnd;
217
218	glob_hinst = hinst;
219
220	gpgme_lib_init ();
221	#ifdef _DEBUG
222	gpgme_set_debug_mode (1);
223	#endif
224	gpgme_set_pgm_string ("WinPT "PGM_VERSION);
225
226	s = PTD_get_version ();
227	if (strcmp (s, "0.8.0")) {
228	log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,
229	_("Please update your PTD.dll to the newest version, "
230	"the version (%s) you use is too old."), s);
231	return 0;
232	}
233
234	if (gpg_md_selftest ()) {
235	msg_box (NULL, _("Cryptographic selftest failed."),
236	_("WinPT Error"), MB_ERR);
237	return 0;
238	}
239
240	if (cmdline && stristr (cmdline, "--mobile"))
241	mobile = 1;
242
243	set_default_kserver ();
244
245	if (!mobile) {
246	regist_inst_gnupg (1);
247	regist_inst_winpt (1, &created);
248	}
249	else {
250	enable_mobile_mode ();
251	/* XXX: ask for GPG path */
252	created = 1; /* Disable registry writing */
253	}
254
255	if (!created) {
256	memset (&reg_prefs, 0, sizeof (reg_prefs));
257	reg_prefs.use_tmpfiles = 1; /* default */
258	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
259	get_reg_winpt_prefs (&reg_prefs);
260	if (!reg_prefs.no_hotkeys)
261	hotkeys_modify ();
262	}
263
264	rc = gnupg_check_homedir ();
265	if (rc) {
266	log_box (_("WinPT Error"), MB_ERR,
267	_("GPG home directory is not set correctly.\n"
268	"Please check the GPG registry settings:\n%s."),
269	winpt_strerror (rc));
270	const char * s = get_filename_dlg (GetActiveWindow (), FILE_OPEN,
271	_("Select GPG Public Keyring"),
272	_("GPG Keyrings (.gpg)\0.gpg\0\0"),
273	NULL);
274	if (s && !file_exist_check (s))
275	{
276	size_t n;
277	char * p = strrchr (s, '\\');
278	if (!p)
279	BUG (0);
280	n = p - s;
281	if (n)
282	{
283	char * file = new char[n+1];
284	if (!file)
285	BUG (NULL);
286	memset (file, 0, n);
287	memcpy (file, s, n);
288	file[n] = '\0';
289	set_reg_entry_gpg ("HomeDir", file);
290	free_if_alloc (file);
291	gnupg_check_homedir (); /* change gpgProgram if needed */
292	}
293	}
294	else {
295	msg_box (NULL, _("GPG home directory could not be determited."),
296	_("WinPT Error"), MB_ERR);
297	goto start;
298	}
299	}
300
301	rc = check_gnupg_prog ();
302	if (rc) {
303	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
304	"Do you want to start the GPG preferences to "
305	"correct this problem?"), _("WinPT Error"),
306	MB_INFO\|MB_YESNO) == IDYES)
307	start_gpgprefs = 1;
308	else
309	{
310	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
311	return 0;
312	}
313	}
314
315	rc = gnupg_access_files ();
316	if (!start_gpgprefs && rc)
317	{
318	if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS)
319	{
320	ec = msg_box (NULL,
321	_("Could not access and/or find the public and secret keyring.\n"
322	"If this is an accident, quit the program and fix it.\n\n"
323	"Continue if you want that WinPT offers you more choices.\n"),
324	"WinPT", MB_INFO\|MB_YESNO);
325	if (ec == IDYES)
326	first_start = 1;
327	}
328	if (!first_start)
329	{
330	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
331	return 0;
332	}
333	}
334
335	if (!first_start)
336	{
337	rc = gpg_check_permissions (1);
338	if (rc && rc == 2)
339	gpg_read_only = 1;
340	else if (rc)
341	return 0;
342	}
343
344	load_gettext ();
345	init_gnupg_table ();
346
347	nfiles = fm_parse_command_line (cmdline);
348	if (nfiles > 0)
349	return 0;
350
351	if (cmdline && stristr (cmdline, "--wipe-freespace")) {
352	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
353	GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
354	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
355	free_gnupg_table ();
356	return 0;
357	}
358
359	load_keyserver_conf (cmdline? 1 : 0);
360	if (cmdline && (stristr (cmdline, "--keymanager")
361	\|\| stristr (cmdline, "--cardmanager"))) {
362	update_keycache (GetDesktopWindow ());
363	if (stristr (cmdline, "keymanager"))
364	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
365	GetDesktopWindow(), keymanager_dlg_proc, NULL,
366	_("Key Manager"), IDS_WINPT_KEYMISC);
367	else {
368	gpgme_card_t crd = smartcard_init ();
369	if (crd)
370	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
371	GetDesktopWindow(), card_edit_dlg_proc,
372	(LPARAM)crd, _("Card Manager"),
373	IDS_WINPT_CARD_EDIT);
374	gpgme_card_release (crd);
375	}
376	keycache_release ();
377	free_gnupg_table ();
378	return 0;
379	}
380
381	CreateMutex (NULL, TRUE, PGM_NAME);
382	if (GetLastError () == ERROR_ALREADY_EXISTS) {
383	free_gnupg_table ();
384	return 0;
385	}
386
387	if (cmdline) {
388	if (stristr (cmdline, "--enable-debug") \|\| stristr (cmdline, "--debug")) {
389	gpgme_set_debug_mode (1);
390	winpt_debug_msg ();
391	debug = 1;
392	}
393	}
394
395	wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
396	rc = RegisterClass (&wc);
397	if (rc == FALSE) {
398	msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);
399	free_gnupg_table ();
400	return 0;
401	}
402
403	hwnd = CreateWindow (PGM_NAME,
404	PGM_NAME,
405	0, 0, 0, 0, 0,
406	NULL,
407	NULL,
408	hinst,
409	NULL);
410	if (hwnd == NULL) {
411	msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
412	free_gnupg_table ();
413	return 0;
414	}
415	glob_hwnd = hwnd;
416	UpdateWindow (hwnd);
417
418	if (!first_start && !start_gpgprefs) {
419	gnupg_backup_options (1);
420	gnupg_backup_options (0);
421
422	rc = check_crypto_engine ();
423	if (rc) {
424	DestroyWindow (hwnd);
425	free_gnupg_table ();
426	return 0;
427	}
428	}
429
430	if (start_gpgprefs)
431	{
432	char *ring;
433	size_t size = 0;
434	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
435	gpgprefs_dlg_proc, NULL);
436	ring = get_gnupg_keyring (0, !NO_STRICT);
437	if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
438	first_start = 1; /* The keyring is empty! */
439	free_if_alloc (ring);
440	}
441
442	if (first_start) {
443	struct key_wizard_s c, dummy;
444	start:
445	DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,
446	first_run_dlg_proc, (LPARAM)&dummy);
447	switch (dummy.interactive)
448	{
449	case SETUP_KEYGEN:
450	c.interactive = 1;
451	rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
452	hwnd, keygen_wizard_dlg_proc, (LPARAM)&c);
453	if (!rc)
454	goto start;
455	break;
456
457	case SETUP_IMPORT:
458	rc = gnupg_copy_keyrings ();
459	if (rc) {
460	msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
461	goto start;
462	}
463	break;
464
465	case SETUP_EXISTING:
466	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
467	gpgprefs_dlg_proc, NULL);
468	break;
469
470	case -1:
471	DestroyWindow (hwnd);
472	free_gnupg_table ();
473	return 0;
474	}
475	update_keycache (hwnd);
476	check_crypto_engine ();
477	}
478	else {
479	gpgme_keycache_t c;
480	update_keycache (hwnd);
481	c = keycache_get_ctx (1);
482	if (!c \|\| !gpgme_keycache_count (c)) {
483	gnupg_display_error ();
484	msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
485	"Please check your GPG config (keyrings, pathes...)"),
486	_("WinPT Error"), MB_ERR);
487	ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
488	"Do you want to start the GPG preferences dialog?"),
489	"WinPT", MB_INFO\|MB_YESNO);
490	if (ec == IDYES) {
491	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
492	gpgprefs_dlg_proc, NULL);
493	update_keycache (hwnd);
494	}
495	else {
496	DestroyWindow (hwnd);
497	free_gnupg_table ();
498	return 0;
499	}
500	}
501	if (check_default_key (c)) {
502	char * p = get_gnupg_default_key ();
503	log_box (_("WinPT Error"), MB_ERR,
504	_("Default key from the GPG options file could not be found.\n"
505	"Please check your gpg.conf (options) to correct this:\n\n"
506	"%s: public key not found."), p? p : "[null]");
507	free_if_alloc (p);
508	DestroyWindow (hwnd);
509	free_gnupg_table ();
510	return 0;
511	}
512	if (count_insecure_elgkeys ())
513	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
514	elgamal_warn_dlg_proc, NULL);
515	}
516
517	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
518	keyring_check_last_access (); /* init */
519	while (GetMessage (&msg, hwnd, 0, 0)) {
520	if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
521	TranslateMessage (&msg);
522	DispatchMessage (&msg);
523	}
524	}
525
526	return 0;
527	} /* WinMain */