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