/[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 159 by twoaday, Wed Jan 18 13:57:31 2006 UTC revision 337 by twoaday, Sun Nov 27 12:38:43 2011 UTC
# Line 1  Line 1 
1  /* WinPT.cpp - Windows Privacy Tray (WinPT)  /* WinPT.cpp - Windows Privacy Tray (WinPT)
2   *      Copyright (C) 2000-2006 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>
# Line 40  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    void remove_crit_file_attrs (const char *fname, int force);
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;  
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  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
54  static void  int
55  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
56  {  {
57      refresh_cache_s rcs = {0};      int err;
58      rcs.kr_reload = 0;      refresh_cache_s rcs;
59      rcs.kr_update = 1;  
60      rcs.tr_update = 1;      /* no need to rebuild the sig cache each time. */
61      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      memset (&rcs, 0, sizeof (rcs));
62        rcs.kring_update = 1;
63        err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
64                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
65        if (err) {
66            char *cfgf = get_gnupg_config ();
67            if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
68                msg_box (GetDesktopWindow (),
69                         _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
70            free_if_alloc (cfgf);
71            return -1;
72        }
73        return 0;
74  }  }
75    
76    
77  /* 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. */
78  void  void
79  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
80  {        {
81      if (val)      static char buf[MAX_PATH+1];
82          putenv ("GPGME_DEBUG=5:gpgme.dbg");      char tmp[128];
83        
84        /* XXX: no gpgme.dbg is created. */
85        if (val > 0) {
86            GetTempPath (DIM (tmp)-1, tmp);
87            _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
88            putenv (buf);
89        }
90      else      else
91          putenv ("GPGME_DEBUG=");          putenv ("GPGME_DEBUG=");
92  }  }
93    
94    
95  /* Return the name of the gettext language file. */  /* Return true if the GPG environment is useable. */
96  static char*  static bool
97  get_gettext_lang (void)  gpg_prefs_ok (void)
98  {      {
99      char *fname;      char *p = get_reg_entry_gpg4win ("gpg.exe");
100      fname = get_reg_entry_mo ();      if (!p || file_exist_check (p) != 0) {
101      if (!fname)          free_if_alloc (p);
102          return NULL;          p = get_reg_entry_gpg ("gpgProgram");
103      return fname;          if (!p || file_exist_check (p) != 0) {
104                free_if_alloc (p);
105                log_debug ("gpg_prefs_ok: could not locate gpg.exe");
106                return false;
107            }
108        }
109        free_if_alloc (p);
110        p = get_reg_entry_gpg4win (NULL);
111        if (!p || dir_exist_check (p) != 0) {
112            free_if_alloc (p);
113            p = get_reg_entry_gpg ("HomeDir");
114            if (!p || dir_exist_check (p) != 0) {
115                free_if_alloc (p);
116                log_debug ("gpg_prefs_ok: could not determine home directory");
117                return false;
118            }
119        }
120        free_if_alloc (p);
121        return true;
122  }  }
123    
124    
125  /* Initialize the gettext sub system. */  /* Check gpg files if they are read-only and ask the user
126       if this should be corrected. */
127  static void  static void
128  load_gettext (int prev_inst)  check_readonly_attr (const char *homedir)
129  {  {
130      char *nls = NULL;      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
131    
132      nls = get_gettext_lang ();      for (int i=0; files[i] != NULL; i++) {
133      if (nls != NULL) {          char *file = make_filename (homedir, files[i], NULL);
134          set_gettext_file ("winpt", nls);          remove_crit_file_attrs (file, 0);
135          free_if_alloc (nls);          free_if_alloc (file);
136      }      }
137  }  }
138    
# Line 113  load_gpg_env (void) Line 148  load_gpg_env (void)
148      SECURITY_ATTRIBUTES sec_attr;      SECURITY_ATTRIBUTES sec_attr;
149      char *p;      char *p;
150      char *pkr;      char *pkr;
151        int err = 0;
152    
153      p = get_reg_entry_gpg4win ("gpg.exe");      p = get_reg_entry_gpg4win ("gpg.exe");
154      if (!p)      if (!p)
# Line 122  load_gpg_env (void) Line 158  load_gpg_env (void)
158          return (1);          return (1);
159      }      }
160      free_if_alloc (p);      free_if_alloc (p);
161      p = multi_gnupg_path (0);  
162        p = get_reg_entry_gpg ("HomeDir");
163        if (!p || dir_exist_check (p) != 0) {
164            free_if_alloc (p);
165            p = multi_gnupg_path (0);
166        }
167      if (p && dir_exist_check (p)) {      if (p && dir_exist_check (p)) {
168          memset (&sec_attr, 0, sizeof (sec_attr));          memset (&sec_attr, 0, sizeof (sec_attr));
169          sec_attr.nLength = sizeof (sec_attr);          sec_attr.nLength = sizeof (sec_attr);
170          if (!CreateDirectory (p, &sec_attr)) {          if (!CreateDirectory (p, &sec_attr)) {
171              msg_box (NULL, _("Could not create GPG home directory"),              msg_box (GetDesktopWindow (),
172                         _("Could not create GPG home directory"),
173                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
174              free_if_alloc (p);              free_if_alloc (p);
175              return (2);              return (2);
176          }          }
177      }      }
178        check_readonly_attr (p);
179      pkr = make_filename (p, "pubring", "gpg");      pkr = make_filename (p, "pubring", "gpg");
180      free_if_alloc (p);      free_if_alloc (p);
181      if (!pkr)      if (get_file_size (pkr) == 0)
182          return -1;          err = -1;
183      if (get_file_size (pkr) == 0) {      free_if_alloc (pkr);
184          free_if_alloc (pkr);      return err;
         return -1;  
     }  
     return 0;  
185  }  }
186    
187    
188  /* 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
189     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
190  static int  static int
191  check_default_key (gpg_keycache_t kc)  check_default_key (void)
192  {  {
193      gpgme_key_t key;      gpgme_key_t key;
194      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
195        gpg_keycache_t kc;
196      char *defkey;      char *defkey;
197    
198        kc = keycache_get_ctx (0);
199      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
200      if (defkey)      if (defkey != NULL) {
201          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
202      else          if (err) {
203          msg_box (NULL, _("No useable secret key found."),              free_if_alloc (defkey);
204                   _("WinPT Error"), MB_ERR);              return -1;
     free_if_alloc (defkey);  
     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;  
205          }          }
         currdir[j] = 0;  
         _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);  
206      }      }
207      return program;      else {
208            /* Actually this is just a warning but we still continue. */
209            msg_box (GetDesktopWindow (), _("No useable secret key found."),
210                     _("WinPT Warning"), MB_WARN);
211            return 0;
212        }
213    
214        /* Because the secret key listing has no information
215           about the validity/status, we need to check the public key. */
216        kc = keycache_get_ctx (1);
217        if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
218            (key->revoked || key->expired)) {
219            msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
220                     _("WinPT Warning"), MB_ERR);
221            free_if_alloc (defkey);
222            return -1;
223        }
224        free_if_alloc (defkey);
225        return 0;
226  }  }
227    
228    
# Line 203  get_prog_part (const char * fname, int u Line 231  get_prog_part (const char * fname, int u
231  static bool  static bool
232  check_crypto_engine (void)  check_crypto_engine (void)
233  {  {
234      int ma=0, mi=0, pa=0;      int ma = 0, mi = 0, pa = 0;
235      int rc;      int rc;
236    
237      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
238      if (rc == -1) {      if (rc == -1) {
239          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (GetDesktopWindow (), _("Could not read GnuPG version."),
240                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
241          return false;          return false;
242      }      }
243      else if (rc) {      else if (rc) {
244          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
245                   _("Sorry, you need a newer GPG version.\n"                   _("A newer GPG version is needed.\n"
246                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
247                     ma, mi, pa);                     ma, mi, pa);
248          return false;          return false;
249      }      }
250      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */      
251      if (ma > 1 || pa >= 3)          // TODO: smart card support needs to be revamped
252        // and adjusted according to newer OpenPGP cards.
253        /*
254        if ((ma > 1 || pa >= 4) && pcsc_available ())
255          scard_support = 1;          scard_support = 1;
256        */
257        scard_support = 0;
258        
259      gpgver[0] = ma;      gpgver[0] = ma;
260      gpgver[1] = mi;      gpgver[1] = mi;
261      gpgver[2] = pa;      gpgver[2] = pa;
# Line 230  check_crypto_engine (void) Line 263  check_crypto_engine (void)
263  }  }
264    
265    
 /* Try to load the keyserver config file. If @quiet is 1  
    do not show any errors. */  
 static int  
 load_keyserver_conf (int quiet)  
 {  
     char *buf;  
     const char *t;  
     int rc;  
   
     /* Create $APPDATA\winpt if needed. */  
     buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);  
     if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {  
         MessageBox (NULL, _("Failed to create WinPT directory"),  
                     _("Keyserver"), MB_ERR);  
         free_if_alloc (buf);  
         return -1;  
     }  
     free_if_alloc (buf);  
   
     /* Check for $APPDATA\winpt\keyserver.conf */  
     buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);  
   
     if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))  
         t = get_prog_part ("keyserver.conf", 0);  
     else  
         t = "keyserver.conf";  
     if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {  
         //log_box (_("Keyserver"), MB_INFO,  
         //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);  
         if (!CopyFile (t, buf, FALSE)) {  
             MessageBox (NULL, _("Failed to copy the keyserver.conf"),  
                         _("Keyserver"), MB_ERR);  
             free_if_alloc (buf);  
             return -1;  
         }  
         t = buf;  
     }  
     else  
         t = buf;  
       
     rc = kserver_load_conf (t);  
     if (rc && !quiet)  
         msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);  
     else {  
         free_if_alloc (reg_prefs.kserv_conf);  
         reg_prefs.kserv_conf = m_strdup (t);  
     }  
     free_if_alloc (buf);  
     return rc;  
 }  
   
