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