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"
#include "wptCardEdit.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 */


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{       
    if (val)
        putenv ("GPGME_DEBUG=5:gpgme.dbg");
    else
        putenv ("GPGME_DEBUG=");
}

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

    defkey = get_gnupg_default_key ();
    if (defkey)
        err = gpg_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=4, pa=1; /* GPG 1.4.1 */
    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 required GPG version 1.4.0"),
                   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 = NULL;

    glob_hinst = hinst;

    #ifdef _DEBUG
    gpg_set_debug_mode (1);
    debug = 1;
    #endif

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

    s = gpgme_check_version ("1.1.0");
    if (!s || !*s) {
        msg_box (NULL, _("A newer GPGME version is needed."), "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_fileopen_dlg (GetActiveWindow (),
                                           _("Select GPG Public Keyring"),
                                           _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
                                           NULL);
        if (s != NULL) {
            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 {
            gpg_card_t crd = gpg_card_load ();
            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);
            gpg_card_release (crd);
        }
        keycache_release (0);
        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")) {
            gpg_set_debug_mode (1);
            winpt_debug_msg ();
            debug = 1;
        }
    }

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (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 ();        
        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 first_start_s fs;
        struct genkey_s c;
        HWND h;
start:
        h = GetDesktopWindow ();
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
                            gpgprefs_dlg_proc, NULL);
        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
                        first_run_dlg_proc, (LPARAM)&fs);
        switch (fs.choice) {
        case SETUP_KEYGEN:
            c.interactive = 1;
            c.first_start = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 h, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

        case SETUP_IMPORT:
            rc = gnupg_copy_keyrings ();
            if (rc) {
                msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
                goto start;
            }
            break;

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