/[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 409 by twoaday, Mon Feb 6 19:39:00 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 */
# Line 52  HWND glob_hwnd;                /* global window handle Line 46  HWND glob_hwnd;                /* global window handle
46  int scard_support = 0;  int scard_support = 0;
47  int debug = 0;  int debug = 0;
48  int gpg_read_only = 0;  int gpg_read_only = 0;
 int admin_user = 0;  
49  char gpgver[3];  char gpgver[3];
50  /* End */  /* 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  int  int
100  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
101  {  {
102      int err;      refresh_cache_s rcs;
103    
104      refresh_cache_s rcs = {0};      /* no need to rebuild the sig cache each time. */
105      rcs.kr_reload = 0;      memset (&rcs, 0, sizeof (rcs));
106      rcs.kr_update = 1;      rcs.kring_update = 1;
107      rcs.tr_update = 1;      int err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
     err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,  
108                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
109      if (err) {      if (err) {
110          char *cfgf = get_gnupg_config ();          char *cfgf = get_gnupg_config ();
111          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
112              msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);              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);          free_if_alloc (cfgf);
115          return -1;          return -1;
116      }      }
# Line 84  update_keycache (HWND hwnd) Line 122  update_keycache (HWND hwnd)
122  void  void
123  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
124  {  {
125      static char buf[256];      static char buf[MAX_PATH+1];
     char tmp[128];  
126            
127      /* XXX: no gpgme.dbg is created. */      /* XXX: no gpgme.dbg is created. */
128      if (val > 0) {      if (val > 0) {
129            char tmp[128];
130          GetTempPath (DIM (tmp)-1, tmp);          GetTempPath (DIM (tmp)-1, tmp);
131          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
132          putenv (buf);          putenv (buf);
# Line 98  gpg_set_debug_mode (int val) Line 136  gpg_set_debug_mode (int val)
136  }  }
137    
138    
 /* 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);  
     }  
 }  
   
   
139  /* Return true if the GPG environment is useable. */  /* Return true if the GPG environment is useable. */
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");
# Line 151  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 193  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 212  load_gpg_env (void) Line 233  load_gpg_env (void)
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_error (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                return -1;
250            }
251        }
252        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);                   _("WinPT Warning"), MB_WARN);
256      free_if_alloc (defkey);          return 0;
257      return err? -1 : 0;      }
 }  
   
258    
259  /* Return the WinPT program file name (with full pathname). */      /* Because the secret key listing has no information
260  static const char*         about the validity/status, we need to check the public key. */
261  get_prog_part (const char * fname, int use_cwd)      kc = keycache_get_ctx (1);
262  {      if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
263      static char program[2*MAX_PATH+1];          (key->revoked || key->expired)) {
264      char currdir[MAX_PATH+1];          msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
265      char *cmd = NULL;                   _("WinPT Warning"), MB_ERR);
266      int j;          free_if_alloc (defkey);
267                    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);  
268      }      }
269      return program;      free_if_alloc (defkey);
270        return 0;
271  }  }
272    
273    
# Line 272  check_crypto_engine (void) Line 281  check_crypto_engine (void)
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      /* Enable smart card support for GPG 2 or >= 1.4 */      
296        // 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 ())      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 294  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)  
 {      
     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;  
 }  
   
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 357  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 373  check_for_empty_keyrings (bool pub_only) Line 332  check_for_empty_keyrings (bool pub_only)
332  }  }
333    
334    
 #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);  
 }  
   
