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


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
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
{
    WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
    HACCEL accel_tab;
    int rc, ec, created = 0, use_cwd = 0, nfiles = 0;
    int first_start = 0, start_gpgprefs = 0;
    const char * s;
    MSG msg;
    HWND hwnd;

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

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

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

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