/[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 278 by twoaday, Mon Jan 15 22:02:04 2007 UTC revision 417 by twoaday, Thu Feb 16 19:50:32 2012 UTC
# Line 1  Line 1 
1  /* WinPT.cpp - Windows Privacy Tray (WinPT)  /* WinPT.cpp - Windows Privacy Tray (WinPT)
2   *      Copyright (C) 2000-2006 Timo Schulz   *      Copyright (C) 2000-2009, 2012 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 39  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);  
 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  {  {
     int err;  
103      refresh_cache_s rcs;      refresh_cache_s rcs;
104    
105      /* no need to rebuild the sig cache each time. */      /* no need to rebuild the sig cache each time. */
106      memset (&rcs, 0, sizeof (rcs));      memset (&rcs, 0, sizeof (rcs));
107      rcs.kring_update = 1;      rcs.kring_update = 1;
108      err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      int 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 80  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 94  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) {  
         gettext_set_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 147  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 189  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 217  check_default_key (void) Line 243  check_default_key (void)
243    
244      kc = keycache_get_ctx (0);      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          if (err) {          if (err) {
249              free_if_alloc (defkey);              free_if_alloc (defkey);
# Line 226  check_default_key (void) Line 252  check_default_key (void)
252      }      }
253      else {      else {
254          /* Actually this is just a warning but we still continue. */          /* Actually this is just a warning but we still continue. */
255          msg_box (NULL, _("No useable secret key found."),          msg_box (GetDesktopWindow (), _("No useable secret key found."),
256                   _("WinPT Warning"), MB_WARN);                   _("WinPT Warning"), MB_WARN);
         free_if_alloc (defkey);  
257          return 0;          return 0;
258      }      }
259    
# Line 237  check_default_key (void) Line 262  check_default_key (void)
262      kc = keycache_get_ctx (1);      kc = keycache_get_ctx (1);
263      if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&      if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
264          (key->revoked || key->expired)) {          (key->revoked || key->expired)) {
265          msg_box (NULL, _("Default secret key is unuseable"),          msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
266                   _("WinPT Warning"), MB_ERR);                   _("WinPT Warning"), MB_ERR);
267          free_if_alloc (defkey);          free_if_alloc (defkey);
268          return -1;          return -1;
# Line 247  check_default_key (void) Line 272  check_default_key (void)
272  }  }
273    
274    
 /* Return the WinPT program file name (with full pathname). */  
 static const char*  
 get_prog_part (const char *fname, int use_cwd)  
 {  
     static char program[2*MAX_PATH+1];  
     char currdir[MAX_PATH+1];  
     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)  
             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);  
     }  
     return program;  
 }  
   
   
275  /* Check that the underlying crypto engine fullfills the minimal  /* Check that the underlying crypto engine fullfills the minimal
276     requirements so all commands work properly. */     requirements so all commands work properly. */
277  static bool  static bool
# Line 290  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      }      }
# Line 301  check_crypto_engine (void) Line 293  check_crypto_engine (void)
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 312  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. */
315  static bool  static bool
316  check_for_empty_keyrings (bool pub_only)  check_for_empty_keyrings (bool pub_only)
317  {  {
     char *p;  
318      int n = 0;      int n = 0;
319        char *p = get_gnupg_keyring (1, 0);
     p = get_gnupg_keyring (1, 0);  
320      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
321          n++;          n++;
322      free_if_alloc (p);      free_if_alloc (p);
# Line 387  check_for_empty_keyrings (bool pub_only) Line 326  check_for_empty_keyrings (bool pub_only)
326      if (file_exist_check (p) == 0 && get_file_size (p) == 0)      if (file_exist_check (p) == 0 && get_file_size (p) == 0)
327          n++;          n++;
328      free_if_alloc (p);      free_if_alloc (p);
329      return n==2? true : false;      return n == 2? true : false;
330  }  }
331    
332    
 #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);  
 }  
   
