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