/[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 80 by twoaday, Wed Nov 16 11:05:16 2005 UTC revision 193 by twoaday, Sat Apr 1 12:36:35 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.2"   /* Minimal GPG version. */  void remove_crit_file_attrs (const char *fname, int force);
 #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */  
46    
47    
48  HINSTANCE glob_hinst;   /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
49  HWND glob_hwnd;         /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
50  HWND activ_hwnd;  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  char gpgver[3];  char gpgver[3];
56    
57    
58  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
59  static void  void
60  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
61  {  {
62      refresh_cache_s rcs = {0};      refresh_cache_s rcs = {0};
# Line 71  update_keycache (HWND hwnd) Line 71  update_keycache (HWND hwnd)
71  /* 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. */
72  void  void
73  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
74  {        {
75      if (val)      static char buf[256];
76          putenv ("GPGME_DEBUG=5:gpgme.dbg");      char tmp[128];
77        
78        /* XXX: no gpgme.dbg is created. */
79        if (val > 0) {
80            GetTempPath (sizeof (tmp)-1, tmp);
81            _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
82            putenv (buf);
83        }
84      else      else
85          putenv ("GPGME_DEBUG=");          putenv ("GPGME_DEBUG=");
86  }  }
87    
88    
 /* 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;  
 }  
   
   
89  /* Initialize the gettext sub system. */  /* Initialize the gettext sub system. */
90  static void  static void
91  load_gettext (int prev_inst)  load_gettext (void)
92  {  {
93      char *nls = NULL;      char *nls = NULL;
     char *file = NULL;  
94    
95      nls = get_gettext_lang ();      /* Return the name of the gettext language file. */
96      if (nls) {      nls = get_reg_entry_mo ();
97        if (nls != NULL) {
98          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);  
         }  
99          free_if_alloc (nls);          free_if_alloc (nls);
100        }
101    }
102    
103    
104    /* Return true if the GPG environment is useable. */
105    static bool
106    gpg_prefs_ok (void)
107    {
108        char *p;
109    
110        p = get_reg_entry_gpg4win ("gpg.exe");
111        if (!p || file_exist_check (p) != 0) {
112            free_if_alloc (p);
113            p = get_reg_entry_gpg ("gpgProgram");
114            if (!p || file_exist_check (p) != 0) {
115                free_if_alloc (p);
116                log_debug ("gpg_prefs_ok: could not locate gpg.exe");
117                return false;
118            }
119        }
120        free_if_alloc (p);
121        p = get_reg_entry_gpg4win (NULL);    
122        if (!p || dir_exist_check (p) != 0) {
123            free_if_alloc (p);
124            p = get_reg_entry_gpg ("HomeDir");
125            if (!p || dir_exist_check (p) != 0) {
126                free_if_alloc (p);
127                log_debug ("gpg_prefs_ok: could not determine home directory");
128                return false;
129            }
130        }
131        free_if_alloc (p);
132        return true;
133    }
134    
135    
136    /* Check gpg files if they are read-only and ask the user
137       if this should be corrected. */
138    static void
139    check_readonly_attr (const char *homedir)
140    {
141        const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
142        char *file;
143        int i;
144    
145        for (i=0; files[i] != NULL; i++) {
146            file = make_filename (homedir, files[i], NULL);
147            remove_crit_file_attrs (file, 0);
148          free_if_alloc (file);          free_if_alloc (file);
149      }      }
150  }  }
151    
152    
153    /* Load the GPG environment. On the first start, some
154       checks are performed to find out in what state GPG is.
155       Return value: 0  everything OK.
156                     >0  fatal error.
157                     -1 public keyring is empty or does not exist. */
158    static int
159    load_gpg_env (void)
160    {
161        SECURITY_ATTRIBUTES sec_attr;
162        char *p;
163        char *pkr;
164    
165        p = get_reg_entry_gpg4win ("gpg.exe");
166        if (!p)
167            return (1);
168        if (file_exist_check (p)) {
169            free_if_alloc (p);
170            return (1);
171        }
172        free_if_alloc (p);
173    
174        p = get_reg_entry_gpg ("HomeDir");
175        if (!p || dir_exist_check (p) != 0) {
176            free_if_alloc (p);
177            p = multi_gnupg_path (0);
178        }
179        if (p && dir_exist_check (p)) {
180            memset (&sec_attr, 0, sizeof (sec_attr));
181            sec_attr.nLength = sizeof (sec_attr);
182            if (!CreateDirectory (p, &sec_attr)) {
183                msg_box (NULL, _("Could not create GPG home directory"),
184                         _("WinPT Error"), MB_ERR);
185                free_if_alloc (p);
186                return (2);
187            }
188        }
189        check_readonly_attr (p);
190        pkr = make_filename (p, "pubring", "gpg");
191        free_if_alloc (p);
192        if (!pkr)
193            return -1;
194        if (get_file_size (pkr) == 0) {
195            free_if_alloc (pkr);
196            return -1;
197        }
198        return 0;
199    }
200    
201    
202  /* check if the default key from the gpg.conf file is available in the  /* check if the default key from the gpg.conf file is available in the
203     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
204  static int  static int
205  check_default_key (gpg_keycache_t kc)  check_default_key (gpg_keycache_t kc)
206  {  {
207      gpgme_key_t key;      gpgme_key_t key;
208      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
209      char * defkey;      char *defkey;
210    
211      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
212      if (defkey)      if (defkey)
213          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
214      else      else
215          msg_box (NULL, _("No useable secret key found."), _("WinPT Error"), MB_ERR);          msg_box (NULL, _("No useable secret key found."),
216                     _("WinPT Error"), MB_ERR);
217      free_if_alloc (defkey);      free_if_alloc (defkey);
218      return err? -1 : 0;      return err? -1 : 0;
219  }  }
220    
221    
222  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
223  static const char *  static const char*
224  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char * fname, int use_cwd)
225  {  {
226      static char program[512];      static char program[512];
# Line 168  get_prog_part (const char * fname, int u Line 254  get_prog_part (const char * fname, int u
254    
255  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
256     requirements so all commands work properly. */     requirements so all commands work properly. */
257  static int  static bool
258  check_crypto_engine (void)  check_crypto_engine (void)
259  {  {
260      int ma=1, mi=4, pa=2; /* GPG 1.4.2 */      int ma = 0, mi = 0, pa = 0;
261      int rc;      int rc;
262    
263      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
264      if (rc == -1) {      if (rc == -1) {
265          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (NULL, _("Could not read GnuPG version."),
266                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
267          return rc;          return false;
268      }      }
269      else if (rc) {      else if (rc) {
270          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
271                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
272                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
273                     ma, mi, pa);                     ma, mi, pa);
274          return rc;          return false;
275      }      }
276      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
277      if (ma > 1 || pa >= 3)      if (ma > 1 || pa >= 3)
# Line 194  check_crypto_engine (void) Line 280  check_crypto_engine (void)
280      gpgver[0] = ma;      gpgver[0] = ma;
281      gpgver[1] = mi;      gpgver[1] = mi;
282      gpgver[2] = pa;      gpgver[2] = pa;
283      return rc;      return true;
284  }  }
285    
286    
# Line 203  check_crypto_engine (void) Line 289  check_crypto_engine (void)
289  static int  static int
290  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
291  {  {
292      const char * t;      char *buf;
293        const char *t, *conf;
294      int rc;      int rc;
295    
296      if (reg_prefs.kserv_conf)      /* Create $APPDATA\winpt if needed. */
297          t = reg_prefs.kserv_conf;      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
298      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
299          t = get_prog_part ("keyserver.conf", 0);          MessageBox (NULL, _("Failed to create WinPT directory"),
300      else                      _("Keyserver"), MB_ERR);
301            free_if_alloc (buf);
302            return -1;
303        }
304        free_if_alloc (buf);
305    
306        /* Check for $APPDATA\winpt\keyserver.conf */
307        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
308    
309        conf = get_prog_part ("keyserver.conf", 0);
310        if (!file_exist_check (conf))
311            t = conf;
312        else
313          t = "keyserver.conf";          t = "keyserver.conf";
314        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
315            if (!CopyFile (t, buf, FALSE)) {
316                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
317                            _("Keyserver"), MB_ERR);
318                free_if_alloc (buf);
319                return -1;
320            }
321            t = buf;
322        }
323        else
324            t = buf;
325        
326      rc = kserver_load_conf (t);      rc = kserver_load_conf (t);
327      if (rc && !quiet)      if (rc && !quiet)
328          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
329        else {
330            free_if_alloc (reg_prefs.kserv_conf);
331            reg_prefs.kserv_conf = m_strdup (t);
332        }
333        free_if_alloc (buf);
334      return rc;      return rc;
335  }  }
336    
337    
338    /* Check if both keyrings are empty. This indicates that
339       WinPT should offer to generate a key pair. */
340    static bool
341    check_for_empty_keyrings (bool pub_only)
342    {
343        char *p;
344        int n = 0;
345    
346        p = get_gnupg_keyring (1, 0);
347        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
348            n++;
349        free_if_alloc (p);
350        if (pub_only)
351            return n == 1? true : false;
352        p = get_gnupg_keyring (0, 0);
353        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
354            n++;
355        free_if_alloc (p);
356        return n==2? true : false;
357    }
358    
359    
360  /* Enable the mobility mode. */  /* Enable the mobility mode. */
361  static void  static int
362  enable_mobile_mode (void)  enable_mobile_mode (void)
363  {  {
364        if (dir_exist_check ("temp") != 0) {
365            if (!CreateDirectory ("temp", NULL)) {
366                MessageBox (NULL, "Could not create mobile temp directory",
367                            "WinPT Mobile Error", MB_ERR);
368                return -1;
369            }
370        }
371    
372      memset (&reg_prefs, 0, sizeof (reg_prefs));      memset (&reg_prefs, 0, sizeof (reg_prefs));
373      reg_prefs.always_trust = 0;      reg_prefs.always_trust = 0;
374      reg_prefs.auto_backup = 0;      reg_prefs.auto_backup = 0;
375      reg_prefs.cache_time = 0;      reg_prefs.cache_time = 0;
376      reg_prefs.expert = 0;      reg_prefs.expert = 0;
     reg_prefs.keylist_mode = 1;  
377      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
378      reg_prefs.no_zip_mmedia = 1;      reg_prefs.no_zip_mmedia = 1;
379      reg_prefs.use_tmpfiles = 1;      reg_prefs.use_tmpfiles = 1;
380      reg_prefs.word_wrap = 80;      reg_prefs.word_wrap = 80;
381      reg_prefs.use_viewer = 0; /* XXX */      reg_prefs.use_viewer = 0; /* XXX */
382        return 0;
383    }
384    
385    
386    void
387    set_default_keyserver (void)
388    {
389        char *host = get_reg_entry_keyserver ("Default");
390        char *str_port = get_reg_entry_keyserver ("Default_Port");
391        WORD port = HKP_PORT;
392    
393        if (!host)
394            keyserver_set_default (NULL, 0);
395        else {
396            if (str_port && *str_port)
397                port = atoi (str_port);
398            keyserver_set_default (host, port);
399        }
400        free_if_alloc (host);
401        free_if_alloc (str_port);
402  }  }
403    
 char* multi_gnupg_path (void);  
