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