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")) {
        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 && !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	16	if (cmdline && stristr (cmdline, "--mobile")) {
247			msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!", "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			if (s && !file_exist_check (s))
283			{
284			size_t n;
285			char * p = strrchr (s, '\\');
286			if (!p)
287			BUG (0);
288			n = p - s;
289			if (n)
290			{
291			char * file = new char[n+1];
292			if (!file)
293			BUG (NULL);
294			memset (file, 0, n);
295			memcpy (file, s, n);
296			file[n] = '\0';
297			set_reg_entry_gpg ("HomeDir", file);
298			free_if_alloc (file);
299			gnupg_check_homedir (); /* change gpgProgram if needed */
300			}
301			}
302	twoaday	5	else {
303	twoaday	2	msg_box (NULL, _("GPG home directory could not be determited."),
304			_("WinPT Error"), MB_ERR);
305			goto start;
306			}
307			}
308
309			rc = check_gnupg_prog ();
310	twoaday	5	if (rc) {
311	twoaday	2	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
312			"Do you want to start the GPG preferences to "
313			"correct this problem?"), _("WinPT Error"),
314			MB_INFO\|MB_YESNO) == IDYES)
315			start_gpgprefs = 1;
316			else
317			{
318			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
319			return 0;
320			}
321			}
322
323			rc = gnupg_access_files ();
324			if (!start_gpgprefs && rc)
325			{
326			if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS)
327			{
328			ec = msg_box (NULL,
329			_("Could not access and/or find the public and secret keyring.\n"
330			"If this is an accident, quit the program and fix it.\n\n"
331			"Continue if you want that WinPT offers you more choices.\n"),
332			"WinPT", MB_INFO\|MB_YESNO);
333			if (ec == IDYES)
334			first_start = 1;
335			}
336			if (!first_start)
337			{
338			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
339			return 0;
340			}
341			}
342
343			if (!first_start)
344			{
345			rc = gpg_check_permissions (1);
346			if (rc && rc == 2)
347			gpg_read_only = 1;
348			else if (rc)
349			return 0;
350			}
351
352			load_gettext ();
353			init_gnupg_table ();
354
355			nfiles = fm_parse_command_line (cmdline);
356			if (nfiles > 0)
357			return 0;
358
359			if (cmdline && stristr (cmdline, "--wipe-freespace")) {
360			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
361			GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
362			_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
363			free_gnupg_table ();
364			return 0;
365			}
366
367			load_keyserver_conf (cmdline? 1 : 0);
368	twoaday	14	if (start_keymanager) {
369			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
370			GetDesktopWindow(), keymanager_dlg_proc, NULL,
371			_("Key Manager"), IDS_WINPT_KEYMISC);
372			keycache_release ();
373			free_gnupg_table ();
374			return 0;
375			}
376
377	twoaday	2	if (cmdline && (stristr (cmdline, "--keymanager")
378			\|\| stristr (cmdline, "--cardmanager"))) {
379			update_keycache (GetDesktopWindow ());
380			if (stristr (cmdline, "keymanager"))
381			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
382			GetDesktopWindow(), keymanager_dlg_proc, NULL,
383	twoaday	14	_("Key Manager"), IDS_WINPT_KEYMISC);
384	twoaday	2	else {
385			gpgme_card_t crd = smartcard_init ();
386			if (crd)
387			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
388			GetDesktopWindow(), card_edit_dlg_proc,
389			(LPARAM)crd, _("Card Manager"),
390			IDS_WINPT_CARD_EDIT);
391			gpgme_card_release (crd);
392			}
393			keycache_release ();
394			free_gnupg_table ();
395			return 0;
396			}
397
398			CreateMutex (NULL, TRUE, PGM_NAME);
399			if (GetLastError () == ERROR_ALREADY_EXISTS) {
400			free_gnupg_table ();
401			return 0;
402			}
403
404	twoaday	6	if (cmdline) {
405			if (stristr (cmdline, "--enable-debug") \|\| stristr (cmdline, "--debug")) {
406			gpgme_set_debug_mode (1);
407			winpt_debug_msg ();
408			debug = 1;
409			}
410	twoaday	2	}
411
412			wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
413			rc = RegisterClass (&wc);
414			if (rc == FALSE) {
415			msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);
416			free_gnupg_table ();
417			return 0;
418			}
419
420			hwnd = CreateWindow (PGM_NAME,
421			PGM_NAME,
422			0, 0, 0, 0, 0,
423			NULL,
424			NULL,
425			hinst,
426			NULL);
427			if (hwnd == NULL) {
428			msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
429			free_gnupg_table ();
430			return 0;
431			}
432			glob_hwnd = hwnd;
433			UpdateWindow (hwnd);
434
435			if (!first_start && !start_gpgprefs) {
436			gnupg_backup_options (1);
437			gnupg_backup_options (0);
438
439			rc = check_crypto_engine ();
440			if (rc) {
441			DestroyWindow (hwnd);
442			free_gnupg_table ();
443			return 0;
444			}
445			}
446
447			if (start_gpgprefs)
448			{
449			char *ring;
450			size_t size = 0;
451			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
452			gpgprefs_dlg_proc, NULL);
453			ring = get_gnupg_keyring (0, !NO_STRICT);
454			if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
455			first_start = 1; /* The keyring is empty! */
456			free_if_alloc (ring);
457			}
458
459			if (first_start) {
460			struct key_wizard_s c, dummy;
461			start:
462			DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,
463			first_run_dlg_proc, (LPARAM)&dummy);
464			switch (dummy.interactive)
465			{
466			case SETUP_KEYGEN:
467			c.interactive = 1;
468			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
469			hwnd, keygen_wizard_dlg_proc, (LPARAM)&c);
470			if (!rc)
471			goto start;
472			break;
473
474			case SETUP_IMPORT:
475			rc = gnupg_copy_keyrings ();
476			if (rc) {
477			msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
478			goto start;
479			}
480			break;
481
482			case SETUP_EXISTING:
483	twoaday	4	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
484			gpgprefs_dlg_proc, NULL);
485			break;
486	twoaday	2
487			case -1:
488			DestroyWindow (hwnd);
489			free_gnupg_table ();
490			return 0;
491			}
492	twoaday	4	update_keycache (hwnd);
493			check_crypto_engine ();
494	twoaday	2	}
495			else {
496			gpgme_keycache_t c;
497			update_keycache (hwnd);
498			c = keycache_get_ctx (1);
499			if (!c \|\| !gpgme_keycache_count (c)) {
500			gnupg_display_error ();
501			msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
502			"Please check your GPG config (keyrings, pathes...)"),
503			_("WinPT Error"), MB_ERR);
504			ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
505			"Do you want to start the GPG preferences dialog?"),
506			"WinPT", MB_INFO\|MB_YESNO);
507			if (ec == IDYES) {
508			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
509			gpgprefs_dlg_proc, NULL);
510			update_keycache (hwnd);
511			}
512			else {
513			DestroyWindow (hwnd);
514			free_gnupg_table ();
515			return 0;
516			}
517			}
518			if (check_default_key (c)) {
519			char * p = get_gnupg_default_key ();
520			log_box (_("WinPT Error"), MB_ERR,
521			_("Default key from the GPG options file could not be found.\n"
522			"Please check your gpg.conf (options) to correct this:\n\n"
523			"%s: public key not found."), p? p : "[null]");
524			free_if_alloc (p);
525			DestroyWindow (hwnd);
526			free_gnupg_table ();
527			return 0;
528			}
529			if (count_insecure_elgkeys ())
530			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
531			elgamal_warn_dlg_proc, NULL);
532			}
533
534			accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
535			keyring_check_last_access (); /* init */
536			while (GetMessage (&msg, hwnd, 0, 0)) {
537			if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
538			TranslateMessage (&msg);
539			DispatchMessage (&msg);
540			}
541			}
542
543			return 0;
544			} /* WinMain */