404    
405  const char * fm_get_file_type (const char *fname, int *r_type);  /* Display info message that WinPT is now in debug mode. */
406    void
407    winpt_debug_msg (void)
408    {      
409        char output[512];
410        char temp[128];
411            
412        GetTempPath (sizeof temp -1, temp);
413        _snprintf (output, sizeof output - 1,
414            "The GPGME output file is %sgpgme.dbg\n"
415            "The WinPT output file is %swinpt.log\n", temp, temp);
416        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
417    }
418    
419    
420  /* Main entry point. */  /* Main entry point. */
421  int WINAPI  int WINAPI
# Line 246  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 423  WinMain (HINSTANCE hinst, HINSTANCE hpre
423  {  {
424      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};
425      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;  
426      MSG msg;      MSG msg;
427      HWND hwnd = NULL;      HWND hwnd = NULL;
428        /*WORD ver[3], ptdver[4];*/
429        int rc, ec, created = 0;
430        int first_start = 0, start_gpgprefs = 0;
431        int winpt_inst_found = 0;
432        int start_manager = 0;
433        const char *s;
434    
435      glob_hinst = hinst;      glob_hinst = hinst;
436        if (cmdline && stristr (cmdline, "--stop")) {
437            hwnd = FindWindow ("WinPT", "WinPT");
438            if (hwnd != NULL)
439                PostMessage (hwnd, WM_DESTROY, 0, 0);
440            return 0;
441        }
442    
443  #ifdef _DEBUG      #ifdef _DEBUG
444      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
445      debug = 1;      debug = 1;
446  #endif      #endif
447    
448        /* XXX
449        get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
450        get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
451                                     &ptdver[2], &ptdver[3]);
452        
453        if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
454            log_box (_("WinPT Error"), MB_ERR,
455                     _("The PTD.dll file has a different version than WinPT.exe\n"
456                       "Please update the PTD.dll to version %d.%d.%d"),
457                       ver[0], ver[1], ver[2]);
458            return 0;
459        }
460        */
461    
462      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
463          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 266  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 465  WinMain (HINSTANCE hinst, HINSTANCE hpre
465          return 0;          return 0;
466      }      }
467    
468      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
469      if (!s || !*s) {      if (!s || !*s) {
470          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),
471                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
472          return 0;          return 0;
473      }      }
# Line 280  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 479  WinMain (HINSTANCE hinst, HINSTANCE hpre
479      if (cmdline && stristr (cmdline, "--mobile")) {      if (cmdline && stristr (cmdline, "--mobile")) {
480          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
481                   "WinPT", MB_INFO);                   "WinPT", MB_INFO);
482          mobile = 1;          mobile_mode_active = 1;
483      }      }
484        
485        set_default_keyserver ();
486        load_gettext ();
487    
488      set_default_kserver ();      if (!mobile_mode_active) {
   
     if (!mobile) {  
489          regist_inst_gnupg (1);          regist_inst_gnupg (1);
490          regist_inst_winpt (1, &created);          regist_inst_winpt (1, &created);
491      }      }
492      else {      else {
493          enable_mobile_mode ();          if (enable_mobile_mode ())
494          /* XXX: ask for GPG path */              return 0;
495          created = 1; /* Disable registry writing */          created = 1; /* Disable registry writing */
496      }      }
497    
# Line 300  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 500  WinMain (HINSTANCE hinst, HINSTANCE hpre
500          reg_prefs.use_tmpfiles = 1; /* default */          reg_prefs.use_tmpfiles = 1; /* default */
501          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 */
502          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
         if (!reg_prefs.no_hotkeys)  
             hotkeys_modify ();  
