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