trunk/Src/WinPT.cpp

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

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


#define MIN_GPG_VER   "1.4.3"   /* 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 (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);
    }
}


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

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


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


/* 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=3; /* GPG 1.4.3 */
    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: 1.9 or >= 1.4 */
    if (ma >= 1 && mi >= 4)
        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;
}


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 */
}


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

    glob_hinst = hinst;

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

    s = PTD_get_version ();
    if (strcmp (s, "0.8.0")) {
        log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,
                 _("Please update your PTD.dll to the newest version, "
                   "the version (%s) you use is too old."), s);
        return 0;
    }

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

    s = gpgme_check_version (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;
    }

    if (cmdline && stristr (cmdline, "--mobile")) {
        msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!", 
                 "WinPT", MB_INFO);
        mobile = 1;
    }

    set_default_kserver ();

    if (!mobile) {
        regist_inst_gnupg (1);
        regist_inst_winpt (1, &created);
    }
    else {
        enable_mobile_mode ();
        /* XXX: ask for GPG path */
        created = 1; /* Disable registry writing */
    }

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        reg_prefs.use_tmpfiles = 1; /* default */
        reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
        get_reg_winpt_prefs (&reg_prefs);
        if (!reg_prefs.no_hotkeys)
            hotkeys_modify ();
    }

    rc = gnupg_check_homedir ();
    if (rc) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("GPG home directory is not set correctly.\n"
                   "Please check the GPG registry settings:\n%s."),
                 winpt_strerror (rc));
        const char * s = get_fileopen_dlg (GetActiveWindow (),
                                           _("Select GPG Public Keyring"),
                                           _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
                                           NULL);
        if (s != NULL) {
            size_t n;
            char * p = strrchr (s, '\\');
            if (!p)
                BUG (0);
            n = p - s;
            if (n) 
            {
                char * file = new char[n+1];
                if (!file)
                    BUG (NULL);
                memset (file, 0, n);
                memcpy (file, s, n);
                file[n] = '\0';         
                set_reg_entry_gpg ("HomeDir", file);
                free_if_alloc (file);
                gnupg_check_homedir (); /* change gpgProgram if needed */
            }
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determited."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
                             "Do you want to start the GPG preferences to "
                             "correct  this problem?"), _("WinPT Error"),
                             MB_INFO|MB_YESNO) == IDYES)
            start_gpgprefs = 1;
        else 
        {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }

    rc = gnupg_access_files ();
    if (!start_gpgprefs && rc) 
    {
        if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) 
        {
            ec = msg_box (NULL,
                _("Could not access and/or find the public and secret keyring.\n"
                  "If this is an accident, quit the program and fix it.\n\n"
                  "Continue if you want that WinPT offers you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) 
        {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }

    if (!first_start)
    {
        rc = gpg_check_permissions (1);
        if (rc && rc == 2)
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }

    load_gettext ();
    init_gnupg_table ();

    nfiles = fm_parse_command_line (cmdline);
    if (nfiles > 0)
        return 0;

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
                            _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
        free_gnupg_table ();
        return 0;
    }

    load_keyserver_conf (cmdline? 1 : 0);

    if (cmdline && (stristr (cmdline, "--keymanager")
                || stristr (cmdline, "--cardmanager"))) {
        update_keycache (GetDesktopWindow ());
        if (stristr (cmdline, "keymanager"))
            dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
                            GetDesktopWindow(), keymanager_dlg_proc, NULL,
                            _("Key Manager"), IDS_WINPT_KEYMISC);  
        else {
            gpg_card_t crd = gpg_card_load ();
            if (crd)
                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
                                  GetDesktopWindow(), card_edit_dlg_proc,
                                  (LPARAM)crd, _("Card Manager"),
                                  IDS_WINPT_CARD_EDIT);
            gpg_card_release (crd);
        }
        keycache_release (0);
        free_gnupg_table ();
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS) {
        free_gnupg_table ();
        return 0;
    }

    if (cmdline) {
        if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {
            gpg_set_debug_mode (1);
            winpt_debug_msg ();
            debug = 1;
        }
    }

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (NULL, _("Could not register window class"), 
                 _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }

    hwnd = CreateWindow (PGM_NAME, 
                         PGM_NAME, 
                         0, 0, 0, 0, 0, 
                         NULL, 
                         NULL, 
                         hinst, 
                         NULL);
    if (hwnd == NULL) {
        msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }
    glob_hwnd = hwnd;
    UpdateWindow (hwnd);

    if (!first_start && !start_gpgprefs) {
        gnupg_backup_options ();        
        rc = check_crypto_engine ();
        if (rc) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    
    if (start_gpgprefs) {
        char *ring;
        size_t size = 0;
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, NULL);
        ring = get_gnupg_keyring (0, !NO_STRICT);
        if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
            first_start = 1; /* The keyring is empty! */
        free_if_alloc (ring);
    }

    if (first_start) {
        struct first_start_s fs;
        struct genkey_s c;
        HWND h;
start:
        h = GetDesktopWindow ();
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
                            gpgprefs_dlg_proc, NULL);
        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
                        first_run_dlg_proc, (LPARAM)&fs);
        switch (fs.choice) {
        case SETUP_KEYGEN:
            c.interactive = 1;
            c.first_start = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 h, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

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

        case -1:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        check_crypto_engine ();
    }
    else {
        gpg_keycache_t c;
        update_keycache (hwnd);
        c = keycache_get_ctx (1);
        if (!c || !gpg_keycache_get_size (c)) {
            gnupg_display_error ();
            msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
                             "Please check your GPG config (keyrings, pathes...)"),
                             _("WinPT Error"), MB_ERR);
            ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
                                  "Do you want to start the GPG preferences dialog?"),
                            "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES) {
                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                                gpgprefs_dlg_proc, NULL);
                update_keycache (hwnd);
            }
            else {
                DestroyWindow (hwnd);
                free_gnupg_table ();
                return 0;
            }
        }
        if (check_default_key (c)) {
            char * p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR, 
                     _("Default key from the GPG options file could not be found.\n"
                       "Please check your gpg.conf (options) to correct this:\n\n"
                       "%s: public key not found."), p? p : "[null]");
            free_if_alloc (p);
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        if (count_insecure_elgkeys ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
                            elgamal_warn_dlg_proc, NULL);
    }

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