/[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 271 by twoaday, Sun Nov 5 08:57:45 2006 UTC revision 415 by twoaday, Sat Feb 11 16:51:01 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 43  Line 39 
39  #include "wptUTF8.h"  #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);
 BOOL user_is_admin (void);  
 extern "C" int  pcsc_available (void);  
42    
43  /* Global variables. */  /* 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 */
46  int scard_support = 0;  int scard_support = 0;
47    int disable_hook = 0;
48  int debug = 0;  int debug = 0;
49  int gpg_read_only = 0;  int gpg_read_only = 0;
 int admin_user = 0;  
50  char gpgver[3];  char gpgver[3];
51  /* End */  /* End */
52    
53    
54    /* Retrieve the product verion of the given file @fname.
55       Format: MAJOR.MINOR.PATCH1.PATCH2
56       Return value: 0 on success. */
57    int
58    get_file_version (const char *fname, WORD *major, WORD *minor, WORD *patch1, WORD *patch2)
59    {
60        VS_FIXEDFILEINFO *inf;
61        char file[MAX_PATH+1] = {0};
62        LPVOID buf, data;
63        DWORD size;
64        UINT qlen;
65        int err = 0;
66    
67        strncpy (file, fname, MAX_PATH);
68        size = GetFileVersionInfoSize (file, NULL);
69        if (!size)
70            return -1;
71        
72        buf = (LPVOID)new char[size];
73        if (!buf)
74            BUG (NULL);
75        if (!GetFileVersionInfo (file, 0, size, buf)) {
76            err = -1;
77            goto fail;
78        }
79    
80        qlen = 0;
81        VerQueryValue (buf, (char*)"\\", &data, &qlen);
82        if (!qlen) {
83            err = -1;
84            goto fail;
85        }
86        
87        inf = (VS_FIXEDFILEINFO*)data;
88        *major = HIWORD (inf->dwProductVersionMS);
89        *minor = LOWORD (inf->dwProductVersionMS);
90        *patch1 = HIWORD (inf->dwProductVersionLS);
91        *patch2 = LOWORD (inf->dwProductVersionLS);
92    
93    fail:
94        delete [](char*)buf;
95        return err;
96    }
97    
98    
99  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
100  int  int
101  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
102  {  {
103      int err;      refresh_cache_s rcs;
104    
105      refresh_cache_s rcs = {0};      /* no need to rebuild the sig cache each time. */
106      rcs.kr_reload = 0;      memset (&rcs, 0, sizeof (rcs));
107      rcs.kr_update = 1;      rcs.kring_update = 1;
108      rcs.tr_update = 1;      int err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
     err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  
109                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
110      if (err) {      if (err) {
111          char *cfgf = get_gnupg_config ();          char *cfgf = get_gnupg_config ();
112          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
113              msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);              msg_box (GetDesktopWindow (),
114                         _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
115          free_if_alloc (cfgf);          free_if_alloc (cfgf);
116          return -1;          return -1;
117      }      }
# Line 84  update_keycache (HWND hwnd) Line 123  update_keycache (HWND hwnd)
123  void  void
124  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
125  {  {
126      static char buf[256];      static char buf[MAX_PATH+1];
     char tmp[128];  
127            
128      /* XXX: no gpgme.dbg is created. */      /* XXX: no gpgme.dbg is created. */
129      if (val > 0) {      if (val > 0) {
130            char tmp[128];
131          GetTempPath (DIM (tmp)-1, tmp);          GetTempPath (DIM (tmp)-1, tmp);
132          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
133          putenv (buf);          putenv (buf);
# Line 98  gpg_set_debug_mode (int val) Line 137  gpg_set_debug_mode (int val)
137  }  }
138    
139    
 /* Initialize the gettext sub system. */  
 static void  
 load_gettext (void)  
 {  
     char *nls;  
   
     /* Return the name of the gettext language file. */  
     nls = get_reg_entry_mo ();  
     if (nls != NULL) {  
         set_gettext_file ("winpt", nls);  
         free_if_alloc (nls);  
     }  
 }  
   
   
140  /* Return true if the GPG environment is useable. */  /* Return true if the GPG environment is useable. */
141  static bool  static bool
142  gpg_prefs_ok (void)  gpg_prefs_ok (void)
143  {  {
144      char *p;      char *p = get_reg_entry_gpg4win ("gpg.exe");
   
     p = get_reg_entry_gpg4win ("gpg.exe");  
145      if (!p || file_exist_check (p) != 0) {      if (!p || file_exist_check (p) != 0) {
146          free_if_alloc (p);          free_if_alloc (p);
147          p = get_reg_entry_gpg ("gpgProgram");          p = get_reg_entry_gpg ("gpgProgram");
# Line 151  static void Line 173  static void
173  check_readonly_attr (const char *homedir)  check_readonly_attr (const char *homedir)
174  {  {
175      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};      const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
176      char *file;      
177      int i;      log_debug("check if there are gpg files with a read-only attribute");
178        for (int i=0; files[i] != NULL; i++) {
179      for (i=0; files[i] != NULL; i++) {          char *file = make_filename (homedir, files[i], NULL);
         file = make_filename (homedir, files[i], NULL);  
180          remove_crit_file_attrs (file, 0);          remove_crit_file_attrs (file, 0);
181          free_if_alloc (file);          free_if_alloc (file);
182      }      }
# Line 193  load_gpg_env (void) Line 214  load_gpg_env (void)
214          memset (&sec_attr, 0, sizeof (sec_attr));          memset (&sec_attr, 0, sizeof (sec_attr));
215          sec_attr.nLength = sizeof (sec_attr);          sec_attr.nLength = sizeof (sec_attr);
216          if (!CreateDirectory (p, &sec_attr)) {          if (!CreateDirectory (p, &sec_attr)) {
217              msg_box (NULL, _("Could not create GPG home directory"),              msg_box (GetDesktopWindow (),
218                         _("Could not create GPG home directory"),
219                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
220              free_if_alloc (p);              free_if_alloc (p);
221              return (2);              return (2);
# Line 212  load_gpg_env (void) Line 234  load_gpg_env (void)
234  /* 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
235     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
236  static int  static int
237  check_default_key (gpg_keycache_t kc)  check_default_key (void)
238  {  {
239      gpgme_key_t key;      gpgme_key_t key;
240      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
241        gpg_keycache_t kc;
242      char *defkey;      char *defkey;
243    
244        kc = keycache_get_ctx (0);
245      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
246      if (defkey)      if (defkey != NULL) {
247          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
248      else          if (err) {
249          msg_box (NULL, _("No useable secret key found."),              free_if_alloc (defkey);
250                return -1;
251            }
252        }
253        else {
254            /* Actually this is just a warning but we still continue. */
255            msg_box (GetDesktopWindow (), _("No useable secret key found."),
256                   _("WinPT Warning"), MB_WARN);                   _("WinPT Warning"), MB_WARN);
257      free_if_alloc (defkey);          return 0;
258      return err? -1 : 0;      }
 }  
   
259    
260  /* Return the WinPT program file name (with full pathname). */      /* Because the secret key listing has no information
261  static const char*         about the validity/status, we need to check the public key. */
262  get_prog_part (const char * fname, int use_cwd)      kc = keycache_get_ctx (1);
263  {      if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
264      static char program[2*MAX_PATH+1];          (key->revoked || key->expired)) {
265      char currdir[MAX_PATH+1];          msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
266      char *cmd = NULL;                   _("WinPT Warning"), MB_ERR);
267      int j;          free_if_alloc (defkey);
268                    return -1;
     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)  
             return NULL;  
         strncpy (currdir, cmd, DIM (currdir)-1);  
         j = strlen (currdir);  
         while (j--) {  
             if (currdir[j] == '\\')  
                 break;  
         }  
         currdir[j] = 0;  
         _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);  
269      }      }
270      return program;      free_if_alloc (defkey);
271        return 0;
272  }  }
273    
274    
# Line 272  check_crypto_engine (void) Line 282  check_crypto_engine (void)
282    
283      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
284      if (rc == -1) {      if (rc == -1) {
285          msg_box (NULL, _("Could not read GnuPG version."),          msg_box (GetDesktopWindow (), _("Could not read GnuPG version."),
286                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
287          return false;          return false;
288      }      }
289      else if (rc) {      else if (rc) {
290          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
291                   _("Sorry, you need a newer GPG version.\n"                   _("A newer GPG version is needed.\n"
292                     "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),                     "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
293                     ma, mi, pa);                     ma, mi, pa);
294          return false;          return false;
295      }      }
296      /* Enable smart card support for GPG 2 or >= 1.4 */      
297        // TODO: smart card support needs to be revamped
298        // and adjusted according to newer OpenPGP cards.
299        /*
300      if ((ma > 1 || pa >= 4) && pcsc_available ())      if ((ma > 1 || pa >= 4) && pcsc_available ())
301          scard_support = 1;          scard_support = 1;
302        */
303        scard_support = 0;
304        
305      gpgver[0] = ma;      gpgver[0] = ma;
306      gpgver[1] = mi;      gpgver[1] = mi;
307      gpgver[2] = pa;      gpgver[2] = pa;
# Line 294  check_crypto_engine (void) Line 309  check_crypto_engine (void)
309  }  }
310    
311    
 /* Try to load the keyserver config file. If @quiet is 1  
    do not show any errors. */  
 static int  
 load_keyserver_conf (int quiet)  
 {      
     const char *t, *conf;  
     char *buf;  
     int rc;  
   
     #ifdef WINPT_MOBILE  
     /* In mobile mode we automatically assume the config file  
        in the current directory. */  
     return kserver_load_conf ("keyserver.conf");  
     #endif  
   
     /* 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);  
   
     conf = get_prog_part ("keyserver.conf", 0);  
     if (!file_exist_check (conf))  
         t = conf;  
     else  
         t = "keyserver.conf";  
     if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {  
         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;  
 }  
   
312    
313  /* Check if both keyrings are empty. This indicates that  /* Check if both keyrings are empty. This indicates that
314     WinPT should offer to generate a key pair. */     WinPT should offer to generate a key pair. */
# Line 357  static bool Line 316  static bool
316  check_for_empty_keyrings (bool pub_only)  check_for_empty_keyrings (bool pub_only)
317  {  {
318      char *p;      char *p;
319      int n = 0;      int n;
320    
321        n=0;
322      p = get_gnupg_keyring (1, 0);      p = get_gnupg_keyring (1, 0);
323      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
324          n++;          n++;
# Line 373  check_for_empty_keyrings (bool pub_only) Line 333  check_for_empty_keyrings (bool pub_only)
333  }  }
334    
335    
 #ifdef WINPT_MOBILE  
 /* Enable the mobile mode if possible.  
    There are some constraints which must be fullfilled.  
    Return value: 0 on success. */  
 static int  
 enable_mobile_mode (void)  
 {  
     static const char *test_fname = "winpt_mobile_test.txt";  
     FILE *fp;  
     char *pubring;  
     ULARGE_INTEGER caller, total;  
     DWORD temp_size;  
   
     fp = fopen (test_fname, "wb");  
     if (fp == NULL) {  
         MessageBox (NULL, "Mobile mode cannot be used without write permission\n"  
                           "for the current directory", "WinPT Error", MB_ERR);  
               
         return -1;  
     }  
     fclose (fp);  
     DeleteFile (test_fname);  
     if (file_exist_check ("gpg.exe")) {  
         MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"  
                           "as the WinPT program", "WinPT Error", MB_ERR);  
         return -1;  
     }  
       
     /* Because write operations to the keyring result in a temporary  
        file, we need at least 2 MB plus the size of the keyring for  
        free space. */  
     pubring = get_gnupg_keyring (1);  
     temp_size = get_file_size (pubring) + 2097152;  
     free_if_alloc (pubring);  
   
     if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||  
         caller.LowPart < temp_size) {  
         log_box ("WinPT Error", MB_ERR,  
                  "The mobile mode needs at least %lu KB for temporary files",  
                  temp_size/1024);  
         return -1;  
     }  
   
     /* XXX: shall we check for 'temp-directory' in the gpg.conf? */  
   
     return 0;  
 }  
 #endif  
   
   
 /* Set the default keyserver for this instance. */  
 void  
 set_default_keyserver (void)  
 {  
     char *host = get_reg_entry_keyserver ("Default");  
     char *str_port = get_reg_entry_keyserver ("Default_Port");  
     WORD port = HKP_PORT;  
   
     if (!host)  
         keyserver_set_default (NULL, 0);  
     else {  
         if (str_port && *str_port)  
             port = atoi (str_port);  
         keyserver_set_default (host, port);  
     }  
     free_if_alloc (host);  
     free_if_alloc (str_port);  
 }  
   
336    
337  /* Display info message that WinPT is now in debug mode. */  /* Display info message that WinPT is now in debug mode. */
338  void  void
339  winpt_debug_msg (void)  winpt_debug_msg (void)
340  {        {      
341      char output[512];      char output[512];
342      char temp[128];      char temp[MAX_PATH+1];
343                    
344      GetTempPath (DIM (temp) -1, temp);      GetTempPath (DIM (temp) - 1, temp);
345      _snprintf (output, DIM (output)-1,      _snprintf (output, DIM (output)-1,
346          "The GPGME output file is %sgpgme.dbg\n"          "The GPGME output file is %sgpgme.dbg\n"
347          "The WinPT output file is %swinpt.log\n", temp, temp);          "The WinPT output file is %swinpt.log\n", temp, temp);
# Line 465  count_insecure_elgkeys (void) Line 356  count_insecure_elgkeys (void)
356  {  {
357      gpg_keycache_t pc;      gpg_keycache_t pc;
358      gpgme_key_t key;      gpgme_key_t key;
     int n = 0;  
359    
360        int n = 0;
361      pc = keycache_get_ctx (1);      pc = keycache_get_ctx (1);
362      while (!gpg_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
363          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
# Line 477  count_insecure_elgkeys (void) Line 368  count_insecure_elgkeys (void)
368  }  }
369    
370    
371    /* Return 1 if the current OS version is at least Windows XP */
372    static int
373    check_os_version (void)
374    {
375        OSVERSIONINFOA osver;    
376        memset (&osver, 0, sizeof (osver));
377        osver.dwOSVersionInfoSize = sizeof (osver);
378            
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 486  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;      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;    
408        
409  #ifdef WINPT_MOBILE      log_debug("check OS version");
410      /* Do not continue in case of problems. */      if (!check_os_version ())
     if (enable_mobile_mode ())  
411          return 0;          return 0;
412  #endif      
   
413      glob_hinst = hinst;      glob_hinst = hinst;
414        
415        /* Allow to shutdown the process, for instance by an installer */
416      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
417          hwnd = FindWindow ("WinPT", "WinPT");          hwnd = FindWindow ("WinPT", "WinPT");
418          if (hwnd != NULL)          if (hwnd != NULL) {
419                log_debug("shutdown an existing WinPT process");
420              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
421            }
422          return 0;          return 0;
423      }      }
424        
425        /* KLUDGE: test if the hooking is causing problems with some AV programs */
426        if (cmdline && stristr (cmdline, "--disable-hook"))
427            disable_hook = 1;
428            
429    
430      #ifdef _DEBUG      log_debug("check PTD and GPGME version");
431      gpg_set_debug_mode (1);      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
432      debug = 1;      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
433      #endif      if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1] || ptdver[2] != ver[2])) {
   
     get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);  
     ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],    
                                  &ptdver[2], &ptdver[3]);  
       
     if (!ec && (ptdver[0] != ver[0] ||  
                 ptdver[1] != ver[1] ||  
                 ptdver[2] != ver[2])) {  
434          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
435                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
436                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
# Line 525  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 438  WinMain (HINSTANCE hinst, HINSTANCE hpre
438          return 0;          return 0;
439      }      }
440    
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
   
441      s = gpgme_check_version (NEED_GPGME_VERSION);      s = gpgme_check_version (NEED_GPGME_VERSION);
442      if (!s || !*s) {      if (!s || !*s) {
443          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),          msg_box (GetDesktopWindow (),
444                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
445                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
446          return 0;          return 0;
447      }      }
# Line 542  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 450  WinMain (HINSTANCE hinst, HINSTANCE hpre
450      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
451          winpt_inst_found = 1;          winpt_inst_found = 1;
452            
453      set_default_keyserver ();      gettext_set_user_domain ();
     load_gettext ();  
     admin_user = user_is_admin ();  
454    
455      regist_inst_gnupg (1);      regist_inst_gnupg (1);
456      regist_inst_winpt (1, &created);      regist_inst_winpt (1, &created);
# Line 552  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 458  WinMain (HINSTANCE hinst, HINSTANCE hpre
458      if (!created) {      if (!created) {
459          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
460          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
461          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */          reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
462          gnupg_load_config ();          if (gnupg_load_config () == -2)
463                msg_box (GetDesktopWindow (),
464                         _("The gpg.conf file contains the 'textmode' option\n"
465                           "which leads to broken binary output during decryption.\n"
466                           "If this is on purpose, just continue otherwise the option should be disabled."),
467                         _("WinPT Error"), MB_ERR);
468      }      }
469    
470      if (is_gpg4win_installed ())      if (is_gpg4win_installed ()) {
471          load_gpg_env (); /* XXX: check return code. */          log_debug("gpg4win: load gpg environment");
472            load_gpg_env (); /* TODO: check return code. */
473        }
474    
475      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
476      if (rc) {      if (rc) {  
         char *p;  
   
477          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
478                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
479                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
# Line 571  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 482  WinMain (HINSTANCE hinst, HINSTANCE hpre
482                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
483                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
484                                NULL);                                NULL);
485          if (s != NULL && (p=strrchr (s, '\\'))) {          
486            char * p;
487            if (s != NULL && (p = strrchr (s, '\\'))) {
488              char *path = substr (s, 0, (p-s));              char *path = substr (s, 0, (p-s));
489    
490              set_reg_entry_gpg ("HomeDir", path);              set_reg_entry_gpg ("HomeDir", path);
491              free_if_alloc (path);              free_if_alloc (path);
492          }          }
493          else {          else {
494              msg_box (NULL, _("GPG home directory could not be determined."),              msg_box (GetDesktopWindow (),
495                         _("GPG home directory could not be determined."),
496                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
497              goto start;              goto start;
498          }          }
# Line 586  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 500  WinMain (HINSTANCE hinst, HINSTANCE hpre
500    
501      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
502      if (rc) {      if (rc) {
503          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
504                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
505                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
506                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
507                         MB_INFO|MB_YESNO) == IDYES)
508              start_gpgprefs = 1;              start_gpgprefs = 1;
509          else {          else {
510              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
511                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
512              return 0;              return 0;
513          }          }
514      }      }
# Line 600  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 516  WinMain (HINSTANCE hinst, HINSTANCE hpre
516      rc = gnupg_access_files ();      rc = gnupg_access_files ();
517      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
518          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
519              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
520                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
521                    "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"
522                    "Continue if you want WinPT to offer you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
# Line 609  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 525  WinMain (HINSTANCE hinst, HINSTANCE hpre
525                  first_start = 1;                  first_start = 1;
526          }          }
527          if (!first_start) {          if (!first_start) {
528              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
529              return 0;              return 0;
530          }          }
531      }      }
# Line 631  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 547  WinMain (HINSTANCE hinst, HINSTANCE hpre
547          return 0;          return 0;
548      }      }
549    
550      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      rc = kserver_load_conf ();
551          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (rc)
552                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,          msg_box (GetDesktopWindow (), winpt_strerror (rc),
553                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                   _("Keyserver"), MB_ERR);
         free_gnupg_table ();  
         return 0;  
     }  
   
     load_keyserver_conf (cmdline? 1 : 0);  
