/[winpt]/trunk/Src/WinPT.cpp
ViewVC logotype

Diff of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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