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

Diff of /trunk/Src/WinPT.cpp

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

revision 73 by twoaday, Tue Nov 8 07:15:13 2005 UTC revision 415 by twoaday, Sat Feb 11 16:51:01 2012 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-2009 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 12  Line 12 
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  
15   */   */
16  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
17  #include <config.h>  #include <config.h>
18  #endif  #endif
19    
20  #include <windows.h>  #include <windows.h>
21    #include <shlobj.h>
22    
23  #include "resource.h"  #include "resource.h"
24  #include "wptTypes.h"  #include "wptTypes.h"
# Line 39  Line 36 
36  #include "wptContext.h"  #include "wptContext.h"
37  #include "wptCardEdit.h"  #include "wptCardEdit.h"
38  #include "wptCrypto.h"  #include "wptCrypto.h"
39    #include "wptUTF8.h"
40    
41  #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */  void remove_crit_file_attrs (const char *fname, int force);
 #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */  
   
42    
43    /* Global variables. */
44  HINSTANCE glob_hinst;   /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
45  HWND glob_hwnd;         /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
 HWND activ_hwnd;  
 LOCK mo_file;  
46  int scard_support = 0;  int scard_support = 0;
47    int disable_hook = 0;
48  int debug = 0;  int debug = 0;
 int mobile = 0;  
