/[winpt]/trunk/Src/WinPT.cpp
ViewVC logotype

Diff of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 66 by twoaday, Thu Nov 3 17:55:18 2005 UTC revision 271 by twoaday, Sun Nov 5 08:57:45 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  #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */  extern "C" int  pcsc_available (void);
   
48    
49    /* Global variables. */
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;
 int mobile = 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 *cfgf = get_gnupg_config ();
74            if (cfgf && check_gnupg_options (cfgf, 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 (cfgf);
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 (DIM (tmp)-1, tmp);
93            _snprintf (buf, DIM (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;
     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        int err = 0;
177    
178        p = get_reg_entry_gpg4win ("gpg.exe");
179        if (!p)
180            return (1);
181        if (file_exist_check (p)) {
182            free_if_alloc (p);
183            return (1);
184        }
185        free_if_alloc (p);
186    
187        p = get_reg_entry_gpg ("HomeDir");
188        if (!p || dir_exist_check (p) != 0) {
189            free_if_alloc (p);
190            p = multi_gnupg_path (0);
191        }
192        if (p && dir_exist_check (p)) {
193            memset (&sec_attr, 0, sizeof (sec_attr));
194            sec_attr.nLength = sizeof (sec_attr);
195            if (!CreateDirectory (p, &sec_attr)) {
196                msg_box (NULL, _("Could not create GPG home directory"),
197                         _("WinPT Error"), MB_ERR);
198                free_if_alloc (p);
199                return (2);
200            }
201        }
202        check_readonly_attr (p);
203        pkr = make_filename (p, "pubring", "gpg");
204        free_if_alloc (p);
205        if (get_file_size (pkr) == 0)
206            err = -1;
207        free_if_alloc (pkr);
208        return err;
209    }
210    
211    
212  /* 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
213     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
214  static int  static int
215  check_default_key (gpg_keycache_t kc)  check_default_key (gpg_keycache_t kc)
216  {  {
217      gpgme_key_t key;      gpgme_key_t key;
218      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
219      char * defkey;      char *defkey;
220    
221      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
222      if (defkey)      if (defkey)
223          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
224      else      else
225          msg_box (NULL, _("No useable secret key found."), _("WinPT Error"), MB_ERR);          msg_box (NULL, _("No useable secret key found."),
226                     _("WinPT Warning"), MB_WARN);
227      free_if_alloc (defkey);      free_if_alloc (defkey);
228      return err? -1 : 0;      return err? -1 : 0;
229  }  }
230    
231    
232  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
233  static const char *  static const char*
234  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char * fname, int use_cwd)
235  {  {
236      static char program[512];      static char program[2*MAX_PATH+1];
237      char currdir[256];      char currdir[MAX_PATH+1];
238      char *cmd = NULL;      char *cmd = NULL;
239      int j;      int j;
240                    
# Line 152  get_prog_part (const char * fname, int u Line 247  get_prog_part (const char * fname, int u
247      }      }
248      else {      else {
249          cmd = GetCommandLine ();          cmd = GetCommandLine ();
250          if (cmd == NULL)          if (!cmd)
251              return NULL;              return NULL;
252          strncpy (currdir, cmd, sizeof (currdir)-1);          strncpy (currdir, cmd, DIM (currdir)-1);
253          j = strlen (currdir);          j = strlen (currdir);
254          while (j--) {          while (j--) {
255              if (currdir[j] == '\\')              if (currdir[j] == '\\')
# Line 169  get_prog_part (const char * fname, int u Line 264  get_prog_part (const char * fname, int u
264    
265  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
266     requirements so all commands work properly. */     requirements so all commands work properly. */
267  static int  static bool
268  check_crypto_engine (void)  check_crypto_engine (void)
269  {  {
270      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      int ma = 0, mi = 0, pa = 0;
271      int rc;      int rc;
272    
273      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
274      if (rc == -1) {      if (rc == -1) {
275          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (NULL, _("Could not read GnuPG version."),
276                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
277          return rc;          return false;
278      }      }
279      else if (rc) {      else if (rc) {
280          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
281                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
282                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
283                     ma, mi, pa);                     ma, mi, pa);
284          return rc;          return false;
285      }      }
286      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */      /* Enable smart card support for GPG 2 or >= 1.4 */
287      if ((ma == 1 && mi >= 4) || ma > 1)      if ((ma > 1 || pa >= 4) && pcsc_available ())
288          scard_support = 1;          scard_support = 1;
289    
290      gpgver[0] = ma;      gpgver[0] = ma;
291      gpgver[1] = mi;      gpgver[1] = mi;
292      gpgver[2] = pa;      gpgver[2] = pa;
293      return rc;      return true;
294  }  }
295    
296    
# Line 203  check_crypto_engine (void) Line 298  check_crypto_engine (void)
298     do not show any errors. */     do not show any errors. */
299  static int  static int
300  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
301  {  {    
302      const char * t;      const char *t, *conf;
303        char *buf;
304      int rc;      int rc;
305    
306      if (reg_prefs.kserv_conf)      #ifdef WINPT_MOBILE
307          t = reg_prefs.kserv_conf;      /* In mobile mode we automatically assume the config file
308      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))         in the current directory. */
309          t = get_prog_part ("keyserver.conf", 0);      return kserver_load_conf ("keyserver.conf");
310      else      #endif
311    
312        /* Create $APPDATA\winpt if needed. */
313        buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
314        if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
315            MessageBox (NULL, _("Failed to create WinPT directory"),
316                        _("Keyserver"), MB_ERR);
317            free_if_alloc (buf);
318            return -1;
319        }
320        free_if_alloc (buf);
321    
322        /* Check for $APPDATA\winpt\keyserver.conf */
323        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
324    
325        conf = get_prog_part ("keyserver.conf", 0);
326        if (!file_exist_check (conf))
327            t = conf;
328        else
329          t = "keyserver.conf";          t = "keyserver.conf";
330        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
331            if (!CopyFile (t, buf, FALSE)) {
332                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
333                            _("Keyserver"), MB_ERR);
334                free_if_alloc (buf);
335                return -1;
336            }
337            t = buf;
338        }
339        else
340            t = buf;
341        
342      rc = kserver_load_conf (t);      rc = kserver_load_conf (t);
343      if (rc && !quiet)      if (rc && !quiet)
344          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
345        else {
346            free_if_alloc (reg_prefs.kserv_conf);
347            reg_prefs.kserv_conf = m_strdup (t);
348        }
349        free_if_alloc (buf);
350      return rc;      return rc;
351  }  }
352    
353    
354  /* Enable the mobility mode. */  /* Check if both keyrings are empty. This indicates that
355  static void     WinPT should offer to generate a key pair. */
356    static bool
357    check_for_empty_keyrings (bool pub_only)
358    {
359        char *p;
360        int n = 0;
361    
362        p = get_gnupg_keyring (1, 0);
363        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
364            n++;
365        free_if_alloc (p);
366        if (pub_only)
367            return n == 1? true : false;
368        p = get_gnupg_keyring (0, 0);
369        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
370            n++;
371        free_if_alloc (p);
372        return n==2? true : false;
373    }
374    
375    
376    #ifdef WINPT_MOBILE
377    /* Enable the mobile mode if possible.
378       There are some constraints which must be fullfilled.
379       Return value: 0 on success. */
380    static int
381  enable_mobile_mode (void)  enable_mobile_mode (void)
382  {  {
383      memset (&reg_prefs, 0, sizeof (reg_prefs));      static const char *test_fname = "winpt_mobile_test.txt";
384      reg_prefs.always_trust = 0;      FILE *fp;
385      reg_prefs.auto_backup = 0;      char *pubring;
386      reg_prefs.cache_time = 0;      ULARGE_INTEGER caller, total;
387      reg_prefs.expert = 0;      DWORD temp_size;
388      reg_prefs.keylist_mode = 1;  
389      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      fp = fopen (test_fname, "wb");
390      reg_prefs.no_zip_mmedia = 1;      if (fp == NULL) {
391      reg_prefs.use_tmpfiles = 1;          MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
392      reg_prefs.word_wrap = 80;                            "for the current directory", "WinPT Error", MB_ERR);
393      reg_prefs.use_viewer = 0; /* XXX */              
394            return -1;
395        }
396        fclose (fp);
397        DeleteFile (test_fname);
398        if (file_exist_check ("gpg.exe")) {
399            MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
400                              "as the WinPT program", "WinPT Error", MB_ERR);
401            return -1;
402        }
403        
404        /* Because write operations to the keyring result in a temporary
405           file, we need at least 2 MB plus the size of the keyring for
406           free space. */
407        pubring = get_gnupg_keyring (1);
408        temp_size = get_file_size (pubring) + 2097152;
409        free_if_alloc (pubring);
410    
411        if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
412            caller.LowPart < temp_size) {
413            log_box ("WinPT Error", MB_ERR,
414                     "The mobile mode needs at least %lu KB for temporary files",
415                     temp_size/1024);
416            return -1;
417        }
418    
419        /* XXX: shall we check for 'temp-directory' in the gpg.conf? */
420    
421        return 0;
422  }  }
423    #endif
424    
 char* multi_gnupg_path (void);  
