/[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 59 by twoaday, Wed Nov 2 13:50:48 2005 UTC revision 273 by twoaday, Fri Dec 8 10:22:17 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. */  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      refresh_cache_s rcs = {0};      int err;
65      rcs.kr_reload = 0;      refresh_cache_s rcs;
66      rcs.kr_update = 1;  
67      rcs.tr_update = 1;      /* no need to rebuild the sig cache each time. */
68      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      memset (&rcs, 0, sizeof (rcs));
69        rcs.kring_update = 1;
70        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 (void)
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;      gpg_keycache_t kc;
220        char *defkey;
221    
222        kc = keycache_get_ctx (0);
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            if (err) {
227                free_if_alloc (defkey);
228                return -1;
229            }
230        }
231        else {
232            /* Actually this is just a warning but we still continue. */
233            msg_box (NULL, _("No useable secret key found."),
234                     _("WinPT Warning"), MB_WARN);
235            free_if_alloc (defkey);
236            return 0;
237        }
238    
239        /* Because the secret key listing has no information
240           about the validity/status, we need to check the public key. */
241        kc = keycache_get_ctx (1);
242        if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
243            (key->revoked || key->expired)) {
244            msg_box (NULL, _("Default secret key is unuseable"),
245                     _("WinPT Warning"), MB_ERR);
246            free_if_alloc (defkey);
247            return -1;
248        }
249      free_if_alloc (defkey);      free_if_alloc (defkey);
250      return err? -1 : 0;      return 0;
251  }  }
252    
253    
254  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
255  static const char *  static const char*
256  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char *fname, int use_cwd)
257  {  {
258      static char program[512];      static char program[2*MAX_PATH+1];
259      char currdir[256];      char currdir[MAX_PATH+1];
260      char *cmd = NULL;      char *cmd = NULL;
261      int j;      int j;
262                    
# Line 150  get_prog_part (const char * fname, int u Line 269  get_prog_part (const char * fname, int u
269      }      }
270      else {      else {
271          cmd = GetCommandLine ();          cmd = GetCommandLine ();
272          if (cmd == NULL)          if (!cmd)
273              return NULL;              return NULL;
274          strncpy (currdir, cmd, sizeof (currdir)-1);          strncpy (currdir, cmd, DIM (currdir)-1);
275          j = strlen (currdir);          j = strlen (currdir);
276          while (j--) {          while (j--) {
277              if (currdir[j] == '\\')              if (currdir[j] == '\\')
# Line 167  get_prog_part (const char * fname, int u Line 286  get_prog_part (const char * fname, int u
286    
287  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
288     requirements so all commands work properly. */     requirements so all commands work properly. */
289  static int  static bool
290  check_crypto_engine (void)  check_crypto_engine (void)
291  {  {
292      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      int ma = 0, mi = 0, pa = 0;
293      int rc;      int rc;
294    
295      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
296      if (rc == -1) {      if (rc == -1) {
297          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (NULL, _("Could not read GnuPG version."),
298                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
299          return rc;          return false;
300      }      }
301      else if (rc) {      else if (rc) {
302          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
303                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
304                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
305                     ma, mi, pa);                     ma, mi, pa);
306          return rc;          return false;
307      }      }
308      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */      /* Enable smart card support for GPG 2 or >= 1.4 */
309      if ((ma == 1 && mi >= 4) || ma > 1)      if ((ma > 1 || pa >= 4) && pcsc_available ())
310          scard_support = 1;          scard_support = 1;
311    
312      gpgver[0] = ma;      gpgver[0] = ma;
313      gpgver[1] = mi;      gpgver[1] = mi;
314      gpgver[2] = pa;      gpgver[2] = pa;
315      return rc;      return true;
316  }  }
317    
318    
# Line 201  check_crypto_engine (void) Line 320  check_crypto_engine (void)
320     do not show any errors. */     do not show any errors. */
321  static int  static int
322  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
323  {  {    
324      const char * t;      const char *t, *conf;
325        char *buf;
326      int rc;      int rc;
327    
328      if (reg_prefs.kserv_conf)      #ifdef WINPT_MOBILE
329          t = reg_prefs.kserv_conf;      /* In mobile mode we automatically assume the config file
330      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))         in the current directory. */
331          t = get_prog_part ("keyserver.conf", 0);      return kserver_load_conf ("keyserver.conf");
332      else      #endif
333    
334        /* Create $APPDATA\winpt if needed. */
335        buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
336        if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
337            MessageBox (NULL, _("Failed to create WinPT directory"),
338                        _("Keyserver"), MB_ERR);
339            free_if_alloc (buf);
340            return -1;
341        }
342        free_if_alloc (buf);
343    
344        /* Check for $APPDATA\winpt\keyserver.conf */
345        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
346    
347        conf = get_prog_part ("keyserver.conf", 0);
348        if (!file_exist_check (conf))
349            t = conf;
350        else
351          t = "keyserver.conf";          t = "keyserver.conf";
352        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
353            if (!CopyFile (t, buf, FALSE)) {
354                MessageBox (NULL, _("Failed to copy the keyserver.conf"),
355                            _("Keyserver"), MB_ERR);
356                free_if_alloc (buf);
357                return -1;
358            }
359            t = buf;
360        }
361        else
362            t = buf;
363        
364      rc = kserver_load_conf (t);      rc = kserver_load_conf (t);
365      if (rc && !quiet)      if (rc && !quiet)
366          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
367        else {
368            free_if_alloc (reg_prefs.kserv_conf);
369            reg_prefs.kserv_conf = m_strdup (t);
370        }
371        free_if_alloc (buf);
372      return rc;      return rc;
373  }  }
374    
375    
376  /* Enable the mobility mode. */  /* Check if both keyrings are empty. This indicates that
377  static void     WinPT should offer to generate a key pair. */
378    static bool
379    check_for_empty_keyrings (bool pub_only)
380    {
381        char *p;
382        int n = 0;
383    
384        p = get_gnupg_keyring (1, 0);
385        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
386            n++;
387        free_if_alloc (p);
388        if (pub_only)
389            return n == 1? true : false;
390        p = get_gnupg_keyring (0, 0);
391        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
392            n++;
393        free_if_alloc (p);
394        return n==2? true : false;
395    }
396    
397    
398    #ifdef WINPT_MOBILE
399    /* Enable the mobile mode if possible.
400       There are some constraints which must be fullfilled.
401       Return value: 0 on success. */
402    static int
403  enable_mobile_mode (void)  enable_mobile_mode (void)
404  {  {
405      memset (&reg_prefs, 0, sizeof (reg_prefs));      static const char *test_fname = "winpt_mobile_test.txt";
406      reg_prefs.always_trust = 0;      FILE *fp;
407      reg_prefs.auto_backup = 0;      char *pubring;
408      reg_prefs.cache_time = 0;      ULARGE_INTEGER caller, total;
409      reg_prefs.expert = 0;      DWORD temp_size;
410      reg_prefs.keylist_mode = 1;  
411      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      fp = fopen (test_fname, "wb");
412      reg_prefs.no_zip_mmedia = 1;      if (fp == NULL) {
413      reg_prefs.use_tmpfiles = 1;          MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
414      reg_prefs.word_wrap = 80;                            "for the current directory", "WinPT Error", MB_ERR);
415      reg_prefs.use_viewer = 0; /* XXX */              
416            return -1;
417        }
418        fclose (fp);
419        DeleteFile (test_fname);
420        if (file_exist_check ("gpg.exe")) {
421            MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
422                              "as the WinPT program", "WinPT Error", MB_ERR);
423            return -1;
424        }
425        
426        /* Because write operations to the keyring result in a temporary
427           file, we need at least 2 MB plus the size of the keyring for
428           free space. */
429        pubring = get_gnupg_keyring (1);
430        temp_size = get_file_size (pubring) + 2097152;
431        free_if_alloc (pubring);
432    
433        if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
434            caller.LowPart < temp_size) {
435            log_box ("WinPT Error", MB_ERR,
436                     "The mobile mode needs at least %lu KB for temporary files",
437                     temp_size/1024);
438            return -1;
439        }
440    
441        /* XXX: shall we check for 'temp-directory' in the gpg.conf? */
442    
443        return 0;
444    }
445    #endif
446    
447    
448    /* Set the default keyserver for this instance. */
449    void
450    set_default_keyserver (void)
451    {
452        char *host = get_reg_entry_keyserver ("Default");
453        char *str_port = get_reg_entry_keyserver ("Default_Port");
454        WORD port = HKP_PORT;
455    
456        if (!host)
457            keyserver_set_default (NULL, 0);
458        else {
459            if (str_port && *str_port)
460                port = atoi (str_port);
461            keyserver_set_default (host, port);
462        }
463        free_if_alloc (host);
464        free_if_alloc (str_port);
465  }  }
466    
 char* multi_gnupg_path (void);  
