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 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 and >= 1.3.90 */
    if (ma > 1 || mi >= 9 || mi > 3)
        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;
}


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

    set_default_kserver ();
    regist_inst_gnupg (1);
    regist_inst_winpt (1, &created);
    if (!created) 
    {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        reg_prefs.use_tmpfiles = 1; /* default */
        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 (file_exist_check ("loadimage.exe"))
        PTD_create_loadimage (NULL);*/
        
    if (cmdline && stristr (cmdline, "--enable-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;
            update_keycache (hwnd);
            check_crypto_engine ();
            break;

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

        case SETUP_EXISTING:
            break; /* todo */

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