49  int gpg_read_only = 0;  int gpg_read_only = 0;
50  char gpgver[3];  char gpgver[3];
51    /* End */
52    
53    
54    /* Retrieve the product verion of the given file @fname.
55       Format: MAJOR.MINOR.PATCH1.PATCH2
56       Return value: 0 on success. */
57    int
58    get_file_version (const char *fname, WORD *major, WORD *minor, WORD *patch1, WORD *patch2)
59    {
60        VS_FIXEDFILEINFO *inf;
61        char file[MAX_PATH+1] = {0};
62        LPVOID buf, data;
63        DWORD size;
64        UINT qlen;
65        int err = 0;
66    
67        strncpy (file, fname, MAX_PATH);
68        size = GetFileVersionInfoSize (file, NULL);
69        if (!size)
70            return -1;
71        
72        buf = (LPVOID)new char[size];
73        if (!buf)
74            BUG (NULL);
75        if (!GetFileVersionInfo (file, 0, size, buf)) {
76            err = -1;
77            goto fail;
78        }
79    
80        qlen = 0;
81        VerQueryValue (buf, (char*)"\\", &data, &qlen);
82        if (!qlen) {
83            err = -1;
84            goto fail;
85        }
86        
87        inf = (VS_FIXEDFILEINFO*)data;
88        *major = HIWORD (inf->dwProductVersionMS);
89        *minor = LOWORD (inf->dwProductVersionMS);
90        *patch1 = HIWORD (inf->dwProductVersionLS);
91        *patch2 = LOWORD (inf->dwProductVersionLS);
92    
93    fail:
94        delete [](char*)buf;
95        return err;
96    }
97    
98    
99  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
100  static void  int
101  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
102  {  {
103      refresh_cache_s rcs = {0};      refresh_cache_s rcs;
104      rcs.kr_reload = 0;  
105      rcs.kr_update = 1;      /* no need to rebuild the sig cache each time. */
106      rcs.tr_update = 1;      memset (&rcs, 0, sizeof (rcs));
107      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      rcs.kring_update = 1;
108        int err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
109                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
110        if (err) {
111            char *cfgf = get_gnupg_config ();
112            if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
113                msg_box (GetDesktopWindow (),
114                         _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
115            free_if_alloc (cfgf);
116            return -1;
117        }
118        return 0;
119  }  }
120    
121    
122  /* 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. */
123  void  void
124  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
125  {        {
126      if (val)      static char buf[MAX_PATH+1];
127          putenv ("GPGME_DEBUG=5:gpgme.dbg");      
128        /* XXX: no gpgme.dbg is created. */
129        if (val > 0) {
130            char tmp[128];
131            GetTempPath (DIM (tmp)-1, tmp);
132            _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
133            putenv (buf);
134        }
135      else      else
136          putenv ("GPGME_DEBUG=");          putenv ("GPGME_DEBUG=");
137  }  }
138    
139    
140  /* Return the name of the gettext language file. */  /* Return true if the GPG environment is useable. */
141  static char*  static bool
142  get_gettext_lang (void)  gpg_prefs_ok (void)
143  {      {
144      char *fname;      char *p = get_reg_entry_gpg4win ("gpg.exe");
145      fname = get_reg_entry_mo ();      if (!p || file_exist_check (p) != 0) {
146      if (!fname)          free_if_alloc (p);
147          return NULL;          p = get_reg_entry_gpg ("gpgProgram");
148      return fname;          if (!p || file_exist_check (p) != 0) {
149                free_if_alloc (p);
150                log_debug ("gpg_prefs_ok: could not locate gpg.exe");
151                return false;
152            }
153        }
154        free_if_alloc (p);
155        p = get_reg_entry_gpg4win (NULL);
156        if (!p || dir_exist_check (p) != 0) {
157            free_if_alloc (p);
158            p = get_reg_entry_gpg ("HomeDir");
159            if (!p || dir_exist_check (p) != 0) {
160                free_if_alloc (p);
161                log_debug ("gpg_prefs_ok: could not determine home directory");
162                return false;
163            }
164        }
165        free_if_alloc (p);
166        return true;
167  }  }
168    
169    
170  /* Initialize the gettext sub system. */  /* Check gpg files if they are read-only and ask the user
171       if this should be corrected. */
172  static void  static void
173  load_gettext (int prev_inst)  check_readonly_attr (const char *homedir)
174  {  {
175      char *nls = NULL;      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
176      char *file = NULL;      
177        log_debug("check if there are gpg files with a read-only attribute");
178        for (int i=0; files[i] != NULL; i++) {
179            char *file = make_filename (homedir, files[i], NULL);
180            remove_crit_file_attrs (file, 0);
181            free_if_alloc (file);
182        }
183    }
184    
185      nls = get_gettext_lang ();  
186      if (nls) {  /* Load the GPG environment. On the first start, some
187          set_gettext_file ("winpt", nls);     checks are performed to find out in what state GPG is.
188          file = make_filename (nls, "winpt", "mo");     Return value: 0  everything OK.
189          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {                   >0  fatal error.
190              if (!prev_inst)                   -1 public keyring is empty or does not exist. */
191                  msg_box (NULL, _("Could not initizalize file lock.\n"  static int
192                                   "Native Language Support"),  load_gpg_env (void)
193                           _("WinPT Error"), MB_ERR);  {
194        SECURITY_ATTRIBUTES sec_attr;
195        char *p;
196        char *pkr;
197        int err = 0;
198    
199        p = get_reg_entry_gpg4win ("gpg.exe");
200        if (!p)
201            return (1);
202        if (file_exist_check (p)) {
203            free_if_alloc (p);
204            return (1);
205        }
206        free_if_alloc (p);
207    
208        p = get_reg_entry_gpg ("HomeDir");
209        if (!p || dir_exist_check (p) != 0) {
210            free_if_alloc (p);
211            p = multi_gnupg_path (0);
212        }
213        if (p && dir_exist_check (p)) {
214            memset (&sec_attr, 0, sizeof (sec_attr));
215            sec_attr.nLength = sizeof (sec_attr);
216            if (!CreateDirectory (p, &sec_attr)) {
217                msg_box (GetDesktopWindow (),
218                         _("Could not create GPG home directory"),
219                         _("WinPT Error"), MB_ERR);
220                free_if_alloc (p);
221                return (2);
222          }          }
         free_if_alloc (nls);  
         free_if_alloc (file);  
223      }      }
224        check_readonly_attr (p);
225        pkr = make_filename (p, "pubring", "gpg");
226        free_if_alloc (p);
227        if (get_file_size (pkr) == 0)
228            err = -1;
229        free_if_alloc (pkr);
230        return err;
231  }  }
232    
233    
234  /* 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
235     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
236  static int  static int
237  check_default_key (gpg_keycache_t kc)  check_default_key (void)
238  {  {
239      gpgme_key_t key;      gpgme_key_t key;
240      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
241      char * defkey;      gpg_keycache_t kc;
242        char *defkey;
243    
244        kc = keycache_get_ctx (0);
245      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
246      if (defkey)      if (defkey != NULL) {
247          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
248      else          if (err) {
249          msg_box (NULL, _("No useable secret key found."), _("WinPT Error"), MB_ERR);              free_if_alloc (defkey);
250      free_if_alloc (defkey);              return -1;
     return err? -1 : 0;  
 }  
   
   
 /* Return the WinPT program file name (with full pathname). */  
 static const char *  
 get_prog_part (const char * fname, int use_cwd)  
 {  
     static char program[512];  
     char currdir[256];  
     char *cmd = NULL;  
     int j;  
           
     memset (currdir, 0, DIM (currdir));  
     memset (program, 0, DIM (program));  
           
     if (use_cwd) {  
         GetCurrentDirectory (DIM (currdir)-1, currdir);  
         _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);  
     }  
     else {  
         cmd = GetCommandLine ();  
         if (cmd == NULL)  
             return NULL;  
         strncpy (currdir, cmd, sizeof (currdir)-1);  
         j = strlen (currdir);  
         while (j--) {  
             if (currdir[j] == '\\')  
                 break;  
251          }          }
         currdir[j] = 0;  
         _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);  