467    
468  const char * fm_get_file_type (const char *fname, int *r_type);  /* Display info message that WinPT is now in debug mode. */
469    void
470    winpt_debug_msg (void)
471    {      
472        char output[512];
473        char temp[128];
474            
475        GetTempPath (DIM (temp) -1, temp);
476        _snprintf (output, DIM (output)-1,
477            "The GPGME output file is %sgpgme.dbg\n"
478            "The WinPT output file is %swinpt.log\n", temp, temp);
479        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
480    }
481    
482    
483    /* Search for insecure ElGamal keys and return the
484       number of founded keys. */
485    static int
486    count_insecure_elgkeys (void)
487    {
488        gpg_keycache_t pc;
489        gpgme_key_t key;
490        int n = 0;
491    
492        pc = keycache_get_ctx (1);
493        while (!gpg_keycache_next_key (pc, 0, &key)) {
494            if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
495                n++;
496        }
497        gpg_keycache_rewind (pc);
498        return n;
499    }
500    
501    
502  /* Main entry point. */  /* Main entry point. */
503  int WINAPI  int WINAPI
# Line 245  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 505  WinMain (HINSTANCE hinst, HINSTANCE hpre
505  {  {
506      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};
507      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;  
508      MSG msg;      MSG msg;
509      HWND hwnd = NULL;      HWND hwnd = NULL;
510        WORD ver[3], ptdver[4];
511        const char *s;
512        int rc, ec, created = 0;
513        int first_start = 0, start_gpgprefs = 0;
514        int winpt_inst_found = 0;
515        int start_manager = 0;    
516    
517    #ifdef WINPT_MOBILE
518        /* Do not continue in case of problems. */
519        if (enable_mobile_mode ())
520            return 0;
521    #endif
522    
523      glob_hinst = hinst;      glob_hinst = hinst;
524        if (cmdline && stristr (cmdline, "--stop")) {
525            hwnd = FindWindow ("WinPT", "WinPT");
526            if (hwnd != NULL)
527                PostMessage (hwnd, WM_DESTROY, 0, 0);
528            return 0;
529        }
530    
531  #ifdef _DEBUG      #ifdef _DEBUG
532      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
533      debug = 1;      debug = 1;
534  #endif      #endif
535    
536        get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
537        ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
538                                     &ptdver[2], &ptdver[3]);
539        
540        if (!ec && (ptdver[0] != ver[0] ||
541                    ptdver[1] != ver[1] ||
542                    ptdver[2] != ver[2])) {
543            log_box (_("WinPT Error"), MB_ERR,
544                     _("The PTD.dll file has a different version than WinPT.exe\n"
545                       "Please update the PTD.dll to version %d.%d.%d"),
546                       ver[0], ver[1], ver[2]);
547            return 0;
548        }
549    
550      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
551          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 265  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 553  WinMain (HINSTANCE hinst, HINSTANCE hpre
553          return 0;          return 0;
554      }      }
555    
556      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
557      if (!s || !*s) {      if (!s || !*s) {
558          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),
559                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
560          return 0;          return 0;
561      }      }
# Line 275  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 563  WinMain (HINSTANCE hinst, HINSTANCE hpre
563      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
564      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
565          winpt_inst_found = 1;          winpt_inst_found = 1;
566        
567        set_default_keyserver ();
568        load_gettext ();
569        admin_user = user_is_admin ();
570    
571      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
572          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 */  
     }  
