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