/[winpt]/trunk/Src/WinPT.cpp
ViewVC logotype

Diff of /trunk/Src/WinPT.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 34 by twoaday, Wed Oct 26 11:20:09 2005 UTC revision 66 by twoaday, Thu Nov 3 17:55:18 2005 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-2005 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * WinPT is free software; you can redistribute it and/or modify
7   * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
8   * the Free Software Foundation; either version 2 of the License, or   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
15   *   *
16   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19   */   */
20  #include <windows.h>  #ifdef HAVE_CONFIG_H
21    #include <config.h>
22  #include "../resource.h"  #endif
23  #include "wptTypes.h"  
24  #include "wptW32API.h"  #include <windows.h>
25  #include "wptVersion.h"  
26  #include "wptErrors.h"  #include "resource.h"
27  #include "wptGPG.h"  #include "wptTypes.h"
28  #include "wptRegistry.h"  #include "wptW32API.h"
29  #include "wptCommonCtl.h"  #include "wptVersion.h"
30  #include "wptDlgs.h"  #include "wptErrors.h"
31  #include "wptNLS.h"  #include "wptGPG.h"
32  #include "wptKeyserver.h"  #include "wptRegistry.h"
33  #include "wptCard.h"  #include "wptCommonCtl.h"
34  #include "wptFileManager.h"  #include "wptDlgs.h"
35  #include "wptContext.h"  #include "wptNLS.h"
36  #include "wptCardEdit.h"  #include "wptKeyserver.h"
37    #include "wptCard.h"
38    #include "wptFileManager.h"
39  #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */  #include "wptContext.h"
40  #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */  #include "wptCardEdit.h"
41  #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */  #include "wptCrypto.h"
42    
43    #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */
44  HINSTANCE glob_hinst;   /* global instance for the dialogs */  #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */
45  HWND glob_hwnd;         /* global window handle for the dialogs */  #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */
46  HWND activ_hwnd;  
47  LOCK mo_file;  
48  int scard_support = 0;  HINSTANCE glob_hinst;   /* global instance for the dialogs */
49  int debug = 0;  HWND glob_hwnd;         /* global window handle for the dialogs */
50  int mobile = 0;  HWND activ_hwnd;
51  int gpg_read_only = 0;  LOCK mo_file;
52  char gpgver[3];  int scard_support = 0;
53    int debug = 0;
54    int mobile = 0;
55  /* Load the key cache and rebuild the signature cache. */  int gpg_read_only = 0;
56  static void  char gpgver[3];
57  update_keycache (HWND hwnd)  
58  {  
59      refresh_cache_s rcs = {0};  /* Load the key cache and rebuild the signature cache. */
60      rcs.kr_reload = 0;  static void
61      rcs.kr_update = 1;  update_keycache (HWND hwnd)
62      rcs.tr_update = 1;  {
63      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      refresh_cache_s rcs = {0};
64                      keycache_dlg_proc, (LPARAM)&rcs);      rcs.kr_reload = 0;
65  }      rcs.kr_update = 1;
66        rcs.tr_update = 1;
67        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
68  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */                      keycache_dlg_proc, (LPARAM)&rcs);
69  void  }
70  gpg_set_debug_mode (int val)  
71  {        
72      if (val)  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
73          putenv ("GPGME_DEBUG=5:gpgme.dbg");  void
74      else  gpg_set_debug_mode (int val)
75          putenv ("GPGME_DEBUG=");  {      
76  }      if (val)
77            putenv ("GPGME_DEBUG=5:gpgme.dbg");
78        else
79  /* Return the name of the gettext language file. */          putenv ("GPGME_DEBUG=");
80  static char*  }
81  get_gettext_lang (void)  
82  {      
83      char *fname;  /* Return the name of the gettext language file. */
84      fname = get_reg_entry_mo ();  static char*
85      if (!fname)  get_gettext_lang (void)
86          return NULL;  {    
87      return fname;      char *fname;
88  }      fname = get_reg_entry_mo ();
89        if (!fname)
90            return NULL;
91  /* Initialize the gettext sub system. */      return fname;
92  static void  }
93  load_gettext (int prev_inst)  
94  {  
95      char *nls = NULL;  /* Initialize the gettext sub system. */
96      char *file = NULL;  static void
97    load_gettext (int prev_inst)
98      nls = get_gettext_lang ();  {
99      if (nls) {      char *nls = NULL;
100          set_gettext_file ("winpt", nls);      char *file = NULL;
101          file = make_filename (nls, "winpt", "mo");  
102          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {      nls = get_gettext_lang ();
103              if (!prev_inst)      if (nls) {
104                  msg_box (NULL, _("Could not initizalize file lock.\n"          set_gettext_file ("winpt", nls);
105                                   "Native Language Support"),          file = make_filename (nls, "winpt", "mo");
106                           _("WinPT Error"), MB_ERR);          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {
107          }              if (!prev_inst)
108          free_if_alloc (nls);                  msg_box (NULL, _("Could not initizalize file lock.\n"
109          free_if_alloc (file);                                   "Native Language Support"),
110      }                           _("WinPT Error"), MB_ERR);
111  }          }
112            free_if_alloc (nls);
113            free_if_alloc (file);
114  /* check if the default key from the gpg.conf file is available in the      }
115     keyring. if not, bail out because encryption won't work properly then. */  }
116  static int  
117  check_default_key (gpg_keycache_t kc)  
118  {  /* check if the default key from the gpg.conf file is available in the
119      gpgme_key_t key;     keyring. if not, bail out because encryption won't work properly then. */
120      gpgme_error_t err = GPG_ERR_NO_ERROR;  static int
121      char * defkey;  check_default_key (gpg_keycache_t kc)
122    {
123      defkey = get_gnupg_default_key ();      gpgme_key_t key;
124      if (defkey)      gpgme_error_t err = GPG_ERR_NO_ERROR;
125          err = gpg_keycache_find_key (kc, defkey, 0, &key);      char * defkey;
126      free_if_alloc (defkey);  
127      return err? -1 : 0;      defkey = get_gnupg_default_key ();
128  }      if (defkey)
129            err = gpg_keycache_find_key (kc, defkey, 0, &key);
130        else
131  /* Return the WinPT program file name (with full pathname). */          msg_box (NULL, _("No useable secret key found."), _("WinPT Error"), MB_ERR);
132  static const char *      free_if_alloc (defkey);
133  get_prog_part (const char * fname, int use_cwd)      return err? -1 : 0;
134  {  }
135      static char program[512];  
136      char currdir[256];  
137      char *cmd = NULL;  /* Return the WinPT program file name (with full pathname). */
138      int j;  static const char *
139            get_prog_part (const char * fname, int use_cwd)
140      memset (currdir, 0, DIM (currdir));  {
141      memset (program, 0, DIM (program));      static char program[512];
142                char currdir[256];
143      if (use_cwd) {      char *cmd = NULL;
144          GetCurrentDirectory (DIM (currdir)-1, currdir);      int j;
145          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);          
146      }      memset (currdir, 0, DIM (currdir));
147      else {      memset (program, 0, DIM (program));
148          cmd = GetCommandLine ();          
149          if (cmd == NULL)      if (use_cwd) {
150              return NULL;          GetCurrentDirectory (DIM (currdir)-1, currdir);
151          strncpy (currdir, cmd, sizeof (currdir)-1);          _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
152          j = strlen (currdir);      }
153          while (j--) {      else {
154              if (currdir[j] == '\\')          cmd = GetCommandLine ();
155                  break;          if (cmd == NULL)
156          }              return NULL;
157          currdir[j] = 0;          strncpy (currdir, cmd, sizeof (currdir)-1);
158          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);          j = strlen (currdir);
159      }          while (j--) {
160      return program;              if (currdir[j] == '\\')
161  }                  break;
162            }
163            currdir[j] = 0;
164  /* Check that the underlying crypto engine fullfills the minimal          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
165     requirements so all commands work properly. */      }
166  static int      return program;
167  check_crypto_engine (void)  }
168  {  
169      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */  
170      int rc;  /* Check that the underlying crypto engine fullfills the minimal
171       requirements so all commands work properly. */
172      rc = check_gnupg_engine (&ma, &mi, &pa);  static int
173      if (rc == -1) {  check_crypto_engine (void)
174          msg_box (NULL, _("Could not read GnuPG version."),  {
175                   _("WinPT Error"), MB_ERR);      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */
176          return rc;      int rc;
177      }  
178      else if (rc) {      rc = check_gnupg_engine (&ma, &mi, &pa);
179          log_box (_("WinPT Error"), MB_ERR,      if (rc == -1) {
180                   _("Sorry, you need a newer GPG version.\n"          msg_box (NULL, _("Could not read GnuPG version."),
181                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),                   _("WinPT Error"), MB_ERR);
182                     ma, mi, pa);          return rc;
183          return rc;      }
184      }      else if (rc) {
185      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */          log_box (_("WinPT Error"), MB_ERR,
186      if (ma >= 1 && mi >= 4)                   _("Sorry, you need a newer GPG version.\n"
187          scard_support = 1;                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),
188                       ma, mi, pa);
189      gpgver[0] = ma;          return rc;
190      gpgver[1] = mi;      }
191      gpgver[2] = pa;      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */
192      return rc;      if ((ma == 1 && mi >= 4) || ma > 1)
193  }          scard_support = 1;
194    
195        gpgver[0] = ma;
196  /* Try to load the keyserver config file. If @quiet is 1      gpgver[1] = mi;
197     do not show any errors. */      gpgver[2] = pa;
198  static int      return rc;
199  load_keyserver_conf (int quiet)  }
200  {  
201      const char * t;  
202      int rc;  /* Try to load the keyserver config file. If @quiet is 1
203       do not show any errors. */
204      if (reg_prefs.kserv_conf)  static int
205          t = reg_prefs.kserv_conf;  load_keyserver_conf (int quiet)
206      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))  {
207          t = get_prog_part ("keyserver.conf", 0);      const char * t;
208      else      int rc;
209          t = "keyserver.conf";  
210      rc = kserver_load_conf (t);      if (reg_prefs.kserv_conf)
211      if (rc && !quiet)          t = reg_prefs.kserv_conf;
212          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);      else if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
213      return rc;          t = get_prog_part ("keyserver.conf", 0);
214  }      else
215            t = "keyserver.conf";
216        rc = kserver_load_conf (t);
217  /* Enable the mobility mode. */      if (rc && !quiet)
218  static void          msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
219  enable_mobile_mode (void)      return rc;
220  {  }
221      memset (&reg_prefs, 0, sizeof (reg_prefs));  
222      reg_prefs.always_trust = 0;  
223      reg_prefs.auto_backup = 0;  /* Enable the mobility mode. */
224      reg_prefs.cache_time = 0;  static void
225      reg_prefs.expert = 0;  enable_mobile_mode (void)
226      reg_prefs.keylist_mode = 1;  {
227      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      memset (&reg_prefs, 0, sizeof (reg_prefs));
228      reg_prefs.no_zip_mmedia = 1;      reg_prefs.always_trust = 0;
229      reg_prefs.use_tmpfiles = 1;      reg_prefs.auto_backup = 0;
230      reg_prefs.word_wrap = 80;      reg_prefs.cache_time = 0;
231      reg_prefs.use_viewer = 0; /* XXX */      reg_prefs.expert = 0;
232  }      reg_prefs.keylist_mode = 1;
233        reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
234  char* multi_gnupg_path (void);      reg_prefs.no_zip_mmedia = 1;
235        reg_prefs.use_tmpfiles = 1;
236  /* Main entry point. */      reg_prefs.word_wrap = 80;
237  int WINAPI      reg_prefs.use_viewer = 0; /* XXX */
238  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  }
239  {  
240      WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};  char* multi_gnupg_path (void);
241      HACCEL accel_tab;  
242      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;  const char * fm_get_file_type (const char *fname, int *r_type);
243      int first_start = 0, start_gpgprefs = 0;  
244      int winpt_inst_found = 0;  /* Main entry point. */
245      const char *s;  int WINAPI
246      MSG msg;  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
247      HWND hwnd = NULL;  {
248        WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
249      glob_hinst = hinst;      HACCEL accel_tab;
250        int rc, ec, created = 0, nfiles = 0;
251      #ifdef _DEBUG      int first_start = 0, start_gpgprefs = 0;
252      gpg_set_debug_mode (1);      int winpt_inst_found = 0;
253      debug = 1;      const char *s;
254      #endif      MSG msg;
255        HWND hwnd = NULL;
256      s = PTD_get_version ();  
257      if (strcmp (s, MIN_PTD_VER)) {      glob_hinst = hinst;
258          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,  
259                   _("Please update your PTD.dll to the newest version, "  #ifdef _DEBUG
260                     "the version (%s) you use is too old."), s);      gpg_set_debug_mode (1);
261          return 0;      debug = 1;
262      }  #endif
263    
264      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
265          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
266                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
267          return 0;          return 0;
268      }      }
269    
270      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (MIN_GPGME_VER);
271      if (!s || !*s) {      if (!s || !*s) {
272          msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),          msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),
273                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
274          return 0;          return 0;
275      }      }
276    
277      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
278      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
279          winpt_inst_found = 1;          winpt_inst_found = 1;
280    
281      if (cmdline && stristr (cmdline, "--mobile")) {      if (cmdline && stristr (cmdline, "--mobile")) {
282          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
283                   "WinPT", MB_INFO);                   "WinPT", MB_INFO);
284          mobile = 1;          mobile = 1;
285      }      }
286    
287      set_default_kserver ();      set_default_kserver ();
288    
289      if (!mobile) {      if (!mobile) {
290          regist_inst_gnupg (1);          regist_inst_gnupg (1);
291          regist_inst_winpt (1, &created);          regist_inst_winpt (1, &created);
292      }      }
293      else {      else {
294          enable_mobile_mode ();          enable_mobile_mode ();
295          /* XXX: ask for GPG path */          /* XXX: ask for GPG path */
296          created = 1; /* Disable registry writing */          created = 1; /* Disable registry writing */
297      }      }
298    
299      if (!created) {      if (!created) {
300          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
301          reg_prefs.use_tmpfiles = 1; /* default */          reg_prefs.use_tmpfiles = 1; /* default */
302          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
303          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
304          if (!reg_prefs.no_hotkeys)          if (!reg_prefs.no_hotkeys)
305              hotkeys_modify ();              hotkeys_modify ();
306      }          gnupg_load_config ();
307        }
308      rc = gnupg_check_homedir ();  
309      if (rc) {      rc = gnupg_check_homedir ();
310          log_box (_("WinPT Error"), MB_ERR,      if (rc) {
311                   _("GPG home directory is not set correctly.\n"          log_box (_("WinPT Error"), MB_ERR,
312                     "Please check the GPG registry settings:\n%s."),                   _("GPG home directory is not set correctly.\n"
313                   winpt_strerror (rc));                     "Please check the GPG registry settings:\n%s."),
314          const char * s = get_fileopen_dlg (GetActiveWindow (),                   winpt_strerror (rc));
315                                             _("Select GPG Public Keyring"),          s = get_fileopen_dlg (GetActiveWindow (),
316                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                _("Select GPG Public Keyring"),
317                                             NULL);                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
318          if (s != NULL) {                                NULL);
319              size_t n;          if (s != NULL) {
320              char * p = strrchr (s, '\\');              size_t n;
321              if (!p)              char * p = strrchr (s, '\\');
322                  BUG (0);              if (!p)
323              n = p - s;                  BUG (0);
324              if (n) {              n = p - s;
325                  char * file = new char[n+1];              if (n) {
326                  if (!file)                  char * file = new char[n+1];
327                      BUG (NULL);                  if (!file)
328                  memset (file, 0, n);                      BUG (NULL);
329                  memcpy (file, s, n);                  memset (file, 0, n);
330                  file[n] = '\0';                          memcpy (file, s, n);
331                  set_reg_entry_gpg ("HomeDir", file);                  file[n] = '\0';        
332                  free_if_alloc (file);                  set_reg_entry_gpg ("HomeDir", file);
333                  gnupg_check_homedir (); /* change gpgProgram if needed */                  free_if_alloc (file);
334              }                  gnupg_check_homedir (); /* change gpgProgram if needed */
335          }              }
336          else {          }
337              msg_box (NULL, _("GPG home directory could not be determited."),          else {
338                       _("WinPT Error"), MB_ERR);              msg_box (NULL, _("GPG home directory could not be determited."),
339              goto start;                       _("WinPT Error"), MB_ERR);
340          }              goto start;
341      }          }
342        }
343      rc = check_gnupg_prog ();  
344      if (rc) {      rc = check_gnupg_prog ();
345          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"      if (rc) {
346                               "Do you want to start the GPG preferences to "          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
347                               "correct  this problem?"), _("WinPT Error"),                               "Do you want to start the GPG preferences to "
348                               MB_INFO|MB_YESNO) == IDYES)                               "correct  this problem?"), _("WinPT Error"),
349              start_gpgprefs = 1;                               MB_INFO|MB_YESNO) == IDYES)
350          else              start_gpgprefs = 1;
351          {          else
352              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          {
353              return 0;              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
354          }              return 0;
355      }          }
356        }
357      rc = gnupg_access_files ();  
358      if (!start_gpgprefs && rc) {      rc = gnupg_access_files ();
359          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {      if (!start_gpgprefs && rc) {
360              ec = msg_box (NULL,          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
361                  _("Could not access and/or find the public and secret keyring.\n"              ec = msg_box (NULL,
362                    "If this is an accident, quit the program and fix it.\n\n"                  _("Could not access and/or find the public and secret keyring.\n"
363                    "Continue if you want that WinPT offers you more choices.\n"),                    "If this is an accident, quit the program and fix it.\n\n"
364                    "WinPT", MB_INFO|MB_YESNO);                    "Continue if you want that WinPT offers you more choices.\n"),
365              if (ec == IDYES)                    "WinPT", MB_INFO|MB_YESNO);
366                  first_start = 1;              if (ec == IDYES)
367          }                  first_start = 1;
368          if (!first_start) {          }
369              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);          if (!first_start) {
370              return 0;              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
371          }              return 0;
372      }          }
373        }
374      if (!first_start) {  
375          rc = gpg_check_permissions (1);      if (!first_start) {
376          if (rc && rc == 2)          rc = gpg_check_permissions (1);
377              gpg_read_only = 1;          if (rc && rc == 2)
378          else if (rc)              gpg_read_only = 1;
379              return 0;          else if (rc)
380      }              return 0;
381        }
382      load_gettext (winpt_inst_found);  
383      init_gnupg_table ();      load_gettext (winpt_inst_found);
384        init_gnupg_table ();
385      nfiles = fm_parse_command_line (cmdline);  
386      if (nfiles > 0) {      nfiles = fm_parse_command_line (cmdline);
387          free_gnupg_table ();      if (nfiles > 0) {
388          return 0;          free_gnupg_table ();
389      }          return 0;
390        }
391      if (cmdline && stristr (cmdline, "--wipe-freespace")) {  
392          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
393                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
394                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                              GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,
395          free_gnupg_table ();                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
396          return 0;          free_gnupg_table ();
397      }          return 0;
398        }
399      load_keyserver_conf (cmdline? 1 : 0);  
400        load_keyserver_conf (cmdline? 1 : 0);
401      if (cmdline && (stristr (cmdline, "--keymanager")  
402                  || stristr (cmdline, "--cardmanager"))) {      if (cmdline && (stristr (cmdline, "--keymanager")
403          update_keycache (GetDesktopWindow ());                  || stristr (cmdline, "--cardmanager"))) {
404          if (stristr (cmdline, "keymanager"))          update_keycache (GetDesktopWindow ());
405              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,          if (stristr (cmdline, "keymanager"))
406                              GetDesktopWindow(), keymanager_dlg_proc, NULL,              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
407                              _("Key Manager"), IDS_WINPT_KEYMISC);                                GetDesktopWindow(), keymanager_dlg_proc, NULL,
408          else {                              _("Key Manager"), IDS_WINPT_KEYMISC);  
409              gpg_card_t crd = gpg_card_load ();          else {
410              if (crd)              gpg_card_t crd = gpg_card_load ();
411                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,              if (crd)
412                                    GetDesktopWindow(), card_edit_dlg_proc,                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
413                                    (LPARAM)crd, _("Card Manager"),                                    GetDesktopWindow(), card_edit_dlg_proc,
414                                    IDS_WINPT_CARD_EDIT);                                    (LPARAM)crd, _("Card Manager"),
415              gpg_card_release (crd);                                    IDS_WINPT_CARD_EDIT);
416          }              gpg_card_release (crd);
417          keycache_release (0);          }
418          free_gnupg_table ();          keycache_release (0);
419          return 0;          free_gnupg_table ();
420      }          return 0;
421        }
422      /* If we found another WinPT instance, just quit to avoid it  
423         will be executed twice. */      /* If we found another WinPT instance, just quit to avoid it
424      if (winpt_inst_found) {         will be executed twice. */
425          log_debug ("%s", "WinMain: WinPT is already running.");      if (winpt_inst_found) {
426          free_gnupg_table ();          log_debug ("%s", "WinMain: WinPT is already running.");
427          return 0;          free_gnupg_table ();
428      }          return 0;
429        }
430      if (cmdline) {  
431          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {      if (cmdline) {
432              gpg_set_debug_mode (1);          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {
433              winpt_debug_msg ();              gpg_set_debug_mode (1);
434              debug = 1;              winpt_debug_msg ();
435          }              debug = 1;
436      }          }
437        }
438      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));  
439      rc = RegisterClass (&wc);      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
440      if (rc == FALSE) {      rc = RegisterClass (&wc);
441          msg_box (NULL, _("Could not register window class"),      if (rc == FALSE) {
442                   _("WinPT Error"), MB_ERR);          msg_box (NULL, _("Could not register window class"),
443          free_gnupg_table ();                   _("WinPT Error"), MB_ERR);
444          return 0;          free_gnupg_table ();
445      }          return 0;
446        }
447      hwnd = CreateWindow (PGM_NAME,  
448                           PGM_NAME,      hwnd = CreateWindow (PGM_NAME,
449                           0, 0, 0, 0, 0,                           PGM_NAME,
450                           NULL,                           0, 0, 0, 0, 0,
451                           NULL,                           NULL,
452                           hinst,                           NULL,
453                           NULL);                           hinst,
454      if (hwnd == NULL) {                           NULL);
455          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);      if (hwnd == NULL) {
456          free_gnupg_table ();          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
457          return 0;          free_gnupg_table ();
458      }          return 0;
459      glob_hwnd = hwnd;      }
460      UpdateWindow (hwnd);      glob_hwnd = hwnd;
461        UpdateWindow (hwnd);
462      if (!first_start && !start_gpgprefs) {  
463          gnupg_backup_options ();              if (!first_start && !start_gpgprefs) {
464          rc = check_crypto_engine ();          gnupg_backup_options ();        
465          if (rc) {          rc = check_crypto_engine ();
466              DestroyWindow (hwnd);          if (rc) {
467              free_gnupg_table ();              DestroyWindow (hwnd);
468              return 0;              free_gnupg_table ();
469          }              return 0;
470      }          }
471            }
472      if (start_gpgprefs) {      
473          char *ring;      if (start_gpgprefs) {
474          size_t size = 0;          char *ring;
475          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,  
476                          gpgprefs_dlg_proc, NULL);          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
477          ring = get_gnupg_keyring (0, !NO_STRICT);                          gpgprefs_dlg_proc, 0);
478          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)          ring = get_gnupg_keyring (0, !NO_STRICT);
479              first_start = 1; /* The keyring is empty! */          if (gnupg_access_keyring (0) == -1 && get_file_size (ring) == 0)
480          free_if_alloc (ring);              first_start = 1; /* The keyring is empty! */
481      }          free_if_alloc (ring);
482        }
483      if (first_start) {  
484          struct first_start_s fs;      if (first_start) {
485          struct genkey_s c;          struct first_start_s fs;
486          HWND h;          struct genkey_s c;
487  start:          HWND h;
488          h = GetDesktopWindow ();  start:
489          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          h = GetDesktopWindow ();
490                              gpgprefs_dlg_proc, NULL);          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
491          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,                              gpgprefs_dlg_proc, 0);
492                          first_run_dlg_proc, (LPARAM)&fs);          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
493          switch (fs.choice) {                          first_run_dlg_proc, (LPARAM)&fs);
494          case SETUP_KEYGEN:          switch (fs.choice) {
495              c.interactive = 1;          case SETUP_KEYGEN:
496              c.first_start = 1;              c.interactive = 1;
497              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,              c.first_start = 1;
498                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
499              if (!rc)                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);
500                  goto start;              if (!rc)
501              break;                  goto start;
502                break;
503          case SETUP_IMPORT:  
504              rc = gnupg_copy_keyrings ();          case SETUP_IMPORT:
505              if (rc) {              rc = gnupg_copy_keyrings ();
506                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              if (rc) {
507                  goto start;                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
508              }                  goto start;
509              break;              }
510                break;
511          case -1:  
512              DestroyWindow (hwnd);          case -1:
513              free_gnupg_table ();              DestroyWindow (hwnd);
514              return 0;              free_gnupg_table ();
515          }              return 0;
516          update_keycache (hwnd);          }
517          check_crypto_engine ();          update_keycache (hwnd);
518      }          check_crypto_engine ();
519      else {      }
520          gpg_keycache_t c;      else {
521          update_keycache (hwnd);          gpg_keycache_t c;
522          c = keycache_get_ctx (1);          update_keycache (hwnd);
523          if (!c || !gpg_keycache_get_size (c)) {          c = keycache_get_ctx (1);
524              gnupg_display_error ();          if (!c || !gpg_keycache_get_size (c)) {
525              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              gnupg_display_error ();
526                               "Please check your GPG config (keyrings, pathes...)"),              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
527                               _("WinPT Error"), MB_ERR);                               "Please check your GPG config (keyrings, pathes...)"),
528              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"                               _("WinPT Error"), MB_ERR);
529                                    "Do you want to start the GPG preferences dialog?"),              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
530                              "WinPT", MB_INFO|MB_YESNO);                                    "Do you want to start the GPG preferences dialog?"),
531              if (ec == IDYES) {                              "WinPT", MB_INFO|MB_YESNO);
532                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,              if (ec == IDYES) {
533                                  gpgprefs_dlg_proc, NULL);                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
534                  update_keycache (hwnd);                                  gpgprefs_dlg_proc, 0);
535              }                  update_keycache (hwnd);
536              else {              }
537                  DestroyWindow (hwnd);              else {
538                  free_gnupg_table ();                  DestroyWindow (hwnd);
539                  return 0;                  free_gnupg_table ();
540              }                  return 0;
541          }              }
542          if (check_default_key (c)) {          }
543              char * p = get_gnupg_default_key ();          if (check_default_key (c)) {
544              log_box (_("WinPT Error"), MB_ERR,              char * p = get_gnupg_default_key ();
545                       _("Default key from the GPG options file could not be found.\n"              log_box (_("WinPT Error"), MB_ERR,
546                         "Please check your gpg.conf (options) to correct this:\n\n"                       _("Default key from the GPG options file could not be found.\n"
547                         "%s: public key not found."), p? p : "[null]");                         "Please check your gpg.conf (options) to correct this:\n\n"
548              free_if_alloc (p);                         "%s: public key not found."), p? p : "[null]");
549              DestroyWindow (hwnd);              free_if_alloc (p);
550              free_gnupg_table ();              DestroyWindow (hwnd);
551              return 0;              free_gnupg_table ();
552          }              return 0;
553          if (count_insecure_elgkeys ())          }
554              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,          if (count_insecure_elgkeys ())
555                              elgamal_warn_dlg_proc, NULL);              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
556      }                              elgamal_warn_dlg_proc, 0);
557        }
558      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);  
559      keyring_check_last_access (); /* init */      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
560      while (GetMessage (&msg, hwnd, 0, 0)) {      keyring_check_last_access (); /* init */
561          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {      while (GetMessage (&msg, hwnd, 0, 0)) {
562              TranslateMessage (&msg);          if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
563              DispatchMessage (&msg);              TranslateMessage (&msg);
564          }              DispatchMessage (&msg);
565      }          }
566                }
567      return 0;          
568  }      return 0;
569    }
Legend:
Removed from v.34  
changed lines
  Added in v.66
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26