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