/[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 28 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 159 by twoaday, Wed Jan 18 13:57:31 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   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * WinPT is free software; you can redistribute it and/or modify
7   * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
8   * the Free Software Foundation; either version 2 of the License, or   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
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.
15   *   *
16   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19   */   */
20  #include <windows.h>  #ifdef HAVE_CONFIG_H
21    #include <config.h>
22  #include "../resource.h"  #endif
23  #include "wptTypes.h"  
24  #include "wptW32API.h"  #include <windows.h>
25  #include "wptVersion.h"  #include <shlobj.h>
26  #include "wptErrors.h"  
27  #include "wptGPG.h"  #include "resource.h"
28  #include "wptRegistry.h"  #include "wptTypes.h"
29  #include "wptCommonCtl.h"  #include "wptW32API.h"
30  #include "wptDlgs.h"  #include "wptVersion.h"
31  #include "wptNLS.h"  #include "wptErrors.h"
32  #include "wptKeyserver.h"  #include "wptGPG.h"
33  #include "wptCard.h"  #include "wptRegistry.h"
34  #include "wptFileManager.h"  #include "wptCommonCtl.h"
35  #include "wptContext.h"  #include "wptDlgs.h"
36  #include "wptCardEdit.h"  #include "wptNLS.h"
37    #include "wptKeyserver.h"
38  #define MIN_GPG_VER "1.4.3"  #include "wptCard.h"
39    #include "wptFileManager.h"
40  HINSTANCE glob_hinst;   /* global instance for the dialogs */  #include "wptContext.h"
41  HWND glob_hwnd;         /* global window handle for the dialogs */  #include "wptCardEdit.h"
42  HWND activ_hwnd;  #include "wptCrypto.h"
43  LOCK mo_file;  
44  int scard_support = 0;  
45  int debug = 0;  HINSTANCE glob_hinst;   /* global instance for the dialogs */
46  int mobile = 0;  HWND glob_hwnd;         /* global window handle for the dialogs */
47  int gpg_read_only = 0;  HWND activ_hwnd;
48  char gpgver[3];  int scard_support = 0;
49    int debug = 0;
50    int mobile = 0;
51  /* Load the key cache and rebuild the signature cache. */  int gpg_read_only = 0;
52  static void  char gpgver[3];
53  update_keycache (HWND hwnd)  
54  {  
55      refresh_cache_s rcs = {0};  /* Load the key cache and rebuild the signature cache. */
56      rcs.kr_reload = 0;  static void
57      rcs.kr_update = 1;  update_keycache (HWND hwnd)
58      rcs.tr_update = 1;  {
59      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      refresh_cache_s rcs = {0};
60                      keycache_dlg_proc, (LPARAM)&rcs);      rcs.kr_reload = 0;
61  }      rcs.kr_update = 1;
62        rcs.tr_update = 1;
63        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
64  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */                      keycache_dlg_proc, (LPARAM)&rcs);
65  void  }
66  gpg_set_debug_mode (int val)  
67  {        
68      if (val)  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
69          putenv ("GPGME_DEBUG=5:gpgme.dbg");  void
70      else  gpg_set_debug_mode (int val)
71          putenv ("GPGME_DEBUG=");  {      
72  }      if (val)
73            putenv ("GPGME_DEBUG=5:gpgme.dbg");
74  static char *      else
75  get_gettext_lang (void)          putenv ("GPGME_DEBUG=");
76  {      }
77      char * fname;  
78      fname = get_reg_entry_mo ();  
79      if (!fname)  /* Return the name of the gettext language file. */
80          return NULL;  static char*
81      return fname;  get_gettext_lang (void)
82  } /* get_gettext_lang */  {    
83        char *fname;
84        fname = get_reg_entry_mo ();
85  static void      if (!fname)
86  load_gettext (void)          return NULL;
87  {      return fname;
88      char *nls = NULL;  }
89      char *file = NULL;  
90    
91      nls = get_gettext_lang ();  /* Initialize the gettext sub system. */
92      if (nls) {  static void
93          set_gettext_file ("winpt", nls);  load_gettext (int prev_inst)
94          file = make_filename (nls, "winpt", "mo");  {
95          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {      char *nls = NULL;
96              msg_box (NULL, _("Could not initizalize file lock.\n"  
97                               "Native Language Support"),      nls = get_gettext_lang ();
98                       _("WinPT Error"), MB_ERR);      if (nls != NULL) {
99          }          set_gettext_file ("winpt", nls);
100          free_if_alloc (nls);          free_if_alloc (nls);
101          free_if_alloc (file);      }
102      }  }
103  } /* load_gettext */  
104    
105    /* Load the GPG environment. On the first start, some
106  /* check if the default key from the gpg.conf file is available in the     checks are performed to find out in what state GPG is.
107     keyring. if not, bail out because encryption won't work properly then. */     Return value: 0  everything OK.
108  static int                   >0  fatal error.
109  check_default_key (gpg_keycache_t kc)                   -1 public keyring is empty or does not exist. */
110  {  static int
111      gpgme_key_t key;  load_gpg_env (void)
112      gpgme_error_t err = GPG_ERR_NO_ERROR;  {
113      char * defkey;      SECURITY_ATTRIBUTES sec_attr;
114        char *p;
115      defkey = get_gnupg_default_key ();      char *pkr;
116      if (defkey)  
117          err = gpg_keycache_find_key (kc, defkey, 0, &key);      p = get_reg_entry_gpg4win ("gpg.exe");
118      free_if_alloc (defkey);      if (!p)
119      return err? -1 : 0;          return (1);
120  } /* check_default_key */      if (file_exist_check (p)) {
121            free_if_alloc (p);
122            return (1);
123  /* Return the WinPT program file name (with full pathname). */      }
124  static const char *      free_if_alloc (p);
125  get_prog_part (const char * fname, int use_cwd)      p = multi_gnupg_path (0);
126  {      if (p && dir_exist_check (p)) {
127      static char program[1024];          memset (&sec_attr, 0, sizeof (sec_attr));
128      char currdir[256], * cmd = NULL;          sec_attr.nLength = sizeof (sec_attr);
129      int j;          if (!CreateDirectory (p, &sec_attr)) {
130                        msg_box (NULL, _("Could not create GPG home directory"),
131      memset (currdir, 0, DIM (currdir));                       _("WinPT Error"), MB_ERR);
132      memset (program, 0, DIM (program));              free_if_alloc (p);
133                        return (2);
134      if (use_cwd) {          }
135          GetCurrentDirectory (DIM (currdir)-1, currdir);      }
136          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);      pkr = make_filename (p, "pubring", "gpg");
137      }      free_if_alloc (p);
138      else {      if (!pkr)
139          cmd = GetCommandLine ();          return -1;
140          if (cmd == NULL)      if (get_file_size (pkr) == 0) {
141              return NULL;          free_if_alloc (pkr);
142          strncpy (currdir, cmd, 255);          return -1;
143          j = strlen (currdir);      }
144          while (j--) {      return 0;
145              if (currdir[j] == '\\')  }
146                  break;            
147          }  
148          currdir[j] = 0;  /* check if the default key from the gpg.conf file is available in the
149          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);     keyring. if not, bail out because encryption won't work properly then. */
150      }  static int
151      return program;  check_default_key (gpg_keycache_t kc)
152  } /* get_prog_part */  {
153        gpgme_key_t key;
154        gpgme_error_t err = GPG_ERR_NO_ERROR;
155  static int      char *defkey;
156  check_crypto_engine (void)  
157  {      defkey = get_gnupg_default_key ();
158      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */      if (defkey)
159      int rc;          err = gpg_keycache_find_key (kc, defkey, 0, &key);
160        else
161      rc = check_gnupg_engine (&ma, &mi, &pa);          msg_box (NULL, _("No useable secret key found."),
162      if (rc == -1) {                   _("WinPT Error"), MB_ERR);
163          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);      free_if_alloc (defkey);
164          return rc;      return err? -1 : 0;
165      }  }
166      else if (rc) {  
167          log_box (_("WinPT Error"), MB_ERR,  
168                   _("Sorry, you need a newer GPG version.\n"  /* Return the WinPT program file name (with full pathname). */
169                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),  static const char*
170                     ma, mi, pa);  get_prog_part (const char * fname, int use_cwd)
171          return rc;  {
172      }      static char program[512];
173      /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */      char currdir[256];
174      if (ma >= 1 && mi >= 4)      char *cmd = NULL;
175          scard_support = 1;      int j;
176            
177      gpgver[0] = ma;      memset (currdir, 0, DIM (currdir));
178      gpgver[1] = mi;      memset (program, 0, DIM (program));
179      gpgver[2] = pa;          
180      return rc;      if (use_cwd) {
181  } /* check_crypto_engine */          GetCurrentDirectory (DIM (currdir)-1, currdir);
182            _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
183        }
184  static int      else {
185  load_keyserver_conf (int quiet)          cmd = GetCommandLine ();
186  {          if (cmd == NULL)
187      const char * t;              return NULL;
188      int rc;          strncpy (currdir, cmd, sizeof (currdir)-1);
189            j = strlen (currdir);
190      if (reg_prefs.kserv_conf)          while (j--) {
191          t = reg_prefs.kserv_conf;              if (currdir[j] == '\\')
192      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))                  break;
193          t = get_prog_part ("keyserver.conf", 0);          }
194      else          currdir[j] = 0;
195          t = "keyserver.conf";          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
196      rc = kserver_load_conf (t);      }
197      if (rc && !quiet)      return program;
198          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);  }
199      return rc;  
200  }  
201    /* Check that the underlying crypto engine fullfills the minimal
202       requirements so all commands work properly. */
203  static void  static bool
204  enable_mobile_mode (void)  check_crypto_engine (void)
205  {  {
206      memset (&reg_prefs, 0, sizeof (reg_prefs));      int ma=0, mi=0, pa=0;
207      reg_prefs.always_trust = 0;      int rc;
208      reg_prefs.auto_backup = 0;  
209      reg_prefs.cache_time = 0;      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
210      reg_prefs.expert = 0;      if (rc == -1) {
211      reg_prefs.keylist_mode = 1;          msg_box (NULL, _("Could not read GnuPG version."),
212      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");                   _("WinPT Error"), MB_ERR);
213      reg_prefs.no_zip_mmedia = 1;          return false;
214      reg_prefs.use_tmpfiles = 1;      }
215      reg_prefs.word_wrap = 80;      else if (rc) {
216      reg_prefs.use_viewer = 0; /* XXX */          log_box (_("WinPT Error"), MB_ERR,
217  }                   _("Sorry, you need a newer GPG version.\n"
218                       "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
219  char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);                     ma, mi, pa);
220            return false;
221        }
222  int WINAPI      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
223  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)      if (ma > 1 || pa >= 3)    
224  {          scard_support = 1;
225      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};  
226      HACCEL accel_tab;      gpgver[0] = ma;
227      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;      gpgver[1] = mi;
228      int first_start = 0, start_gpgprefs = 0;      gpgver[2] = pa;
229      const char * s;      return true;
230      MSG msg;  }
231      HWND hwnd = NULL;  
232    
233      glob_hinst = hinst;  /* Try to load the keyserver config file. If @quiet is 1
234       do not show any errors. */
235      #ifdef _DEBUG  static int
236      gpg_set_debug_mode (1);  load_keyserver_conf (int quiet)
237      debug = 1;  {
238      #endif      char *buf;
239        const char *t;
240      s = PTD_get_version ();      int rc;
241      if (strcmp (s, "0.8.0")) {  
242          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,      /* Create $APPDATA\winpt if needed. */
243                   _("Please update your PTD.dll to the newest version, "      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
244                     "the version (%s) you use is too old."), s);      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
245          return 0;          MessageBox (NULL, _("Failed to create WinPT directory"),
246      }                      _("Keyserver"), MB_ERR);
247            free_if_alloc (buf);
248      if (gpg_md_selftest ()) {          return -1;
249          msg_box (NULL, _("Cryptographic selftest failed."),      }
250                   _("WinPT Error"), MB_ERR);      free_if_alloc (buf);
251          return 0;  
252      }      /* Check for $APPDATA\winpt\keyserver.conf */
253        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
254      s = gpgme_check_version ("1.1.0");  
255      if (!s || !*s) {      if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
256          msg_box (NULL, _("A newer GPGME version is needed."), "WinPT Error", MB_ERR);          t = get_prog_part ("keyserver.conf", 0);
257          return 0;      else
258      }          t = "keyserver.conf";
259        if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
260      if (cmdline && stristr (cmdline, "--mobile")) {          //log_box (_("Keyserver"), MB_INFO,
261          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
262                   "WinPT", MB_INFO);          if (!CopyFile (t, buf, FALSE)) {
263          mobile = 1;              MessageBox (NULL, _("Failed to copy the keyserver.conf"),
264      }                          _("Keyserver"), MB_ERR);
265                free_if_alloc (buf);
266      set_default_kserver ();              return -1;
267            }
268      if (!mobile) {          t = buf;
269          regist_inst_gnupg (1);      }
270          regist_inst_winpt (1, &created);      else
271      }          t = buf;
272      else {      
273          enable_mobile_mode ();      rc = kserver_load_conf (t);
274          /* XXX: ask for GPG path */      if (rc && !quiet)
275          created = 1; /* Disable registry writing */          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
276      }      else {
277            free_if_alloc (reg_prefs.kserv_conf);
278      if (!created) {          reg_prefs.kserv_conf = m_strdup (t);
279          memset (&reg_prefs, 0, sizeof (reg_prefs));      }
280          reg_prefs.use_tmpfiles = 1; /* default */      free_if_alloc (buf);
281          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */      return rc;
282          get_reg_winpt_prefs (&reg_prefs);  }
283          if (!reg_prefs.no_hotkeys)  
284              hotkeys_modify ();  
285      }  /* Check if both keyrings are empty. This indicates that
286       WinPT should offer to generate a key pair. */
287      rc = gnupg_check_homedir ();  static bool
288      if (rc) {  check_for_empty_keyrings (bool pub_only)
289          log_box (_("WinPT Error"), MB_ERR,  {
290                   _("GPG home directory is not set correctly.\n"      char *p;
291                     "Please check the GPG registry settings:\n%s."),      int n = 0;
292                   winpt_strerror (rc));  
293          const char * s = get_fileopen_dlg (GetActiveWindow (),      p = get_gnupg_keyring (1, 0);
294                                             _("Select GPG Public Keyring"),      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
295                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),          n++;
296                                             NULL);      free_if_alloc (p);
297          if (s != NULL) {      if (pub_only)
298              size_t n;          return n == 1? true : false;
299              char * p = strrchr (s, '\\');      p = get_gnupg_keyring (0, 0);
300              if (!p)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
301                  BUG (0);          n++;
302              n = p - s;      free_if_alloc (p);
303              if (n)      return n==2? true : false;
304              {  }
305                  char * file = new char[n+1];  
306                  if (!file)  
307                      BUG (NULL);  /* Enable the mobility mode. */
308                  memset (file, 0, n);  static void
309                  memcpy (file, s, n);  enable_mobile_mode (void)
310                  file[n] = '\0';          {
311                  set_reg_entry_gpg ("HomeDir", file);      memset (&reg_prefs, 0, sizeof (reg_prefs));
312                  free_if_alloc (file);      reg_prefs.always_trust = 0;
313                  gnupg_check_homedir (); /* change gpgProgram if needed */      reg_prefs.auto_backup = 0;
314              }      reg_prefs.cache_time = 0;
315          }      reg_prefs.expert = 0;
316          else {      reg_prefs.keylist_mode = 1;
317              msg_box (NULL, _("GPG home directory could not be determited."),      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
318                       _("WinPT Error"), MB_ERR);      reg_prefs.no_zip_mmedia = 1;
319              goto start;      reg_prefs.use_tmpfiles = 1;
320          }      reg_prefs.word_wrap = 80;
321      }      reg_prefs.use_viewer = 0; /* XXX */
322    }
323      rc = check_gnupg_prog ();  
324      if (rc) {  
325          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"  /* Main entry point. */
326                               "Do you want to start the GPG preferences to "  int WINAPI
327                               "correct  this problem?"), _("WinPT Error"),  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
328                               MB_INFO|MB_YESNO) == IDYES)  {
329              start_gpgprefs = 1;      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
330          else      HACCEL accel_tab;
331          {      MSG msg;
332              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);      HWND hwnd = NULL;
333              return 0;      WORD ver[3], ptdver[4];
334          }      int rc, ec, created = 0;
335      }      int first_start = 0, start_gpgprefs = 0;
336        int winpt_inst_found = 0;
337      rc = gnupg_access_files ();      int start_manager = 0;
338      if (!start_gpgprefs && rc)      const char *s;
339      {  
340          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)      glob_hinst = hinst;
341          {      if (cmdline && stristr (cmdline, "--stop")) {
342              ec = msg_box (NULL,          hwnd = FindWindow ("WinPT", "WinPT");
343                  _("Could not access and/or find the public and secret keyring.\n"          if (hwnd != NULL)
344                    "If this is an accident, quit the program and fix it.\n\n"              PostMessage (hwnd, WM_DESTROY, 0, 0);
345                    "Continue if you want that WinPT offers you more choices.\n"),          return 0;
346                    "WinPT", MB_INFO|MB_YESNO);      }
347              if (ec == IDYES)  
348                  first_start = 1;      /*
349          }      OSVERSIONINFO osinf;
350          if (!first_start)      memset (&osinf, 0, sizeof (osinf));
351          {      if (GetVersionEx (&osinf) &&
352              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
353              return 0;          osinf.dwMinorVersion == 0) {
354          }          msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
355      }                   "WinPT Warning", MB_INFO);
356        }
357      if (!first_start)      */
358      {  
359          rc = gpg_check_permissions (1);      #ifdef _DEBUG
360          if (rc && rc == 2)      gpg_set_debug_mode (1);
361              gpg_read_only = 1;      debug = 1;
362          else if (rc)      #endif
363              return 0;  
364      }      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
365        get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
366      load_gettext ();                                   &ptdver[2], &ptdver[3]);
367      init_gnupg_table ();      /* XXX
368        if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
369      nfiles = fm_parse_command_line (cmdline);          log_box (_("WinPT Error"), MB_ERR,
370      if (nfiles > 0)                   _("The PTD.dll file has a different version than WinPT.exe\n"
371          return 0;                     "Please update the PTD.dll to version %d.%d.%d"),
372                       ver[0], ver[1], ver[2]);
373      if (cmdline && stristr (cmdline, "--wipe-freespace")) {          return 0;
374          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      }
375                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,      */
376                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);  
377          free_gnupg_table ();      if (gpg_md_selftest ()) {
378          return 0;          msg_box (NULL, _("Cryptographic selftest failed."),
379      }                   _("WinPT Error"), MB_ERR);
380            return 0;
381      load_keyserver_conf (cmdline? 1 : 0);      }
382    
383      if (cmdline && (stristr (cmdline, "--keymanager")      s = gpgme_check_version (NEED_GPGME_VERSION);
384                  || stristr (cmdline, "--cardmanager"))) {      if (!s || !*s) {
385          update_keycache (GetDesktopWindow ());          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
386          if (stristr (cmdline, "keymanager"))                   _("WinPT Error"), MB_ERR);
387              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,          return 0;
388                              GetDesktopWindow(), keymanager_dlg_proc, NULL,      }
389                              _("Key Manager"), IDS_WINPT_KEYMISC);    
390          else {      CreateMutex (NULL, TRUE, PGM_NAME);
391              gpg_card_t crd = gpg_card_load ();      if (GetLastError () == ERROR_ALREADY_EXISTS)
392              if (crd)          winpt_inst_found = 1;
393                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,  
394                                    GetDesktopWindow(), card_edit_dlg_proc,      if (cmdline && stristr (cmdline, "--mobile")) {
395                                    (LPARAM)crd, _("Card Manager"),          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
396                                    IDS_WINPT_CARD_EDIT);                   "WinPT", MB_INFO);
397              gpg_card_release (crd);          mobile = 1;
398          }      }
399          keycache_release (0);  
400          free_gnupg_table ();      set_default_kserver ();
401          return 0;      load_gettext (winpt_inst_found);
402      }  
403        if (!mobile) {
404      CreateMutex (NULL, TRUE, PGM_NAME);          regist_inst_gnupg (1);
405      if (GetLastError () == ERROR_ALREADY_EXISTS) {          regist_inst_winpt (1, &created);
406          free_gnupg_table ();      }
407          return 0;      else {
408      }          enable_mobile_mode ();
409            /* XXX: ask for GPG path */
410      if (cmdline) {          created = 1; /* Disable registry writing */
411          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      }
412              gpg_set_debug_mode (1);  
413              winpt_debug_msg ();      if (!created) {
414              debug = 1;          memset (&reg_prefs, 0, sizeof (reg_prefs));
415          }          reg_prefs.use_tmpfiles = 1; /* default */
416      }          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
417            get_reg_winpt_prefs (&reg_prefs);
418      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));          if (!reg_prefs.no_hotkeys)
419      rc = RegisterClass (&wc);              hotkeys_modify ();
420      if (rc == FALSE) {          gnupg_load_config ();
421          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);      }
422          free_gnupg_table ();  
423          return 0;      if (is_gpg4win_installed ())
424      }          load_gpg_env (); /* XXX: check return code. */
425    
426      hwnd = CreateWindow (PGM_NAME,      rc = gnupg_check_homedir ();
427                           PGM_NAME,      if (rc) {
428                           0, 0, 0, 0, 0,          log_box (_("WinPT Error"), MB_ERR,
429                           NULL,                   _("GPG home directory is not set correctly.\n"
430                           NULL,                     "Please check the GPG registry settings:\n%s."),
431                           hinst,                   winpt_strerror (rc));
432                           NULL);          s = get_fileopen_dlg (GetActiveWindow (),
433      if (hwnd == NULL) {                                _("Select GPG Public Keyring"),
434          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
435          free_gnupg_table ();                                NULL);
436          return 0;          if (s != NULL) {
437      }              size_t n;
438      glob_hwnd = hwnd;              char *p = strrchr (s, '\\');
439      UpdateWindow (hwnd);              if (!p)
440                    BUG (0);
441      if (!first_start && !start_gpgprefs) {              n = p - s;
442          gnupg_backup_options ();                      if (n) {
443          rc = check_crypto_engine ();                  char *file = new char[n+1];
444          if (rc) {                  if (!file)
445              DestroyWindow (hwnd);                      BUG (NULL);
446              free_gnupg_table ();                  memset (file, 0, n);
447              return 0;                  memcpy (file, s, n);
448          }                  file[n] = '\0';        
449      }                  set_reg_entry_gpg ("HomeDir", file);
450                        free_if_alloc (file);
451      if (start_gpgprefs) {                  gnupg_check_homedir (); /* change gpgProgram if needed */
452          char *ring;              }
453          size_t size = 0;          }
454          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          else {
455                          gpgprefs_dlg_proc, NULL);              msg_box (NULL, _("GPG home directory could not be determited."),
456          ring = get_gnupg_keyring (0, !NO_STRICT);                       _("WinPT Error"), MB_ERR);
457          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)              goto start;
458              first_start = 1; /* The keyring is empty! */          }
459          free_if_alloc (ring);      }
460      }  
461        rc = check_gnupg_prog ();
462      if (first_start) {      if (rc) {
463          struct first_start_s fs;          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
464          struct genkey_s c;                               "Do you want to start the GPG preferences to "
465          HWND h;                               "correct  this problem?"), _("WinPT Error"),
466  start:                               MB_INFO|MB_YESNO) == IDYES)
467          h = GetDesktopWindow ();              start_gpgprefs = 1;
468          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          else {
469                              gpgprefs_dlg_proc, NULL);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
470          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,              return 0;
471                          first_run_dlg_proc, (LPARAM)&fs);          }
472          switch (fs.choice) {      }
473          case SETUP_KEYGEN:  
474              c.interactive = 1;      rc = gnupg_access_files ();
475              c.first_start = 1;      if (!start_gpgprefs && rc) {
476              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
477                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);              ec = msg_box (NULL,
478              if (!rc)                  _("Could not access and/or find the public and secret keyring.\n"
479                  goto start;                    "If this is an accident, quit the program and fix it.\n\n"
480              break;                    "Continue if you want that WinPT offers you more choices.\n"),
481                      "WinPT", MB_INFO|MB_YESNO);
482          case SETUP_IMPORT:              if (ec == IDYES)
483              rc = gnupg_copy_keyrings ();                  first_start = 1;
484              if (rc) {          }
485                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          if (!first_start) {
486                  goto start;              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
487              }              return 0;
488              break;          }
489        }
490          case -1:      if (check_for_empty_keyrings (false))
491              DestroyWindow (hwnd);          first_start = 1;
492              free_gnupg_table ();  
493              return 0;      if (!first_start) {
494          }          rc = gpg_check_permissions (1);
495          update_keycache (hwnd);          if (rc && rc == 2)
496          check_crypto_engine ();              gpg_read_only = 1;
497      }          else if (rc)
498      else {              return 0;
499          gpg_keycache_t c;      }
500          update_keycache (hwnd);      
501          c = keycache_get_ctx (1);      init_gnupg_table ();
502          if (!c || !gpg_keycache_get_size (c)) {  
503              gnupg_display_error ();      if (fm_parse_command_line (cmdline) > 0) {
504              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"          free_gnupg_table ();
505                               "Please check your GPG config (keyrings, pathes...)"),          return 0;
506                               _("WinPT Error"), MB_ERR);      }
507              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"  
508                                    "Do you want to start the GPG preferences dialog?"),      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
509                              "WinPT", MB_INFO|MB_YESNO);          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
510              if (ec == IDYES) {                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
511                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
512                                  gpgprefs_dlg_proc, NULL);          free_gnupg_table ();
513                  update_keycache (hwnd);          return 0;
514              }      }
515              else {  
516                  DestroyWindow (hwnd);      load_keyserver_conf (cmdline? 1 : 0);
517                  free_gnupg_table ();  
518                  return 0;      if (cmdline && (stristr (cmdline, "--keymanager")
519              }                  || stristr (cmdline, "--cardmanager"))) {
520          }          /* If an instance of WinPT is running, just send the command
521          if (check_default_key (c)) {             to open the key manager. Otherwise start a new instance.
522              char * p = get_gnupg_default_key ();           */
523              log_box (_("WinPT Error"), MB_ERR,          HWND tray = FindWindow ("WinPT", "WinPT");
524                       _("Default key from the GPG options file could not be found.\n"          if (stristr (cmdline, "keymanager"))
525                         "Please check your gpg.conf (options) to correct this:\n\n"              start_manager = ID_WINPT_KEY;
526                         "%s: public key not found."), p? p : "[null]");          else
527              free_if_alloc (p);              start_manager = ID_WINPT_CARD;
528              DestroyWindow (hwnd);          if (tray != NULL) {
529              free_gnupg_table ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
530              return 0;              free_gnupg_table ();
531          }              return 0;
532          if (count_insecure_elgkeys ())          }
533              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,      }
534                              elgamal_warn_dlg_proc, NULL);  
535      }      /* If we found another WinPT instance, just quit to avoid it
536           will be executed twice. */
537      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      if (winpt_inst_found) {
538      keyring_check_last_access (); /* init */          log_debug ("%s", "WinMain: WinPT is already running.");
539      while (GetMessage (&msg, hwnd, 0, 0)) {          free_gnupg_table ();
540          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {          return 0;
541              TranslateMessage (&msg);      }
542              DispatchMessage (&msg);  
543          }      if (cmdline) {
544      }          if (stristr (cmdline, "--enable-debug") ||
545                        stristr (cmdline, "--debug")) {
546      return 0;              gpg_set_debug_mode (1);
547  } /* WinMain */              winpt_debug_msg ();
548                debug = 1;
549            }
550        }
551    
552        wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
553        rc = RegisterClass (&wc);
554        if (rc == FALSE) {
555            msg_box (NULL, _("Could not register window class"),
556                     _("WinPT Error"), MB_ERR);
557            free_gnupg_table ();
558            return 0;
559        }
560    
561        hwnd = CreateWindow (PGM_NAME,
562                             PGM_NAME,
563                             0, 0, 0, 0, 0,
564                             NULL,
565                             NULL,
566                             hinst,
567                             NULL);
568        if (hwnd == NULL) {
569            msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
570            free_gnupg_table ();
571            return 0;
572        }
573        glob_hwnd = hwnd;
574        UpdateWindow (hwnd);
575    
576        if (!first_start && !start_gpgprefs) {
577            gnupg_backup_options ();        
578            if (!check_crypto_engine ()) {
579                DestroyWindow (hwnd);
580                free_gnupg_table ();
581                return 0;
582            }
583        }
584        
585        if (start_gpgprefs) {
586            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
587                            gpgprefs_dlg_proc, 0);
588            if (check_for_empty_keyrings (true))
589                first_start = 1; /* The public keyring is empty! */
590        }
591    
592        if (first_start) {
593            struct first_start_s fs;
594            struct genkey_s c;
595            HWND h;
596    start:
597            h = GetDesktopWindow ();
598            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
599                                gpgprefs_dlg_proc, 0);
600            DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
601                            first_run_dlg_proc, (LPARAM)&fs);
602            switch (fs.choice) {
603            case SETUP_KEYGEN:
604                c.interactive = 1;
605                c.first_start = 1;
606                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
607                                     h, keygen_wizard_dlg_proc, (LPARAM)&c);
608                if (!rc)
609                    goto start;
610                break;
611    
612            case SETUP_IMPORT:
613                rc = gnupg_copy_keyrings ();
614                if (rc) {
615                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
616                    goto start;
617                }
618                break;
619    
620            case -1: /* Cancel/Abort. */
621                DestroyWindow (hwnd);
622                free_gnupg_table ();
623                return 0;
624            }
625            update_keycache (hwnd);
626            check_crypto_engine ();
627        }
628        else {
629            gpg_keycache_t c;
630            update_keycache (hwnd);
631            c = keycache_get_ctx (1);
632            if (!c || !gpg_keycache_get_size (c)) {
633                gnupg_display_error ();
634                msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
635                                 "Please check your GPG config (keyrings, pathes...)"),
636                                 _("WinPT Error"), MB_ERR);
637                ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
638                                      "Do you want to start the GPG preferences dialog?"),
639                                "WinPT", MB_INFO|MB_YESNO);
640                if (ec == IDYES) {
641                    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
642                                    gpgprefs_dlg_proc, 0);
643                    update_keycache (hwnd);
644                }
645                else {
646                    DestroyWindow (hwnd);
647                    free_gnupg_table ();
648                    return 0;
649                }
650            }
651            if (check_default_key (c)) {
652                char *p = get_gnupg_default_key ();
653                log_box (_("WinPT Error"), MB_ERR,
654                         _("Default key from the GPG options file could not be found.\n"
655                           "Please check your gpg.conf (options) to correct this:\n\n"
656                           "%s: public key not found."), p? p : "[null]");
657                free_if_alloc (p);
658                DestroyWindow (hwnd);
659                free_gnupg_table ();
660                return 0;
661            }
662            if (count_insecure_elgkeys ())
663                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
664                                elgamal_warn_dlg_proc, 0);
665        }
666    
667        if (start_manager)
668            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
669    
670        accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
671        keyring_check_last_access (); /* init */
672        while (GetMessage (&msg, hwnd, 0, 0)) {
673            if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
674                TranslateMessage (&msg);
675                DispatchMessage (&msg);
676            }
677        }
678            
679        return 0;
680    }
Legend:
Removed from v.28  
changed lines
  Added in v.159
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26