/[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 58 by werner, Wed Nov 2 13:36:03 2005 UTC revision 231 by twoaday, Tue Jun 20 09:18:44 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
220            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 167  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 202  check_crypto_engine (void) Line 294  check_crypto_engine (void)
294  static int  static int
295  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
296  {  {
297      const char * t;      char *buf;
298        const char *t, *conf;
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 245  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;
449      int rc, ec, created = 0, nfiles = 0;      MSG msg;
450        HWND hwnd = NULL;
451        int rc, ec, created = 0;
452      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
453      int winpt_inst_found = 0;      int winpt_inst_found = 0;
454        int start_manager = 0;
455      const char *s;      const char *s;
     MSG msg;  
     HWND hwnd = NULL;  
456    
457      glob_hinst = hinst;      glob_hinst = hinst;
458        if (cmdline && stristr (cmdline, "--stop")) {
459            hwnd = FindWindow ("WinPT", "WinPT");
460            if (hwnd != NULL)
461                PostMessage (hwnd, WM_DESTROY, 0, 0);
462            return 0;
463        }
464    
465  #ifdef _DEBUG      #ifdef _DEBUG
466      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
467      debug = 1;      debug = 1;
468  #endif      #endif
469    
470      s = PTD_get_version ();      /* XXX
471      // FIXME: Using strcmp here is wrong      WORD ver[3], ptdver[4];
472  //     if (strcmp (s, MIN_PTD_VER)) {      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
473  //      log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,      get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
474  //               _("Please update your PTD.dll to the newest version, "                                   &ptdver[2], &ptdver[3]);
475  //                 "the version (%s) you use is too old."), s);      
476  //      return 0;      if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
477  //     }          log_box (_("WinPT Error"), MB_ERR,
478                     _("The PTD.dll file has a different version than WinPT.exe\n"
479                       "Please update the PTD.dll to version %d.%d.%d"),
480                       ver[0], ver[1], ver[2]);
481            return 0;
482        }
483        */
484    
485      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
486          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 274  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 488  WinMain (HINSTANCE hinst, HINSTANCE hpre
488          return 0;          return 0;
489      }      }
490    
491      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
492      if (!s || !*s) {      if (!s || !*s) {
493          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),
494                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
495          return 0;          return 0;
496      }      }
# Line 288  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 502  WinMain (HINSTANCE hinst, HINSTANCE hpre
502      if (cmdline && stristr (cmdline, "--mobile")) {      if (cmdline && stristr (cmdline, "--mobile")) {
503          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
504                   "WinPT", MB_INFO);                   "WinPT", MB_INFO);
505          mobile = 1;          mobile_mode_active = 1;
506      }      }
507        
508        set_default_keyserver ();
509        load_gettext ();
510        admin_user = user_is_admin ();
511    
512      set_default_kserver ();      if (!mobile_mode_active) {
   
     if (!mobile) {  
513          regist_inst_gnupg (1);          regist_inst_gnupg (1);
514          regist_inst_winpt (1, &created);          regist_inst_winpt (1, &created);
515      }      }
516      else {      else {
517          enable_mobile_mode ();          if (enable_mobile_mode ())
518          /* XXX: ask for GPG path */              return 0;
519          created = 1; /* Disable registry writing */          created = 1; /* Disable registry writing */
520      }      }
521    
522      if (!created) {      if (!created) {
523          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
         reg_prefs.use_tmpfiles = 1; /* default */  
524          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 */
525          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
         if (!reg_prefs.no_hotkeys)  
             hotkeys_modify ();  
526          gnupg_load_config ();          gnupg_load_config ();
527      }      }
528    
529        if (is_gpg4win_installed ())
530            load_gpg_env (); /* XXX: check return code. */
531    
532      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
533      if (rc) {      if (rc) {
534          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
# Line 320  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 536  WinMain (HINSTANCE hinst, HINSTANCE hpre
536                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
537                   winpt_strerror (rc));                   winpt_strerror (rc));
538          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
539                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
540                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
541                                NULL);                                NULL);
542          if (s != NULL) {          if (s != NULL) {
543              size_t n;              size_t n;
544              char * p = strrchr (s, '\\');              char *p = strrchr (s, '\\');
545              if (!p)              if (!p)
546                  BUG (0);                  BUG (0);
547              n = p - s;              n = p - s;
548              if (n) {              if (n) {
549                  char * file = new char[n+1];                  char *file = new char[n+1];
550                  if (!file)                  if (!file)
551                      BUG (NULL);                      BUG (NULL);
552                  memset (file, 0, n);                  memset (file, 0, n);
# Line 342  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 558  WinMain (HINSTANCE hinst, HINSTANCE hpre
558              }              }
559          }          }
560          else {          else {
561              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determined."),
562                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
563              goto start;              goto start;
564          }          }
# Line 355  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 571  WinMain (HINSTANCE hinst, HINSTANCE hpre
571                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
572                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
573              start_gpgprefs = 1;              start_gpgprefs = 1;
574          else          else {
         {  
575              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
576              return 0;              return 0;
577          }          }
# Line 378  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 593  WinMain (HINSTANCE hinst, HINSTANCE hpre
593              return 0;              return 0;
594          }          }
595      }      }
596        if (check_for_empty_keyrings (false))
597            first_start = 1;
598    
599      if (!first_start) {      if (!first_start) {
600          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
# Line 386  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 603  WinMain (HINSTANCE hinst, HINSTANCE hpre
603          else if (rc)          else if (rc)
604              return 0;              return 0;
605      }      }
606        
     load_gettext (winpt_inst_found);  
