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

Legend:
Removed from v.4  
changed lines
  Added in v.231

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26