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