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