266    
267  /* Check if both keyrings are empty. This indicates that  /* Check if both keyrings are empty. This indicates that
268     WinPT should offer to generate a key pair. */     WinPT should offer to generate a key pair. */
# Line 288  static bool Line 270  static bool
270  check_for_empty_keyrings (bool pub_only)  check_for_empty_keyrings (bool pub_only)
271  {  {
272      char *p;      char *p;
273      int n = 0;      int n;
274    
275        n=0;
276      p = get_gnupg_keyring (1, 0);      p = get_gnupg_keyring (1, 0);
277      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
278          n++;          n++;
# Line 304  check_for_empty_keyrings (bool pub_only) Line 287  check_for_empty_keyrings (bool pub_only)
287  }  }
288    
289    
290  /* Enable the mobility mode. */  
291  static void  /* Display info message that WinPT is now in debug mode. */
292  enable_mobile_mode (void)  void
293    winpt_debug_msg (void)
294    {      
295        char output[512];
296        char temp[MAX_PATH+1];
297            
298        GetTempPath (DIM (temp) -1, temp);
299        _snprintf (output, DIM (output)-1,
300            "The GPGME output file is %sgpgme.dbg\n"
301            "The WinPT output file is %swinpt.log\n", temp, temp);
302        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
303    }
304    
305    
306    /* Search for insecure ElGamal keys and return the
307       number of founded keys. */
308    static int
309    count_insecure_elgkeys (void)
310  {  {
311      memset (&reg_prefs, 0, sizeof (reg_prefs));      gpg_keycache_t pc;
312      reg_prefs.always_trust = 0;      gpgme_key_t key;
313      reg_prefs.auto_backup = 0;      int n;
314      reg_prefs.cache_time = 0;  
315      reg_prefs.expert = 0;      n=0;
316      reg_prefs.keylist_mode = 1;      pc = keycache_get_ctx (1);
317      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      while (!gpg_keycache_next_key (pc, 0, &key)) {
318      reg_prefs.no_zip_mmedia = 1;          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
319      reg_prefs.use_tmpfiles = 1;              n++;
320      reg_prefs.word_wrap = 80;      }
321      reg_prefs.use_viewer = 0; /* XXX */      gpg_keycache_rewind (pc);
322        return n;
323  }  }
324    
325    
326    /* Return 1 if the current OS version is at least Windows XP */
327    static int
328    check_os_version (void)
329    {
330        OSVERSIONINFOA osver;    
331        memset (&osver, 0, sizeof (osver));
332        osver.dwOSVersionInfoSize = sizeof (osver);
333        
334        if (!GetVersionEx (&osver)) {
335            MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
336            return 0;
337        }
338    
339        if (osver.dwMajorVersion < 5 ||
340            (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
341            MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
342            return 0;
343        }
344        
345        return 1;
346    }
347        
348  /* Main entry point. */  /* Main entry point. */
349  int WINAPI  int WINAPI
350  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
# Line 331  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 354  WinMain (HINSTANCE hinst, HINSTANCE hpre
354      MSG msg;      MSG msg;
355      HWND hwnd = NULL;      HWND hwnd = NULL;
356      WORD ver[3], ptdver[4];      WORD ver[3], ptdver[4];
357        
358        const char *s;
359      int rc, ec, created = 0;      int rc, ec, created = 0;
360      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
361      int winpt_inst_found = 0;      int winpt_inst_found = 0;
362      int start_manager = 0;      int start_manager = 0;    
     const char *s;  
363    
364        if (!check_os_version ())
365            return 0;
366        
367      glob_hinst = hinst;      glob_hinst = hinst;
368        
369        /* Allow to shutdown the process, for instance by an installer */
370      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
371          hwnd = FindWindow ("WinPT", "WinPT");          hwnd = FindWindow ("WinPT", "WinPT");
372          if (hwnd != NULL)          if (hwnd != NULL)
373              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
374          return 0;          return 0;
375      }      }    
376    
377      /*      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
378      OSVERSIONINFO osinf;      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
379      memset (&osinf, 0, sizeof (osinf));      if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1] || ptdver[2] != ver[2])) {
     if (GetVersionEx (&osinf) &&  
         osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&  
         osinf.dwMinorVersion == 0) {  
         msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",  
                  "WinPT Warning", MB_INFO);  
     }  
     */  
   
     #ifdef _DEBUG  
     gpg_set_debug_mode (1);  
     debug = 1;  
     #endif  
   
     get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);  
     get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
                                  &ptdver[2], &ptdver[3]);  
     /* XXX  
     if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {  
380          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
381                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
382                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
383                     ver[0], ver[1], ver[2]);                     ver[0], ver[1], ver[2]);
384          return 0;          return 0;
385      }      }
     */  
   
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
386    
387      s = gpgme_check_version (NEED_GPGME_VERSION);      s = gpgme_check_version (NEED_GPGME_VERSION);
388      if (!s || !*s) {      if (!s || !*s) {
389          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),          msg_box (GetDesktopWindow (),
390                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
391                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
392          return 0;          return 0;
393      }      }
# Line 390  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 395  WinMain (HINSTANCE hinst, HINSTANCE hpre
395      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
396      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
397          winpt_inst_found = 1;          winpt_inst_found = 1;
398        
399        gettext_set_user_domain ();
400    
401      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
402          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",      regist_inst_winpt (1, &created);
                  "WinPT", MB_INFO);  
         mobile = 1;  
     }  
   
     set_default_kserver ();  
     load_gettext (winpt_inst_found);  
   
     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 */  
     }  
