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

Diff of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 47 by werner, Mon Oct 31 14:04:59 2005 UTC revision 176 by twoaday, Mon Feb 13 09:38:03 2006 UTC
# Line 1  Line 1 
1  /* WinPT.cpp - Windows Privacy Tray (WinPT)  /* WinPT.cpp - Windows Privacy Tray (WinPT)
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 22  Line 22 
22  #endif  #endif
23    
24  #include <windows.h>  #include <windows.h>
25  #include <windows.h>  #include <shlobj.h>
26    
27  #include "resource.h"  #include "resource.h"
28  #include "wptTypes.h"  #include "wptTypes.h"
# Line 39  Line 39 
39  #include "wptFileManager.h"  #include "wptFileManager.h"
40  #include "wptContext.h"  #include "wptContext.h"
41  #include "wptCardEdit.h"  #include "wptCardEdit.h"
42    #include "wptCrypto.h"
43    
44    void remove_crit_file_attrs (const char *fname, int force);
 #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */  
 #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */  
 #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */  
45    
46    
47  HINSTANCE glob_hinst;   /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
48  HWND glob_hwnd;         /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
49  HWND activ_hwnd;  HWND activ_hwnd;
 LOCK mo_file;  
50  int scard_support = 0;  int scard_support = 0;
51  int debug = 0;  int debug = 0;
52  int mobile = 0;  int mobile = 0;
# Line 98  static void Line 95  static void
95  load_gettext (int prev_inst)  load_gettext (int prev_inst)
96  {  {
97      char *nls = NULL;      char *nls = NULL;
     char *file = NULL;  
98    
99      nls = get_gettext_lang ();      nls = get_gettext_lang ();
100      if (nls) {      if (nls != NULL) {
101          set_gettext_file ("winpt", nls);          set_gettext_file ("winpt", nls);
         file = make_filename (nls, "winpt", "mo");  
         if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {  
             if (!prev_inst)  
                 msg_box (NULL, _("Could not initizalize file lock.\n"  
                                  "Native Language Support"),  
                          _("WinPT Error"), MB_ERR);  
         }  
102          free_if_alloc (nls);          free_if_alloc (nls);
103        }
104    }
105    
106    
107    /* Return true if the GPG environment is useable. */
108    static bool
109    gpg_prefs_ok (void)
110    {
111        char *p;
112    
113        p = get_reg_entry_gpg4win ("gpg.exe");
114        if (!p || file_exist_check (p) != 0) {
115            free_if_alloc (p);
116            p = get_reg_entry_gpg ("gpgProgram");
117            if (!p || file_exist_check (p) != 0) {
118                free_if_alloc (p);
119                return false;
120            }
121        }
122        free_if_alloc (p);
123        p = get_reg_entry_gpg4win (NULL);    
124        if (!p || dir_exist_check (p) != 0) {
125            free_if_alloc (p);
126            p = get_reg_entry_gpg ("HomeDir");
127            if (!p || dir_exist_check (p) != 0) {
128                free_if_alloc (p);
129                return false;
130            }
131        }
132        free_if_alloc (p);
133        return true;
134    }
135    
136    
137    /* Check gpg files if they are read-only and ask the user
138       if this should be corrected. */
139    static void
140    check_readonly_attr (const char *homedir)
141    {
142        const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
143        char *file;
144        int i;
145    
146        for (i=0; files[i] != NULL; i++) {
147            file = make_filename (homedir, files[i], NULL);
148            remove_crit_file_attrs (file, 0);
149          free_if_alloc (file);          free_if_alloc (file);
150      }      }
151  }  }
152    
153    
154    /* Load the GPG environment. On the first start, some
155       checks are performed to find out in what state GPG is.
156       Return value: 0  everything OK.
157                     >0  fatal error.
158                     -1 public keyring is empty or does not exist. */
159    static int
160    load_gpg_env (void)
161    {
162        SECURITY_ATTRIBUTES sec_attr;
163        char *p;
164        char *pkr;
165    
166        p = get_reg_entry_gpg4win ("gpg.exe");
167        if (!p)
168            return (1);
169        if (file_exist_check (p)) {
170            free_if_alloc (p);
171            return (1);
172        }
173        free_if_alloc (p);
174    
175        p = get_reg_entry_gpg ("HomeDir");
176        if (!p || dir_exist_check (p) != 0) {
177            free_if_alloc (p);
178            p = multi_gnupg_path (0);
179        }
180        if (p && dir_exist_check (p)) {
181            memset (&sec_attr, 0, sizeof (sec_attr));
182            sec_attr.nLength = sizeof (sec_attr);
183            if (!CreateDirectory (p, &sec_attr)) {
184                msg_box (NULL, _("Could not create GPG home directory"),
185                         _("WinPT Error"), MB_ERR);
186                free_if_alloc (p);
187                return (2);
188            }
189        }
190        check_readonly_attr (p);
191        pkr = make_filename (p, "pubring", "gpg");
192        free_if_alloc (p);
193        if (!pkr)
194            return -1;
195        if (get_file_size (pkr) == 0) {
196            free_if_alloc (pkr);
197            return -1;
198        }
199        return 0;
200    }
201    
202    
203  /* check if the default key from the gpg.conf file is available in the  /* check if the default key from the gpg.conf file is available in the
204     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
205  static int  static int
# Line 123  check_default_key (gpg_keycache_t kc) Line 207  check_default_key (gpg_keycache_t kc)
207  {  {
208      gpgme_key_t key;      gpgme_key_t key;
209      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = GPG_ERR_NO_ERROR;
210      char * defkey;      char *defkey;
211    
212      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
213      if (defkey)      if (defkey)
214          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
215        else
216            msg_box (NULL, _("No useable secret key found."),
217                     _("WinPT Error"), MB_ERR);
218      free_if_alloc (defkey);      free_if_alloc (defkey);
219      return err? -1 : 0;      return err? -1 : 0;
220  }  }
221    
222    
223  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
224  static const char *  static const char*
225  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char * fname, int use_cwd)
226  {  {
227      static char program[512];      static char program[512];
# Line 168  get_prog_part (const char * fname, int u Line 255  get_prog_part (const char * fname, int u
255    
256  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
257     requirements so all commands work properly. */     requirements so all commands work properly. */
258  static int  static bool
259  check_crypto_engine (void)  check_crypto_engine (void)
260  {  {
261      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      int ma=0, mi=0, pa=0;
262      int rc;      int rc;
263    
264      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
265      if (rc == -1) {      if (rc == -1) {
266          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (NULL, _("Could not read GnuPG version."),
267                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
268          return rc;          return false;
269      }      }
270      else if (rc) {      else if (rc) {
271          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
272                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
273                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
274                     ma, mi, pa);                     ma, mi, pa);
275          return rc;          return false;
276      }      }
277      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
278      if (ma >= 1 && mi >= 4)      if (ma > 1 || pa >= 3)    
279          scard_support = 1;          scard_support = 1;
280    
281      gpgver[0] = ma;      gpgver[0] = ma;
282      gpgver[1] = mi;      gpgver[1] = mi;
283      gpgver[2] = pa;      gpgver[2] = pa;
284      return rc;      return true;
285  }  }
286    
287    
# Line 203  check_crypto_engine (void) Line 290  check_crypto_engine (void)
290  static int  static int
291  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
292  {  {
293      const char * t;      char *buf;
294        const char *t;
295      int rc;      int rc;
296    
297      if (reg_prefs.kserv_conf)      /* Create $APPDATA\winpt if needed. */
298          t = reg_prefs.kserv_conf;      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
299      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
300            MessageBox (NULL, _("Failed to create WinPT directory"),
301                        _("Keyserver"), MB_ERR);
302            free_if_alloc (buf);
303            return -1;
304        }
305        free_if_alloc (buf);
306    
307        /* Check for $APPDATA\winpt\keyserver.conf */
308        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
309    
310        if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
311          t = get_prog_part ("keyserver.conf", 0);          t = get_prog_part ("keyserver.conf", 0);
312      else      else
313          t = "keyserver.conf";          t = "keyserver.conf";
314        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
315            //log_box (_("Keyserver"), MB_INFO,
316            //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
317            if (!CopyFile (t, buf, FALSE)) {
318                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
319                            _("Keyserver"), MB_ERR);
320                free_if_alloc (buf);
321                return -1;
322            }
323            t = buf;
324        }
325        else
326            t = buf;
327        
328      rc = kserver_load_conf (t);      rc = kserver_load_conf (t);
329      if (rc && !quiet)      if (rc && !quiet)
330          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
331        else {
332            free_if_alloc (reg_prefs.kserv_conf);
333            reg_prefs.kserv_conf = m_strdup (t);
334        }
335        free_if_alloc (buf);
336      return rc;      return rc;
337  }  }
338    
339    
340    /* Check if both keyrings are empty. This indicates that
341       WinPT should offer to generate a key pair. */
342    static bool
343    check_for_empty_keyrings (bool pub_only)
344    {
345        char *p;
346        int n = 0;
347    
348        p = get_gnupg_keyring (1, 0);
349        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
350            n++;
351        free_if_alloc (p);
352        if (pub_only)
353            return n == 1? true : false;
354        p = get_gnupg_keyring (0, 0);
355        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
356            n++;
357        free_if_alloc (p);
358        return n==2? true : false;
359    }
360    
361    
362  /* Enable the mobility mode. */  /* Enable the mobility mode. */
363  static void  static void
364  enable_mobile_mode (void)  enable_mobile_mode (void)
# Line 228  enable_mobile_mode (void) Line 368  enable_mobile_mode (void)
368      reg_prefs.auto_backup = 0;      reg_prefs.auto_backup = 0;
369      reg_prefs.cache_time = 0;      reg_prefs.cache_time = 0;
370      reg_prefs.expert = 0;      reg_prefs.expert = 0;
     reg_prefs.keylist_mode = 1;  
