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