/[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 42 by werner, Fri Oct 28 08:25:30 2005 UTC revision 409 by twoaday, Mon Feb 6 19:39:00 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 <windows.h>  #include <shlobj.h>
22    
23  #include "../resource.h"  #include "resource.h"
24  #include "wptTypes.h"  #include "wptTypes.h"
25  #include "wptW32API.h"  #include "wptW32API.h"
26  #include "wptVersion.h"  #include "wptVersion.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  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      nls = get_gettext_lang ();  
185      if (nls) {  /* Load the GPG environment. On the first start, some
186          set_gettext_file ("winpt", nls);     checks are performed to find out in what state GPG is.
187          file = make_filename (nls, "winpt", "mo");     Return value: 0  everything OK.
188          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {                   >0  fatal error.
189              if (!prev_inst)                   -1 public keyring is empty or does not exist. */
190                  msg_box (NULL, _("Could not initizalize file lock.\n"  static int
191                                   "Native Language Support"),  load_gpg_env (void)
192                           _("WinPT Error"), MB_ERR);  {
193        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      free_if_alloc (defkey);          if (err) {
248      return err? -1 : 0;              free_if_alloc (defkey);
249  }              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;  
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)      // 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        if (!GetVersionEx (&osver)) {
379            MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
380            return 0;
381        }
382    
383        if (osver.dwMajorVersion < 5 ||
384            (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
385            MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
386            return 0;
387        }
388        
389        return 1;
390    }
391        
392  /* Main entry point. */  /* Main entry point. */
393  int WINAPI  int WINAPI
394  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
395  {  {
396      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};
397      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;  
398      MSG msg;      MSG msg;
399      HWND hwnd = NULL;      HWND hwnd = NULL;
400        WORD ver[3], ptdver[4];
401        
402        const char *s;
403        int rc, ec, created = 0;
404        int first_start = 0, start_gpgprefs = 0;
405        int winpt_inst_found = 0;
406        int start_manager = 0;    
407        
408        log_debug("check OS version");
409        if (!check_os_version ())
410            return 0;
411        
412      glob_hinst = hinst;      glob_hinst = hinst;
413        
414      #ifdef _DEBUG      /* Allow to shutdown the process, for instance by an installer */
415      gpg_set_debug_mode (1);      if (cmdline && stristr (cmdline, "--stop")) {
416      debug = 1;          hwnd = FindWindow ("WinPT", "WinPT");
417      #endif          if (hwnd != NULL) {
418                log_debug("shutdown an existing WinPT process");
419      s = PTD_get_version ();              PostMessage (hwnd, WM_DESTROY, 0, 0);
420      if (strcmp (s, MIN_PTD_VER)) {          }
         log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,  
                  _("Please update your PTD.dll to the newest version, "  
                    "the version (%s) you use is too old."), s);  
421          return 0;          return 0;
422      }      }    
423    
424      if (gpg_md_selftest ()) {      log_debug("check PTD and GPGME version");
425          msg_box (NULL, _("Cryptographic selftest failed."),      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
426                   _("WinPT Error"), MB_ERR);      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
427        if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1] || ptdver[2] != ver[2])) {
428            log_box (_("WinPT Error"), MB_ERR,
429                     _("The PTD.dll file has a different version than WinPT.exe\n"
430                       "Please update the PTD.dll to version %d.%d.%d"),
431                       ver[0], ver[1], ver[2]);
432          return 0;          return 0;
433      }      }
434    
435      s = gpgme_check_version (MIN_GPGME_VER);      s = gpgme_check_version (NEED_GPGME_VERSION);
436      if (!s || !*s) {      if (!s || !*s) {
437          msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),          msg_box (GetDesktopWindow (),
438                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
439                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
440          return 0;          return 0;
441      }      }
# Line 284  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 443  WinMain (HINSTANCE hinst, HINSTANCE hpre
443      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
444      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
445          winpt_inst_found = 1;          winpt_inst_found = 1;
446        
447        gettext_set_user_domain ();
448    
449      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
450          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 */  
     }  