425    
426  const char * fm_get_file_type (const char *fname, int *r_type);  /* Set the default keyserver for this instance. */
427    void
428    set_default_keyserver (void)
429    {
430        char *host = get_reg_entry_keyserver ("Default");
431        char *str_port = get_reg_entry_keyserver ("Default_Port");
432        WORD port = HKP_PORT;
433    
434        if (!host)
435            keyserver_set_default (NULL, 0);
436        else {
437            if (str_port && *str_port)
438                port = atoi (str_port);
439            keyserver_set_default (host, port);
440        }
441        free_if_alloc (host);
442        free_if_alloc (str_port);
443    }
444    
445    
446    /* Display info message that WinPT is now in debug mode. */
447    void
448    winpt_debug_msg (void)
449    {      
450        char output[512];
451        char temp[128];
452            
453        GetTempPath (DIM (temp) -1, temp);
454        _snprintf (output, DIM (output)-1,
455            "The GPGME output file is %sgpgme.dbg\n"
456            "The WinPT output file is %swinpt.log\n", temp, temp);
457        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
458    }
459    
460    
461    /* Search for insecure ElGamal keys and return the
462       number of founded keys. */
463    static int
464    count_insecure_elgkeys (void)
465    {
466        gpg_keycache_t pc;
467        gpgme_key_t key;
468        int n = 0;
469    
470        pc = keycache_get_ctx (1);
471        while (!gpg_keycache_next_key (pc, 0, &key)) {
472            if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
473                n++;
474        }
475        gpg_keycache_rewind (pc);
476        return n;
477    }
478    
479    
480  /* Main entry point. */  /* Main entry point. */
481  int WINAPI  int WINAPI
# Line 247  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 483  WinMain (HINSTANCE hinst, HINSTANCE hpre
483  {  {
484      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};
485      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;  
486      MSG msg;      MSG msg;
487      HWND hwnd = NULL;      HWND hwnd = NULL;
488        WORD ver[3], ptdver[4];
489        const char *s;
490        int rc, ec, created = 0;
491        int first_start = 0, start_gpgprefs = 0;
492        int winpt_inst_found = 0;
493        int start_manager = 0;    
494    
495    #ifdef WINPT_MOBILE
496        /* Do not continue in case of problems. */
497        if (enable_mobile_mode ())
498            return 0;
499    #endif
500    
501      glob_hinst = hinst;      glob_hinst = hinst;
502        if (cmdline && stristr (cmdline, "--stop")) {
503            hwnd = FindWindow ("WinPT", "WinPT");
504            if (hwnd != NULL)
505                PostMessage (hwnd, WM_DESTROY, 0, 0);
506            return 0;
507        }
508    
509  #ifdef _DEBUG      #ifdef _DEBUG
510      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
511      debug = 1;      debug = 1;
512  #endif      #endif
513    
514        get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
515        ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
516                                     &ptdver[2], &ptdver[3]);
517        
518        if (!ec && (ptdver[0] != ver[0] ||
519                    ptdver[1] != ver[1] ||
520                    ptdver[2] != ver[2])) {
521            log_box (_("WinPT Error"), MB_ERR,
522                     _("The PTD.dll file has a different version than WinPT.exe\n"
523                       "Please update the PTD.dll to version %d.%d.%d"),
524                       ver[0], ver[1], ver[2]);
525            return 0;
526        }
527    
528      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
529          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 267  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 531  WinMain (HINSTANCE hinst, HINSTANCE hpre
531          return 0;          return 0;
532      }      }
533    
534      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
535      if (!s || !*s) {      if (!s || !*s) {
536          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),
537                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
538          return 0;          return 0;
539      }      }
# Line 277  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 541  WinMain (HINSTANCE hinst, HINSTANCE hpre
541      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
542      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
543          winpt_inst_found = 1;          winpt_inst_found = 1;
544        
545        set_default_keyserver ();
546        load_gettext ();
547        admin_user = user_is_admin ();
548    
549      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
550          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",      regist_inst_winpt (1, &created);
                  "WinPT", MB_INFO);  
         mobile = 1;  
     }  
   
     set_default_kserver ();  
   
     if (!mobile) {  
         regist_inst_gnupg (1);  
         regist_inst_winpt (1, &created);  
     }  
     else {  
         enable_mobile_mode ();  
         /* XXX: ask for GPG path */  
         created = 1; /* Disable registry writing */  
     }  
