/[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 25 by twoaday, Wed Oct 12 10:04:26 2005 UTC revision 270 by twoaday, Sat Oct 21 18:08:57 2006 UTC
# Line 1  Line 1 
1  /* WinPT.cpp - Windows Privacy Tray (WinPT)  /* WinPT.cpp - Windows Privacy Tray (WinPT)
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
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  HINSTANCE glob_hinst; /* global instance for the dialogs */  #include "wptCard.h"
39  HWND glob_hwnd; /* global window handle for the dialogs */  #include "wptFileManager.h"
40  HWND activ_hwnd;  #include "wptContext.h"
41  LOCK mo_file;  #include "wptCardEdit.h"
42  int scard_support = 0;  #include "wptCrypto.h"
43  int debug = 0;  #include "wptUTF8.h"
44  int mobile = 0;  
45  int gpg_read_only = 0;  void remove_crit_file_attrs (const char *fname, int force);
46  char gpgver[3];  BOOL user_is_admin (void);
47    extern "C" int  pcsc_available (void);
48  static void  
49  update_keycache (HWND hwnd)  /* Global variables. */
50  {  HINSTANCE glob_hinst;   /* global instance for the dialogs */
51      refresh_cache_s rcs = {0};  HWND glob_hwnd;         /* global window handle for the dialogs */
52      rcs.kr_reload = 0;  int scard_support = 0;
53      rcs.kr_update = 1;  int debug = 0;
54      rcs.tr_update = 1;  int mobile_mode_active = 0;
55      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  int gpg_read_only = 0;
56                      keycache_dlg_proc, (LPARAM)&rcs);  int admin_user = 0;
57  } /* update_keycache */  char gpgver[3];
58    /* End */
59    
60  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */  
61  void  /* Load the key cache and rebuild the signature cache. */
62  gpg_set_debug_mode (int val)  int
63  {        update_keycache (HWND hwnd)
64      if (val)  {
65          putenv ("GPGME_DEBUG=5:gpgme.dbg");      int err;
66      else  
67          putenv ("GPGME_DEBUG=");      refresh_cache_s rcs = {0};
68  }      rcs.kr_reload = 0;
69        rcs.kr_update = 1;
70  static char *      rcs.tr_update = 1;
71  get_gettext_lang (void)      err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
72  {                          keycache_dlg_proc, (LPARAM)&rcs);
73      char * fname;      if (err) {
74      fname = get_reg_entry_mo ();          char *cfgf = get_gnupg_config ();
75      if (!fname)          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
76          return NULL;              msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
77      return fname;          free_if_alloc (cfgf);
78  } /* get_gettext_lang */          return -1;
79        }
80        return 0;
81  static void  }
82  load_gettext (void)  
83  {  
84      char *nls = NULL;  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
85      char *file = NULL;  void
86    gpg_set_debug_mode (int val)
87      nls = get_gettext_lang ();  {
88      if (nls) {      static char buf[256];
89          set_gettext_file ("winpt", nls);      char tmp[128];
90          file = make_filename (nls, "winpt", "mo");      
91          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {      /* XXX: no gpgme.dbg is created. */
92              msg_box (NULL, _("Could not initizalize file lock.\n"      if (val > 0) {
93                               "Native Language Support"),          GetTempPath (sizeof (tmp)-1, tmp);
94                       _("WinPT Error"), MB_ERR);          _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
95          }          putenv (buf);
96          free_if_alloc (nls);      }
97          free_if_alloc (file);      else
98      }          putenv ("GPGME_DEBUG=");
99  } /* load_gettext */  }
100    
101    
102  /* check if the default key from the gpg.conf file is available in the  /* Initialize the gettext sub system. */
103     keyring. if not, bail out because encryption won't work properly then. */  static void
104  static int  load_gettext (void)
105  check_default_key (gpg_keycache_t kc)  {
106  {      char *nls;
107      gpgme_key_t key;  
108      gpgme_error_t err = GPG_ERR_NO_ERROR;      /* Return the name of the gettext language file. */
109      char * defkey;      nls = get_reg_entry_mo ();
110        if (nls != NULL) {
111      defkey = get_gnupg_default_key ();          set_gettext_file ("winpt", nls);
112      if (defkey)          free_if_alloc (nls);
113          err = gpg_keycache_find_key (kc, defkey, 0, &key);      }
114      free_if_alloc (defkey);  }
115      return err? -1 : 0;  
116  } /* check_default_key */  
117    /* Return true if the GPG environment is useable. */
118    static bool
119  /* Return the WinPT program file name (with full pathname). */  gpg_prefs_ok (void)
120  static const char *  {
121  get_prog_part (const char * fname, int use_cwd)      char *p;
122  {  
123      static char program[1024];      p = get_reg_entry_gpg4win ("gpg.exe");
124      char currdir[256], * cmd = NULL;      if (!p || file_exist_check (p) != 0) {
125      int j;          free_if_alloc (p);
126                    p = get_reg_entry_gpg ("gpgProgram");
127      memset (currdir, 0, DIM (currdir));          if (!p || file_exist_check (p) != 0) {
128      memset (program, 0, DIM (program));              free_if_alloc (p);
129                        log_debug ("gpg_prefs_ok: could not locate gpg.exe");
130      if (use_cwd) {              return false;
131          GetCurrentDirectory (DIM (currdir)-1, currdir);          }
132          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);      }
133      }      free_if_alloc (p);
134      else {      p = get_reg_entry_gpg4win (NULL);
135          cmd = GetCommandLine ();      if (!p || dir_exist_check (p) != 0) {
136          if (cmd == NULL)          free_if_alloc (p);
137              return NULL;          p = get_reg_entry_gpg ("HomeDir");
138          strncpy (currdir, cmd, 255);          if (!p || dir_exist_check (p) != 0) {
139          j = strlen (currdir);              free_if_alloc (p);
140          while (j--) {              log_debug ("gpg_prefs_ok: could not determine home directory");
141              if (currdir[j] == '\\')              return false;
142                  break;                    }
143          }      }
144          currdir[j] = 0;      free_if_alloc (p);
145          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);      return true;
146      }  }
147      return program;  
148  } /* get_prog_part */  
149    /* Check gpg files if they are read-only and ask the user
150       if this should be corrected. */
151  static int  static void
152  check_crypto_engine (void)  check_readonly_attr (const char *homedir)
153  {  {
154      int ma=1, mi=4, pa=0; /* GPG 1.4.0 */      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
155      int rc;      char *file;
156        int i;
157      rc = check_gnupg_engine (&ma, &mi, &pa);  
158      if (rc == -1) {      for (i=0; files[i] != NULL; i++) {
159          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);          file = make_filename (homedir, files[i], NULL);
160          return rc;          remove_crit_file_attrs (file, 0);
161      }          free_if_alloc (file);
162      else if (rc) {      }
163          log_box (_("WinPT Error"), MB_ERR,  }
164                   _("Sorry, you need a newer GPG version.\n"  
165                     "GPG version %d.%d.%d required GPG version 1.4.0"),  
166                     ma, mi, pa);  /* Load the GPG environment. On the first start, some
167          return rc;     checks are performed to find out in what state GPG is.
168      }     Return value: 0  everything OK.
169      /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */                   >0  fatal error.
170      if (ma >= 1 && mi >= 4)                   -1 public keyring is empty or does not exist. */
171          scard_support = 1;  static int
172    load_gpg_env (void)
173      gpgver[0] = ma;  {
174      gpgver[1] = mi;      SECURITY_ATTRIBUTES sec_attr;
175      gpgver[2] = pa;      char *p;
176      return rc;      char *pkr;
177  } /* check_crypto_engine */      int err = 0;
178    
179        p = get_reg_entry_gpg4win ("gpg.exe");
180  static int      if (!p)
181  load_keyserver_conf (int quiet)          return (1);
182  {      if (file_exist_check (p)) {
183      const char * t;          free_if_alloc (p);
184      int rc;          return (1);
185        }
186      if (reg_prefs.kserv_conf)      free_if_alloc (p);
187          t = reg_prefs.kserv_conf;  
188      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      p = get_reg_entry_gpg ("HomeDir");
189          t = get_prog_part ("keyserver.conf", 0);      if (!p || dir_exist_check (p) != 0) {
190      else          free_if_alloc (p);
191          t = "keyserver.conf";          p = multi_gnupg_path (0);
192      rc = kserver_load_conf (t);      }
193      if (rc && !quiet)      if (p && dir_exist_check (p)) {
194          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          memset (&sec_attr, 0, sizeof (sec_attr));
195      return rc;          sec_attr.nLength = sizeof (sec_attr);
196  }          if (!CreateDirectory (p, &sec_attr)) {
197                msg_box (NULL, _("Could not create GPG home directory"),
198                         _("WinPT Error"), MB_ERR);
199  static void              free_if_alloc (p);
200  enable_mobile_mode (void)              return (2);
201  {          }
202      memset (&reg_prefs, 0, sizeof (reg_prefs));      }
203      reg_prefs.always_trust = 0;      check_readonly_attr (p);
204      reg_prefs.auto_backup = 0;      pkr = make_filename (p, "pubring", "gpg");
205      reg_prefs.cache_time = 0;      free_if_alloc (p);
206      reg_prefs.expert = 0;      if (get_file_size (pkr) == 0)
207      reg_prefs.keylist_mode = 1;          err = -1;
208      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      free_if_alloc (pkr);
209      reg_prefs.no_zip_mmedia = 1;      return err;
210      reg_prefs.use_tmpfiles = 1;  }
211      reg_prefs.word_wrap = 80;  
212      reg_prefs.use_viewer = 0; /* XXX */  
213  }  /* check if the default key from the gpg.conf file is available in the
214       keyring. if not, bail out because encryption won't work properly then. */
215  char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);  static int
216    check_default_key (gpg_keycache_t kc)
217  int WINAPI  {
218        gpgme_key_t key;
219  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
220  {      char *defkey;
221      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};  
222      HACCEL accel_tab;      defkey = get_gnupg_default_key ();
223      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;      if (defkey)
224      int first_start = 0, start_gpgprefs = 0;          err = gpg_keycache_find_key (kc, defkey, 0, &key);
225      const char * s;      else
226      MSG msg;          msg_box (NULL, _("No useable secret key found."),
227      HWND hwnd = NULL;                   _("WinPT Warning"), MB_WARN);
228        free_if_alloc (defkey);
229      glob_hinst = hinst;      return err? -1 : 0;
230    }
231      #ifdef _DEBUG  
232      gpg_set_debug_mode (1);  
233      debug = 1;  /* Return the WinPT program file name (with full pathname). */
234      #endif  static const char*
235    get_prog_part (const char * fname, int use_cwd)
236      s = PTD_get_version ();  {
237      if (strcmp (s, "0.8.0")) {      static char program[2*MAX_PATH+1];
238          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,      char currdir[MAX_PATH+1];
239                   _("Please update your PTD.dll to the newest version, "      char *cmd = NULL;
240                     "the version (%s) you use is too old."), s);      int j;
241          return 0;          
242      }      memset (currdir, 0, DIM (currdir));
243        memset (program, 0, DIM (program));
244      if (gpg_md_selftest ()) {          
245          msg_box (NULL, _("Cryptographic selftest failed."),      if (use_cwd) {
246                   _("WinPT Error"), MB_ERR);          GetCurrentDirectory (DIM (currdir)-1, currdir);
247          return 0;          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
248      }      }
249        else {
250      s = gpgme_check_version ("1.1.0");          cmd = GetCommandLine ();
251      if (!s || !*s) {          if (!cmd)
252          msg_box (NULL, _("A newer GPGME version is needed."), "WinPT Error", MB_ERR);              return NULL;
253          return 0;          strncpy (currdir, cmd, sizeof (currdir)-1);
254      }          j = strlen (currdir);
255            while (j--) {
256      if (cmdline && stristr (cmdline, "--mobile")) {              if (currdir[j] == '\\')
257          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",                  break;
258                   "WinPT", MB_INFO);          }
259          mobile = 1;          currdir[j] = 0;
260      }          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
261        }
262      set_default_kserver ();      return program;
263    }
264      if (!mobile) {  
265          regist_inst_gnupg (1);  
266          regist_inst_winpt (1, &created);  /* Check that the underlying crypto engine fullfills the minimal
267      }     requirements so all commands work properly. */
268      else {  static bool
269          enable_mobile_mode ();  check_crypto_engine (void)
270          /* XXX: ask for GPG path */  {
271          created = 1; /* Disable registry writing */      int ma = 0, mi = 0, pa = 0;
272      }      int rc;
273    
274      if (!created) {      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
275          memset (&reg_prefs, 0, sizeof (reg_prefs));      if (rc == -1) {
276          reg_prefs.use_tmpfiles = 1; /* default */          msg_box (NULL, _("Could not read GnuPG version."),
277          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */                   _("WinPT Error"), MB_ERR);
278          get_reg_winpt_prefs (&reg_prefs);          return false;
279          if (!reg_prefs.no_hotkeys)      }
280              hotkeys_modify ();      else if (rc) {
281      }          log_box (_("WinPT Error"), MB_ERR,
282                     _("Sorry, you need a newer GPG version.\n"
283      rc = gnupg_check_homedir ();                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
284      if (rc) {                     ma, mi, pa);
285          log_box (_("WinPT Error"), MB_ERR,          return false;
286                   _("GPG home directory is not set correctly.\n"      }
287                     "Please check the GPG registry settings:\n%s."),      /* Enable smart card support for GPG 2 or >= 1.4 */
288                   winpt_strerror (rc));      if ((ma > 1 || pa >= 4) && pcsc_available ())
289          const char * s = get_fileopen_dlg (GetActiveWindow (),          scard_support = 1;
290                                             _("Select GPG Public Keyring"),  
291                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),      gpgver[0] = ma;
292                                             NULL);      gpgver[1] = mi;
293          if (s != NULL) {      gpgver[2] = pa;
294              size_t n;      return true;
295              char * p = strrchr (s, '\\');  }
296              if (!p)  
297                  BUG (0);  
298              n = p - s;  /* Try to load the keyserver config file. If @quiet is 1
299              if (n)     do not show any errors. */
300              {  static int
301                  char * file = new char[n+1];  load_keyserver_conf (int quiet)
302                  if (!file)  {    
303                      BUG (NULL);      const char *t, *conf;
304                  memset (file, 0, n);      char *buf;
305                  memcpy (file, s, n);      int rc;
306                  file[n] = '\0';          
307                  set_reg_entry_gpg ("HomeDir", file);      /* Create $APPDATA\winpt if needed. */
308                  free_if_alloc (file);      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
309                  gnupg_check_homedir (); /* change gpgProgram if needed */      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
310              }          MessageBox (NULL, _("Failed to create WinPT directory"),
311          }                      _("Keyserver"), MB_ERR);
312          else {          free_if_alloc (buf);
313              msg_box (NULL, _("GPG home directory could not be determited."),          return -1;
314                       _("WinPT Error"), MB_ERR);      }
315              goto start;      free_if_alloc (buf);
316          }  
317      }      /* Check for $APPDATA\winpt\keyserver.conf */
318        buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
319      rc = check_gnupg_prog ();  
320      if (rc) {      conf = get_prog_part ("keyserver.conf", 0);
321          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"      if (!file_exist_check (conf))
322                               "Do you want to start the GPG preferences to "          t = conf;
323                               "correct  this problem?"), _("WinPT Error"),      else
324                               MB_INFO|MB_YESNO) == IDYES)          t = "keyserver.conf";
325              start_gpgprefs = 1;      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
326          else          if (!CopyFile (t, buf, FALSE)) {
327          {              MessageBox (NULL, _("Failed to copy the keyserver.conf"),
328              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);                          _("Keyserver"), MB_ERR);
329              return 0;              free_if_alloc (buf);
330          }              return -1;
331      }          }
332            t = buf;
333      rc = gnupg_access_files ();      }
334      if (!start_gpgprefs && rc)      else
335      {          t = buf;
336          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)      
337          {      rc = kserver_load_conf (t);
338              ec = msg_box (NULL,      if (rc && !quiet)
339                  _("Could not access and/or find the public and secret keyring.\n"          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
340                    "If this is an accident, quit the program and fix it.\n\n"      else {
341                    "Continue if you want that WinPT offers you more choices.\n"),          free_if_alloc (reg_prefs.kserv_conf);
342                    "WinPT", MB_INFO|MB_YESNO);          reg_prefs.kserv_conf = m_strdup (t);
343              if (ec == IDYES)      }
344                  first_start = 1;      free_if_alloc (buf);
345          }      return rc;
346          if (!first_start)  }
347          {  
348              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);  
349              return 0;  /* Check if both keyrings are empty. This indicates that
350          }     WinPT should offer to generate a key pair. */
351      }  static bool
352    check_for_empty_keyrings (bool pub_only)
353      if (!first_start)  {
354      {      char *p;
355          rc = gpg_check_permissions (1);      int n = 0;
356          if (rc && rc == 2)  
357              gpg_read_only = 1;      p = get_gnupg_keyring (1, 0);
358          else if (rc)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
359              return 0;          n++;
360      }      free_if_alloc (p);
361        if (pub_only)
362      load_gettext ();          return n == 1? true : false;
363      init_gnupg_table ();      p = get_gnupg_keyring (0, 0);
364        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
365      nfiles = fm_parse_command_line (cmdline);          n++;
366      if (nfiles > 0)      free_if_alloc (p);
367          return 0;      return n==2? true : false;
368    }
369      if (cmdline && stristr (cmdline, "--wipe-freespace")) {  
370          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,  
371                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,  /* Enable the mobility mode. */
372                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);  static int
373          free_gnupg_table ();  enable_mobile_mode (void)
374          return 0;  {
375      }      if (dir_exist_check ("temp") != 0) {
376            if (!CreateDirectory ("temp", NULL)) {
377      load_keyserver_conf (cmdline? 1 : 0);              MessageBox (NULL, "Could not create mobile temp directory",
378                            "WinPT Mobile Error", MB_ERR);
379      if (cmdline && (stristr (cmdline, "--keymanager")              return -1;
380                  || stristr (cmdline, "--cardmanager"))) {          }
381          update_keycache (GetDesktopWindow ());      }
382          if (stristr (cmdline, "keymanager"))  
383              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,      memset (&reg_prefs, 0, sizeof (reg_prefs));
384                              GetDesktopWindow(), keymanager_dlg_proc, NULL,      reg_prefs.always_trust = 0;
385                              _("Key Manager"), IDS_WINPT_KEYMISC);        reg_prefs.auto_backup = 0;
386          else {      reg_prefs.cache_time = 0;
387              gpg_card_t crd = smartcard_init ();      reg_prefs.expert = 0;
388              if (crd)      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
389                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,      reg_prefs.no_zip_mmedia = 1;
390                                    GetDesktopWindow(), card_edit_dlg_proc,      reg_prefs.word_wrap = 80;
391                                    (LPARAM)crd, _("Card Manager"),      reg_prefs.use_viewer = 0; /* XXX */
392                                    IDS_WINPT_CARD_EDIT);      return 0;
393              gpg_card_release (crd);  }
394          }  
395          keycache_release (0);  
396          free_gnupg_table ();  void
397          return 0;  set_default_keyserver (void)
398      }  {
399        char *host = get_reg_entry_keyserver ("Default");
400      CreateMutex (NULL, TRUE, PGM_NAME);      char *str_port = get_reg_entry_keyserver ("Default_Port");
401      if (GetLastError () == ERROR_ALREADY_EXISTS) {      WORD port = HKP_PORT;
402          free_gnupg_table ();  
403          return 0;      if (!host)
404      }          keyserver_set_default (NULL, 0);
405        else {
406      if (cmdline) {          if (str_port && *str_port)
407          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {              port = atoi (str_port);
408              gpg_set_debug_mode (1);          keyserver_set_default (host, port);
409              winpt_debug_msg ();      }
410              debug = 1;      free_if_alloc (host);
411          }      free_if_alloc (str_port);
412      }  }
413    
414      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));  
415      rc = RegisterClass (&wc);  /* Display info message that WinPT is now in debug mode. */
416      if (rc == FALSE) {  void
417          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);  winpt_debug_msg (void)
418          free_gnupg_table ();  {      
419          return 0;      char output[512];
420      }      char temp[128];
421            
422      hwnd = CreateWindow (PGM_NAME,      GetTempPath (sizeof temp -1, temp);
423                           PGM_NAME,      _snprintf (output, sizeof output - 1,
424                           0, 0, 0, 0, 0,          "The GPGME output file is %sgpgme.dbg\n"
425                           NULL,          "The WinPT output file is %swinpt.log\n", temp, temp);
426                           NULL,      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
427                           hinst,  }
428                           NULL);  
429      if (hwnd == NULL) {  
430          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);  /* Search for insecure ElGamal keys and return the
431          free_gnupg_table ();     number of founded keys. */
432          return 0;  static int
433      }  count_insecure_elgkeys (void)
434      glob_hwnd = hwnd;  {
435      UpdateWindow (hwnd);      gpg_keycache_t pc;
436        gpgme_key_t key;
437      if (!first_start && !start_gpgprefs) {      int n = 0;
438          gnupg_backup_options ();          
439          rc = check_crypto_engine ();      pc = keycache_get_ctx (1);
440          if (rc) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
441              DestroyWindow (hwnd);          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
442              free_gnupg_table ();              n++;
443              return 0;      }
444          }      gpg_keycache_rewind (pc);
445      }      return n;
446        }
447      if (start_gpgprefs) {  
448          char *ring;  
449          size_t size = 0;  /* Main entry point. */
450          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,  int WINAPI
451                          gpgprefs_dlg_proc, NULL);  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
452          ring = get_gnupg_keyring (0, !NO_STRICT);  {
453          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
454              first_start = 1; /* The keyring is empty! */      HACCEL accel_tab;
455          free_if_alloc (ring);      MSG msg;
456      }      HWND hwnd = NULL;
457        WORD ver[3], ptdver[4];
458      if (first_start) {      const char *s;
459          struct first_start_s fs;      int rc, ec, created = 0;
460          struct genkey_s c;      int first_start = 0, start_gpgprefs = 0;
461          HWND h;      int winpt_inst_found = 0;
462  start:      int start_manager = 0;    
463          h = GetDesktopWindow ();  
464          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,      glob_hinst = hinst;
465                              gpgprefs_dlg_proc, NULL);      if (cmdline && stristr (cmdline, "--stop")) {
466          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          hwnd = FindWindow ("WinPT", "WinPT");
467                          first_run_dlg_proc, (LPARAM)&fs);          if (hwnd != NULL)
468          switch (fs.choice) {              PostMessage (hwnd, WM_DESTROY, 0, 0);
469          case SETUP_KEYGEN:          return 0;
470              c.interactive = 1;      }
471              c.first_start = 1;  
472              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,      #ifdef _DEBUG
473                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);      gpg_set_debug_mode (1);
474              if (!rc)      debug = 1;
475                  goto start;      #endif
476              break;  
477        get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
478          case SETUP_IMPORT:      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
479              rc = gnupg_copy_keyrings ();                                   &ptdver[2], &ptdver[3]);
480              if (rc) {      
481                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);      if (!ec && (ptdver[0] != ver[0] ||
482                  goto start;                  ptdver[1] != ver[1] ||
483              }                  ptdver[2] != ver[2])) {
484              break;          log_box (_("WinPT Error"), MB_ERR,
485                     _("The PTD.dll file has a different version than WinPT.exe\n"
486          case -1:                     "Please update the PTD.dll to version %d.%d.%d"),
487              DestroyWindow (hwnd);                     ver[0], ver[1], ver[2]);
488              free_gnupg_table ();          return 0;
489              return 0;      }
490          }  
491          update_keycache (hwnd);      if (gpg_md_selftest ()) {
492          check_crypto_engine ();          msg_box (NULL, _("Cryptographic selftest failed."),
493      }                   _("WinPT Error"), MB_ERR);
494      else {          return 0;
495          gpg_keycache_t c;      }
496          update_keycache (hwnd);  
497          c = keycache_get_ctx (1);      s = gpgme_check_version (NEED_GPGME_VERSION);
498          if (!c || !gpg_keycache_get_size (c)) {      if (!s || !*s) {
499              gnupg_display_error ();          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
500              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"                   _("WinPT Error"), MB_ERR);
501                               "Please check your GPG config (keyrings, pathes...)"),          return 0;
502                               _("WinPT Error"), MB_ERR);      }
503              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"  
504                                    "Do you want to start the GPG preferences dialog?"),      CreateMutex (NULL, TRUE, PGM_NAME);
505                              "WinPT", MB_INFO|MB_YESNO);      if (GetLastError () == ERROR_ALREADY_EXISTS)
506              if (ec == IDYES) {          winpt_inst_found = 1;
507                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,  
508                                  gpgprefs_dlg_proc, NULL);      if (cmdline && stristr (cmdline, "--mobile")) {
509                  update_keycache (hwnd);          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
510              }                   "WinPT", MB_INFO);
511              else {          mobile_mode_active = 1;
512                  DestroyWindow (hwnd);      }
513                  free_gnupg_table ();      
514                  return 0;      set_default_keyserver ();
515              }      load_gettext ();
516          }      admin_user = user_is_admin ();
517          if (check_default_key (c)) {  
518              char * p = get_gnupg_default_key ();      if (!mobile_mode_active) {
519              log_box (_("WinPT Error"), MB_ERR,          regist_inst_gnupg (1);
520                       _("Default key from the GPG options file could not be found.\n"          regist_inst_winpt (1, &created);
521                         "Please check your gpg.conf (options) to correct this:\n\n"      }
522                         "%s: public key not found."), p? p : "[null]");      else {
523              free_if_alloc (p);          if (enable_mobile_mode ())
524              DestroyWindow (hwnd);              return 0;
525              free_gnupg_table ();          created = 1; /* Disable registry writing */
526              return 0;      }
527          }  
528          if (count_insecure_elgkeys ())      if (!created) {
529              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,          memset (&reg_prefs, 0, sizeof (reg_prefs));
530                              elgamal_warn_dlg_proc, NULL);          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
531      }          get_reg_winpt_prefs (&reg_prefs);
532            gnupg_load_config ();
533      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      }
534      keyring_check_last_access (); /* init */  
535      while (GetMessage (&msg, hwnd, 0, 0)) {      if (is_gpg4win_installed ())
536          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {          load_gpg_env (); /* XXX: check return code. */
537              TranslateMessage (&msg);  
538              DispatchMessage (&msg);      rc = gnupg_check_homedir ();
539          }      if (rc) {
540      }          log_box (_("WinPT Error"), MB_ERR,
541                             _("GPG home directory is not set correctly.\n"
542      return 0;                     "Please check the GPG registry settings:\n%s."),
543  } /* WinMain */                   winpt_strerror (rc));
544            s = get_fileopen_dlg (GetActiveWindow (),
545                                  _("Select GPG Public Keyring"),
546                                  "GPG Keyrings (*.gpg)\0*.gpg\0\0",
547                                  NULL);
548            if (s != NULL) {
549                size_t n;
550                char *p = strrchr (s, '\\');
551                if (!p)
552                    BUG (0);
553                n = p - s;
554                if (n > 0) {
555                    char *file = new char[n+1];
556                    if (!file)
557                        BUG (NULL);
558                    memset (file, 0, n);
559                    memcpy (file, s, n);
560                    file[n] = '\0';        
561                    set_reg_entry_gpg ("HomeDir", file);
562                    free_if_alloc (file);
563                    gnupg_check_homedir (); /* change gpgProgram if needed */
564                }
565            }
566            else {
567                msg_box (NULL, _("GPG home directory could not be determined."),
568                         _("WinPT Error"), MB_ERR);
569                goto start;
570            }
571        }
572    
573        rc = check_gnupg_prog ();
574        if (rc) {
575            if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
576                                 "Do you want to start the GPG preferences to "
577                                 "correct  this problem?"), _("WinPT Error"),
578                                 MB_INFO|MB_YESNO) == IDYES)
579                start_gpgprefs = 1;
580            else {
581                msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
582                return 0;
583            }
584        }
585    
586        rc = gnupg_access_files ();
587        if (!start_gpgprefs && rc) {
588            if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
589                ec = msg_box (NULL,
590                    _("Could not access and/or find the public and secret keyring.\n"
591                      "If this is an accident, quit the program and fix it.\n\n"
592                      "Continue if you want WinPT to offer you more choices.\n"),
593                      "WinPT", MB_INFO|MB_YESNO);
594                if (ec == IDYES)
595                    first_start = 1;
596            }
597            if (!first_start) {
598                msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
599                return 0;
600            }
601        }
602        if (check_for_empty_keyrings (false))
603            first_start = 1;
604    
605        if (!first_start) {
606            rc = gpg_check_permissions (1);
607            if (rc && rc == 2)
608                gpg_read_only = 1;
609            else if (rc)
610                return 0;
611        }
612        
613        init_gnupg_table ();
614    
615        if (fm_parse_command_line (cmdline) > 0) {
616            free_gnupg_table ();
617            return 0;
618        }
619    
620        if (cmdline && stristr (cmdline, "--wipe-freespace")) {
621            dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
622                                GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
623                                _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
624            free_gnupg_table ();
625            return 0;
626        }
627    
628        load_keyserver_conf (cmdline? 1 : 0);
629    
630        if (cmdline && (stristr (cmdline, "--keymanager")
631                    || stristr (cmdline, "--cardmanager"))) {
632            /* If an instance of WinPT is running, just send the command
633               to open the key manager. Otherwise start a new instance. */
634            HWND tray = FindWindow ("WinPT", "WinPT");
635            if (stristr (cmdline, "keymanager"))
636                start_manager = ID_WINPT_KEY;
637            else
638                start_manager = ID_WINPT_CARD;
639            if (tray != NULL) {
640                PostMessage (tray, WM_COMMAND, start_manager, 0);
641                free_gnupg_table ();
642                return 0;
643            }
644        }
645    
646        /* If we found another WinPT instance, just quit to avoid it
647           will be executed twice. */
648        if (winpt_inst_found) {
649            log_debug ("%s", "WinMain: WinPT is already running.");
650            free_gnupg_table ();
651            return 0;
652        }
653    
654        if (cmdline && (stristr (cmdline, "--enable-debug") ||
655                        stristr (cmdline, "--debug"))) {
656            gpg_set_debug_mode (1);
657            winpt_debug_msg ();
658            debug = 1;
659        }
660    
661        wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
662        rc = RegisterClass (&wc);
663        if (rc == FALSE) {
664            msg_box (NULL, _("Could not register window class"),
665                     _("WinPT Error"), MB_ERR);
666            free_gnupg_table ();
667            return 0;
668        }
669    
670        hwnd = CreateWindow (PGM_NAME,
671                             PGM_NAME,
672                             0, 0, 0, 0, 0,
673                             NULL,
674                             NULL,
675                             hinst,
676                             NULL);
677        if (hwnd == NULL) {
678            msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
679            free_gnupg_table ();
680            return 0;
681        }
682        glob_hwnd = hwnd;
683        UpdateWindow (hwnd);
684    
685        if (!first_start && !start_gpgprefs) {
686            gnupg_backup_options ();        
687            if (!check_crypto_engine ()) {
688                DestroyWindow (hwnd);
689                free_gnupg_table ();
690                return 0;
691            }
692        }
693        
694        if (start_gpgprefs) {
695            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
696                            gpgprefs_dlg_proc, 0);
697            if (check_for_empty_keyrings (true))
698                first_start = 1; /* The public keyring is empty! */
699        }
700    
701        if (first_start) {
702            struct genkey_s c;
703            int choice;
704            HWND h;
705    start:
706            h = GetDesktopWindow ();
707            if (!gpg_prefs_ok ())
708                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
709                                gpgprefs_dlg_proc, 0);
710            choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
711                                     first_run_dlg_proc, 0);
712            switch (choice) {
713            case SETUP_KEYGEN:
714                c.interactive = 1;
715                c.first_start = 1;
716                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
717                                     h, keygen_wizard_dlg_proc, (LPARAM)&c);
718                if (!rc)
719                    goto start;
720                break;
721    
722            case SETUP_IMPORT:
723                rc = gnupg_copy_keyrings ();
724                if (rc) {
725                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
726                    goto start;
727                }
728                break;
729    
730            case SETUP_CARDGEN:
731                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
732                                     h, card_keygen_dlg_proc, 0);
733                if (!rc)
734                    goto start;
735                break;
736    
737            case 0: /* Cancel/Abort. */
738            default:
739                DestroyWindow (hwnd);
740                free_gnupg_table ();
741                return 0;
742            }
743            update_keycache (hwnd);
744            if (!check_crypto_engine ()) {
745                DestroyWindow (hwnd);
746                free_gnupg_table ();
747                keycache_release (1);
748                return 0;
749            }
750            if (!is_gpg4win_installed ()) {
751                select_language ();
752                load_gettext ();
753            }
754        }
755        else {
756            gpg_keycache_t c, sec_c;
757            if (update_keycache (hwnd)) {
758                DestroyWindow (hwnd);
759                free_gnupg_table ();
760                keycache_release (1);
761                return 0;
762            }
763            c = keycache_get_ctx (1);
764            if (!gpg_keycache_get_size (c)) {
765                msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
766                                 "Please check your GPG config (keyrings, pathes...)"),
767                                 _("WinPT Error"), MB_ERR);
768                ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"
769                                      "Do you want to start the GPG preferences dialog?"),
770                                "WinPT", MB_INFO|MB_YESNO);
771                if (ec == IDYES) {
772                    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
773                                    gpgprefs_dlg_proc, 0);
774                    update_keycache (hwnd);
775                }
776                else {
777                    DestroyWindow (hwnd);
778                    free_gnupg_table ();
779                    keycache_release (1);
780                    return 0;
781                }
782            }
783            sec_c = keycache_get_ctx (0);
784            if (check_default_key (sec_c)) {
785                char *p = get_gnupg_default_key ();
786                log_box (_("WinPT Error"), MB_ERR,
787                         _("Default key (from the GPG config file) could not be found.\n"
788                           "Please check your gpg.conf or set a new default key to correct it:\n\n"
789                           "%s: public key not found."), p? p : "[null]");
790                set_gnupg_default_key (NULL);
791            }
792            if (count_insecure_elgkeys ())
793                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
794                                elgamal_warn_dlg_proc, 0);
795        }
796    
797        if (start_manager)
798            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
799    
800        accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
801        keyring_check_last_access (); /* init */
802        while (GetMessage (&msg, hwnd, 0, 0)) {
803            if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
804                TranslateMessage (&msg);
805                DispatchMessage (&msg);
806            }
807        }
808            
809        return 0;
810    }
Legend:
Removed from v.25  
changed lines
  Added in v.270
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26