451    
452      if (!created) {      if (!created) {
453          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 */  
454          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
455          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
456              hotkeys_modify ();          if (gnupg_load_config () == -2)
457          gnupg_load_config ();              msg_box (GetDesktopWindow (),
458                         _("The gpg.conf file contains the 'textmode' option\n"
459                           "which leads to broken binary output during decryption.\n"
460                           "If this is on purpose, just continue otherwise the option should be disabled."),
461                         _("WinPT Error"), MB_ERR);
462        }
463    
464        if (is_gpg4win_installed ()) {
465            log_debug("gpg4win: load gpg environment");
466            load_gpg_env (); /* TODO: check return code. */
467      }      }
468    
469      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
470      if (rc) {      if (rc) {  
471          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
472                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
473                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
474                   winpt_strerror (rc));                   winpt_strerror (rc));
475          const char * s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
476                                             _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
477                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
478                                             NULL);                                NULL);
479          if (s != NULL) {          
480              size_t n;          char * p;
481              char * p = strrchr (s, '\\');          if (s != NULL && (p = strrchr (s, '\\'))) {
482              if (!p)              char *path = substr (s, 0, (p-s));
483                  BUG (0);  
484              n = p - s;              set_reg_entry_gpg ("HomeDir", path);
485              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 */  
             }  
486          }          }
487          else {          else {
488              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (GetDesktopWindow (),
489                         _("GPG home directory could not be determined."),
490                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
491              goto start;              goto start;
492          }          }
# Line 350  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 494  WinMain (HINSTANCE hinst, HINSTANCE hpre
494    
495      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
496      if (rc) {      if (rc) {
497          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
498                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
499                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
500                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
501                         MB_INFO|MB_YESNO) == IDYES)
502              start_gpgprefs = 1;              start_gpgprefs = 1;
503          else          else {
504          {              msg_box (GetDesktopWindow (),
505              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);                       winpt_strerror (rc), _("WinPT Error"), MB_ERR);
506              return 0;              return 0;
507          }          }
508      }      }
# Line 365  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 510  WinMain (HINSTANCE hinst, HINSTANCE hpre
510      rc = gnupg_access_files ();      rc = gnupg_access_files ();
511      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
512          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
513              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
514                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
515                    "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"
516                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
517                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
518              if (ec == IDYES)              if (ec == IDYES)
519                  first_start = 1;                  first_start = 1;
520          }          }
521          if (!first_start) {          if (!first_start) {
522              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
523              return 0;              return 0;
524          }          }
525      }      }
526        if (check_for_empty_keyrings (false))
527            first_start = 1;
528    
529      if (!first_start) {      if (!first_start) {
530          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
531          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
532              gpg_read_only = 1;              gpg_read_only = 1;
533          else if (rc)          else if (rc)
534              return 0;              return 0;
535      }      }
536        
     load_gettext (winpt_inst_found);  
537      init_gnupg_table ();      init_gnupg_table ();
538    
539      nfiles = fm_parse_command_line (cmdline);      if (fm_parse_command_line (cmdline) > 0) {
     if (nfiles > 0) {  
         free_gnupg_table ();  
         return 0;  
     }  
   
     if (cmdline && stristr (cmdline, "--wipe-freespace")) {  
         dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,  
                             GetDesktopWindow(), space_wipefrees_dlg_proc, NULL,  
                             _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);  
540          free_gnupg_table ();          free_gnupg_table ();
541          return 0;          return 0;
542      }      }
543    
544      load_keyserver_conf (cmdline? 1 : 0);      rc = kserver_load_conf ();
545        if (rc)
546            msg_box (GetDesktopWindow (), winpt_strerror (rc),
547                     _("Keyserver"), MB_ERR);
548    
549      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
550                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
551          update_keycache (GetDesktopWindow ());          /* If an instance of WinPT is running, just send the command
552               to open the key manager. Otherwise start a new instance. */
553            HWND tray = FindWindow ("WinPT", "WinPT");
554          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
555              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              start_manager = ID_WINPT_KEY;
556                              GetDesktopWindow(), keymanager_dlg_proc, NULL,          else
557                              _("Key Manager"), IDS_WINPT_KEYMISC);                start_manager = ID_WINPT_CARD;
558          else {          if (tray != NULL) {
559              gpg_card_t crd = gpg_card_load ();              PostMessage (tray, WM_COMMAND, start_manager, 0);
560              if (crd)              free_gnupg_table ();
561                  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);  
562          }          }
         keycache_release (0);  
         free_gnupg_table ();  
         return 0;  