252      }      }
253      return program;      else {
254            /* Actually this is just a warning but we still continue. */
255            msg_box (GetDesktopWindow (), _("No useable secret key found."),
256                     _("WinPT Warning"), MB_WARN);
257            return 0;
258        }
259    
260        /* Because the secret key listing has no information
261           about the validity/status, we need to check the public key. */
262        kc = keycache_get_ctx (1);
263        if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
264            (key->revoked || key->expired)) {
265            msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
266                     _("WinPT Warning"), MB_ERR);
267            free_if_alloc (defkey);
268            return -1;
269        }
270        free_if_alloc (defkey);
271        return 0;
272  }  }
273    
274    
275  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
276     requirements so all commands work properly. */     requirements so all commands work properly. */
277  static int  static bool
278  check_crypto_engine (void)  check_crypto_engine (void)
279  {  {
280      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      int ma = 0, mi = 0, pa = 0;
281      int rc;      int rc;
282    
283      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
284      if (rc == -1) {      if (rc == -1) {
285          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (GetDesktopWindow (), _("Could not read GnuPG version."),
286                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
287          return rc;          return false;
288      }      }
289      else if (rc) {      else if (rc) {
290          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
291                   _("Sorry, you need a newer GPG version.\n"                   _("A newer GPG version is needed.\n"
292                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
293                     ma, mi, pa);                     ma, mi, pa);
294          return rc;          return false;
295      }      }
296      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */      
297      if ((ma == 1 && mi >= 4) || ma > 1)      // TODO: smart card support needs to be revamped
298        // and adjusted according to newer OpenPGP cards.
299        /*
300        if ((ma > 1 || pa >= 4) && pcsc_available ())
301          scard_support = 1;          scard_support = 1;
302        */
303        scard_support = 0;
304        
305      gpgver[0] = ma;      gpgver[0] = ma;
306      gpgver[1] = mi;      gpgver[1] = mi;
307      gpgver[2] = pa;      gpgver[2] = pa;
308      return rc;      return true;
309  }  }
310    
311    
312  /* Try to load the keyserver config file. If @quiet is 1  
313     do not show any errors. */  /* Check if both keyrings are empty. This indicates that
314  static int     WinPT should offer to generate a key pair. */
315  load_keyserver_conf (int quiet)  static bool
316    check_for_empty_keyrings (bool pub_only)
317  {  {
318      const char * t;      char *p;
319      int rc;      int n;
320    
321      if (reg_prefs.kserv_conf)      n=0;
322          t = reg_prefs.kserv_conf;      p = get_gnupg_keyring (1, 0);
323      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
324          t = get_prog_part ("keyserver.conf", 0);          n++;
325      else      free_if_alloc (p);
326          t = "keyserver.conf";      if (pub_only)
327      rc = kserver_load_conf (t);          return n == 1? true : false;
328      if (rc && !quiet)      p = get_gnupg_keyring (0, 0);
329          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
330      return rc;          n++;
331        free_if_alloc (p);
332        return n==2? true : false;
333  }  }
334    
335    
336  /* Enable the mobility mode. */  
337  static void  /* Display info message that WinPT is now in debug mode. */
338  enable_mobile_mode (void)  void
339    winpt_debug_msg (void)
340    {      
341        char output[512];
342        char temp[MAX_PATH+1];
343            
344        GetTempPath (DIM (temp) - 1, temp);
345        _snprintf (output, DIM (output)-1,
346            "The GPGME output file is %sgpgme.dbg\n"
347            "The WinPT output file is %swinpt.log\n", temp, temp);
348        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
349    }
350    
351    
352    /* Search for insecure ElGamal keys and return the
353       number of founded keys. */
354    static int
355    count_insecure_elgkeys (void)
356  {  {
357      memset (&reg_prefs, 0, sizeof (reg_prefs));      gpg_keycache_t pc;
358      reg_prefs.always_trust = 0;      gpgme_key_t key;
359      reg_prefs.auto_backup = 0;  
360      reg_prefs.cache_time = 0;      int n = 0;
361      reg_prefs.expert = 0;      pc = keycache_get_ctx (1);
362      reg_prefs.keylist_mode = 1;      while (!gpg_keycache_next_key (pc, 0, &key)) {
363      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
364      reg_prefs.no_zip_mmedia = 1;              n++;
365      reg_prefs.use_tmpfiles = 1;      }
366      reg_prefs.word_wrap = 80;      gpg_keycache_rewind (pc);
367      reg_prefs.use_viewer = 0; /* XXX */      return n;
368  }  }
369    
 char* multi_gnupg_path (void);  
370    
371  const char * fm_get_file_type (const char *fname, int *r_type);  /* Return 1 if the current OS version is at least Windows XP */
372    static int
373    check_os_version (void)
374    {
375        OSVERSIONINFOA osver;    
376        memset (&osver, 0, sizeof (osver));
377        osver.dwOSVersionInfoSize = sizeof (osver);
378            
379        if (!GetVersionEx (&osver)) {
380            MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
381            return 0;
382        }
383    
384        if (osver.dwMajorVersion < 5 ||
385            (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
386            MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
387            return 0;
388        }
389        
390        return 1;
391    }
392        
393  /* Main entry point. */  /* Main entry point. */
394  int WINAPI  int WINAPI
395  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
396  {  {
397      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};
398      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;  
399      MSG msg;      MSG msg;
400      HWND hwnd = NULL;      HWND hwnd = NULL;
401        WORD ver[3], ptdver[4];
402        
403        const char *s;
404        int rc, ec, created = 0;
405        int first_start = 0, start_gpgprefs = 0;
406        int winpt_inst_found = 0;
407        int start_manager = 0;    
408        
409        log_debug("check OS version");
410        if (!check_os_version ())
411            return 0;
412        
413      glob_hinst = hinst;      glob_hinst = hinst;
414        
415        /* Allow to shutdown the process, for instance by an installer */
416        if (cmdline && stristr (cmdline, "--stop")) {
417            hwnd = FindWindow ("WinPT", "WinPT");
418            if (hwnd != NULL) {
419                log_debug("shutdown an existing WinPT process");
420                PostMessage (hwnd, WM_DESTROY, 0, 0);
421            }
422            return 0;
423        }
424        
425        /* KLUDGE: test if the hooking is causing problems with some AV programs */
426        if (cmdline && stristr (cmdline, "--disable-hook"))
427            disable_hook = 1;
428            
429    
430  #ifdef _DEBUG      log_debug("check PTD and GPGME version");
431      gpg_set_debug_mode (1);      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
432      debug = 1;      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
433  #endif      if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1] || ptdver[2] != ver[2])) {
434            log_box (_("WinPT Error"), MB_ERR,
435      if (gpg_md_selftest ()) {                   _("The PTD.dll file has a different version than WinPT.exe\n"
436          msg_box (NULL, _("Cryptographic selftest failed."),                     "Please update the PTD.dll to version %d.%d.%d"),
437                   _("WinPT Error"), MB_ERR);                     ver[0], ver[1], ver[2]);
438          return 0;          return 0;
439      }      }
440    
441      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
442      if (!s || !*s) {      if (!s || !*s) {
443          msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),          msg_box (GetDesktopWindow (),
444                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
445                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
446          return 0;          return 0;
447      }      }
# Line 276  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 449  WinMain (HINSTANCE hinst, HINSTANCE hpre
449      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
450      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
451          winpt_inst_found = 1;          winpt_inst_found = 1;
452        
453        gettext_set_user_domain ();
454    
455      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
456          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 */  
     }  
457    
458      if (!created) {      if (!created) {
459          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 */  
460          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
461          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
462              hotkeys_modify ();          if (gnupg_load_config () == -2)
463          gnupg_load_config ();              msg_box (GetDesktopWindow (),
464                         _("The gpg.conf file contains the 'textmode' option\n"
465                           "which leads to broken binary output during decryption.\n"
466                           "If this is on purpose, just continue otherwise the option should be disabled."),
467                         _("WinPT Error"), MB_ERR);
468        }
469    
470        if (is_gpg4win_installed ()) {
471            log_debug("gpg4win: load gpg environment");
472            load_gpg_env (); /* TODO: check return code. */
473      }      }
474    
475      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
476      if (rc) {      if (rc) {  
477          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
478                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
479                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
480                   winpt_strerror (rc));                   winpt_strerror (rc));
481          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
482                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
483                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
484                                NULL);                                NULL);
485          if (s != NULL) {          
486              size_t n;          char * p;
487              char * p = strrchr (s, '\\');          if (s != NULL && (p = strrchr (s, '\\'))) {
488              if (!p)              char *path = substr (s, 0, (p-s));
489                  BUG (0);  
490              n = p - s;              set_reg_entry_gpg ("HomeDir", path);
491              if (n) {              free_if_alloc (path);
                 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 */  
             }  
492          }          }
493          else {          else {
494              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (GetDesktopWindow (),
495                         _("GPG home directory could not be determined."),
496                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
497              goto start;              goto start;
498          }          }
# Line 342  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 500  WinMain (HINSTANCE hinst, HINSTANCE hpre
500    
501      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
502      if (rc) {      if (rc) {
503          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
504                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
505                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
506                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
507                         MB_INFO|MB_YESNO) == IDYES)
508              start_gpgprefs = 1;              start_gpgprefs = 1;
509          else          else {
510          {              msg_box (GetDesktopWindow (),
511              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);                       winpt_strerror (rc), _("WinPT Error"), MB_ERR);
512              return 0;              return 0;
513          }          }
514      }      }
# Line 357  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 516  WinMain (HINSTANCE hinst, HINSTANCE hpre
516      rc = gnupg_access_files ();      rc = gnupg_access_files ();
517      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
518          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
519              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
520                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
521                    "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"
522                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
523                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
524              if (ec == IDYES)              if (ec == IDYES)
525                  first_start = 1;                  first_start = 1;
526          }          }
527          if (!first_start) {          if (!first_start) {
528              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
529              return 0;              return 0;
530          }          }
531      }      }
532        if (check_for_empty_keyrings (false))
533            first_start = 1;
534    
535      if (!first_start) {      if (!first_start) {
536          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
537          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
538              gpg_read_only = 1;              gpg_read_only = 1;
539          else if (rc)          else if (rc)
540              return 0;              return 0;
541      }      }
542        
     load_gettext (winpt_inst_found);  
