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