573    
574      if (!created) {      if (!created) {
575          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 */  
576          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
577          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
578              hotkeys_modify ();          if (gnupg_load_config () == -2)
579          gnupg_load_config ();              msg_box (NULL, _("The gpg.conf file contains the 'textmode' option\n"
580                                 "which leads to broken binary output during decryption.\n"
581                                 "If this is on purpose, just continue otherwise the option should be disabled."),
582                                _("WinPT Error"), MB_ERR);
583      }      }
584    
585        if (is_gpg4win_installed ())
586            load_gpg_env (); /* XXX: check return code. */
587    
588      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
589      if (rc) {      if (rc) {
590            char *p;
591    
592          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
593                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
594                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
595                   winpt_strerror (rc));                   winpt_strerror (rc));
596          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
597                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
598                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
599                                NULL);                                NULL);
600          if (s != NULL) {          if (s != NULL && (p=strrchr (s, '\\'))) {
601              size_t n;              char *path = substr (s, 0, (p-s));
602              char * p = strrchr (s, '\\');  
603              if (!p)              set_reg_entry_gpg ("HomeDir", path);
604                  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 */  
             }  
605          }          }
606          else {          else {
607              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determined."),
608                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
609              goto start;              goto start;
610          }          }
# Line 346  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 617  WinMain (HINSTANCE hinst, HINSTANCE hpre
617                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
618                               MB_INFO|MB_YESNO) == IDYES)                               MB_INFO|MB_YESNO) == IDYES)
619              start_gpgprefs = 1;              start_gpgprefs = 1;
620          else          else {
         {  
621              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
622              return 0;              return 0;
623          }          }
# Line 359  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 629  WinMain (HINSTANCE hinst, HINSTANCE hpre
629              ec = msg_box (NULL,              ec = msg_box (NULL,
630                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
631                    "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"
632                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
633                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
634              if (ec == IDYES)              if (ec == IDYES)
635                  first_start = 1;                  first_start = 1;
# Line 369  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 639  WinMain (HINSTANCE hinst, HINSTANCE hpre
639              return 0;              return 0;
640          }          }
641      }      }
642        if (check_for_empty_keyrings (false))
643            first_start = 1;
644    
645      if (!first_start) {      if (!first_start) {
646          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
647          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
648              gpg_read_only = 1;              gpg_read_only = 1;
649          else if (rc)          else if (rc)
650              return 0;              return 0;
651      }      }
652        
     load_gettext (winpt_inst_found);  
