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