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

/* Internal IPC */
int start_keymanager = 0;

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