335    
336  /* Display info message that WinPT is now in debug mode. */  /* Display info message that WinPT is now in debug mode. */
337  void  void
338  winpt_debug_msg (void)  winpt_debug_msg (void)
339  {        {      
340      char output[512];      char output[512];
341      char temp[128];      char temp[MAX_PATH+1];
342                    
343      GetTempPath (DIM (temp) -1, temp);      GetTempPath (DIM (temp) - 1, temp);
344      _snprintf (output, DIM (output)-1,      _snprintf (output, DIM (output)-1,
345          "The GPGME output file is %sgpgme.dbg\n"          "The GPGME output file is %sgpgme.dbg\n"
346          "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 355  count_insecure_elgkeys (void)
355  {  {
356      gpg_keycache_t pc;      gpg_keycache_t pc;
357      gpgme_key_t key;      gpgme_key_t key;
     int n = 0;  
358    
359        int n = 0;
360      pc = keycache_get_ctx (1);      pc = keycache_get_ctx (1);
361      while (!gpg_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
362          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
# Line 477  count_insecure_elgkeys (void) Line 367  count_insecure_elgkeys (void)
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        if (!GetVersionEx (&osver)) {
379            MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
380            return 0;
381        }
382    
383        if (osver.dwMajorVersion < 5 ||
384            (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
385            MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
386            return 0;
387        }
388        
389        return 1;
390    }
391        
392  /* Main entry point. */  /* Main entry point. */
393  int WINAPI  int WINAPI
394  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 398  WinMain (HINSTANCE hinst, HINSTANCE hpre
398      MSG msg;      MSG msg;
399      HWND hwnd = NULL;      HWND hwnd = NULL;
400      WORD ver[3], ptdver[4];      WORD ver[3], ptdver[4];
401        
402      const char *s;      const char *s;
403      int rc, ec, created = 0;      int rc, ec, created = 0;
404      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
405      int winpt_inst_found = 0;      int winpt_inst_found = 0;
406      int start_manager = 0;          int start_manager = 0;    
407        
408  #ifdef WINPT_MOBILE      log_debug("check OS version");
409      /* Do not continue in case of problems. */      if (!check_os_version ())
     if (enable_mobile_mode ())  
410          return 0;          return 0;
411  #endif      
   
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                log_debug("shutdown an existing WinPT process");
419              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
420            }
421          return 0;          return 0;
422      }      }    
423    
424      #ifdef _DEBUG      log_debug("check PTD and GPGME version");
425      gpg_set_debug_mode (1);      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
426      debug = 1;      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
427      #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])) {  
428          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
429                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
430                     "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 432  WinMain (HINSTANCE hinst, HINSTANCE hpre
432          return 0;          return 0;
433      }      }
434    
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
   
435      s = gpgme_check_version (NEED_GPGME_VERSION);      s = gpgme_check_version (NEED_GPGME_VERSION);
436      if (!s || !*s) {      if (!s || !*s) {
437          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),          msg_box (GetDesktopWindow (),
438                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
439                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
440          return 0;          return 0;
441      }      }
# Line 542  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 444  WinMain (HINSTANCE hinst, HINSTANCE hpre
444      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
445          winpt_inst_found = 1;          winpt_inst_found = 1;
446            
447      set_default_keyserver ();      gettext_set_user_domain ();
     load_gettext ();  
     admin_user = user_is_admin ();  
448    
449      regist_inst_gnupg (1);      regist_inst_gnupg (1);
450      regist_inst_winpt (1, &created);      regist_inst_winpt (1, &created);
# Line 552  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 452  WinMain (HINSTANCE hinst, HINSTANCE hpre
452      if (!created) {      if (!created) {
453          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
454          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
455          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 */
456          gnupg_load_config ();          if (gnupg_load_config () == -2)
457                msg_box (GetDesktopWindow (),
458                         _("The gpg.conf file contains the 'textmode' option\n"
459                           "which leads to broken binary output during decryption.\n"
460                           "If this is on purpose, just continue otherwise the option should be disabled."),
461                         _("WinPT Error"), MB_ERR);
462      }      }
463    
464      if (is_gpg4win_installed ())      if (is_gpg4win_installed ()) {
465          load_gpg_env (); /* XXX: check return code. */          log_debug("gpg4win: load gpg environment");
466            load_gpg_env (); /* TODO: check return code. */
467        }
468    
469      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
470      if (rc) {      if (rc) {  
         char *p;  
   
471          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
472                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
473                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
# Line 571  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 476  WinMain (HINSTANCE hinst, HINSTANCE hpre
476                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
477                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
478                                NULL);                                NULL);
479          if (s != NULL && (p=strrchr (s, '\\'))) {          
480            char * p;
481            if (s != NULL && (p = strrchr (s, '\\'))) {
482              char *path = substr (s, 0, (p-s));              char *path = substr (s, 0, (p-s));
483    
484              set_reg_entry_gpg ("HomeDir", path);              set_reg_entry_gpg ("HomeDir", path);
485              free_if_alloc (path);              free_if_alloc (path);
486          }          }
487          else {          else {
488              msg_box (NULL, _("GPG home directory could not be determined."),              msg_box (GetDesktopWindow (),
489                         _("GPG home directory could not be determined."),
490                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
491              goto start;              goto start;
492          }          }
# Line 586  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 494  WinMain (HINSTANCE hinst, HINSTANCE hpre
494    
495      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
496      if (rc) {      if (rc) {
497          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
498                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
499                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
500                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
501                         MB_INFO|MB_YESNO) == IDYES)
502              start_gpgprefs = 1;              start_gpgprefs = 1;
503          else {          else {
504              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
505                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
506              return 0;              return 0;
507          }          }
508      }      }
# Line 600  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 510  WinMain (HINSTANCE hinst, HINSTANCE hpre
510      rc = gnupg_access_files ();      rc = gnupg_access_files ();
511      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
512          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
513              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
514                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
515                    "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"
516                    "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 519  WinMain (HINSTANCE hinst, HINSTANCE hpre
519                  first_start = 1;                  first_start = 1;
520          }          }
521          if (!first_start) {          if (!first_start) {
522              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
523              return 0;              return 0;
524          }          }
525      }      }
# Line 631  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 541  WinMain (HINSTANCE hinst, HINSTANCE hpre
541          return 0;          return 0;
542      }      }
543    
544      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      rc = kserver_load_conf ();
545          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (rc)
546                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,          msg_box (GetDesktopWindow (), winpt_strerror (rc),
547                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                   _("Keyserver"), MB_ERR);
         free_gnupg_table ();  
         return 0;  
     }  
   
     load_keyserver_conf (cmdline? 1 : 0);  
