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