551    
552      if (!created) {      if (!created) {
553          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
         reg_prefs.use_tmpfiles = 1; /* default */  
         reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */  
554          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
555          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
             hotkeys_modify ();  
556          gnupg_load_config ();          gnupg_load_config ();
557      }      }
558    
559        if (is_gpg4win_installed ())
560            load_gpg_env (); /* XXX: check return code. */
561    
562      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
563      if (rc) {      if (rc) {
564            char *p;
565    
566          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
567                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
568                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
569                   winpt_strerror (rc));                   winpt_strerror (rc));
570          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
571                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
572                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
573                                NULL);                                NULL);
574          if (s != NULL) {          if (s != NULL && (p=strrchr (s, '\\'))) {
575              size_t n;              char *path = substr (s, 0, (p-s));
576              char * p = strrchr (s, '\\');  
577              if (!p)              set_reg_entry_gpg ("HomeDir", path);
578                  BUG (0);              free_if_alloc (path);
             n = p - s;  
             if (n) {  
                 char * file = new char[n+1];  
                 if (!file)  
                     BUG (NULL);  
                 memset (file, 0, n);  
                 memcpy (file, s, n);  
                 file[n] = '\0';          
                 set_reg_entry_gpg ("HomeDir", file);  
                 free_if_alloc (file);  
                 gnupg_check_homedir (); /* change gpgProgram if needed */  
             }  
579          }          }
580          else {          else {
581              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determined."),
582                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
583              goto start;              goto start;
584          }          }
# Line 348  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 591  WinMain (HINSTANCE hinst, HINSTANCE hpre
591                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
592                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
593              start_gpgprefs = 1;              start_gpgprefs = 1;
594          else          else {
         {  
595              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
596              return 0;              return 0;
597          }          }
# Line 361  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 603  WinMain (HINSTANCE hinst, HINSTANCE hpre
603              ec = msg_box (NULL,              ec = msg_box (NULL,
604                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
605                    "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"
606                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
607                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
608              if (ec == IDYES)              if (ec == IDYES)
609                  first_start = 1;                  first_start = 1;
# Line 371  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 613  WinMain (HINSTANCE hinst, HINSTANCE hpre
613              return 0;              return 0;
614          }          }
615      }      }
616        if (check_for_empty_keyrings (false))
617            first_start = 1;
618    
619      if (!first_start) {      if (!first_start) {
620          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
621          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
622              gpg_read_only = 1;              gpg_read_only = 1;
623          else if (rc)          else if (rc)
624              return 0;              return 0;
625      }      }
626        
     load_gettext (winpt_inst_found);  
