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