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
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#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"
#include "wptCrypto.h"

#define MIN_GPG_VER   "1.4.2"   /* Minimal GPG version. */
#define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */


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


/* Load the key cache and rebuild the signature cache. */
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);
}


/* 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=");
}


/* Return the name of the gettext language file. */
static char*
get_gettext_lang (void)
{    
    char *fname;
    fname = get_reg_entry_mo ();
    if (!fname)
        return NULL;
    return fname;
}


/* Initialize the gettext sub system. */
static void
load_gettext (int prev_inst)
{
    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))  {
            if (!prev_inst)
                msg_box (NULL, _("Could not initizalize file lock.\n"
                                 "Native Language Support"),
                         _("WinPT Error"), MB_ERR);
        }
        free_if_alloc (nls);
        free_if_alloc (file);
    }
}


/* 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);
    else
        msg_box (NULL, _("No useable secret key found."), _("WinPT Error"), MB_ERR);
    free_if_alloc (defkey);
    return err? -1 : 0;
}


/* Return the WinPT program file name (with full pathname). */
static const char *
get_prog_part (const char * fname, int use_cwd)
{
    static char program[512];
    char currdir[256];
    char *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, sizeof (currdir)-1);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
}


/* Check that the underlying crypto engine fullfills the minimal
   requirements so all commands work properly. */
static int
check_crypto_engine (void)
{
    int ma=1, mi=4, pa=2; /* GPG 1.4.2 */
    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 "MIN_GPG_VER),
                   ma, mi, pa);
        return rc;
    }
    /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
    if (ma > 1 || pa >= 3)
        scard_support = 1;

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


/* Try to load the keyserver config file. If @quiet is 1
   do not show any errors. */
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;
}


/* Enable the mobility mode. */
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* multi_gnupg_path (void);

const char * fm_get_file_type (const char *fname, int *r_type);

/* Main entry point. */
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, nfiles = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    const char *s;
    MSG msg;
    HWND hwnd = NULL;

    glob_hinst = hinst;

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

    if (gpg_md_selftest ()) {
        msg_box (NULL, _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    s = gpgme_check_version (MIN_GPGME_VER);
    if (!s || !*s) {
        msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS)
        winpt_inst_found = 1;

    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 ();
        gnupg_load_config ();
    }

    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));
        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 (winpt_inst_found);
    init_gnupg_table ();

    nfiles = fm_parse_command_line (cmdline);
    if (nfiles > 0) {
        free_gnupg_table ();
        return 0;
    }

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
                            _("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, 0,
                            _("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;
    }

    /* If we found another WinPT instance, just quit to avoid it
       will be executed twice. */
    if (winpt_inst_found) {
        log_debug ("%s", "WinMain: WinPT is already running."); 
        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;

        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, 0);
        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, 0);
        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, 0);
                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, 0);
    }

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