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