371      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
372      reg_prefs.no_zip_mmedia = 1;      reg_prefs.no_zip_mmedia = 1;
373      reg_prefs.use_tmpfiles = 1;      reg_prefs.use_tmpfiles = 1;
# Line 236  enable_mobile_mode (void) Line 375  enable_mobile_mode (void)
375      reg_prefs.use_viewer = 0; /* XXX */      reg_prefs.use_viewer = 0; /* XXX */
376  }  }
377    
 char* multi_gnupg_path (void);  
   
 const char * fm_get_file_type (const char *fname, int *r_type);  
378    
379  /* Main entry point. */  /* Main entry point. */
380  int WINAPI  int WINAPI
# Line 246  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 382  WinMain (HINSTANCE hinst, HINSTANCE hpre
382  {  {
383      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
384      HACCEL accel_tab;      HACCEL accel_tab;
385      int rc, ec, created = 0, nfiles = 0;      MSG msg;
386        HWND hwnd = NULL;
387        WORD ver[3], ptdver[4];
388        int rc, ec, created = 0;
389      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
390      int winpt_inst_found = 0;      int winpt_inst_found = 0;
391        int start_manager = 0;
392      const char *s;      const char *s;
     MSG msg;  
     HWND hwnd = NULL;  
393    
394      glob_hinst = hinst;      glob_hinst = hinst;
395        if (cmdline && stristr (cmdline, "--stop")) {
396            hwnd = FindWindow ("WinPT", "WinPT");
397            if (hwnd != NULL)
398                PostMessage (hwnd, WM_DESTROY, 0, 0);
399            return 0;
400        }
401    
402        /*
403        OSVERSIONINFO osinf;
404        memset (&osinf, 0, sizeof (osinf));
405        if (GetVersionEx (&osinf) &&
406            osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
407            osinf.dwMinorVersion == 0) {
408            msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
409                     "WinPT Warning", MB_INFO);
410        }
411        */
412    
413      #ifdef _DEBUG      #ifdef _DEBUG
414      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
415      debug = 1;      debug = 1;
416      #endif      #endif
417    
418      s = PTD_get_version ();      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
419      if (strcmp (s, MIN_PTD_VER)) {      get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
420          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,                                   &ptdver[2], &ptdver[3]);
421                   _("Please update your PTD.dll to the newest version, "      /* XXX
422                     "the version (%s) you use is too old."), s);      if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
423            log_box (_("WinPT Error"), MB_ERR,
424                     _("The PTD.dll file has a different version than WinPT.exe\n"
425                       "Please update the PTD.dll to version %d.%d.%d"),
426                       ver[0], ver[1], ver[2]);
427          return 0;          return 0;
428      }      }
429        */
430    
431      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
432          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 274  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 434  WinMain (HINSTANCE hinst, HINSTANCE hpre
434          return 0;          return 0;
435      }      }
436    
437      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
438      if (!s || !*s) {      if (!s || !*s) {
439          msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
440                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
441          return 0;          return 0;
442      }      }
# Line 292  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 452  WinMain (HINSTANCE hinst, HINSTANCE hpre
452      }      }
453    
454      set_default_kserver ();      set_default_kserver ();
455        load_gettext (winpt_inst_found);
456    
457      if (!mobile) {      if (!mobile) {
458          regist_inst_gnupg (1);          regist_inst_gnupg (1);
# Line 313  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 474  WinMain (HINSTANCE hinst, HINSTANCE hpre
474          gnupg_load_config ();          gnupg_load_config ();
475      }      }
476    
477        if (is_gpg4win_installed ())
478            load_gpg_env (); /* XXX: check return code. */
479    
480      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
481      if (rc) {      if (rc) {
482          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
483                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
484                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
485                   winpt_strerror (rc));                   winpt_strerror (rc));
486          const char * s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
487                                             _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
488                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
489                                             NULL);                                NULL);
490          if (s != NULL) {          if (s != NULL) {
491              size_t n;              size_t n;
492              char * p = strrchr (s, '\\');              char *p = strrchr (s, '\\');
493              if (!p)              if (!p)
494                  BUG (0);                  BUG (0);
495              n = p - s;              n = p - s;
496              if (n) {              if (n) {
497                  char * file = new char[n+1];                  char *file = new char[n+1];
498                  if (!file)                  if (!file)
499                      BUG (NULL);                      BUG (NULL);
500                  memset (file, 0, n);                  memset (file, 0, n);
# Line 355  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 519  WinMain (HINSTANCE hinst, HINSTANCE hpre
519                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
520                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
521              start_gpgprefs = 1;              start_gpgprefs = 1;
522          else          else {
         {  
523              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
524              return 0;              return 0;
525          }          }
# Line 378  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 541  WinMain (HINSTANCE hinst, HINSTANCE hpre
541              return 0;              return 0;
542          }          }
543      }      }
544        if (check_for_empty_keyrings (false))
545            first_start = 1;
546    
547      if (!first_start) {      if (!first_start) {
548          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
# Line 386  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 551  WinMain (HINSTANCE hinst, HINSTANCE hpre
551          else if (rc)          else if (rc)
552              return 0;              return 0;
553      }      }
554        
     load_gettext (winpt_inst_found);  