333    
334  /* Display info message that WinPT is now in debug mode. */  /* Display info message that WinPT is now in debug mode. */
335  void  void
336  winpt_debug_msg (void)  winpt_debug_msg (void)
337  {        {      
338      char output[512];      char output[512];
339      char temp[128];      char temp[MAX_PATH+1];
340                    
341      GetTempPath (DIM (temp) -1, temp);      GetTempPath (DIM (temp) - 1, temp);
342      _snprintf (output, DIM (output)-1,      _snprintf (output, DIM (output)-1,
343          "The GPGME output file is %sgpgme.dbg\n"          "The GPGME output file is %sgpgme.dbg\n"
344          "The WinPT output file is %swinpt.log\n", temp, temp);          "The WinPT output file is %swinpt-%08lx.log\n", temp, temp, GetCurrentProcessId());
345      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
346  }  }
347    
# Line 481  winpt_debug_msg (void) Line 351  winpt_debug_msg (void)
351  static int  static int
352  count_insecure_elgkeys (void)  count_insecure_elgkeys (void)
353  {  {
     gpg_keycache_t pc;  
354      gpgme_key_t key;      gpgme_key_t key;
     int n = 0;  
355    
356      pc = keycache_get_ctx (1);      int n = 0;
357        gpg_keycache_t pc = keycache_get_ctx (1);
358      while (!gpg_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
359          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
360              n++;              n++;
# Line 495  count_insecure_elgkeys (void) Line 364  count_insecure_elgkeys (void)
364  }  }
365    
366    
367    /* Return 1 if the current OS version is at least Windows XP */
368    static int
369    check_os_version (void)
370    {
371        OSVERSIONINFOA osver;    
372        memset (&osver, 0, sizeof (osver));
373        osver.dwOSVersionInfoSize = sizeof (osver);
374            
375        if (!GetVersionEx (&osver)) {
376            MessageBox (NULL, _("Could not read the OS version."), _("WinPT Error"), MB_ERR);
377            return 0;
378        }
379    
380        if (osver.dwMajorVersion < 5 ||
381            (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0)) {
382            MessageBox (NULL, _("WinPT requires Windows XP or higher."), _("WinPT Error"), MB_ERR);
383            return 0;
384        }
385        
386        return 1;
387    }
388        
389  /* Main entry point. */  /* Main entry point. */
390  int WINAPI  int WINAPI
391  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
# Line 504  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 395  WinMain (HINSTANCE hinst, HINSTANCE hpre
395      MSG msg;      MSG msg;
396      HWND hwnd = NULL;      HWND hwnd = NULL;
397      WORD ver[3], ptdver[4];      WORD ver[3], ptdver[4];
398        
399      const char *s;      const char *s;
400      int rc, ec, created = 0;      int rc, ec, created = 0;
401      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
402      int winpt_inst_found = 0;      int winpt_inst_found = 0;
403      int start_manager = 0;          int start_manager = 0;    
404        
405  #ifdef WINPT_MOBILE      log_debug("check OS version");
406      /* Do not continue in case of problems. */      if (!check_os_version ())
     if (enable_mobile_mode ())  
407          return 0;          return 0;
408  #endif      
   
409      glob_hinst = hinst;      glob_hinst = hinst;
410        
411        /* Check as early as possible for debug flags and activate
412           the debug mode if requested */
413        if (cmdline && (stristr (cmdline, "--enable-debug") ||
414                        stristr (cmdline, "--debug"))) {
415            //gpg_set_debug_mode (1);
416            winpt_debug_msg ();
417            debug = 1;
418        }
419        
420        /* Allow to shutdown the process, for instance by an installer */
421      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
422          hwnd = FindWindow ("WinPT", "WinPT");          hwnd = FindWindow ("WinPT", "WinPT");
423          if (hwnd != NULL)          if (hwnd != NULL) {
424                log_debug ("shutdown an existing WinPT process");
425              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
426            }
427          return 0;          return 0;
428      }      }
429        
430        /* KLUDGE: test if the hooking is causing problems with some AV programs */
431        if (cmdline && stristr (cmdline, "--disable-hook")) {
432            log_debug ("disable current window hooks");
433            disable_hook = 1;
434        }
435        
436    
437  #ifdef _DEBUG      log_debug("check PTD and GPGME version");
438      gpg_set_debug_mode (1);      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
439      debug = 1;      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
440  #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])) {  
441          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
442                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
443                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
# Line 543  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 445  WinMain (HINSTANCE hinst, HINSTANCE hpre
445          return 0;          return 0;
446      }      }
447    
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
   
