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