555      init_gnupg_table ();      init_gnupg_table ();
556    
557      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
558          free_gnupg_table ();          free_gnupg_table ();
559          return 0;          return 0;
560      }      }
561    
562      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
563          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
564                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
565                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
566          free_gnupg_table ();          free_gnupg_table ();
567          return 0;          return 0;
# Line 408  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 571  WinMain (HINSTANCE hinst, HINSTANCE hpre
571    
572      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
573                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
574          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
575               to open the key manager. Otherwise start a new instance.
576             */
577            HWND tray = FindWindow ("WinPT", "WinPT");
578          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
579              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
580                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
581                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
582          else {          if (tray != NULL) {
583              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
584              if (crd)              free_gnupg_table ();
585                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,              return 0;
                                   GetDesktopWindow(), card_edit_dlg_proc,  
                                   (LPARAM)crd, _("Card Manager"),  
                                   IDS_WINPT_CARD_EDIT);  
             gpg_card_release (crd);  
586          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
587      }      }
588    
589      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 436  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 595  WinMain (HINSTANCE hinst, HINSTANCE hpre
595      }      }
596    
597      if (cmdline) {      if (cmdline) {
598          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {          if (stristr (cmdline, "--enable-debug") ||
599                stristr (cmdline, "--debug")) {
600              gpg_set_debug_mode (1);              gpg_set_debug_mode (1);
601              winpt_debug_msg ();              winpt_debug_msg ();
602              debug = 1;              debug = 1;
# Line 469  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 629  WinMain (HINSTANCE hinst, HINSTANCE hpre
629    
630      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
631          gnupg_backup_options ();                  gnupg_backup_options ();        
632          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
633              DestroyWindow (hwnd);              DestroyWindow (hwnd);
634              free_gnupg_table ();              free_gnupg_table ();
635              return 0;              return 0;
# Line 478  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 637  WinMain (HINSTANCE hinst, HINSTANCE hpre
637      }      }
638            
639      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
         size_t size = 0;  
640          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
641                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
642          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
643          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)              first_start = 1; /* The public keyring is empty! */
             first_start = 1; /* The keyring is empty! */  
         free_if_alloc (ring);  
644      }      }
645    
646      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
647          struct genkey_s c;          struct genkey_s c;
648            int choice;
649          HWND h;          HWND h;
650  start:  start:
651          h = GetDesktopWindow ();          h = GetDesktopWindow ();
652          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
653                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
654                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
655          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
656                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
657          switch (fs.choice) {          switch (choice) {
658          case SETUP_KEYGEN:          case SETUP_KEYGEN:
659              c.interactive = 1;              c.interactive = 1;
660              c.first_start = 1;              c.first_start = 1;
# Line 516  start: Line 672  start:
672              }              }
673              break;              break;
674    
675          case -1:          case 0: /* Cancel/Abort. */
676            default:
677              DestroyWindow (hwnd);              DestroyWindow (hwnd);
678              free_gnupg_table ();              free_gnupg_table ();
679              return 0;              return 0;
680          }          }
681          update_keycache (hwnd);          update_keycache (hwnd);
682          check_crypto_engine ();          if (!check_crypto_engine ()) {
683                DestroyWindow (hwnd);
684                free_gnupg_table ();
685                return 0;
686            }
687      }      }
688      else {      else {
689          gpg_keycache_t c;          gpg_keycache_t c, sec_c;
690          update_keycache (hwnd);          update_keycache (hwnd);
691          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
692          if (!c || !gpg_keycache_get_size (c)) {          if (!c || !gpg_keycache_get_size (c)) {
# Line 547  start: Line 708  start:
708                  return 0;                  return 0;
709              }              }
710          }          }
711          if (check_default_key (c)) {          sec_c = keycache_get_ctx (0);
712              char * p = get_gnupg_default_key ();          if (check_default_key (sec_c)) {
713                char *p = get_gnupg_default_key ();
714              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
715                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found.\n"
716                         "Please check your gpg.conf (options) to correct this:\n\n"                         "Please check your gpg.conf or set a new default key to correct it:\n\n"
717                         "%s: public key not found."), p? p : "[null]");                         "%s: public key not found."), p? p : "[null]");
718              free_if_alloc (p);              free_if_alloc (p);
719              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 563  start: Line 725  start:
725                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
726      }      }
727    
728        if (start_manager)
729            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
730    
731      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
732      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
733      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.47  
changed lines
  Added in v.176
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26