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