448      s = gpgme_check_version (NEED_GPGME_VERSION);      s = gpgme_check_version (NEED_GPGME_VERSION);
449      if (!s || !*s) {      if (!s || !*s) {
450          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),          msg_box (GetDesktopWindow (),
451                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
452                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
453          return 0;          return 0;
454      }      }
455    
456      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
457      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS) {
458            log_debug ("Found running WinPT instance");
459          winpt_inst_found = 1;          winpt_inst_found = 1;
460        }
461            
462      set_default_keyserver ();      gettext_set_user_domain ();
     load_gettext ();  
     admin_user = user_is_admin ();  
463    
464      regist_inst_gnupg (1);      regist_inst_gnupg (1);
465      regist_inst_winpt (1, &created);      regist_inst_winpt (1, &created);
# Line 570  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 467  WinMain (HINSTANCE hinst, HINSTANCE hpre
467      if (!created) {      if (!created) {
468          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
469          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
470          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 */
471          if (gnupg_load_config () == -2)          if (gnupg_load_config () == -2)
472              msg_box (NULL, _("The gpg.conf file contains the 'textmode' option\n"              msg_box (GetDesktopWindow (),
473                               "which leads to broken binary output during decryption.\n"                       _("The gpg.conf file contains the 'textmode' option\n"
474                               "If this is on purpose, just continue otherwise the option should be disabled."),                         "which leads to broken binary output during decryption.\n"
475                              _("WinPT Error"), MB_ERR);                         "If this is on purpose, just continue otherwise the option should be disabled."),
476                         _("WinPT Error"), MB_ERR);
477      }      }
478    
479      if (is_gpg4win_installed ())      if (is_gpg4win_installed ()) {
480          load_gpg_env (); /* XXX: check return code. */          log_debug ("gpg4win: load gpg environment");
481            load_gpg_env (); /* TODO: check return code. */
482        }
483    
484      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
485      if (rc) {      if (rc) {  
         char *p;  
   
486          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
487                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
488                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
# Line 593  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 491  WinMain (HINSTANCE hinst, HINSTANCE hpre
491                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
492                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
493                                NULL);                                NULL);
494          if (s != NULL && (p=strrchr (s, '\\'))) {          
495            char * p;
496            if (s != NULL && (p = strrchr (s, '\\'))) {
497              char *path = substr (s, 0, (p-s));              char *path = substr (s, 0, (p-s));
498    
499              set_reg_entry_gpg ("HomeDir", path);              set_reg_entry_gpg ("HomeDir", path);
500              free_if_alloc (path);              free_if_alloc (path);
501          }          }
502          else {          else {
503              msg_box (NULL, _("GPG home directory could not be determined."),              msg_box (GetDesktopWindow (),
504                         _("GPG home directory could not be determined."),
505                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
506              goto start;              goto start;
507          }          }
# Line 608  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 509  WinMain (HINSTANCE hinst, HINSTANCE hpre
509    
510      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
511      if (rc) {      if (rc) {
512          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
513                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
514                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
515                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
516                         MB_INFO|MB_YESNO) == IDYES)
517              start_gpgprefs = 1;              start_gpgprefs = 1;
518          else {          else {
519              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
520                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
521              return 0;              return 0;
522          }          }
523      }      }
# Line 622  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 525  WinMain (HINSTANCE hinst, HINSTANCE hpre
525      rc = gnupg_access_files ();      rc = gnupg_access_files ();
526      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
527          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
528              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
529                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
530                    "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"
531                    "Continue if you want WinPT to offer you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
# Line 631  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 534  WinMain (HINSTANCE hinst, HINSTANCE hpre
534                  first_start = 1;                  first_start = 1;
535          }          }
536          if (!first_start) {          if (!first_start) {
537              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
538              return 0;              return 0;
539          }          }
540      }      }
541      if (check_for_empty_keyrings (false))      if (check_for_empty_keyrings (false)) {
542            log_debug ("found empty keyrings, assume first start");
543          first_start = 1;          first_start = 1;
544        }
545    
546      if (!first_start) {      if (!first_start) {
547          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
# Line 649  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 554  WinMain (HINSTANCE hinst, HINSTANCE hpre
554      init_gnupg_table ();      init_gnupg_table ();
555    
556      if (fm_parse_command_line (cmdline) > 0) {      if (fm_parse_command_line (cmdline) > 0) {
557            log_debug ("processed arguments with File Manager, exiting...");
558          free_gnupg_table ();          free_gnupg_table ();
559          return 0;          return 0;
560      }      }
561    
562      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      rc = kserver_load_conf ();
563          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (rc)
564                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,          msg_box (GetDesktopWindow (), winpt_strerror (rc),
565                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                   _("Keyserver"), MB_ERR);
         free_gnupg_table ();  
         return 0;  
     }  
   
     load_keyserver_conf (cmdline? 1 : 0);  
566    
567      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
568                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
# Line 686  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 587  WinMain (HINSTANCE hinst, HINSTANCE hpre
587          free_gnupg_table ();          free_gnupg_table ();
588          return 0;          return 0;
589      }      }
590        
 #ifndef WINPT_MOBILE  
     if (cmdline && (stristr (cmdline, "--enable-debug") ||  
                     stristr (cmdline, "--debug"))) {  
         gpg_set_debug_mode (1);  
         winpt_debug_msg ();  
         debug = 1;  
     }  
 #endif  
   