554    
555      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
556                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
# Line 665  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 576  WinMain (HINSTANCE hinst, HINSTANCE hpre
576          return 0;          return 0;
577      }      }
578    
     #ifndef WINPT_MOBILE  
579      if (cmdline && (stristr (cmdline, "--enable-debug") ||      if (cmdline && (stristr (cmdline, "--enable-debug") ||
580                      stristr (cmdline, "--debug"))) {                      stristr (cmdline, "--debug"))) {
581          gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
582          winpt_debug_msg ();          winpt_debug_msg ();
583          debug = 1;          debug = 1;
584      }      }
     #endif  
585    
586      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
587      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
588      if (rc == FALSE) {      if (rc == FALSE) {
589          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
590                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
591          free_gnupg_table ();          free_gnupg_table ();
592          return 0;          return 0;
# Line 691  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 600  WinMain (HINSTANCE hinst, HINSTANCE hpre
600                           hinst,                           hinst,
601                           NULL);                           NULL);
602      if (hwnd == NULL) {      if (hwnd == NULL) {
603          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
604                     _("Could not create window"),
605                     _("WinPT Error"), MB_ERR);
606          free_gnupg_table ();          free_gnupg_table ();
607          return 0;          return 0;
608      }      }
# Line 699  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 610  WinMain (HINSTANCE hinst, HINSTANCE hpre
610      UpdateWindow (hwnd);      UpdateWindow (hwnd);
611    
612      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
613            log_debug("backup gpg config file and check back-end");
614          gnupg_backup_options ();                  gnupg_backup_options ();        
615          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
616              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 743  start: Line 655  start:
655              }              }
656              break;              break;
657    
658            case SETUP_EXISTING:
659                rc = gnupg_import_keypair ();
660                if (rc) {
661                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
662                    goto start;
663                }
664                break;
665    
666          case SETUP_CARDGEN:          case SETUP_CARDGEN:
667              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
668                                   h, card_keygen_dlg_proc, 0);                                   h, card_keygen_dlg_proc, 0);
# Line 763  start: Line 683  start:
683              keycache_release (1);              keycache_release (1);
684              return 0;              return 0;
685          }          }
         if (!is_gpg4win_installed ()) {  
             select_language ();  
             load_gettext ();  
         }  
