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