/[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 41 by twoaday, Fri Oct 28 07:15:26 2005 UTC revision 262 by twoaday, Sat Sep 30 10:24:34 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 17  Line 17 
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * 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>  #include <windows.h>
25    #include <shlobj.h>
26    
27  #include "../resource.h"  #include "resource.h"
28  #include "wptTypes.h"  #include "wptTypes.h"
29  #include "wptW32API.h"  #include "wptW32API.h"
30  #include "wptVersion.h"  #include "wptVersion.h"
# Line 34  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    #include "wptUTF8.h"
44    
45    void remove_crit_file_attrs (const char *fname, int force);
46    BOOL user_is_admin (void);
47    extern "C" int  pcsc_available (void);
48    
49  #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */  /* Global variables. */
 #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */  
 #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */  
   
   
50  HINSTANCE glob_hinst;   /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
51  HWND glob_hwnd;         /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
 HWND activ_hwnd;  
 LOCK mo_file;  
52  int scard_support = 0;  int scard_support = 0;
53  int debug = 0;  int debug = 0;
54  int mobile = 0;  int mobile_mode_active = 0;
55  int gpg_read_only = 0;  int gpg_read_only = 0;
56    int admin_user = 0;
57  char gpgver[3];  char gpgver[3];
58    /* End */
59    
60    
61  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
62  static void  int
63  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
64  {  {
65        int err;
66    
67      refresh_cache_s rcs = {0};      refresh_cache_s rcs = {0};
68      rcs.kr_reload = 0;      rcs.kr_reload = 0;
69      rcs.kr_update = 1;      rcs.kr_update = 1;
70      rcs.tr_update = 1;      rcs.tr_update = 1;
71      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
72                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
73        if (err) {
74            char *cfg = get_gnupg_config ();
75            if (cfg && check_gnupg_options (cfg, 0) == WPTERR_FILE_EXIST)
76                msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
77            free_if_alloc (cfg);
78            return -1;
79        }
80        return 0;
81  }  }
82    
83    
84  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
85  void  void
86  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
87  {        {
88      if (val)      static char buf[256];
89          putenv ("GPGME_DEBUG=5:gpgme.dbg");      char tmp[128];
90        
91        /* XXX: no gpgme.dbg is created. */
92        if (val > 0) {
93            GetTempPath (sizeof (tmp)-1, tmp);
94            _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
95            putenv (buf);
96        }
97      else      else
98          putenv ("GPGME_DEBUG=");          putenv ("GPGME_DEBUG=");
99  }  }
100    
101    
 /* Return the name of the gettext language file. */  
 static char*  
 get_gettext_lang (void)  
 {      
     char *fname;  
     fname = get_reg_entry_mo ();  
     if (!fname)  
         return NULL;  
     return fname;  
 }  
   
   
102  /* Initialize the gettext sub system. */  /* Initialize the gettext sub system. */
103  static void  static void
104  load_gettext (int prev_inst)  load_gettext (void)
105  {  {
106      char *nls = NULL;      char *nls = NULL;
     char *file = NULL;  
107    
108      nls = get_gettext_lang ();      /* Return the name of the gettext language file. */
109      if (nls) {      nls = get_reg_entry_mo ();
110        if (nls != NULL) {
111          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);  
         }  
112          free_if_alloc (nls);          free_if_alloc (nls);
113        }
114    }
115    
116    
117    /* Return true if the GPG environment is useable. */
118    static bool
119    gpg_prefs_ok (void)
120    {
121        char *p;
122    
123        p = get_reg_entry_gpg4win ("gpg.exe");
124        if (!p || file_exist_check (p) != 0) {
125            free_if_alloc (p);
126            p = get_reg_entry_gpg ("gpgProgram");
127            if (!p || file_exist_check (p) != 0) {
128                free_if_alloc (p);
129                log_debug ("gpg_prefs_ok: could not locate gpg.exe");
130                return false;
131            }
132        }
133        free_if_alloc (p);
134        p = get_reg_entry_gpg4win (NULL);    
135        if (!p || dir_exist_check (p) != 0) {
136            free_if_alloc (p);
137            p = get_reg_entry_gpg ("HomeDir");
138            if (!p || dir_exist_check (p) != 0) {
139                free_if_alloc (p);
140                log_debug ("gpg_prefs_ok: could not determine home directory");
141                return false;
142            }
143        }
144        free_if_alloc (p);
145        return true;
146    }
147    
148    
149    /* Check gpg files if they are read-only and ask the user
150       if this should be corrected. */
151    static void
152    check_readonly_attr (const char *homedir)
153    {
154        const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
155        char *file;
156        int i;
157    
158        for (i=0; files[i] != NULL; i++) {
159            file = make_filename (homedir, files[i], NULL);
160            remove_crit_file_attrs (file, 0);
161          free_if_alloc (file);          free_if_alloc (file);
162      }      }
163  }  }
164    
165    
166    /* Load the GPG environment. On the first start, some
167       checks are performed to find out in what state GPG is.
168       Return value: 0  everything OK.
169                     >0  fatal error.
170                     -1 public keyring is empty or does not exist. */
171    static int
172    load_gpg_env (void)
173    {
174        SECURITY_ATTRIBUTES sec_attr;
175        char *p;
176        char *pkr;
177    
178        p = get_reg_entry_gpg4win ("gpg.exe");
179        if (!p)
180            return (1);
181        if (file_exist_check (p)) {
182            free_if_alloc (p);
183            return (1);
184        }
185        free_if_alloc (p);
186    
187        p = get_reg_entry_gpg ("HomeDir");
188        if (!p || dir_exist_check (p) != 0) {
189            free_if_alloc (p);
190            p = multi_gnupg_path (0);
191        }
192        if (p && dir_exist_check (p)) {
193            memset (&sec_attr, 0, sizeof (sec_attr));
194            sec_attr.nLength = sizeof (sec_attr);
195            if (!CreateDirectory (p, &sec_attr)) {
196                msg_box (NULL, _("Could not create GPG home directory"),
197                         _("WinPT Error"), MB_ERR);
198                free_if_alloc (p);
199                return (2);
200            }
201        }
202        check_readonly_attr (p);
203        pkr = make_filename (p, "pubring", "gpg");
204        free_if_alloc (p);
205        if (!pkr)
206            return -1;
207        if (get_file_size (pkr) == 0) {
208            free_if_alloc (pkr);
209            return -1;
210        }
211        return 0;
212    }
213    
214    
215  /* 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
216     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
217  static int  static int
218  check_default_key (gpg_keycache_t kc)  check_default_key (gpg_keycache_t kc)
219  {  {
220      gpgme_key_t key;      gpgme_key_t key;
221      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
222      char * defkey;      char *defkey;
223    
224      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
225      if (defkey)      if (defkey)
226          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
227        else
228            msg_box (NULL, _("No useable secret key found."),
229                     _("WinPT Warning"), MB_WARN);
230      free_if_alloc (defkey);      free_if_alloc (defkey);
231      return err? -1 : 0;      return err? -1 : 0;
232  }  }
233    
234    
235  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
236  static const char *  static const char*
237  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char * fname, int use_cwd)
238  {  {
239      static char program[512];      static char program[512];
# Line 163  get_prog_part (const char * fname, int u Line 267  get_prog_part (const char * fname, int u
267    
268  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
269     requirements so all commands work properly. */     requirements so all commands work properly. */
270  static int  static bool
271  check_crypto_engine (void)  check_crypto_engine (void)
272  {  {
273      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      int ma = 0, mi = 0, pa = 0;
274      int rc;      int rc;
275    
276      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
277      if (rc == -1) {      if (rc == -1) {
278          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (NULL, _("Could not read GnuPG version."),
279                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
280          return rc;          return false;
281      }      }
282      else if (rc) {      else if (rc) {
283          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
284                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
285                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
286                     ma, mi, pa);                     ma, mi, pa);
287          return rc;          return false;
288      }      }
289      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
290      if (ma >= 1 && mi >= 4)      if ((ma > 1 || pa >= 4) && pcsc_available ())
291          scard_support = 1;          scard_support = 1;
292    
293      gpgver[0] = ma;      gpgver[0] = ma;
294      gpgver[1] = mi;      gpgver[1] = mi;
295      gpgver[2] = pa;      gpgver[2] = pa;
296      return rc;      return true;
297  }  }
298    
299    
# Line 197  check_crypto_engine (void) Line 301  check_crypto_engine (void)
301     do not show any errors. */     do not show any errors. */
302  static int  static int
303  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
304  {  {    
305      const char * t;      const char *t, *conf;
306        char *buf;
307      int rc;      int rc;
308    
309      if (reg_prefs.kserv_conf)      /* Create $APPDATA\winpt if needed. */
310          t = reg_prefs.kserv_conf;      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
311      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
312          t = get_prog_part ("keyserver.conf", 0);          MessageBox (NULL, _("Failed to create WinPT directory"),
313      else                      _("Keyserver"), MB_ERR);
314            free_if_alloc (buf);
315            return -1;
316        }
317        free_if_alloc (buf);
318    
319        /* Check for $APPDATA\winpt\keyserver.conf */
320        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
321    
322        conf = get_prog_part ("keyserver.conf", 0);
323        if (!file_exist_check (conf))
324            t = conf;
325        else
326          t = "keyserver.conf";          t = "keyserver.conf";
327        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
328            if (!CopyFile (t, buf, FALSE)) {
329                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
330                            _("Keyserver"), MB_ERR);
331                free_if_alloc (buf);
332                return -1;
333            }
334            t = buf;
335        }
336        else
337            t = buf;
338        
339      rc = kserver_load_conf (t);      rc = kserver_load_conf (t);
340      if (rc && !quiet)      if (rc && !quiet)
341          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
342        else {
343            free_if_alloc (reg_prefs.kserv_conf);
344            reg_prefs.kserv_conf = m_strdup (t);
345        }
346        free_if_alloc (buf);
347      return rc;      return rc;
348  }  }
349    
350    
351    /* Check if both keyrings are empty. This indicates that
352       WinPT should offer to generate a key pair. */
353    static bool
354    check_for_empty_keyrings (bool pub_only)
355    {
356        char *p;
357        int n = 0;
358    
359        p = get_gnupg_keyring (1, 0);
360        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
361            n++;
362        free_if_alloc (p);
363        if (pub_only)
364            return n == 1? true : false;
365        p = get_gnupg_keyring (0, 0);
366        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
367            n++;
368        free_if_alloc (p);
369        return n==2? true : false;
370    }
371    
372    
373  /* Enable the mobility mode. */  /* Enable the mobility mode. */
374  static void  static int
375  enable_mobile_mode (void)  enable_mobile_mode (void)
376  {  {
377        if (dir_exist_check ("temp") != 0) {
378            if (!CreateDirectory ("temp", NULL)) {
379                MessageBox (NULL, "Could not create mobile temp directory",
380                            "WinPT Mobile Error", MB_ERR);
381                return -1;
382            }
383        }
384    
385      memset (&reg_prefs, 0, sizeof (reg_prefs));      memset (&reg_prefs, 0, sizeof (reg_prefs));
386      reg_prefs.always_trust = 0;      reg_prefs.always_trust = 0;
387      reg_prefs.auto_backup = 0;      reg_prefs.auto_backup = 0;
388      reg_prefs.cache_time = 0;      reg_prefs.cache_time = 0;
389      reg_prefs.expert = 0;      reg_prefs.expert = 0;
     reg_prefs.keylist_mode = 1;  
390      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
391      reg_prefs.no_zip_mmedia = 1;      reg_prefs.no_zip_mmedia = 1;
     reg_prefs.use_tmpfiles = 1;  
392      reg_prefs.word_wrap = 80;      reg_prefs.word_wrap = 80;
393      reg_prefs.use_viewer = 0; /* XXX */      reg_prefs.use_viewer = 0; /* XXX */
394        return 0;
395  }  }
396    
 char* multi_gnupg_path (void);  
