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