653      init_gnupg_table ();      init_gnupg_table ();
654    
655      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
656          free_gnupg_table ();          free_gnupg_table ();
657          return 0;          return 0;
658      }      }
659    
660      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
661          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
662                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
663                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
664          free_gnupg_table ();          free_gnupg_table ();
665          return 0;          return 0;
# Line 399  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 669  WinMain (HINSTANCE hinst, HINSTANCE hpre
669    
670      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
671                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
672          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
673               to open the key manager. Otherwise start a new instance. */
674            HWND tray = FindWindow ("WinPT", "WinPT");
675          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
676              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
677                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
678                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
679          else {          if (tray != NULL) {
680              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
681              if (crd)              free_gnupg_table ();
682                  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);  
683          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
684      }      }
685    
686      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 426  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 691  WinMain (HINSTANCE hinst, HINSTANCE hpre
691          return 0;          return 0;
692      }      }
693    
694      if (cmdline) {      #ifndef WINPT_MOBILE
695          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
696              gpg_set_debug_mode (1);                      stristr (cmdline, "--debug"))) {
697              winpt_debug_msg ();          gpg_set_debug_mode (1);
698              debug = 1;          winpt_debug_msg ();
699          }          debug = 1;
700      }      }
701        #endif
702    
703      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
704      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
# Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 726  WinMain (HINSTANCE hinst, HINSTANCE hpre
726    
727      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
728          gnupg_backup_options ();                  gnupg_backup_options ();        
729          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
730              DestroyWindow (hwnd);              DestroyWindow (hwnd);
731              free_gnupg_table ();              free_gnupg_table ();
732              return 0;              return 0;
# Line 469  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 734  WinMain (HINSTANCE hinst, HINSTANCE hpre
734      }      }
735            
736      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
   