503          gnupg_load_config ();          gnupg_load_config ();
504      }      }
505    
506        if (is_gpg4win_installed ())
507            load_gpg_env (); /* XXX: check return code. */
508    
509      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
510      if (rc) {      if (rc) {
511          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
# Line 312  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 513  WinMain (HINSTANCE hinst, HINSTANCE hpre
513                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
514                   winpt_strerror (rc));                   winpt_strerror (rc));
515          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
516                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
517                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
518                                NULL);                                NULL);
519          if (s != NULL) {          if (s != NULL) {
520              size_t n;              size_t n;
521              char * p = strrchr (s, '\\');              char *p = strrchr (s, '\\');
522              if (!p)              if (!p)
523                  BUG (0);                  BUG (0);
524              n = p - s;              n = p - s;
525              if (n) {              if (n) {
526                  char * file = new char[n+1];                  char *file = new char[n+1];
527                  if (!file)                  if (!file)
528                      BUG (NULL);                      BUG (NULL);
529                  memset (file, 0, n);                  memset (file, 0, n);
# Line 347  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 548  WinMain (HINSTANCE hinst, HINSTANCE hpre
548                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
549                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
550              start_gpgprefs = 1;              start_gpgprefs = 1;
551          else          else {
         {  
552              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
553              return 0;              return 0;
554          }          }
# Line 370  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 570  WinMain (HINSTANCE hinst, HINSTANCE hpre
570              return 0;              return 0;
571          }          }
572      }      }
573        if (check_for_empty_keyrings (false))
574            first_start = 1;
575    
576      if (!first_start) {      if (!first_start) {
577          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
# Line 378  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 580  WinMain (HINSTANCE hinst, HINSTANCE hpre
580          else if (rc)          else if (rc)
581              return 0;              return 0;
582      }      }
583        
     load_gettext (winpt_inst_found);  
