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