trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2005 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <windows.h>

#include "../resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptNLS.h"
#include "wptKeyserver.h"
#include "wptCard.h"
#include "wptFileManager.h"
#include "wptContext.h"

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


static void
update_keycache (HWND hwnd)
{
    refresh_cache_s rcs = {0};
    rcs.kr_reload = 0; 
    rcs.kr_update = 1;
    rcs.tr_update = 1;
    DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
} /* update_keycache */


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


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

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


/* check if the default key from the gpg.conf file is available in the
   keyring. if not, bail out because encryption won't work properly then. */
static int
check_default_key (gpgme_keycache_t kc)
{
    gpgme_key_t key;
    gpgme_error_t err = GPGME_No_Error;
    char * defkey;

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


/* Return the WinPT program file name (with full pathname). */
static const char *
get_prog_part (const char * fname, int use_cwd)
{
    static char program[1024];
    char currdir[256], * cmd = NULL;
    int j;
        
    memset (currdir, 0, DIM (currdir));
    memset (program, 0, DIM (program));
        
    if (use_cwd) {
        GetCurrentDirectory (DIM (currdir)-1, currdir);
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
    } 
    else {
        cmd = GetCommandLine ();
        if (cmd == NULL)
            return NULL;
        strncpy (currdir, cmd, 255);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;          
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
} /* get_prog_part */


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

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

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


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

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


static void
enable_mobile_mode (void)
{
    memset (&reg_prefs, 0, sizeof (reg_prefs));
    reg_prefs.always_trust = 0;
    reg_prefs.auto_backup = 0;
    reg_prefs.cache_time = 0;
    reg_prefs.expert = 0;
    reg_prefs.keylist_mode = 1;
    reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
    reg_prefs.no_zip_mmedia = 1;
    reg_prefs.use_tmpfiles = 1;
    reg_prefs.word_wrap = 80;
    reg_prefs.use_viewer = 0; /* XXX */
}


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	twoaday	2	/* WinPT.cpp - Windows Privacy Tray (WinPT)
2			* Copyright (C) 2000-2005 Timo Schulz
3			*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <windows.h>
22
23			#include "../resource.h"
24			#include "wptTypes.h"
25			#include "wptW32API.h"
26			#include "wptVersion.h"
27			#include "wptErrors.h"
28			#include "wptGPG.h"
29			#include "wptRegistry.h"
30			#include "wptCommonCtl.h"
31			#include "wptDlgs.h"
32			#include "wptNLS.h"
33			#include "wptKeyserver.h"
34			#include "wptCard.h"
35			#include "wptFileManager.h"
36			#include "wptContext.h"
37
38			HINSTANCE glob_hinst; /* global instance for the dialogs */
39			HWND glob_hwnd; /* global window handle for the dialogs */
40			HWND activ_hwnd;
41			LOCK mo_file;
42			int scard_support = 0;
43			int debug = 0;
44	twoaday	6	int mobile = 0;
45	twoaday	2	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	twoaday	4	while (j--) {
132	twoaday	2	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	twoaday	6	/* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */
161	twoaday	8	if (ma >= 1 && mi >= 4)
162	twoaday	2	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	twoaday	6	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	twoaday	2	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	twoaday	5	if (strcmp (s, "0.8.0")) {
228	twoaday	2	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	twoaday	5	if (gpg_md_selftest ()) {
235	twoaday	2	msg_box (NULL, _("Cryptographic selftest failed."),
236			_("WinPT Error"), MB_ERR);
237			return 0;
238			}
239
240	twoaday	6	if (cmdline && stristr (cmdline, "--mobile"))
241			mobile = 1;
242
243	twoaday	2	set_default_kserver ();
244	twoaday	6
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	twoaday	5	if (!created) {
256	twoaday	2	memset (&reg_prefs, 0, sizeof (reg_prefs));
257			reg_prefs.use_tmpfiles = 1; /* default */
258	twoaday	5	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
259	twoaday	2	get_reg_winpt_prefs (&reg_prefs);
260			if (!reg_prefs.no_hotkeys)
261			hotkeys_modify ();
262			}
263
264			rc = gnupg_check_homedir ();
265	twoaday	5	if (rc) {
266	twoaday	2	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	twoaday	5	else {
295	twoaday	2	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	twoaday	5	if (rc) {
303	twoaday	2	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	twoaday	6	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	twoaday	2	}
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	twoaday	4	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
467			gpgprefs_dlg_proc, NULL);
468			break;
469	twoaday	2
470			case -1:
471			DestroyWindow (hwnd);
472			free_gnupg_table ();
473			return 0;
474			}
475	twoaday	4	update_keycache (hwnd);
476			check_crypto_engine ();
477	twoaday	2	}
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 */