584      init_gnupg_table ();      init_gnupg_table ();
585    
586      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
587          free_gnupg_table ();          free_gnupg_table ();
588          return 0;          return 0;
589      }      }
# Line 400  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 600  WinMain (HINSTANCE hinst, HINSTANCE hpre
600    
601      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
602                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
603          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
604               to open the key manager. Otherwise start a new instance.
605             */
606            HWND tray = FindWindow ("WinPT", "WinPT");
607          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
608              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
609                              GetDesktopWindow(), keymanager_dlg_proc, 0,          else
610                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
611          else {          if (tray != NULL) {
612              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
613              if (crd)              free_gnupg_table ();
614                  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);  
615          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
616      }      }
617    
618      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 427  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 623  WinMain (HINSTANCE hinst, HINSTANCE hpre
623          return 0;          return 0;
624      }      }
625    
626      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
627          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
628              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
629              winpt_debug_msg ();          winpt_debug_msg ();
630              debug = 1;          debug = 1;
         }  
631      }      }
632    
633      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
# Line 461  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 656  WinMain (HINSTANCE hinst, HINSTANCE hpre
656    
657      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
658          gnupg_backup_options ();                  gnupg_backup_options ();        
659          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
660              DestroyWindow (hwnd);              DestroyWindow (hwnd);
661              free_gnupg_table ();              free_gnupg_table ();
662              return 0;              return 0;
# Line 470  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 664  WinMain (HINSTANCE hinst, HINSTANCE hpre
664      }      }
665            
666      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
   