548    
549      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
550                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
# Line 665  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 570  WinMain (HINSTANCE hinst, HINSTANCE hpre
570          return 0;          return 0;
571      }      }
572    
     #ifndef WINPT_MOBILE  
573      if (cmdline && (stristr (cmdline, "--enable-debug") ||      if (cmdline && (stristr (cmdline, "--enable-debug") ||
574                      stristr (cmdline, "--debug"))) {                      stristr (cmdline, "--debug"))) {
575          gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
576          winpt_debug_msg ();          winpt_debug_msg ();
577          debug = 1;          debug = 1;
578      }      }
     #endif  
579    
580      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
581      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
582      if (rc == FALSE) {      if (rc == FALSE) {
583          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
584                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
585          free_gnupg_table ();          free_gnupg_table ();
586          return 0;          return 0;
# Line 691  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 594  WinMain (HINSTANCE hinst, HINSTANCE hpre
594                           hinst,                           hinst,
595                           NULL);                           NULL);
596      if (hwnd == NULL) {      if (hwnd == NULL) {
597          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
598                     _("Could not create window"),
599                     _("WinPT Error"), MB_ERR);
600          free_gnupg_table ();          free_gnupg_table ();
601          return 0;          return 0;
602      }      }
# Line 699  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 604  WinMain (HINSTANCE hinst, HINSTANCE hpre
604      UpdateWindow (hwnd);      UpdateWindow (hwnd);
605    
606      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
607            log_debug("backup gpg config file and check back-end");
608          gnupg_backup_options ();                  gnupg_backup_options ();        
609          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
610              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 743  start: Line 649  start:
649              }              }
650              break;              break;
651    
652            case SETUP_EXISTING:
653                rc = gnupg_import_keypair ();
654                if (rc) {
655                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
656                    goto start;
657                }
658                break;
659    
660          case SETUP_CARDGEN:          case SETUP_CARDGEN:
661              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
662                                   h, card_keygen_dlg_proc, 0);                                   h, card_keygen_dlg_proc, 0);
# Line 763  start: Line 677  start:
677              keycache_release (1);              keycache_release (1);
678              return 0;              return 0;
679          }          }
         if (!is_gpg4win_installed ()) {  
             select_language ();  
             load_gettext ();  
         }  
680      }      }
681      else {      else {
682          gpg_keycache_t c, sec_c;          gpg_keycache_t c;
683          if (update_keycache (hwnd)) {          if (update_keycache (hwnd)) {
684              DestroyWindow (hwnd);              DestroyWindow (hwnd);
685              free_gnupg_table ();              free_gnupg_table ();
# Line 782  start: Line 692  start:
692              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
693                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
694                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
695              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"              ec = msg_box (GetDesktopWindow (),
696                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
697                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
698                              "WinPT", MB_INFO|MB_YESNO);
699              if (ec == IDYES) {              if (ec == IDYES) {
700                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
701                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 796  start: Line 707  start:
707                  keycache_release (1);                  keycache_release (1);
708                  return 0;                  return 0;
709              }              }
710          }          }      
711          sec_c = keycache_get_ctx (0);          if (check_default_key ()) {
         if (check_default_key (sec_c)) {  
712              char *p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
713              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
714                       _("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"
715                         "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"
716                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
717              set_gnupg_default_key (NULL);              set_gnupg_default_key (NULL);
718                free_if_alloc (p);
719          }          }
720          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
721              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
722                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
723      }      }
724      
725      if (start_manager)      if (start_manager)
726          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
727    
# Line 822  start: Line 733  start:
733              DispatchMessage (&msg);              DispatchMessage (&msg);
734          }          }
735      }      }
736                
737      return 0;      return 0;
738  }  }
Legend:
Removed from v.271  
changed lines
  Added in v.409
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26