/[winpt]/trunk/Src/WinPT.cpp
ViewVC logotype

Contents of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 197 - (show annotations)
Mon Apr 10 07:38:06 2006 UTC (18 years, 10 months ago) by twoaday
File size: 19617 byte(s) 
2006-04-09  Timo Schulz  <ts@g10code.de>
 
        * wptGPGPrefsDlg.cpp (gpgprefs_dlg_proc): Only return true
        if the homedir value was changed.
        * wptGPG.cpp (default_key_from_cache): Only return secret key
        if public part is available.
        (set_gnupg_default_key): Fix NULL problem.
        * wptKeyEditDlgs.cpp (do_editkey_clean): Set update flag.
        * wptFileCBS.cpp (write_cb, read_cb): Better error handling.
        * wptFileManagerDlg.cpp (file_manager_dlg_proc): Handle
        'always-on-top' correctly.
        * wptKeylist.cpp (keylist_get_recipients): Allocate enough
        mem to hold all possible keys.
        (keylist_enum_keys): Likewise.
1 /* WinPT.cpp - Windows Privacy Tray (WinPT)
2 * Copyright (C) 2000-2006 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 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <windows.h>
25 #include <shlobj.h>
26
27 #include "resource.h"
28 #include "wptTypes.h"
29 #include "wptW32API.h"
30 #include "wptVersion.h"
31 #include "wptErrors.h"
32 #include "wptGPG.h"
33 #include "wptRegistry.h"
34 #include "wptCommonCtl.h"
35 #include "wptDlgs.h"
36 #include "wptNLS.h"
37 #include "wptKeyserver.h"
38 #include "wptCard.h"
39 #include "wptFileManager.h"
40 #include "wptContext.h"
41 #include "wptCardEdit.h"
42 #include "wptCrypto.h"
43 #include "wptUTF8.h"
44
45 void remove_crit_file_attrs (const char *fname, int force);
46
47
48 HINSTANCE glob_hinst; /* global instance for the dialogs */
49 HWND glob_hwnd; /* global window handle for the dialogs */
50 HWND activ_hwnd;
51 int scard_support = 0;
52 int debug = 0;
53 int mobile_mode_active = 0;
54 int gpg_read_only = 0;
55 char gpgver[3];
56
57
58 /* Load the key cache and rebuild the signature cache. */
59 void
60 update_keycache (HWND hwnd)
61 {
62 refresh_cache_s rcs = {0};
63 rcs.kr_reload = 0;
64 rcs.kr_update = 1;
65 rcs.tr_update = 1;
66 DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
67 keycache_dlg_proc, (LPARAM)&rcs);
68 }
69
70
71 /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
72 void
73 gpg_set_debug_mode (int val)
74 {
75 static char buf[256];
76 char tmp[128];
77
78 /* XXX: no gpgme.dbg is created. */
79 if (val > 0) {
80 GetTempPath (sizeof (tmp)-1, tmp);
81 _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
82 putenv (buf);
83 }
84 else
85 putenv ("GPGME_DEBUG=");
86 }
87
88
89 /* Initialize the gettext sub system. */
90 static void
91 load_gettext (void)
92 {
93 char *nls = NULL;
94
95 /* Return the name of the gettext language file. */
96 nls = get_reg_entry_mo ();
97 if (nls != NULL) {
98 set_gettext_file ("winpt", nls);
99 free_if_alloc (nls);
100 }
101 }
102
103
104 /* Return true if the GPG environment is useable. */
105 static bool
106 gpg_prefs_ok (void)
107 {
108 char *p;
109
110 p = get_reg_entry_gpg4win ("gpg.exe");
111 if (!p || file_exist_check (p) != 0) {
112 free_if_alloc (p);
113 p = get_reg_entry_gpg ("gpgProgram");
114 if (!p || file_exist_check (p) != 0) {
115 free_if_alloc (p);
116 log_debug ("gpg_prefs_ok: could not locate gpg.exe");
117 return false;
118 }
119 }
120 free_if_alloc (p);
121 p = get_reg_entry_gpg4win (NULL);
122 if (!p || dir_exist_check (p) != 0) {
123 free_if_alloc (p);
124 p = get_reg_entry_gpg ("HomeDir");
125 if (!p || dir_exist_check (p) != 0) {
126 free_if_alloc (p);
127 log_debug ("gpg_prefs_ok: could not determine home directory");
128 return false;
129 }
130 }
131 free_if_alloc (p);
132 return true;
133 }
134
135
136 /* Check gpg files if they are read-only and ask the user
137 if this should be corrected. */
138 static void
139 check_readonly_attr (const char *homedir)
140 {
141 const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
142 char *file;
143 int i;
144
145 for (i=0; files[i] != NULL; i++) {
146 file = make_filename (homedir, files[i], NULL);
147 remove_crit_file_attrs (file, 0);
148 free_if_alloc (file);
149 }
150 }
151
152
153 /* Load the GPG environment. On the first start, some
154 checks are performed to find out in what state GPG is.
155 Return value: 0 everything OK.
156 >0 fatal error.
157 -1 public keyring is empty or does not exist. */
158 static int
159 load_gpg_env (void)
160 {
161 SECURITY_ATTRIBUTES sec_attr;
162 char *p;
163 char *pkr;
164
165 p = get_reg_entry_gpg4win ("gpg.exe");
166 if (!p)
167 return (1);
168 if (file_exist_check (p)) {
169 free_if_alloc (p);
170 return (1);
171 }
172 free_if_alloc (p);
173
174 p = get_reg_entry_gpg ("HomeDir");
175 if (!p || dir_exist_check (p) != 0) {
176 free_if_alloc (p);
177 p = multi_gnupg_path (0);
178 }
179 if (p && dir_exist_check (p)) {
180 memset (&sec_attr, 0, sizeof (sec_attr));
181 sec_attr.nLength = sizeof (sec_attr);
182 if (!CreateDirectory (p, &sec_attr)) {
183 msg_box (NULL, _("Could not create GPG home directory"),
184 _("WinPT Error"), MB_ERR);
185 free_if_alloc (p);
186 return (2);
187 }
188 }
189 check_readonly_attr (p);
190 pkr = make_filename (p, "pubring", "gpg");
191 free_if_alloc (p);
192 if (!pkr)
193 return -1;
194 if (get_file_size (pkr) == 0) {
195 free_if_alloc (pkr);
196 return -1;
197 }
198 return 0;
199 }
200
201
202 /* check if the default key from the gpg.conf file is available in the
203 keyring. if not, bail out because encryption won't work properly then. */
204 static int
205 check_default_key (gpg_keycache_t kc)
206 {
207 gpgme_key_t key;
208 gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
209 char *defkey;
210
211 defkey = get_gnupg_default_key ();
212 if (defkey)
213 err = gpg_keycache_find_key (kc, defkey, 0, &key);
214 else
215 msg_box (NULL, _("No useable secret key found."),
216 _("WinPT Error"), MB_ERR);
217 free_if_alloc (defkey);
218 return err? -1 : 0;
219 }
220
221
222 /* Return the WinPT program file name (with full pathname). */
223 static const char*
224 get_prog_part (const char * fname, int use_cwd)
225 {
226 static char program[512];
227 char currdir[256];
228 char *cmd = NULL;
229 int j;
230
231 memset (currdir, 0, DIM (currdir));
232 memset (program, 0, DIM (program));
233
234 if (use_cwd) {
235 GetCurrentDirectory (DIM (currdir)-1, currdir);
236 _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
237 }
238 else {
239 cmd = GetCommandLine ();
240 if (cmd == NULL)
241 return NULL;
242 strncpy (currdir, cmd, sizeof (currdir)-1);
243 j = strlen (currdir);
244 while (j--) {
245 if (currdir[j] == '\\')
246 break;
247 }
248 currdir[j] = 0;
249 _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
250 }
251 return program;
252 }
253
254
255 /* Check that the underlying crypto engine fullfills the minimal
256 requirements so all commands work properly. */
257 static bool
258 check_crypto_engine (void)
259 {
260 int ma = 0, mi = 0, pa = 0;
261 int rc;
262
263 rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
264 if (rc == -1) {
265 msg_box (NULL, _("Could not read GnuPG version."),
266 _("WinPT Error"), MB_ERR);
267 return false;
268 }
269 else if (rc) {
270 log_box (_("WinPT Error"), MB_ERR,
271 _("Sorry, you need a newer GPG version.\n"
272 "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
273 ma, mi, pa);
274 return false;
275 }
276 /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
277 if (ma > 1 || pa >= 3)
278 scard_support = 1;
279
280 gpgver[0] = ma;
281 gpgver[1] = mi;
282 gpgver[2] = pa;
283 return true;
284 }
285
286
287 /* Try to load the keyserver config file. If @quiet is 1
288 do not show any errors. */
289 static int
290 load_keyserver_conf (int quiet)
291 {
292 char *buf;
293 const char *t, *conf;
294 int rc;
295
296 /* Create $APPDATA\winpt if needed. */
297 buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
298 if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
299 MessageBox (NULL, _("Failed to create WinPT directory"),
300 _("Keyserver"), MB_ERR);
301 free_if_alloc (buf);
302 return -1;
303 }
304 free_if_alloc (buf);
305
306 /* Check for $APPDATA\winpt\keyserver.conf */
307 buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
308
309 conf = get_prog_part ("keyserver.conf", 0);
310 if (!file_exist_check (conf))
311 t = conf;
312 else
313 t = "keyserver.conf";
314 if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
315 if (!CopyFile (t, buf, FALSE)) {
316 MessageBox (NULL, _("Failed to copy the keyserver.conf"),
317 _("Keyserver"), MB_ERR);
318 free_if_alloc (buf);
319 return -1;
320 }
321 t = buf;
322 }
323 else
324 t = buf;
325
326 rc = kserver_load_conf (t);
327 if (rc && !quiet)
328 msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
329 else {
330 free_if_alloc (reg_prefs.kserv_conf);
331 reg_prefs.kserv_conf = m_strdup (t);
332 }
333 free_if_alloc (buf);
334 return rc;
335 }
336
337
338 /* Check if both keyrings are empty. This indicates that
339 WinPT should offer to generate a key pair. */
340 static bool
341 check_for_empty_keyrings (bool pub_only)
342 {
343 char *p;
344 int n = 0;
345
346 p = get_gnupg_keyring (1, 0);
347 if (file_exist_check (p) == 0 && get_file_size (p) == 0)
348 n++;
349 free_if_alloc (p);
350 if (pub_only)
351 return n == 1? true : false;
352 p = get_gnupg_keyring (0, 0);
353 if (file_exist_check (p) == 0 && get_file_size (p) == 0)
354 n++;
355 free_if_alloc (p);
356 return n==2? true : false;
357 }
358
359
360 /* Enable the mobility mode. */
361 static int
362 enable_mobile_mode (void)
363 {
364 if (dir_exist_check ("temp") != 0) {
365 if (!CreateDirectory ("temp", NULL)) {
366 MessageBox (NULL, "Could not create mobile temp directory",
367 "WinPT Mobile Error", MB_ERR);
368 return -1;
369 }
370 }
371
372 memset (&reg_prefs, 0, sizeof (reg_prefs));
373 reg_prefs.always_trust = 0;
374 reg_prefs.auto_backup = 0;
375 reg_prefs.cache_time = 0;
376 reg_prefs.expert = 0;
377 reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
378 reg_prefs.no_zip_mmedia = 1;
379 reg_prefs.use_tmpfiles = 1;
380 reg_prefs.word_wrap = 80;
381 reg_prefs.use_viewer = 0; /* XXX */
382 return 0;
383 }
384
385
386 void
387 set_default_keyserver (void)
388 {
389 char *host = get_reg_entry_keyserver ("Default");
390 char *str_port = get_reg_entry_keyserver ("Default_Port");
391 WORD port = HKP_PORT;
392
393 if (!host)
394 keyserver_set_default (NULL, 0);
395 else {
396 if (str_port && *str_port)
397 port = atoi (str_port);
398 keyserver_set_default (host, port);
399 }
400 free_if_alloc (host);
401 free_if_alloc (str_port);
402 }
403
404
405 /* Display info message that WinPT is now in debug mode. */
406 void
407 winpt_debug_msg (void)
408 {
409 char output[512];
410 char temp[128];
411
412 GetTempPath (sizeof temp -1, temp);
413 _snprintf (output, sizeof output - 1,
414 "The GPGME output file is %sgpgme.dbg\n"
415 "The WinPT output file is %swinpt.log\n", temp, temp);
416 MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
417 }
418
419
420 /* Main entry point. */
421 int WINAPI
422 WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
423 {
424 WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
425 HACCEL accel_tab;
426 MSG msg;
427 HWND hwnd = NULL;
428 /*WORD ver[3], ptdver[4];*/
429 int rc, ec, created = 0;
430 int first_start = 0, start_gpgprefs = 0;
431 int winpt_inst_found = 0;
432 int start_manager = 0;
433 const char *s;
434
435 glob_hinst = hinst;
436 if (cmdline && stristr (cmdline, "--stop")) {
437 hwnd = FindWindow ("WinPT", "WinPT");
438 if (hwnd != NULL)
439 PostMessage (hwnd, WM_DESTROY, 0, 0);
440 return 0;
441 }
442
443 #ifdef _DEBUG
444 gpg_set_debug_mode (1);
445 debug = 1;
446 #endif
447
448 /* XXX
449 get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
450 get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
451 &ptdver[2], &ptdver[3]);
452
453 if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
454 log_box (_("WinPT Error"), MB_ERR,
455 _("The PTD.dll file has a different version than WinPT.exe\n"
456 "Please update the PTD.dll to version %d.%d.%d"),
457 ver[0], ver[1], ver[2]);
458 return 0;
459 }
460 */
461
462 if (gpg_md_selftest ()) {
463 msg_box (NULL, _("Cryptographic selftest failed."),
464 _("WinPT Error"), MB_ERR);
465 return 0;
466 }
467
468 s = gpgme_check_version (NEED_GPGME_VERSION);
469 if (!s || !*s) {
470 msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
471 _("WinPT Error"), MB_ERR);
472 return 0;
473 }
474
475 CreateMutex (NULL, TRUE, PGM_NAME);
476 if (GetLastError () == ERROR_ALREADY_EXISTS)
477 winpt_inst_found = 1;
478
479 if (cmdline && stristr (cmdline, "--mobile")) {
480 msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
481 "WinPT", MB_INFO);
482 mobile_mode_active = 1;
483 }
484
485 set_default_keyserver ();
486 load_gettext ();
487
488 if (!mobile_mode_active) {
489 regist_inst_gnupg (1);
490 regist_inst_winpt (1, &created);
491 }
492 else {
493 if (enable_mobile_mode ())
494 return 0;
495 created = 1; /* Disable registry writing */
496 }
497
498 if (!created) {
499 memset (&reg_prefs, 0, sizeof (reg_prefs));
500 reg_prefs.use_tmpfiles = 1; /* default */
501 reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
502 get_reg_winpt_prefs (&reg_prefs);
503 gnupg_load_config ();
504 }
505
506 if (is_gpg4win_installed ())
507 load_gpg_env (); /* XXX: check return code. */
508
509 rc = gnupg_check_homedir ();
510 if (rc) {
511 log_box (_("WinPT Error"), MB_ERR,
512 _("GPG home directory is not set correctly.\n"
513 "Please check the GPG registry settings:\n%s."),
514 winpt_strerror (rc));
515 s = get_fileopen_dlg (GetActiveWindow (),
516 _("Select GPG Public Keyring"),
517 "GPG Keyrings (*.gpg)\0*.gpg\0\0",
518 NULL);
519 if (s != NULL) {
520 size_t n;
521 char *p = strrchr (s, '\\');
522 if (!p)
523 BUG (0);
524 n = p - s;
525 if (n) {
526 char *file = new char[n+1];
527 if (!file)
528 BUG (NULL);
529 memset (file, 0, n);
530 memcpy (file, s, n);
531 file[n] = '\0';
532 set_reg_entry_gpg ("HomeDir", file);
533 free_if_alloc (file);
534 gnupg_check_homedir (); /* change gpgProgram if needed */
535 }
536 }
537 else {
538 msg_box (NULL, _("GPG home directory could not be determited."),
539 _("WinPT Error"), MB_ERR);
540 goto start;
541 }
542 }
543
544 rc = check_gnupg_prog ();
545 if (rc) {
546 if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
547 "Do you want to start the GPG preferences to "
548 "correct this problem?"), _("WinPT Error"),
549 MB_INFO|MB_YESNO) == IDYES)
550 start_gpgprefs = 1;
551 else {
552 msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
553 return 0;
554 }
555 }
556
557 rc = gnupg_access_files ();
558 if (!start_gpgprefs && rc) {
559 if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
560 ec = msg_box (NULL,
561 _("Could not access and/or find the public and secret keyring.\n"
562 "If this is an accident, quit the program and fix it.\n\n"
563 "Continue if you want that WinPT offers you more choices.\n"),
564 "WinPT", MB_INFO|MB_YESNO);
565 if (ec == IDYES)
566 first_start = 1;
567 }
568 if (!first_start) {
569 msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
570 return 0;
571 }
572 }
573 if (check_for_empty_keyrings (false))
574 first_start = 1;
575
576 if (!first_start) {
577 rc = gpg_check_permissions (1);
578 if (rc && rc == 2)
579 gpg_read_only = 1;
580 else if (rc)
581 return 0;
582 }
583
584 init_gnupg_table ();
585
586 if (fm_parse_command_line (cmdline) > 0) {
587 free_gnupg_table ();
588 return 0;
589 }
590
591 if (cmdline && stristr (cmdline, "--wipe-freespace")) {
592 dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
593 GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
594 _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
595 free_gnupg_table ();
596 return 0;
597 }
598
599 load_keyserver_conf (cmdline? 1 : 0);
600
601 if (cmdline && (stristr (cmdline, "--keymanager")
602 || stristr (cmdline, "--cardmanager"))) {
603 /* If an instance of WinPT is running, just send the command
604 to open the key manager. Otherwise start a new instance.
605 */
606 HWND tray = FindWindow ("WinPT", "WinPT");
607 if (stristr (cmdline, "keymanager"))
608 start_manager = ID_WINPT_KEY;
609 else
610 start_manager = ID_WINPT_CARD;
611 if (tray != NULL) {
612 PostMessage (tray, WM_COMMAND, start_manager, 0);
613 free_gnupg_table ();
614 return 0;
615 }
616 }
617
618 /* If we found another WinPT instance, just quit to avoid it
619 will be executed twice. */
620 if (winpt_inst_found) {
621 log_debug ("%s", "WinMain: WinPT is already running.");
622 free_gnupg_table ();
623 return 0;
624 }
625
626 if (cmdline && (stristr (cmdline, "--enable-debug") ||
627 stristr (cmdline, "--debug"))) {
628 gpg_set_debug_mode (1);
629 winpt_debug_msg ();
630 debug = 1;
631 }
632
633 wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
634 rc = RegisterClass (&wc);
635 if (rc == FALSE) {
636 msg_box (NULL, _("Could not register window class"),
637 _("WinPT Error"), MB_ERR);
638 free_gnupg_table ();
639 return 0;
640 }
641
642 hwnd = CreateWindow (PGM_NAME,
643 PGM_NAME,
644 0, 0, 0, 0, 0,
645 NULL,
646 NULL,
647 hinst,
648 NULL);
649 if (hwnd == NULL) {
650 msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
651 free_gnupg_table ();
652 return 0;
653 }
654 glob_hwnd = hwnd;
655 UpdateWindow (hwnd);
656
657 if (!first_start && !start_gpgprefs) {
658 gnupg_backup_options ();
659 if (!check_crypto_engine ()) {
660 DestroyWindow (hwnd);
661 free_gnupg_table ();
662 return 0;
663 }
664 }
665
666 if (start_gpgprefs) {
667 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
668 gpgprefs_dlg_proc, 0);
669 if (check_for_empty_keyrings (true))
670 first_start = 1; /* The public keyring is empty! */
671 }
672
673 if (first_start) {
674 struct genkey_s c;
675 int choice;
676 HWND h;
677 start:
678 h = GetDesktopWindow ();
679 if (!gpg_prefs_ok ())
680 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
681 gpgprefs_dlg_proc, 0);
682 choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
683 first_run_dlg_proc, 0);
684 switch (choice) {
685 case SETUP_KEYGEN:
686 c.interactive = 1;
687 c.first_start = 1;
688 rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
689 h, keygen_wizard_dlg_proc, (LPARAM)&c);
690 if (!rc)
691 goto start;
692 break;
693
694 case SETUP_IMPORT:
695 rc = gnupg_copy_keyrings ();
696 if (rc) {
697 msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
698 goto start;
699 }
700 break;
701
702 case 0: /* Cancel/Abort. */
703 default:
704 DestroyWindow (hwnd);
705 free_gnupg_table ();
706 return 0;
707 }
708 update_keycache (hwnd);
709 if (!check_crypto_engine ()) {
710 DestroyWindow (hwnd);
711 free_gnupg_table ();
712 return 0;
713 }
714 if (!is_gpg4win_installed ()) {
715 select_language ();
716 load_gettext ();
717 }
718 }
719 else {
720 gpg_keycache_t c, sec_c;
721 update_keycache (hwnd);
722 c = keycache_get_ctx (1);
723 if (!c || !gpg_keycache_get_size (c)) {
724 gnupg_display_error ();
725 msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
726 "Please check your GPG config (keyrings, pathes...)"),
727 _("WinPT Error"), MB_ERR);
728 ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
729 "Do you want to start the GPG preferences dialog?"),
730 "WinPT", MB_INFO|MB_YESNO);
731 if (ec == IDYES) {
732 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
733 gpgprefs_dlg_proc, 0);
734 update_keycache (hwnd);
735 }
736 else {
737 DestroyWindow (hwnd);
738 free_gnupg_table ();
739 return 0;
740 }
741 }
742 sec_c = keycache_get_ctx (0);
743 if (check_default_key (sec_c)) {
744 char *p = get_gnupg_default_key ();
745 log_box (_("WinPT Error"), MB_ERR,
746 _("Default key (from the GPG config file) could not be found.\n"
747 "Please check your gpg.conf or set a new default key to correct it:\n\n"
748 "%s: public key not found."), p? p : "[null]");
749 set_gnupg_default_key (NULL);
750 }
751 if (count_insecure_elgkeys ())
752 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
753 elgamal_warn_dlg_proc, 0);
754 }
755
756 if (start_manager)
757 PostMessage (hwnd, WM_COMMAND, start_manager, 0);
758
759 accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
760 keyring_check_last_access (); /* init */
761 while (GetMessage (&msg, hwnd, 0, 0)) {
762 if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
763 TranslateMessage (&msg);
764 DispatchMessage (&msg);
765 }
766 }
767
768 return 0;
769 }

Properties

Name Value
svn:eol-style native
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26