607      init_gnupg_table ();      init_gnupg_table ();
608    
609      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
610          free_gnupg_table ();          free_gnupg_table ();
611          return 0;          return 0;
612      }      }
613    
614      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
615          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
616                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
617                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
618          free_gnupg_table ();          free_gnupg_table ();
619          return 0;          return 0;
# Line 408  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 623  WinMain (HINSTANCE hinst, HINSTANCE hpre
623    
624      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
625                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
626          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
627               to open the key manager. Otherwise start a new instance.
628             */
629            HWND tray = FindWindow ("WinPT", "WinPT");
630          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
631              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
632                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
633                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
634          else {          if (tray != NULL) {
635              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
636              if (crd)              free_gnupg_table ();
637                  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);  
638          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
639      }      }
640    
641      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 435  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 646  WinMain (HINSTANCE hinst, HINSTANCE hpre
646          return 0;          return 0;
647      }      }
648    
649      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
650          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
651              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
652              winpt_debug_msg ();          winpt_debug_msg ();
653              debug = 1;          debug = 1;
         }  
654      }      }
655    
656      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
# Line 469  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 679  WinMain (HINSTANCE hinst, HINSTANCE hpre
679    
680      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
681          gnupg_backup_options ();                  gnupg_backup_options ();        
682          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
683              DestroyWindow (hwnd);              DestroyWindow (hwnd);
684              free_gnupg_table ();              free_gnupg_table ();
685              return 0;              return 0;
# Line 478  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 687  WinMain (HINSTANCE hinst, HINSTANCE hpre
687      }      }
688            
689      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
   
690          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
691                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
692          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
693          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);  
694      }      }
695    
696      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
697          struct genkey_s c;          struct genkey_s c;
698            int choice;
699          HWND h;          HWND h;
700  start:  start:
701          h = GetDesktopWindow ();          h = GetDesktopWindow ();
702          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
703                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
704                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
705          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
706                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
707          switch (fs.choice) {          switch (choice) {
708          case SETUP_KEYGEN:          case SETUP_KEYGEN:
709              c.interactive = 1;              c.interactive = 1;
710              c.first_start = 1;              c.first_start = 1;
# Line 516  start: Line 722  start:
722              }              }
723              break;              break;
724    
725          case -1:          case 0: /* Cancel/Abort. */
726            default:
727              DestroyWindow (hwnd);              DestroyWindow (hwnd);
728              free_gnupg_table ();              free_gnupg_table ();
729              return 0;              return 0;
730          }          }
731          update_keycache (hwnd);          update_keycache (hwnd);
732          check_crypto_engine ();          if (!check_crypto_engine ()) {
733                DestroyWindow (hwnd);
734                free_gnupg_table ();
735                return 0;
736            }
737            if (!is_gpg4win_installed ()) {
738                select_language ();
739                load_gettext ();
740            }
741      }      }
742      else {      else {
743          gpg_keycache_t c;          gpg_keycache_t c, sec_c;
744          update_keycache (hwnd);          update_keycache (hwnd);
745          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
746          if (!c || !gpg_keycache_get_size (c)) {          if (!c || !gpg_keycache_get_size (c)) {
# Line 547  start: Line 762  start:
762                  return 0;                  return 0;
763              }              }
764          }          }
765          if (check_default_key (c)) {          sec_c = keycache_get_ctx (0);
766              char * p = get_gnupg_default_key ();          if (check_default_key (sec_c)) {
767                char *p = get_gnupg_default_key ();
768              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
769                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found.\n"
770                         "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"
771                         "%s: public key not found."), p? p : "[null]");                         "%s: public key not found."), p? p : "[null]");
772              free_if_alloc (p);              set_gnupg_default_key (NULL);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
773          }          }
774          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
775              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
776                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
777      }      }
778    
779        if (start_manager)
780            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
781    
782      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
783      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
784      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.58  
changed lines
  Added in v.231
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26