627      init_gnupg_table ();      init_gnupg_table ();
628    
629      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
630          free_gnupg_table ();          free_gnupg_table ();
631          return 0;          return 0;
632      }      }
633    
634      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
635          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
636                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
637                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
638          free_gnupg_table ();          free_gnupg_table ();
639          return 0;          return 0;
# Line 401  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 643  WinMain (HINSTANCE hinst, HINSTANCE hpre
643    
644      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
645                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
646          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
647               to open the key manager. Otherwise start a new instance. */
648            HWND tray = FindWindow ("WinPT", "WinPT");
649          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
650              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
651                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
652                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
653          else {          if (tray != NULL) {
654              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
655              if (crd)              free_gnupg_table ();
656                  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);  
657          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
658      }      }
659    
660      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 428  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 665  WinMain (HINSTANCE hinst, HINSTANCE hpre
665          return 0;          return 0;
666      }      }
667    
668      if (cmdline) {      #ifndef WINPT_MOBILE
669          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
670              gpg_set_debug_mode (1);                      stristr (cmdline, "--debug"))) {
671              winpt_debug_msg ();          gpg_set_debug_mode (1);
672              debug = 1;          winpt_debug_msg ();
673          }          debug = 1;
674      }      }
675        #endif
676    
677      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
678      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
# Line 462  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 700  WinMain (HINSTANCE hinst, HINSTANCE hpre
700    
701      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
702          gnupg_backup_options ();                  gnupg_backup_options ();        
703          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
704              DestroyWindow (hwnd);              DestroyWindow (hwnd);
705              free_gnupg_table ();              free_gnupg_table ();
706              return 0;              return 0;
# Line 471  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 708  WinMain (HINSTANCE hinst, HINSTANCE hpre
708      }      }
709            
710      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
   
