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