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