397    
398  const char * fm_get_file_type (const char *fname, int *r_type);  void
399    set_default_keyserver (void)
400    {
401        char *host = get_reg_entry_keyserver ("Default");
402        char *str_port = get_reg_entry_keyserver ("Default_Port");
403        WORD port = HKP_PORT;
404    
405        if (!host)
406            keyserver_set_default (NULL, 0);
407        else {
408            if (str_port && *str_port)
409                port = atoi (str_port);
410            keyserver_set_default (host, port);
411        }
412        free_if_alloc (host);
413        free_if_alloc (str_port);
414    }
415    
416    
417    /* Display info message that WinPT is now in debug mode. */
418    void
419    winpt_debug_msg (void)
420    {      
421        char output[512];
422        char temp[128];
423            
424        GetTempPath (sizeof temp -1, temp);
425        _snprintf (output, sizeof output - 1,
426            "The GPGME output file is %sgpgme.dbg\n"
427            "The WinPT output file is %swinpt.log\n", temp, temp);
428        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
429    }
430    
431    
432    /* Search for insecure ElGamal keys and return the
433       number of founded keys. */
434    static int
435    count_insecure_elgkeys (void)
436    {
437        gpg_keycache_t pc;
438        gpgme_key_t key;
439        int n = 0;
440    
441        pc = keycache_get_ctx (1);
442        while (!gpg_keycache_next_key (pc, 0, &key)) {
443            if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
444                n++;
445        }
446        gpg_keycache_rewind (pc);
447        return n;
448    }
449    
450    
451  /* Main entry point. */  /* Main entry point. */
452  int WINAPI  int WINAPI
# Line 241  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 454  WinMain (HINSTANCE hinst, HINSTANCE hpre
454  {  {
455      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};
456      HACCEL accel_tab;      HACCEL accel_tab;
     int rc, ec, created = 0, nfiles = 0;  
     int first_start = 0, start_gpgprefs = 0;  
     int winpt_inst_found = 0;  
     const char *s;  
457      MSG msg;      MSG msg;
458      HWND hwnd = NULL;      HWND hwnd = NULL;
459        WORD ver[3], ptdver[4];
460        const char *s;
461        int rc, ec, created = 0;
462        int first_start = 0, start_gpgprefs = 0;
463        int winpt_inst_found = 0;
464        int start_manager = 0;    
465    
466      glob_hinst = hinst;      glob_hinst = hinst;
467        if (cmdline && stristr (cmdline, "--stop")) {
468            hwnd = FindWindow ("WinPT", "WinPT");
469            if (hwnd != NULL)
470                PostMessage (hwnd, WM_DESTROY, 0, 0);
471            return 0;
472        }
473    
474      #ifdef _DEBUG      #ifdef _DEBUG
475      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
476      debug = 1;      debug = 1;
477      #endif      #endif
478    
479      s = PTD_get_version ();      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
480      if (strcmp (s, MIN_PTD_VER)) {      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
481          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,                                   &ptdver[2], &ptdver[3]);
482                   _("Please update your PTD.dll to the newest version, "      
483                     "the version (%s) you use is too old."), s);      if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2])) {
484            log_box (_("WinPT Error"), MB_ERR,
485                     _("The PTD.dll file has a different version than WinPT.exe\n"
486                       "Please update the PTD.dll to version %d.%d.%d"),
487                       ver[0], ver[1], ver[2]);
488          return 0;          return 0;
489      }      }
490    
# Line 269  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 494  WinMain (HINSTANCE hinst, HINSTANCE hpre
494          return 0;          return 0;
495      }      }
496    
497      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
498      if (!s || !*s) {      if (!s || !*s) {
499          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),
500                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
501          return 0;          return 0;
502      }      }
# Line 283  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 508  WinMain (HINSTANCE hinst, HINSTANCE hpre
508      if (cmdline && stristr (cmdline, "--mobile")) {      if (cmdline && stristr (cmdline, "--mobile")) {
509          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
510                   "WinPT", MB_INFO);                   "WinPT", MB_INFO);
511          mobile = 1;          mobile_mode_active = 1;
512      }      }
513        
514        set_default_keyserver ();
515        load_gettext ();
516        admin_user = user_is_admin ();
517    
518      set_default_kserver ();      if (!mobile_mode_active) {
   
     if (!mobile) {  
519          regist_inst_gnupg (1);          regist_inst_gnupg (1);
520          regist_inst_winpt (1, &created);          regist_inst_winpt (1, &created);
521      }      }
522      else {      else {
523          enable_mobile_mode ();          if (enable_mobile_mode ())
524          /* XXX: ask for GPG path */              return 0;
525          created = 1; /* Disable registry writing */          created = 1; /* Disable registry writing */
526      }      }
527    
528      if (!created) {      if (!created) {
529          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
         reg_prefs.use_tmpfiles = 1; /* default */  
530          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
531          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
         if (!reg_prefs.no_hotkeys)  
             hotkeys_modify ();  
532          gnupg_load_config ();          gnupg_load_config ();
533      }      }
534    
535        if (is_gpg4win_installed ())
536            load_gpg_env (); /* XXX: check return code. */
537    
538      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
539      if (rc) {      if (rc) {
540          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
541                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
542                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
543                   winpt_strerror (rc));                   winpt_strerror (rc));
544          const char * s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
545                                             _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
546                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
547                                             NULL);                                NULL);
548          if (s != NULL) {          if (s != NULL) {
549              size_t n;              size_t n;
550              char * p = strrchr (s, '\\');              char *p = strrchr (s, '\\');
551              if (!p)              if (!p)
552                  BUG (0);                  BUG (0);
553              n = p - s;              n = p - s;
554              if (n) {              if (n) {
555                  char * file = new char[n+1];                  char *file = new char[n+1];
556                  if (!file)                  if (!file)
557                      BUG (NULL);                      BUG (NULL);
558                  memset (file, 0, n);                  memset (file, 0, n);
# Line 337  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 564  WinMain (HINSTANCE hinst, HINSTANCE hpre
564              }              }
565          }          }
566          else {          else {
567              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determined."),
568                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
569              goto start;              goto start;
570          }          }
# Line 350  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 577  WinMain (HINSTANCE hinst, HINSTANCE hpre
577                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
578                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
579              start_gpgprefs = 1;              start_gpgprefs = 1;
580          else          else {
         {  
581              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
582              return 0;              return 0;
583          }          }
# Line 363  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 589  WinMain (HINSTANCE hinst, HINSTANCE hpre
589              ec = msg_box (NULL,              ec = msg_box (NULL,
590                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
591                    "If this is an accident, quit the program and fix it.\n\n"                    "If this is an accident, quit the program and fix it.\n\n"
592                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
593                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
594              if (ec == IDYES)              if (ec == IDYES)
595                  first_start = 1;                  first_start = 1;
# Line 373  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 599  WinMain (HINSTANCE hinst, HINSTANCE hpre
599              return 0;              return 0;
600          }          }
601      }      }
602        if (check_for_empty_keyrings (false))
603            first_start = 1;
604    
605      if (!first_start) {      if (!first_start) {
606          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
# Line 381  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 609  WinMain (HINSTANCE hinst, HINSTANCE hpre
609          else if (rc)          else if (rc)
610              return 0;              return 0;
611      }      }
612        
     load_gettext (winpt_inst_found);  
