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