711          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
712                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
713          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
714          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);  
715      }      }
716    
717      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
718          struct genkey_s c;          struct genkey_s c;
719            int choice;
720          HWND h;          HWND h;
721  start:  start:
722          h = GetDesktopWindow ();          h = GetDesktopWindow ();
723          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
724                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
725                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
726          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
727                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
728          switch (fs.choice) {          switch (choice) {
729          case SETUP_KEYGEN:          case SETUP_KEYGEN:
730              c.interactive = 1;              c.interactive = 1;
731              c.first_start = 1;              c.first_start = 1;
# Line 509  start: Line 743  start:
743              }              }
744              break;              break;
745    
746          case -1:          case SETUP_CARDGEN:
747                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
748                                     h, card_keygen_dlg_proc, 0);
749                if (!rc)
750                    goto start;
751                break;
752    
753            case 0: /* Cancel/Abort. */
754            default:
755              DestroyWindow (hwnd);              DestroyWindow (hwnd);
756              free_gnupg_table ();              free_gnupg_table ();
757              return 0;              return 0;
758          }          }
759          update_keycache (hwnd);          update_keycache (hwnd);
760          check_crypto_engine ();          if (!check_crypto_engine ()) {
761                DestroyWindow (hwnd);
762                free_gnupg_table ();
763                keycache_release (1);
764                return 0;
765            }
766            if (!is_gpg4win_installed ()) {
767                select_language ();
768                load_gettext ();
769            }
770      }      }
771      else {      else {
772          gpg_keycache_t c;          gpg_keycache_t c, sec_c;
773          update_keycache (hwnd);          if (update_keycache (hwnd)) {
774                DestroyWindow (hwnd);
775                free_gnupg_table ();
776                keycache_release (1);
777                return 0;
778            }
779            /* XXX: rewrite this part. */
780          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
781          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
782              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
783                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
784                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
785              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"
786                                    "Do you want to start the GPG preferences dialog?"),                                    "Do you want to start the GPG preferences dialog?"),
787                              "WinPT", MB_INFO|MB_YESNO);                              "WinPT", MB_INFO|MB_YESNO);
788              if (ec == IDYES) {              if (ec == IDYES) {
# Line 537  start: Line 793  start:
793              else {              else {
794                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
795                  free_gnupg_table ();                  free_gnupg_table ();
796                    keycache_release (1);
797                  return 0;                  return 0;
798              }              }
799          }          }
800          if (check_default_key (c)) {          sec_c = keycache_get_ctx (0);
801              char * p = get_gnupg_default_key ();          if (check_default_key (sec_c)) {
802                char *p = get_gnupg_default_key ();
803              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
804                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found.\n"
805                         "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"
806                         "%s: public key not found."), p? p : "[null]");                         "%s: public key not found."), p? p : "[null]");
807              free_if_alloc (p);              set_gnupg_default_key (NULL);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
808          }          }
809          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
810              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
811                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
812      }      }
813    
814        if (start_manager)
815            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
816    
817      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
818      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
819      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.66  
changed lines
  Added in v.271
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26