/[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 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-2006 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>
# 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    /* 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        
175      nls = get_gettext_lang ();      log_debug("check if there are gpg files with a read-only attribute");
176      if (nls != NULL) {      for (int i=0; files[i] != NULL; i++) {
177          set_gettext_file ("winpt", nls);          char *file = make_filename (homedir, files[i], NULL);
178          free_if_alloc (nls);          remove_crit_file_attrs (file, 0);
179            free_if_alloc (file);
180      }      }
181  }  }
182    
# Line 113  load_gpg_env (void) Line 192  load_gpg_env (void)
192      SECURITY_ATTRIBUTES sec_attr;      SECURITY_ATTRIBUTES sec_attr;
193      char *p;      char *p;
194      char *pkr;      char *pkr;
195        int err = 0;
196    
197      p = get_reg_entry_gpg4win ("gpg.exe");      p = get_reg_entry_gpg4win ("gpg.exe");
198      if (!p)      if (!p)
# Line 122  load_gpg_env (void) Line 202  load_gpg_env (void)
202          return (1);          return (1);
203      }      }
204      free_if_alloc (p);      free_if_alloc (p);
205      p = multi_gnupg_path (0);  
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)) {      if (p && dir_exist_check (p)) {
212          memset (&sec_attr, 0, sizeof (sec_attr));          memset (&sec_attr, 0, sizeof (sec_attr));
213          sec_attr.nLength = sizeof (sec_attr);          sec_attr.nLength = sizeof (sec_attr);
214          if (!CreateDirectory (p, &sec_attr)) {          if (!CreateDirectory (p, &sec_attr)) {
215              msg_box (NULL, _("Could not create GPG home directory"),              msg_box (GetDesktopWindow (),
216                         _("Could not create GPG home directory"),
217                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
218              free_if_alloc (p);              free_if_alloc (p);
219              return (2);              return (2);
220          }          }
221      }      }
222        check_readonly_attr (p);
223      pkr = make_filename (p, "pubring", "gpg");      pkr = make_filename (p, "pubring", "gpg");
224      free_if_alloc (p);      free_if_alloc (p);
225      if (!pkr)      if (get_file_size (pkr) == 0)
226          return -1;          err = -1;
227      if (get_file_size (pkr) == 0) {      free_if_alloc (pkr);
228          free_if_alloc (pkr);      return err;
         return -1;  
     }  
     return 0;  
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        gpg_keycache_t kc;
240      char *defkey;      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."),              free_if_alloc (defkey);
248                   _("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;  
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    
# Line 203  get_prog_part (const char * fname, int u Line 275  get_prog_part (const char * fname, int u
275  static bool  static bool
276  check_crypto_engine (void)  check_crypto_engine (void)
277  {  {
278      int ma=0, mi=0, pa=0;      int ma = 0, mi = 0, pa = 0;
279      int rc;      int rc;
280    
281      rc = check_gnupg_engine (NEED_GPG_VERSION, &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 false;          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 "NEED_GPG_VERSION),                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
291                     ma, mi, pa);                     ma, mi, pa);
292          return false;          return false;
293      }      }
294      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */      
295      if (ma > 1 || pa >= 3)          // 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;
# Line 230  check_crypto_engine (void) Line 307  check_crypto_engine (void)
307  }  }
308    
309    
 /* 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;  
 }  
   
310    
311  /* Check if both keyrings are empty. This indicates that  /* Check if both keyrings are empty. This indicates that
312     WinPT should offer to generate a key pair. */     WinPT should offer to generate a key pair. */
313  static bool  static bool
314  check_for_empty_keyrings (bool pub_only)  check_for_empty_keyrings (bool pub_only)
315  {  {
     char *p;  
316      int n = 0;      int n = 0;
317        char *p = get_gnupg_keyring (1, 0);
     p = get_gnupg_keyring (1, 0);  
318      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
319          n++;          n++;
320      free_if_alloc (p);      free_if_alloc (p);
# Line 300  check_for_empty_keyrings (bool pub_only) Line 324  check_for_empty_keyrings (bool pub_only)
324      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
325          n++;          n++;
326      free_if_alloc (p);      free_if_alloc (p);
327      return n==2? true : false;      return n == 2? true : false;
328  }  }
329    
330    
331  /* Enable the mobility mode. */  
332  static void  /* Display info message that WinPT is now in debug mode. */
333  enable_mobile_mode (void)  void
334    winpt_debug_msg (void)
335    {      
336        char output[512];
337        char temp[MAX_PATH+1];
338            
339        GetTempPath (DIM (temp) - 1, temp);
340        _snprintf (output, DIM (output)-1,
341            "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    /* Search for insecure ElGamal keys and return the
348       number of founded keys. */
349    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    
364    
365    /* 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)
# Line 330  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 392  WinMain (HINSTANCE hinst, HINSTANCE hpre
392      HACCEL accel_tab;      HACCEL accel_tab;
393      MSG msg;      MSG msg;
394      HWND hwnd = NULL;      HWND hwnd = NULL;
395      WORD ver[3], ptdver[4];      WORD ver[4], ptdver[4];
396        
397        const char *s;
398      int rc, ec, created = 0;      int rc, ec, created = 0;
399      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
400      int winpt_inst_found = 0;      int winpt_inst_found = 0;
401      int start_manager = 0;      int start_manager = 0;    
402      const char *s;      
403        log_debug("check OS version");
404        if (!check_os_version ())
405            return 0;
406        
407      glob_hinst = hinst;      glob_hinst = hinst;
408        
409        /* Check as early as possible for debug flags and activate
410           the debug mode if requested */
411        if (cmdline && (stristr (cmdline, "--enable-debug") ||
412                        stristr (cmdline, "--debug"))) {
413            //gpg_set_debug_mode (1);
414            winpt_debug_msg ();
415            debug = 1;
416        }
417        
418        /* Allow to shutdown the process, for instance by an installer */
419      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
420          hwnd = FindWindow ("WinPT", "WinPT");          hwnd = FindWindow ("WinPT", "WinPT");
421          if (hwnd != NULL)          if (hwnd != NULL) {
422                log_debug ("shutdown an existing WinPT process");
423              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
424            }
425          return 0;          return 0;
426      }      }
427        
428      /*      log_debug("check PTD and GPGME version");
429      OSVERSIONINFO osinf;      if (get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3])) {
430      memset (&osinf, 0, sizeof (osinf));          log_box(_("WinPT Error"), MB_ERR, _("Could not read file version of WinPT"));
431      if (GetVersionEx (&osinf) &&          return 0;
         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);  
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])) {
     #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]) {  
435          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
436                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
437                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
438                     ver[0], ver[1], ver[2]);                     ver[0], ver[1], ver[2]);
439          return 0;          return 0;
440      }      }
     */  
   
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
441    
442      s = gpgme_check_version (NEED_GPGME_VERSION);      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 "NEED_GPGME_VERSION),          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      load_gettext (winpt_inst_found);      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 ())      if (is_gpg4win_installed ()) {
474          load_gpg_env (); /* XXX: check return code. */          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 460  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 (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
513                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
514              return 0;              return 0;
515          }          }
516      }      }
# Line 474  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))      if (check_for_empty_keyrings (false)) {
535            log_debug ("found empty keyrings, assume first start");
536          first_start = 1;          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;
# Line 501  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 547  WinMain (HINSTANCE hinst, HINSTANCE hpre
547      init_gnupg_table ();      init_gnupg_table ();
548    
549      if (fm_parse_command_line (cmdline) > 0) {      if (fm_parse_command_line (cmdline) > 0) {
550            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, 0,          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          /* If an instance of WinPT is running, just send the command          /* If an instance of WinPT is running, just send the command
563             to open the key manager. Otherwise start a new instance.             to open the key manager. Otherwise start a new instance. */
          */  
564          HWND tray = FindWindow ("WinPT", "WinPT");          HWND tray = FindWindow ("WinPT", "WinPT");
565          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
566              start_manager = ID_WINPT_KEY;              start_manager = ID_WINPT_KEY;
# Line 539  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 566  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 574  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          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
614              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 586  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 621  WinMain (HINSTANCE hinst, HINSTANCE hpre
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          if (check_for_empty_keyrings (true))          if (check_for_empty_keyrings (true))
624              first_start = 1; /* The public keyring is empty! */              first_start = 1; /* The public keyring is empty. */
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 617  start: Line 653  start:
653              }              }
654              break;              break;
655    
656          case -1: /* Cancel/Abort. */          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 645  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)      if (start_manager)
730          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
731    
# Line 675  start: Line 737  start:
737              DispatchMessage (&msg);              DispatchMessage (&msg);
738          }          }
739      }      }
740                
741      return 0;      return 0;
742  }  }
Legend:
Removed from v.159  
changed lines
  Added in v.419
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26