667          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
668                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
669          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
670          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);  
671      }      }
672    
673      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
674          struct genkey_s c;          struct genkey_s c;
675            int choice;
676          HWND h;          HWND h;
677  start:  start:
678          h = GetDesktopWindow ();          h = GetDesktopWindow ();
679          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
680                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
681                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
682          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
683                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
684          switch (fs.choice) {          switch (choice) {
685          case SETUP_KEYGEN:          case SETUP_KEYGEN:
686              c.interactive = 1;              c.interactive = 1;
687              c.first_start = 1;              c.first_start = 1;
# Line 508  start: Line 699  start:
699              }              }
700              break;              break;
701    
702          case -1:          case 0: /* Cancel/Abort. */
703            default:
704              DestroyWindow (hwnd);              DestroyWindow (hwnd);
705              free_gnupg_table ();              free_gnupg_table ();
706              return 0;              return 0;
707          }          }
708          update_keycache (hwnd);          update_keycache (hwnd);
709          check_crypto_engine ();          if (!check_crypto_engine ()) {
710                DestroyWindow (hwnd);
711                free_gnupg_table ();
712                return 0;
713            }
714            if (!is_gpg4win_installed ()) {
715                select_language ();
716                load_gettext ();
717            }
718      }      }
719      else {      else {
720          gpg_keycache_t c;          gpg_keycache_t c, sec_c;
721          update_keycache (hwnd);          update_keycache (hwnd);
722          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
723          if (!c || !gpg_keycache_get_size (c)) {          if (!c || !gpg_keycache_get_size (c)) {
# Line 539  start: Line 739  start:
739                  return 0;                  return 0;
740              }              }
741          }          }
742          if (check_default_key (c)) {          sec_c = keycache_get_ctx (0);
743              char * p = get_gnupg_default_key ();          if (check_default_key (sec_c)) {
744                char *p = get_gnupg_default_key ();
745              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
746                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found.\n"
747                         "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"
748                         "%s: public key not found."), p? p : "[null]");                         "%s: public key not found."), p? p : "[null]");
749              free_if_alloc (p);              free_if_alloc (p);
750              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 555  start: Line 756  start:
756                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
757      }      }
758    
759        if (start_manager)
760            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
761    
762      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
763      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
764      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.80  
changed lines
  Added in v.193
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26