686      }      }
687      else {      else {
688          gpg_keycache_t c, sec_c;          gpg_keycache_t c;
689          if (update_keycache (hwnd)) {          if (update_keycache (hwnd)) {
690              DestroyWindow (hwnd);              DestroyWindow (hwnd);
691              free_gnupg_table ();              free_gnupg_table ();
# Line 782  start: Line 698  start:
698              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
699                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
700                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
701              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"              ec = msg_box (GetDesktopWindow (),
702                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
703                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
704                              "WinPT", MB_INFO|MB_YESNO);
705              if (ec == IDYES) {              if (ec == IDYES) {
706                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
707                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 796  start: Line 713  start:
713                  keycache_release (1);                  keycache_release (1);
714                  return 0;                  return 0;
715              }              }
716          }          }      
717          sec_c = keycache_get_ctx (0);          if (check_default_key ()) {
         if (check_default_key (sec_c)) {  
718              char *p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
719              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
720                       _("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"
721                         "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"
722                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
723              set_gnupg_default_key (NULL);              set_gnupg_default_key (NULL);
724                free_if_alloc (p);
725          }          }
726          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
727              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
728                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
729      }      }
730      
731      if (start_manager)      if (start_manager)
732          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
733    
# Line 822  start: Line 739  start:
739              DispatchMessage (&msg);              DispatchMessage (&msg);
740          }          }
741      }      }
742                
743      return 0;      return 0;
744  }  }
Legend:
Removed from v.271  
changed lines
  Added in v.415
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26