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