543      init_gnupg_table ();      init_gnupg_table ();
544    
545      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
         free_gnupg_table ();  
         return 0;  
     }  
   
     if (cmdline && stristr (cmdline, "--wipe-freespace")) {  
         dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,  
                             GetDesktopWindow(), space_wipefrees_dlg_proc, 0,  
                             _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);  
546          free_gnupg_table ();          free_gnupg_table ();
547          return 0;          return 0;
548      }      }
549    
550      load_keyserver_conf (cmdline? 1 : 0);      rc = kserver_load_conf ();
551        if (rc)
552            msg_box (GetDesktopWindow (), winpt_strerror (rc),
553                     _("Keyserver"), MB_ERR);
554    
555      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
556                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
557          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
558               to open the key manager. Otherwise start a new instance. */
559            HWND tray = FindWindow ("WinPT", "WinPT");
560          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
561              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
562                              GetDesktopWindow(), keymanager_dlg_proc, 0,          else
563                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
564          else {          if (tray != NULL) {
565              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
566              if (crd)              free_gnupg_table ();
567                  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);  
568          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
569      }      }
570    
571      /* If we found another WinPT instance, just quit to avoid it      /* If we found another WinPT instance, just quit to avoid it
# Line 427  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 576  WinMain (HINSTANCE hinst, HINSTANCE hpre
576          return 0;          return 0;
577      }      }
578    
579      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
580          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
581              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
582              winpt_debug_msg ();          winpt_debug_msg ();
583              debug = 1;          debug = 1;
         }  
584      }      }
585    
586      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
587      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
588      if (rc == FALSE) {      if (rc == FALSE) {
589          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
590                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
591          free_gnupg_table ();          free_gnupg_table ();
592          return 0;          return 0;
# Line 452  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 600  WinMain (HINSTANCE hinst, HINSTANCE hpre
600                           hinst,                           hinst,
601                           NULL);                           NULL);
602      if (hwnd == NULL) {      if (hwnd == NULL) {
603          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
604                     _("Could not create window"),
605                     _("WinPT Error"), MB_ERR);
606          free_gnupg_table ();          free_gnupg_table ();
607          return 0;          return 0;
608      }      }
# Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 610  WinMain (HINSTANCE hinst, HINSTANCE hpre
610      UpdateWindow (hwnd);      UpdateWindow (hwnd);
611    
612      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
613            log_debug("backup gpg config file and check back-end");
614          gnupg_backup_options ();                  gnupg_backup_options ();        
615          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
616              DestroyWindow (hwnd);              DestroyWindow (hwnd);
617              free_gnupg_table ();              free_gnupg_table ();
618              return 0;              return 0;
# Line 470  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 620  WinMain (HINSTANCE hinst, HINSTANCE hpre
620      }      }
621            
622      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
   
623          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
624                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
625          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
626          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);  
627      }      }
628    
629      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
630          struct genkey_s c;          struct genkey_s c;
631            int choice;
632          HWND h;          HWND h;
633  start:  start:
634          h = GetDesktopWindow ();          h = GetDesktopWindow ();
635          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
636                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
637                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
638          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
639                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
640          switch (fs.choice) {          switch (choice) {
641          case SETUP_KEYGEN:          case SETUP_KEYGEN:
642              c.interactive = 1;              c.interactive = 1;
643              c.first_start = 1;              c.first_start = 1;
# Line 508  start: Line 655  start:
655              }              }
656              break;              break;
657    
658          case -1:          case SETUP_EXISTING:
659                rc = gnupg_import_keypair ();
660                if (rc) {
661                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
662                    goto start;
663                }
664                break;
665    
666            case SETUP_CARDGEN:
667                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
668                                     h, card_keygen_dlg_proc, 0);
669                if (!rc)
670                    goto start;
671                break;
672    
673            case 0: /* Cancel/Abort. */
674            default:
675              DestroyWindow (hwnd);              DestroyWindow (hwnd);
676              free_gnupg_table ();              free_gnupg_table ();
677              return 0;              return 0;
678          }          }
679          update_keycache (hwnd);          update_keycache (hwnd);
680          check_crypto_engine ();          if (!check_crypto_engine ()) {
681                DestroyWindow (hwnd);
682                free_gnupg_table ();
683                keycache_release (1);
684                return 0;
685            }
686      }      }
687      else {      else {
688          gpg_keycache_t c;          gpg_keycache_t c;
689          update_keycache (hwnd);          if (update_keycache (hwnd)) {
690                DestroyWindow (hwnd);
691                free_gnupg_table ();
692                keycache_release (1);
693                return 0;
694            }
695            /* XXX: rewrite this part. */
696          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
697          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
698              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
699                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
700                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
701              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"              ec = msg_box (GetDesktopWindow (),
702                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
703                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
704                              "WinPT", MB_INFO|MB_YESNO);
705              if (ec == IDYES) {              if (ec == IDYES) {
706                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
707                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 536  start: Line 710  start:
710              else {              else {
711                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
712                  free_gnupg_table ();                  free_gnupg_table ();
713                    keycache_release (1);
714                  return 0;                  return 0;
715              }              }
716          }          }      
717          if (check_default_key (c)) {          if (check_default_key ()) {
718              char * p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
719              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
720                       _("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"
721                         "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"
722                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
723                set_gnupg_default_key (NULL);
724              free_if_alloc (p);              free_if_alloc (p);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
725          }          }
726          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
727              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
728                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
729      }      }
730      
731        if (start_manager)
732            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
733    
734      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
735      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
# Line 563  start: Line 739  start:
739              DispatchMessage (&msg);              DispatchMessage (&msg);
740          }          }
741      }      }
742                
743      return 0;      return 0;
744  }  }
Legend:
Removed from v.73  
changed lines
  Added in v.415
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26