403    
404      if (!created) {      if (!created) {
405          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 */  
406          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
407          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
408              hotkeys_modify ();          if (gnupg_load_config () == -2)
409          gnupg_load_config ();              msg_box (GetDesktopWindow (),
410                         _("The gpg.conf file contains the 'textmode' option\n"
411                           "which leads to broken binary output during decryption.\n"
412                           "If this is on purpose, just continue otherwise the option should be disabled."),
413                         _("WinPT Error"), MB_ERR);
414      }      }
415    
416      if (is_gpg4win_installed ())      if (is_gpg4win_installed ())
417          load_gpg_env (); /* XXX: check return code. */          load_gpg_env (); /* TODO: check return code. */
418    
419      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
420      if (rc) {      if (rc) {
421            char *p;
422    
423          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
424                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
425                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
426                   winpt_strerror (rc));                   winpt_strerror (rc));
427          s = get_fileopen_dlg (GetActiveWindow (),          s = get_fileopen_dlg (GetActiveWindow (),
428                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
429                                _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
430                                NULL);                                NULL);
431          if (s != NULL) {          if (s != NULL && (p=strrchr (s, '\\'))) {
432              size_t n;              char *path = substr (s, 0, (p-s));
433              char *p = strrchr (s, '\\');  
434              if (!p)              set_reg_entry_gpg ("HomeDir", path);
435                  BUG (0);              free_if_alloc (path);
             n = p - s;  
             if (n) {  
                 char *file = new char[n+1];  
                 if (!file)  
                     BUG (NULL);  
                 memset (file, 0, n);  
                 memcpy (file, s, n);  
                 file[n] = '\0';          
                 set_reg_entry_gpg ("HomeDir", file);  
                 free_if_alloc (file);  
                 gnupg_check_homedir (); /* change gpgProgram if needed */  
             }  
436          }          }
437          else {          else {
438              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (GetDesktopWindow (),
439                         _("GPG home directory could not be determined."),
440                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
441              goto start;              goto start;
442          }          }
# Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 444  WinMain (HINSTANCE hinst, HINSTANCE hpre
444    
445      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
446      if (rc) {      if (rc) {
447          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
448                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
449                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
450                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
451                         MB_INFO|MB_YESNO) == IDYES)
452              start_gpgprefs = 1;              start_gpgprefs = 1;
453          else {          else {
454              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
455                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
456              return 0;              return 0;
457          }          }
458      }      }
# Line 474  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre
460      rc = gnupg_access_files ();      rc = gnupg_access_files ();
461      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
462          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
463              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
464                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
465                    "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"
466                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
467                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
468              if (ec == IDYES)              if (ec == IDYES)
469                  first_start = 1;                  first_start = 1;
470          }          }
471          if (!first_start) {          if (!first_start) {
472              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
473              return 0;              return 0;
474          }          }
475      }      }
# Line 492  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 478  WinMain (HINSTANCE hinst, HINSTANCE hpre
478    
479      if (!first_start) {      if (!first_start) {
480          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
481          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
482              gpg_read_only = 1;              gpg_read_only = 1;
483          else if (rc)          else if (rc)
484              return 0;              return 0;
# Line 505  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 491  WinMain (HINSTANCE hinst, HINSTANCE hpre
491          return 0;          return 0;
492      }      }
493    
494      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      rc = kserver_load_conf ();
495          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (rc)
496                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,          msg_box (GetDesktopWindow (), winpt_strerror (rc),
497                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                   _("Keyserver"), MB_ERR);
         free_gnupg_table ();  
         return 0;  
     }  
   
     load_keyserver_conf (cmdline? 1 : 0);  
