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