trunk/Src/WinPT.cpp

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

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

HINSTANCE glob_hinst; /* global instance for the dialogs */
HWND glob_hwnd; /* global window handle for the dialogs */
HWND activ_hwnd;
LOCK mo_file;
int scard_support = 0;
int debug = 0;
int 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 = GPGME_No_Error;
    char * defkey;

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


/* Return the WinPT program file name (with full pathname). */
static const char *
get_prog_part (const char * fname, int use_cwd)
{
    static char program[1024];
    char currdir[256], * cmd = NULL;
    int j;
        
    memset (currdir, 0, DIM (currdir));
    memset (program, 0, DIM (program));
        
    if (use_cwd) {
        GetCurrentDirectory (DIM (currdir)-1, currdir);
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
    } 
    else {
        cmd = GetCommandLine ();
        if (cmd == NULL)
            return NULL;
        strncpy (currdir, cmd, 255);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;          
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
} /* get_prog_part */


static int
check_crypto_engine (void)
{
    int ma=1, mi=2, pa=4; /* GPG 1.2.4 */
    int rc;

    rc = check_gnupg_engine (&ma, &mi, &pa);
    if (rc == -1) {
        msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);
        return rc;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("Sorry, you need a newer GPG version.\n"
                   "GPG version %d.%d.%d requred GPG version 1.2.4"),
                   ma, mi, pa);
        return rc;
    }
    /* We enable smartcard support for GPG: 1.9.x 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;

    glob_hinst = hinst;
    
    gpgme_lib_init ();
    #ifdef _DEBUG
    gpgme_set_debug_mode (1);
    #endif
    gpgme_set_pgm_string ("WinPT "PGM_VERSION);

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

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

    if (cmdline && stristr (cmdline, "--mobile"))
        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 && !file_exist_check (s))
        {
            size_t n;
            char * p = strrchr (s, '\\');
            if (!p)
                BUG (0);
            n = p - s;
            if (n) 
            {
                char * file = new char[n+1];
                if (!file)
                    BUG (NULL);
                memset (file, 0, n);
                memcpy (file, s, n);
                file[n] = '\0';         
                set_reg_entry_gpg ("HomeDir", file);
                free_if_alloc (file);
                gnupg_check_homedir (); /* change gpgProgram if needed */
            }
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determited."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

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

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

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

    load_gettext ();
    init_gnupg_table ();

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

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

    load_keyserver_conf (cmdline? 1 : 0);
    if (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 {
            gpgme_card_t crd = smartcard_init ();
            if (crd)
                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
                                  GetDesktopWindow(), card_edit_dlg_proc,
                                  (LPARAM)crd, _("Card Manager"),
                                  IDS_WINPT_CARD_EDIT);
            gpgme_card_release (crd);
        }
        keycache_release ();
        free_gnupg_table ();
        return 0;
    }

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

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

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

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

    if (!first_start && !start_gpgprefs) {
        gnupg_backup_options (1);
        gnupg_backup_options (0);
        
        rc = check_crypto_engine ();
        if (rc) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }

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

    if (first_start) {
        struct key_wizard_s c, dummy;
start:
        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,
                        first_run_dlg_proc, (LPARAM)&dummy);
        switch (dummy.interactive) 
        {
        case SETUP_KEYGEN:
            c.interactive = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 hwnd, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

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

        case SETUP_EXISTING:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                            gpgprefs_dlg_proc, NULL);
            break;

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

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