563      }      }
564    
565      /* 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 570  WinMain (HINSTANCE hinst, HINSTANCE hpre
570          return 0;          return 0;
571      }      }
572    
573      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
574          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
575              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
576              winpt_debug_msg ();          winpt_debug_msg ();
577              debug = 1;          debug = 1;
         }  
578      }      }
579    
580      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
581      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
582      if (rc == FALSE) {      if (rc == FALSE) {
583          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
584                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
585          free_gnupg_table ();          free_gnupg_table ();
586          return 0;          return 0;
# Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 594  WinMain (HINSTANCE hinst, HINSTANCE hpre
594                           hinst,                           hinst,
595                           NULL);                           NULL);
596      if (hwnd == NULL) {      if (hwnd == NULL) {
597          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
598                     _("Could not create window"),
599                     _("WinPT Error"), MB_ERR);
600          free_gnupg_table ();          free_gnupg_table ();
601          return 0;          return 0;
602      }      }
# Line 468  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 604  WinMain (HINSTANCE hinst, HINSTANCE hpre
604      UpdateWindow (hwnd);      UpdateWindow (hwnd);
605    
606      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
607            log_debug("backup gpg config file and check back-end");
608          gnupg_backup_options ();                  gnupg_backup_options ();        
609          rc = check_crypto_engine ();          if (!check_crypto_engine ()) {
         if (rc) {  
610              DestroyWindow (hwnd);              DestroyWindow (hwnd);
611              free_gnupg_table ();              free_gnupg_table ();
612              return 0;              return 0;
# Line 478  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 614  WinMain (HINSTANCE hinst, HINSTANCE hpre
614      }      }
615            
616      if (start_gpgprefs) {      if (start_gpgprefs) {
         char *ring;  
         size_t size = 0;  
617          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
618                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
619          ring = get_gnupg_keyring (0, !NO_STRICT);          if (check_for_empty_keyrings (true))
620          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);  
621      }      }
622    
623      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
624          struct genkey_s c;          struct genkey_s c;
625            int choice;
626          HWND h;          HWND h;
627  start:  start:
628          h = GetDesktopWindow ();          h = GetDesktopWindow ();
629          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
630                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
631                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
632          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
633                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
634          switch (fs.choice) {          switch (choice) {
635          case SETUP_KEYGEN:          case SETUP_KEYGEN:
636              c.interactive = 1;              c.interactive = 1;
637              c.first_start = 1;              c.first_start = 1;
# Line 516  start: Line 649  start:
649              }              }
650              break;              break;
651    
652          case -1:          case SETUP_EXISTING:
653                rc = gnupg_import_keypair ();
654                if (rc) {
655                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
656                    goto start;
657                }
658                break;
659    
660            case SETUP_CARDGEN:
661                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
662                                     h, card_keygen_dlg_proc, 0);
663                if (!rc)
664                    goto start;
665                break;
666    
667            case 0: /* Cancel/Abort. */
668            default:
669              DestroyWindow (hwnd);              DestroyWindow (hwnd);
670              free_gnupg_table ();              free_gnupg_table ();
671              return 0;              return 0;
672          }          }
673          update_keycache (hwnd);          update_keycache (hwnd);
674          check_crypto_engine ();          if (!check_crypto_engine ()) {
675                DestroyWindow (hwnd);
676                free_gnupg_table ();
677                keycache_release (1);
678                return 0;
679            }
680      }      }
681      else {      else {
682          gpg_keycache_t c;          gpg_keycache_t c;
683          update_keycache (hwnd);          if (update_keycache (hwnd)) {
684                DestroyWindow (hwnd);
685                free_gnupg_table ();
686                keycache_release (1);
687                return 0;
688            }
689            /* XXX: rewrite this part. */
690          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
691          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
692              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
693                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
694                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
695              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"              ec = msg_box (GetDesktopWindow (),
696                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
697                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
698                              "WinPT", MB_INFO|MB_YESNO);
699              if (ec == IDYES) {              if (ec == IDYES) {
700                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
701                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 544  start: Line 704  start:
704              else {              else {
705                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
706                  free_gnupg_table ();                  free_gnupg_table ();
707                    keycache_release (1);
708                  return 0;                  return 0;
709              }              }
710          }          }      
711          if (check_default_key (c)) {          if (check_default_key ()) {
712              char * p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
713              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
714                       _("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"
715                         "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"
716                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
717                set_gnupg_default_key (NULL);
718              free_if_alloc (p);              free_if_alloc (p);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
719          }          }
720          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
721              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
722                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
723      }      }
724      
725        if (start_manager)
726            PostMessage (hwnd, WM_COMMAND, start_manager, 0);
727    
728      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);      accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
729      keyring_check_last_access (); /* init */      keyring_check_last_access (); /* init */
# Line 571  start: Line 733  start:
733              DispatchMessage (&msg);              DispatchMessage (&msg);
734          }          }
735      }      }
736                
737      return 0;      return 0;
738  }  }
Legend:
Removed from v.42  
changed lines
  Added in v.409
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26