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"

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

/* Internal IPC */
int start_keymanager = 0;

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 = GPG_ERR_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=4, pa=0; /* GPG 1.4.0 */
    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 1.4.0"),
                   ma, mi, pa);
        return rc;
    }
    /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */
    if (ma >= 1 && mi >= 4)
        scard_support = 1;

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


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

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


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

char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);

int WINAPI
#ifndef WINPT_IPC
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
#else
win_main (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
#endif
{
    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
    gpgme_set_debug_mode (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;
    }

    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_filename_dlg (GetActiveWindow (), FILE_OPEN,
                                           _("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 (start_keymanager) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
                            GetDesktopWindow(), keymanager_dlg_proc, NULL,
                            _("Key Manager"), IDS_WINPT_KEYMISC);
        keycache_release ();
        free_gnupg_table ();
        return 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 = 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);
            gpg_card_release (crd);
        }
        keycache_release ();
        free_gnupg_table ();
        return 0;
    }

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

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