/[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 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  #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;  #include "wptUTF8.h"
44  int scard_support = 0;  
45  int debug = 0;  void remove_crit_file_attrs (const char *fname, int force);
46  int mobile = 0;  
47  int gpg_read_only = 0;  
48  char gpgver[3];  HINSTANCE glob_hinst;   /* global instance for the dialogs */
49    HWND glob_hwnd;         /* global window handle for the dialogs */
50    HWND activ_hwnd;
51  /* Load the key cache and rebuild the signature cache. */  int scard_support = 0;
52  static void  int debug = 0;
53  update_keycache (HWND hwnd)  int mobile_mode_active = 0;
54  {  int gpg_read_only = 0;
55      refresh_cache_s rcs = {0};  char gpgver[3];
56      rcs.kr_reload = 0;  
57      rcs.kr_update = 1;  
58      rcs.tr_update = 1;  /* Load the key cache and rebuild the signature cache. */
59      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  void
60                      keycache_dlg_proc, (LPARAM)&rcs);  update_keycache (HWND hwnd)
61  }  {
62        refresh_cache_s rcs = {0};
63        rcs.kr_reload = 0;
64  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */      rcs.kr_update = 1;
65  void      rcs.tr_update = 1;
66  gpg_set_debug_mode (int val)      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
67  {                            keycache_dlg_proc, (LPARAM)&rcs);
68      if (val)  }
69          putenv ("GPGME_DEBUG=5:gpgme.dbg");  
70      else  
71          putenv ("GPGME_DEBUG=");  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
72  }  void
73    gpg_set_debug_mode (int val)
74  static char *  {
75  get_gettext_lang (void)      static char buf[256];
76  {          char tmp[128];
77      char * fname;      
78      fname = get_reg_entry_mo ();      /* XXX: no gpgme.dbg is created. */
79      if (!fname)      if (val > 0) {
80          return NULL;          GetTempPath (sizeof (tmp)-1, tmp);
81      return fname;          _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
82  } /* get_gettext_lang */          putenv (buf);
83        }
84        else
85  static void          putenv ("GPGME_DEBUG=");
86  load_gettext (void)  }
87  {  
88      char *nls = NULL;  
89      char *file = NULL;  /* Return the name of the gettext language file. */
90    static char*
91      nls = get_gettext_lang ();  get_gettext_lang (void)
92      if (nls) {  {    
93          set_gettext_file ("winpt", nls);      char *fname;
94          file = make_filename (nls, "winpt", "mo");      fname = get_reg_entry_mo ();
95          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {      if (!fname)
96              msg_box (NULL, _("Could not initizalize file lock.\n"          return NULL;
97                               "Native Language Support"),      return fname;
98                       _("WinPT Error"), MB_ERR);  }
99          }  
100          free_if_alloc (nls);  
101          free_if_alloc (file);  /* Initialize the gettext sub system. */
102      }  static void
103  } /* load_gettext */  load_gettext (int prev_inst)
104    {
105        char *nls = NULL;
106  /* check if the default key from the gpg.conf file is available in the  
107     keyring. if not, bail out because encryption won't work properly then. */      nls = get_gettext_lang ();
108  static int      if (nls != NULL) {
109  check_default_key (gpg_keycache_t kc)          set_gettext_file ("winpt", nls);
110  {          free_if_alloc (nls);
111      gpgme_key_t key;      }
112      gpgme_error_t err = GPG_ERR_NO_ERROR;  }
113      char * defkey;  
114    
115      defkey = get_gnupg_default_key ();  /* Return true if the GPG environment is useable. */
116      if (defkey)  static bool
117          err = gpg_keycache_find_key (kc, defkey, 0, &key);  gpg_prefs_ok (void)
118      free_if_alloc (defkey);  {
119      return err? -1 : 0;      char *p;
120  } /* check_default_key */  
121        p = get_reg_entry_gpg4win ("gpg.exe");
122        if (!p || file_exist_check (p) != 0) {
123  /* Return the WinPT program file name (with full pathname). */          free_if_alloc (p);
124  static const char *          p = get_reg_entry_gpg ("gpgProgram");
125  get_prog_part (const char * fname, int use_cwd)          if (!p || file_exist_check (p) != 0) {
126  {              free_if_alloc (p);
127      static char program[1024];              log_debug ("gpg_prefs_ok: could not locate gpg.exe");
128      char currdir[256], * cmd = NULL;              return false;
129      int j;          }
130                }
131      memset (currdir, 0, DIM (currdir));      free_if_alloc (p);
132      memset (program, 0, DIM (program));      p = get_reg_entry_gpg4win (NULL);    
133                if (!p || dir_exist_check (p) != 0) {
134      if (use_cwd) {          free_if_alloc (p);
135          GetCurrentDirectory (DIM (currdir)-1, currdir);          p = get_reg_entry_gpg ("HomeDir");
136          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);          if (!p || dir_exist_check (p) != 0) {
137      }              free_if_alloc (p);
138      else {              log_debug ("gpg_prefs_ok: could not determine home directory");
139          cmd = GetCommandLine ();              return false;
140          if (cmd == NULL)          }
141              return NULL;      }
142          strncpy (currdir, cmd, 255);      free_if_alloc (p);
143          j = strlen (currdir);      return true;
144          while (j--) {  }
145              if (currdir[j] == '\\')  
146                  break;            
147          }  /* Check gpg files if they are read-only and ask the user
148          currdir[j] = 0;     if this should be corrected. */
149          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);  static void
150      }  check_readonly_attr (const char *homedir)
151      return program;  {
152  } /* get_prog_part */      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
153        char *file;
154        int i;
155  static int  
156  check_crypto_engine (void)      for (i=0; files[i] != NULL; i++) {
157  {          file = make_filename (homedir, files[i], NULL);
158      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */          remove_crit_file_attrs (file, 0);
159      int rc;          free_if_alloc (file);
160        }
161      rc = check_gnupg_engine (&ma, &mi, &pa);  }
162      if (rc == -1) {  
163          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);  
164          return rc;  /* Load the GPG environment. On the first start, some
165      }     checks are performed to find out in what state GPG is.
166      else if (rc) {     Return value: 0  everything OK.
167          log_box (_("WinPT Error"), MB_ERR,                   >0  fatal error.
168                   _("Sorry, you need a newer GPG version.\n"                   -1 public keyring is empty or does not exist. */
169                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),  static int
170                     ma, mi, pa);  load_gpg_env (void)
171          return rc;  {
172      }      SECURITY_ATTRIBUTES sec_attr;
173      /* We enable smartcard support for GPG: 1.9.x or >= 1.4.0 */      char *p;
174      if (ma >= 1 && mi >= 4)      char *pkr;
175          scard_support = 1;  
176        p = get_reg_entry_gpg4win ("gpg.exe");
177      gpgver[0] = ma;      if (!p)
178      gpgver[1] = mi;          return (1);
179      gpgver[2] = pa;      if (file_exist_check (p)) {
180      return rc;          free_if_alloc (p);
181  } /* check_crypto_engine */          return (1);
182        }
183        free_if_alloc (p);
184  static int  
185  load_keyserver_conf (int quiet)      p = get_reg_entry_gpg ("HomeDir");
186  {      if (!p || dir_exist_check (p) != 0) {
187      const char * t;          free_if_alloc (p);
188      int rc;          p = multi_gnupg_path (0);
189        }
190      if (reg_prefs.kserv_conf)      if (p && dir_exist_check (p)) {
191          t = reg_prefs.kserv_conf;          memset (&sec_attr, 0, sizeof (sec_attr));
192      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))          sec_attr.nLength = sizeof (sec_attr);
193          t = get_prog_part ("keyserver.conf", 0);          if (!CreateDirectory (p, &sec_attr)) {
194      else              msg_box (NULL, _("Could not create GPG home directory"),
195          t = "keyserver.conf";                       _("WinPT Error"), MB_ERR);
196      rc = kserver_load_conf (t);              free_if_alloc (p);
197      if (rc && !quiet)              return (2);
198          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);          }
199      return rc;      }
200  }      check_readonly_attr (p);
201        pkr = make_filename (p, "pubring", "gpg");
202        free_if_alloc (p);
203  static void      if (!pkr)
204  enable_mobile_mode (void)          return -1;
205  {      if (get_file_size (pkr) == 0) {
206      memset (&reg_prefs, 0, sizeof (reg_prefs));          free_if_alloc (pkr);
207      reg_prefs.always_trust = 0;          return -1;
208      reg_prefs.auto_backup = 0;      }
209      reg_prefs.cache_time = 0;      return 0;
210      reg_prefs.expert = 0;  }
211      reg_prefs.keylist_mode = 1;  
212      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");  
213      reg_prefs.no_zip_mmedia = 1;  /* check if the default key from the gpg.conf file is available in the
214      reg_prefs.use_tmpfiles = 1;     keyring. if not, bail out because encryption won't work properly then. */
215      reg_prefs.word_wrap = 80;  static int
216      reg_prefs.use_viewer = 0; /* XXX */  check_default_key (gpg_keycache_t kc)
217  }  {
218        gpgme_key_t key;
219  char* get_subkey_fingerprint (gpgme_ctx_t ctx, const char *keyid);      gpgme_error_t err = GPG_ERR_NO_ERROR;
220        char *defkey;
221    
222  int WINAPI      defkey = get_gnupg_default_key ();
223  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)      if (defkey)
224  {          err = gpg_keycache_find_key (kc, defkey, 0, &key);
225      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};      else
226      HACCEL accel_tab;          msg_box (NULL, _("No useable secret key found."),
227      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;                   _("WinPT Error"), MB_ERR);
228      int first_start = 0, start_gpgprefs = 0;      free_if_alloc (defkey);
229      const char * s;      return err? -1 : 0;
230      MSG msg;  }
231      HWND hwnd = NULL;  
232    
233      glob_hinst = hinst;  /* Return the WinPT program file name (with full pathname). */
234    static const char*
235      #ifdef _DEBUG  get_prog_part (const char * fname, int use_cwd)
236      gpg_set_debug_mode (1);  {
237      debug = 1;      static char program[512];
238      #endif      char currdir[256];
239        char *cmd = NULL;
240      s = PTD_get_version ();      int j;
241      if (strcmp (s, "0.8.0")) {          
242          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,      memset (currdir, 0, DIM (currdir));
243                   _("Please update your PTD.dll to the newest version, "      memset (program, 0, DIM (program));
244                     "the version (%s) you use is too old."), s);          
245          return 0;      if (use_cwd) {
246      }          GetCurrentDirectory (DIM (currdir)-1, currdir);
247            _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
248      if (gpg_md_selftest ()) {      }
249          msg_box (NULL, _("Cryptographic selftest failed."),      else {
250                   _("WinPT Error"), MB_ERR);          cmd = GetCommandLine ();
251          return 0;          if (cmd == NULL)
252      }              return NULL;
253            strncpy (currdir, cmd, sizeof (currdir)-1);
254      s = gpgme_check_version ("1.1.0");          j = strlen (currdir);
255      if (!s || !*s) {          while (j--) {
256          msg_box (NULL, _("A newer GPGME version is needed."), "WinPT Error", MB_ERR);              if (currdir[j] == '\\')
257          return 0;                  break;
258      }          }
259            currdir[j] = 0;
260      if (cmdline && stristr (cmdline, "--mobile")) {          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
261          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",      }
262                   "WinPT", MB_INFO);      return program;
263          mobile = 1;  }
264      }  
265    
266      set_default_kserver ();  /* Check that the underlying crypto engine fullfills the minimal
267       requirements so all commands work properly. */
268      if (!mobile) {  static bool
269          regist_inst_gnupg (1);  check_crypto_engine (void)
270          regist_inst_winpt (1, &created);  {
271      }      int ma=0, mi=0, pa=0;
272      else {      int rc;
273          enable_mobile_mode ();  
274          /* XXX: ask for GPG path */      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
275          created = 1; /* Disable registry writing */      if (rc == -1) {
276      }          msg_box (NULL, _("Could not read GnuPG version."),
277                     _("WinPT Error"), MB_ERR);
278      if (!created) {          return false;
279          memset (&reg_prefs, 0, sizeof (reg_prefs));      }
280          reg_prefs.use_tmpfiles = 1; /* default */      else if (rc) {
281          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */          log_box (_("WinPT Error"), MB_ERR,
282          get_reg_winpt_prefs (&reg_prefs);                   _("Sorry, you need a newer GPG version.\n"
283          if (!reg_prefs.no_hotkeys)                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
284              hotkeys_modify ();                     ma, mi, pa);
285      }          return false;
286        }
287      rc = gnupg_check_homedir ();      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
288      if (rc) {      if (ma > 1 || pa >= 3)    
289          log_box (_("WinPT Error"), MB_ERR,          scard_support = 1;
290                   _("GPG home directory is not set correctly.\n"  
291                     "Please check the GPG registry settings:\n%s."),      gpgver[0] = ma;
292                   winpt_strerror (rc));      gpgver[1] = mi;
293          const char * s = get_fileopen_dlg (GetActiveWindow (),      gpgver[2] = pa;
294                                             _("Select GPG Public Keyring"),      return true;
295                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),  }
296                                             NULL);  
297          if (s != NULL) {  
298              size_t n;  /* Try to load the keyserver config file. If @quiet is 1
299              char * p = strrchr (s, '\\');     do not show any errors. */
300              if (!p)  static int
301                  BUG (0);  load_keyserver_conf (int quiet)
302              n = p - s;  {
303              if (n)      char *buf;
304              {      const char *t;
305                  char * file = new char[n+1];      int rc;
306                  if (!file)  
307                      BUG (NULL);      /* Create $APPDATA\winpt if needed. */
308                  memset (file, 0, n);      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
309                  memcpy (file, s, n);      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
310                  file[n] = '\0';                  MessageBox (NULL, _("Failed to create WinPT directory"),
311                  set_reg_entry_gpg ("HomeDir", file);                      _("Keyserver"), MB_ERR);
312                  free_if_alloc (file);          free_if_alloc (buf);
313                  gnupg_check_homedir (); /* change gpgProgram if needed */          return -1;
314              }      }
315          }      free_if_alloc (buf);
316          else {  
317              msg_box (NULL, _("GPG home directory could not be determited."),      /* Check for $APPDATA\winpt\keyserver.conf */
318                       _("WinPT Error"), MB_ERR);      buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
319              goto start;  
320          }      if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
321      }          t = get_prog_part ("keyserver.conf", 0);
322        else
323      rc = check_gnupg_prog ();          t = "keyserver.conf";
324      if (rc) {      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
325          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          //log_box (_("Keyserver"), MB_INFO,
326                               "Do you want to start the GPG preferences to "          //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
327                               "correct  this problem?"), _("WinPT Error"),          if (!CopyFile (t, buf, FALSE)) {
328                               MB_INFO|MB_YESNO) == IDYES)              MessageBox (NULL, _("Failed to copy the keyserver.conf"),
329              start_gpgprefs = 1;                          _("Keyserver"), MB_ERR);
330          else              free_if_alloc (buf);
331          {              return -1;
332              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          }
333              return 0;          t = buf;
334          }      }
335      }      else
336            t = buf;
337      rc = gnupg_access_files ();      
338      if (!start_gpgprefs && rc)      rc = kserver_load_conf (t);
339      {      if (rc && !quiet)
340          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
341          {      else {
342              ec = msg_box (NULL,          free_if_alloc (reg_prefs.kserv_conf);
343                  _("Could not access and/or find the public and secret keyring.\n"          reg_prefs.kserv_conf = m_strdup (t);
344                    "If this is an accident, quit the program and fix it.\n\n"      }
345                    "Continue if you want that WinPT offers you more choices.\n"),      free_if_alloc (buf);
346                    "WinPT", MB_INFO|MB_YESNO);      return rc;
347              if (ec == IDYES)  }
348                  first_start = 1;  
349          }  
350          if (!first_start)  /* Check if both keyrings are empty. This indicates that
351          {     WinPT should offer to generate a key pair. */
352              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);  static bool
353              return 0;  check_for_empty_keyrings (bool pub_only)
354          }  {
355      }      char *p;
356        int n = 0;
357      if (!first_start)  
358      {      p = get_gnupg_keyring (1, 0);
359          rc = gpg_check_permissions (1);      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
360          if (rc && rc == 2)          n++;
361              gpg_read_only = 1;      free_if_alloc (p);
362          else if (rc)      if (pub_only)
363              return 0;          return n == 1? true : false;
364      }      p = get_gnupg_keyring (0, 0);
365        if (file_exist_check (p) == 0 && get_file_size (p) == 0)
366      load_gettext ();          n++;
367      init_gnupg_table ();      free_if_alloc (p);
368        return n==2? true : false;
369      nfiles = fm_parse_command_line (cmdline);  }
370      if (nfiles > 0)  
371          return 0;  
372    /* Enable the mobility mode. */
373      if (cmdline && stristr (cmdline, "--wipe-freespace")) {  static int
374          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,  enable_mobile_mode (void)
375                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,  {
376                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);      if (dir_exist_check ("temp") != 0) {
377          free_gnupg_table ();          if (!CreateDirectory ("temp", NULL)) {
378          return 0;              MessageBox (NULL, "Could not create mobile temp directory",
379      }                          "WinPT Mobile Error", MB_ERR);
380                return -1;
381      load_keyserver_conf (cmdline? 1 : 0);          }
382        }
383      if (cmdline && (stristr (cmdline, "--keymanager")  
384                  || stristr (cmdline, "--cardmanager"))) {      memset (&reg_prefs, 0, sizeof (reg_prefs));
385          update_keycache (GetDesktopWindow ());      reg_prefs.always_trust = 0;
386          if (stristr (cmdline, "keymanager"))      reg_prefs.auto_backup = 0;
387              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,      reg_prefs.cache_time = 0;
388                              GetDesktopWindow(), keymanager_dlg_proc, NULL,      reg_prefs.expert = 0;
389                              _("Key Manager"), IDS_WINPT_KEYMISC);        reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
390          else {      reg_prefs.no_zip_mmedia = 1;
391              gpg_card_t crd = gpg_card_load ();      reg_prefs.use_tmpfiles = 1;
392              if (crd)      reg_prefs.word_wrap = 80;
393                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,      reg_prefs.use_viewer = 0; /* XXX */
394                                    GetDesktopWindow(), card_edit_dlg_proc,      return 0;
395                                    (LPARAM)crd, _("Card Manager"),  }
396                                    IDS_WINPT_CARD_EDIT);  
397              gpg_card_release (crd);  
398          }  void
399          keycache_release (0);  set_default_keyserver (void)
400          free_gnupg_table ();  {
401          return 0;      char *host = get_reg_entry_keyserver ("Default");
402      }      char *str_port = get_reg_entry_keyserver ("Default_Port");
403        WORD port = HKP_PORT;
404      CreateMutex (NULL, TRUE, PGM_NAME);  
405      if (GetLastError () == ERROR_ALREADY_EXISTS) {      if (!host)
406          free_gnupg_table ();          keyserver_set_default (NULL, 0);
407          return 0;      else {
408      }          if (str_port && *str_port)
409                port = atoi (str_port);
410      if (cmdline) {          keyserver_set_default (host, port);
411          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      }
412              gpg_set_debug_mode (1);      free_if_alloc (host);
413              winpt_debug_msg ();      free_if_alloc (str_port);
414              debug = 1;  }
415          }  
416      }  
417    /* Display info message that WinPT is now in debug mode. */
418      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));  void
419      rc = RegisterClass (&wc);  winpt_debug_msg (void)
420      if (rc == FALSE) {  {      
421          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);      char output[512];
422          free_gnupg_table ();      char temp[128];
423          return 0;          
424      }      GetTempPath (sizeof temp -1, temp);
425        _snprintf (output, sizeof output - 1,
426      hwnd = CreateWindow (PGM_NAME,          "The GPGME output file is %sgpgme.dbg\n"
427                           PGM_NAME,          "The WinPT output file is %swinpt.log\n", temp, temp);
428                           0, 0, 0, 0, 0,      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
429                           NULL,  }
430                           NULL,  
431                           hinst,  
432                           NULL);  /* Main entry point. */
433      if (hwnd == NULL) {  int WINAPI
434          msg_box (NULL, _("Could not create window"), _("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      glob_hwnd = hwnd;      MSG msg;
439      UpdateWindow (hwnd);      HWND hwnd = NULL;
440        WORD ver[3], ptdver[4];
441      if (!first_start && !start_gpgprefs) {      int rc, ec, created = 0;
442          gnupg_backup_options ();              int first_start = 0, start_gpgprefs = 0;
443          rc = check_crypto_engine ();      int winpt_inst_found = 0;
444          if (rc) {      int start_manager = 0;
445              DestroyWindow (hwnd);      const char *s;
446              free_gnupg_table ();  
447              return 0;      glob_hinst = hinst;
448          }      if (cmdline && stristr (cmdline, "--stop")) {
449      }          hwnd = FindWindow ("WinPT", "WinPT");
450                if (hwnd != NULL)
451      if (start_gpgprefs) {              PostMessage (hwnd, WM_DESTROY, 0, 0);
452          char *ring;          return 0;
453          size_t size = 0;      }
454          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,  
455                          gpgprefs_dlg_proc, NULL);      /*
456          ring = get_gnupg_keyring (0, !NO_STRICT);      OSVERSIONINFO osinf;
457          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)      memset (&osinf, 0, sizeof (osinf));
458              first_start = 1; /* The keyring is empty! */      if (GetVersionEx (&osinf) &&
459          free_if_alloc (ring);          osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
460      }          osinf.dwMinorVersion == 0) {
461            msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
462      if (first_start) {                   "WinPT Warning", MB_INFO);
463          struct first_start_s fs;      }
464          struct genkey_s c;      */
465          HWND h;  
466  start:      #ifdef _DEBUG
467          h = GetDesktopWindow ();      gpg_set_debug_mode (1);
468          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,      debug = 1;
469                              gpgprefs_dlg_proc, NULL);      #endif
470          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,  
471                          first_run_dlg_proc, (LPARAM)&fs);      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
472          switch (fs.choice) {      get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
473          case SETUP_KEYGEN:                                   &ptdver[2], &ptdver[3]);
474              c.interactive = 1;      /* XXX
475              c.first_start = 1;      if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {
476              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,          log_box (_("WinPT Error"), MB_ERR,
477                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);                   _("The PTD.dll file has a different version than WinPT.exe\n"
478              if (!rc)                     "Please update the PTD.dll to version %d.%d.%d"),
479                  goto start;                     ver[0], ver[1], ver[2]);
480              break;          return 0;
481        }
482          case SETUP_IMPORT:      */
483              rc = gnupg_copy_keyrings ();  
484              if (rc) {      if (gpg_md_selftest ()) {
485                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          msg_box (NULL, _("Cryptographic selftest failed."),
486                  goto start;                   _("WinPT Error"), MB_ERR);
487              }          return 0;
488              break;      }
489    
490          case -1:      s = gpgme_check_version (NEED_GPGME_VERSION);
491              DestroyWindow (hwnd);      if (!s || !*s) {
492              free_gnupg_table ();          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
493              return 0;                   _("WinPT Error"), MB_ERR);
494          }          return 0;
495          update_keycache (hwnd);      }
496          check_crypto_engine ();  
497      }      CreateMutex (NULL, TRUE, PGM_NAME);
498      else {      if (GetLastError () == ERROR_ALREADY_EXISTS)
499          gpg_keycache_t c;          winpt_inst_found = 1;
500          update_keycache (hwnd);  
501          c = keycache_get_ctx (1);      if (cmdline && stristr (cmdline, "--mobile")) {
502          if (!c || !gpg_keycache_get_size (c)) {          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
503              gnupg_display_error ();                   "WinPT", MB_INFO);
504              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"          mobile_mode_active = 1;
505                               "Please check your GPG config (keyrings, pathes...)"),      }
506                               _("WinPT Error"), MB_ERR);      
507              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"      set_default_keyserver ();
508                                    "Do you want to start the GPG preferences dialog?"),      load_gettext (winpt_inst_found);
509                              "WinPT", MB_INFO|MB_YESNO);  
510              if (ec == IDYES) {      if (!mobile_mode_active) {
511                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          regist_inst_gnupg (1);
512                                  gpgprefs_dlg_proc, NULL);          regist_inst_winpt (1, &created);
513                  update_keycache (hwnd);      }
514              }      else {
515              else {          if (enable_mobile_mode ())
516                  DestroyWindow (hwnd);              return 0;
517                  free_gnupg_table ();          created = 1; /* Disable registry writing */
518                  return 0;      }
519              }  
520          }      if (!created) {
521          if (check_default_key (c)) {          memset (&reg_prefs, 0, sizeof (reg_prefs));
522              char * p = get_gnupg_default_key ();          reg_prefs.use_tmpfiles = 1; /* default */
523              log_box (_("WinPT Error"), MB_ERR,          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
524                       _("Default key from the GPG options file could not be found.\n"          get_reg_winpt_prefs (&reg_prefs);
525                         "Please check your gpg.conf (options) to correct this:\n\n"          gnupg_load_config ();
526                         "%s: public key not found."), p? p : "[null]");      }
527              free_if_alloc (p);  
528              DestroyWindow (hwnd);      if (is_gpg4win_installed ())
529              free_gnupg_table ();          load_gpg_env (); /* XXX: check return code. */
530              return 0;  
531          }      rc = gnupg_check_homedir ();
532          if (count_insecure_elgkeys ())      if (rc) {
533              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,          log_box (_("WinPT Error"), MB_ERR,
534                              elgamal_warn_dlg_proc, NULL);                   _("GPG home directory is not set correctly.\n"
535      }                     "Please check the GPG registry settings:\n%s."),
536                     winpt_strerror (rc));
537      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);          s = get_fileopen_dlg (GetActiveWindow (),
538      keyring_check_last_access (); /* init */                                _("Select GPG Public Keyring"),
539      while (GetMessage (&msg, hwnd, 0, 0)) {                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
540          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {                                NULL);
541              TranslateMessage (&msg);          if (s != NULL) {
542              DispatchMessage (&msg);              size_t n;
543          }              char *p = strrchr (s, '\\');
544      }              if (!p)
545                            BUG (0);
546      return 0;              n = p - s;
547  } /* WinMain */              if (n) {
548                    char *file = new char[n+1];
549                    if (!file)
550                        BUG (NULL);
551                    memset (file, 0, n);
552                    memcpy (file, s, n);
553                    file[n] = '\0';        
554                    set_reg_entry_gpg ("HomeDir", file);
555                    free_if_alloc (file);
556                    gnupg_check_homedir (); /* change gpgProgram if needed */
557                }
558            }
559            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.28  
changed lines
  Added in v.190
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26