591      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
592      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
593      if (rc == FALSE) {      if (rc == FALSE) {
594          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
595                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
596          free_gnupg_table ();          free_gnupg_table ();
597          return 0;          return 0;
# Line 713  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 605  WinMain (HINSTANCE hinst, HINSTANCE hpre
605                           hinst,                           hinst,
606                           NULL);                           NULL);
607      if (hwnd == NULL) {      if (hwnd == NULL) {
608          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
609                     _("Could not create window"),
610                     _("WinPT Error"), MB_ERR);
611          free_gnupg_table ();          free_gnupg_table ();
612          return 0;          return 0;
613      }      }
# Line 721  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 615  WinMain (HINSTANCE hinst, HINSTANCE hpre
615      UpdateWindow (hwnd);      UpdateWindow (hwnd);
616    
617      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
618            log_debug("backup gpg config file and check back-end");
619          gnupg_backup_options ();                  gnupg_backup_options ();        
620          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
621              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 765  start: Line 660  start:
660              }              }
661              break;              break;
662    
663            case SETUP_EXISTING:
664                rc = gnupg_import_keypair ();
665                if (rc) {
666                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
667                    goto start;
668                }
669                break;
670    
671          case SETUP_CARDGEN:          case SETUP_CARDGEN:
672              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
673                                   h, card_keygen_dlg_proc, 0);                                   h, card_keygen_dlg_proc, 0);
# Line 785  start: Line 688  start:
688              keycache_release (1);              keycache_release (1);
689              return 0;              return 0;
690          }          }
         if (!is_gpg4win_installed ()) {  
             select_language ();  
             load_gettext ();  
         }  
691      }      }
692      else {      else {
693          gpg_keycache_t c;          gpg_keycache_t c;
# Line 804  start: Line 703  start:
703              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
704                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
705                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
706              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"              ec = msg_box (GetDesktopWindow (),
707                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
708                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
709                              "WinPT", MB_INFO|MB_YESNO);
710              if (ec == IDYES) {              if (ec == IDYES) {
711                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
712                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 832  start: Line 732  start:
732              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
733                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
734      }      }
735      
736      if (start_manager)      if (start_manager)
737          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
738    
# Line 844  start: Line 744  start:
744              DispatchMessage (&msg);              DispatchMessage (&msg);
745          }          }
746      }      }
747                
748      return 0;      return 0;
749  }  }
Legend:
Removed from v.278  
changed lines
  Added in v.417
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26