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