613      init_gnupg_table ();      init_gnupg_table ();
614    
615      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
616          free_gnupg_table ();          free_gnupg_table ();
617          return 0;          return 0;
618      }      }
619    
620      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
621          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
622                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
623                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
624          free_gnupg_table ();          free_gnupg_table ();
625          return 0;          return 0;
# Line 403  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 629  WinMain (HINSTANCE hinst, HINSTANCE hpre
629    
630      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
631                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
632          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
633               to open the key manager. Otherwise start a new instance.
634             */
635            HWND tray = FindWindow ("WinPT", "WinPT");
636          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
637              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
638                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
639                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
640          else {          if (tray != NULL) {
641              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
642              if (crd)              free_gnupg_table ();
643                  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);  
644          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
645      }      }
646    
647      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 430  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 652  WinMain (HINSTANCE hinst, HINSTANCE hpre
652          return 0;          return 0;
653      }      }
654    
655      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
656          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
657              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
658              winpt_debug_msg ();          winpt_debug_msg ();
659              debug = 1;          debug = 1;
         }  
660      }      }
661    
662      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
# Line 464  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 685  WinMain (HINSTANCE hinst, HINSTANCE hpre
685    
686      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
687          gnupg_backup_options ();                  gnupg_backup_options ();        
688          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
689              DestroyWindow (hwnd);              DestroyWindow (hwnd);
690              free_gnupg_table ();              free_gnupg_table ();
691              return 0;              return 0;
# Line 473  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 693  WinMain (HINSTANCE hinst, HINSTANCE hpre
693      }      }
694            
695      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
         size_t size = 0;  
