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