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