498    
499      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
500                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
501          /* If an instance of WinPT is running, just send the command          /* If an instance of WinPT is running, just send the command
502             to open the key manager. Otherwise start a new instance.             to open the key manager. Otherwise start a new instance. */
          */  
503          HWND tray = FindWindow ("WinPT", "WinPT");          HWND tray = FindWindow ("WinPT", "WinPT");
504          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
505              start_manager = ID_WINPT_KEY;              start_manager = ID_WINPT_KEY;
# Line 540  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 520  WinMain (HINSTANCE hinst, HINSTANCE hpre
520          return 0;          return 0;
521      }      }
522    
523      if (cmdline) {      if (cmdline && (stristr (cmdline, "--enable-debug") ||
524          if (stristr (cmdline, "--enable-debug") ||                      stristr (cmdline, "--debug"))) {
525              stristr (cmdline, "--debug")) {          gpg_set_debug_mode (1);
526              gpg_set_debug_mode (1);          winpt_debug_msg ();
527              winpt_debug_msg ();          debug = 1;
             debug = 1;  
         }  
528      }      }
529    
530      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
531      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
532      if (rc == FALSE) {      if (rc == FALSE) {
533          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
534                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
535          free_gnupg_table ();          free_gnupg_table ();
536          return 0;          return 0;
# Line 566  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 544  WinMain (HINSTANCE hinst, HINSTANCE hpre
544                           hinst,                           hinst,
545                           NULL);                           NULL);
546      if (hwnd == NULL) {      if (hwnd == NULL) {
547          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
548                     _("Could not create window"),
549                     _("WinPT Error"), MB_ERR);
550          free_gnupg_table ();          free_gnupg_table ();
551          return 0;          return 0;
552      }      }
# Line 586  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 566  WinMain (HINSTANCE hinst, HINSTANCE hpre
566          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
567                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
568          if (check_for_empty_keyrings (true))          if (check_for_empty_keyrings (true))
569              first_start = 1; /* The public keyring is empty! */              first_start = 1; /* The public keyring is empty. */
570      }      }
571    
572      if (first_start) {      if (first_start) {
         struct first_start_s fs;  
573          struct genkey_s c;          struct genkey_s c;
574            int choice;
575          HWND h;          HWND h;
576  start:  start:
577          h = GetDesktopWindow ();          h = GetDesktopWindow ();
578          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,          if (!gpg_prefs_ok ())
579                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
580                              gpgprefs_dlg_proc, 0);                              gpgprefs_dlg_proc, 0);
581          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,          choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
582                          first_run_dlg_proc, (LPARAM)&fs);                                   first_run_dlg_proc, 0);
583          switch (fs.choice) {          switch (choice) {
584          case SETUP_KEYGEN:          case SETUP_KEYGEN:
585              c.interactive = 1;              c.interactive = 1;
586              c.first_start = 1;              c.first_start = 1;
# Line 617  start: Line 598  start:
598              }              }
599              break;              break;
600    
601          case -1: /* Cancel/Abort. */          case SETUP_EXISTING:
602                rc = gnupg_import_keypair ();
603                if (rc) {
604                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
605                    goto start;
606                }
607                break;
608    
609            case SETUP_CARDGEN:
610                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
611                                     h, card_keygen_dlg_proc, 0);
612                if (!rc)
613                    goto start;
614                break;
615    
616            case 0: /* Cancel/Abort. */
617            default:
618              DestroyWindow (hwnd);              DestroyWindow (hwnd);
619              free_gnupg_table ();              free_gnupg_table ();
620              return 0;              return 0;
621          }          }
622          update_keycache (hwnd);          update_keycache (hwnd);
623          check_crypto_engine ();          if (!check_crypto_engine ()) {
624                DestroyWindow (hwnd);
625                free_gnupg_table ();
626                keycache_release (1);
627                return 0;
628            }
629      }      }
630      else {      else {
631          gpg_keycache_t c;          gpg_keycache_t c;
632          update_keycache (hwnd);          if (update_keycache (hwnd)) {
633                DestroyWindow (hwnd);
634                free_gnupg_table ();
635                keycache_release (1);
636                return 0;
637            }
638            /* XXX: rewrite this part. */
639          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
640          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
641              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
642                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
643                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
644              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"              ec = msg_box (GetDesktopWindow (),
645                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
646                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
647                              "WinPT", MB_INFO|MB_YESNO);
648              if (ec == IDYES) {              if (ec == IDYES) {
649                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
650                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 645  start: Line 653  start:
653              else {              else {
654                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
655                  free_gnupg_table ();                  free_gnupg_table ();
656                    keycache_release (1);
657                  return 0;                  return 0;
658              }              }
659          }          }      
660          if (check_default_key (c)) {          if (check_default_key ()) {
661              char *p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
662              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
663                       _("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"
664                         "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"
665                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
666                set_gnupg_default_key (NULL);
667              free_if_alloc (p);              free_if_alloc (p);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
668          }          }
669          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
670              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
671                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
672      }      }
673      
674      if (start_manager)      if (start_manager)
675          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
676    
# Line 675  start: Line 682  start:
682              DispatchMessage (&msg);              DispatchMessage (&msg);
683          }          }
684      }      }
685                
686      return 0;      return 0;
687  }  }
Legend:
Removed from v.159  
changed lines
  Added in v.337
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26