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