737          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
738                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
739          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
740          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);  
741      }      }
742    
743      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
744          struct genkey_s c;          struct genkey_s c;
745            int choice;
746          HWND h;          HWND h;
747  start:  start:
748          h = GetDesktopWindow ();          h = GetDesktopWindow ();
749          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
750                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
751                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
752          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
753                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
754          switch (fs.choice) {          switch (choice) {
755          case SETUP_KEYGEN:          case SETUP_KEYGEN:
756              c.interactive = 1;              c.interactive = 1;
757              c.first_start = 1;              c.first_start = 1;
# Line 507  start: Line 769  start:
769              }              }
770              break;              break;
771    
772          case -1:          case SETUP_CARDGEN:
773                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
774                                     h, card_keygen_dlg_proc, 0);
775                if (!rc)
776                    goto start;
777                break;
778    
779            case 0: /* Cancel/Abort. */
780            default:
781              DestroyWindow (hwnd);              DestroyWindow (hwnd);
782              free_gnupg_table ();              free_gnupg_table ();
783              return 0;              return 0;
784          }          }
785          update_keycache (hwnd);          update_keycache (hwnd);
786          check_crypto_engine ();          if (!check_crypto_engine ()) {
787                DestroyWindow (hwnd);
788                free_gnupg_table ();
789                keycache_release (1);
790                return 0;
791            }
792            if (!is_gpg4win_installed ()) {
793                select_language ();
794                load_gettext ();
795            }
796      }      }
797      else {      else {
798          gpg_keycache_t c;          gpg_keycache_t c;
799          update_keycache (hwnd);          if (update_keycache (hwnd)) {
800                DestroyWindow (hwnd);
801                free_gnupg_table ();
802                keycache_release (1);
803                return 0;
804            }
805            /* XXX: rewrite this part. */
806          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
807          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
808              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
809                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
810                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
811              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"
812                                    "Do you want to start the GPG preferences dialog?"),                                    "Do you want to start the GPG preferences dialog?"),
813                              "WinPT", MB_INFO|MB_YESNO);                              "WinPT", MB_INFO|MB_YESNO);
814              if (ec == IDYES) {              if (ec == IDYES) {
# Line 535  start: Line 819  start:
819              else {              else {
820                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
821                  free_gnupg_table ();                  free_gnupg_table ();
822                    keycache_release (1);
823                  return 0;                  return 0;
824              }              }
825          }          }      
826          if (check_default_key (c)) {          if (check_default_key ()) {
827              char * p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
828              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
829                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found or is unuseable.\n"
830                         "Please check your gpg.conf (options) to correct this:\n\n"                         "The default key will be resetted and can be set later in the Key Manager again.\n\n"
831                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
832                set_gnupg_default_key (NULL);
833              free_if_alloc (p);              free_if_alloc (p);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
834          }          }
835          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
836              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
837                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
838      }      }
839    
840        if (start_manager)
841            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
842    
843      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
844      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
845      while (GetMessage (&msg, hwnd, 0, 0)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
Legend:
Removed from v.59  
changed lines
  Added in v.273
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26