696          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
697                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
698          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
699          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);  
700      }      }
701    
702      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
703          struct genkey_s c;          struct genkey_s c;
704            int choice;
705          HWND h;          HWND h;
706  start:  start:
707          h = GetDesktopWindow ();          h = GetDesktopWindow ();
708          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
709                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
710                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
711          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
712                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
713          switch (fs.choice) {          switch (choice) {
714          case SETUP_KEYGEN:          case SETUP_KEYGEN:
715              c.interactive = 1;              c.interactive = 1;
716              c.first_start = 1;              c.first_start = 1;
# Line 511  start: Line 728  start:
728              }              }
729              break;              break;
730    
731          case -1:          case SETUP_CARDGEN:
732                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
733                                     h, card_keygen_dlg_proc, 0);
734                if (!rc)
735                    goto start;
736                break;
737    
738            case 0: /* Cancel/Abort. */
739            default:
740              DestroyWindow (hwnd);              DestroyWindow (hwnd);
741              free_gnupg_table ();              free_gnupg_table ();
742              return 0;              return 0;
743          }          }
744          update_keycache (hwnd);          update_keycache (hwnd);
745          check_crypto_engine ();          if (!check_crypto_engine ()) {
746                DestroyWindow (hwnd);
747                free_gnupg_table ();
748                keycache_release (1);
749                return 0;
750            }
751            if (!is_gpg4win_installed ()) {
752                select_language ();
753                load_gettext ();
754            }
755      }      }
756      else {      else {
757          gpg_keycache_t c;          gpg_keycache_t c, sec_c;
758          update_keycache (hwnd);          if (update_keycache (hwnd)) {
759                DestroyWindow (hwnd);
760                free_gnupg_table ();
761                keycache_release (1);
762                return 0;
763            }
764          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
765          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
766              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
767                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
768                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
769              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"
770                                    "Do you want to start the GPG preferences dialog?"),                                    "Do you want to start the GPG preferences dialog?"),
771                              "WinPT", MB_INFO|MB_YESNO);                              "WinPT", MB_INFO|MB_YESNO);
772              if (ec == IDYES) {              if (ec == IDYES) {
# Line 539  start: Line 777  start:
777              else {              else {
778                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
779                  free_gnupg_table ();                  free_gnupg_table ();
780                    keycache_release (1);
781                  return 0;                  return 0;
782              }              }
783          }          }
784          if (check_default_key (c)) {          sec_c = keycache_get_ctx (0);
785              char * p = get_gnupg_default_key ();          if (check_default_key (sec_c)) {
786                char *p = get_gnupg_default_key ();
787              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
788                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found.\n"
789                         "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"
790                         "%s: public key not found."), p? p : "[null]");                         "%s: public key not found."), p? p : "[null]");
791              free_if_alloc (p);              set_gnupg_default_key (NULL);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
792          }          }
793          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
794              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
795                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
796      }      }
797    
798        if (start_manager)
799            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
800    
801      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
802      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
803      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.41  
changed lines
  Added in v.262
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26