/[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 248 by twoaday, Fri Jul 28 11:11:09 2006 UTC revision 355 by twoaday, Sat Dec 3 18:59:01 2011 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);  
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 debug = 0;  int debug = 0;
 int mobile_mode_active = 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  void  int
100  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
101  {  {
102      refresh_cache_s rcs = {0};      int err;
103      rcs.kr_reload = 0;      refresh_cache_s rcs;
104      rcs.kr_update = 1;  
105      rcs.tr_update = 1;      /* no need to rebuild the sig cache each time. */
106      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      memset (&rcs, 0, sizeof (rcs));
107        rcs.kring_update = 1;
108        err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
109                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
110      /* XXX: the dialog return 0 when an error occurs.      if (err) {
111              in this case figure out if the gpg env is OK          char *cfgf = get_gnupg_config ();
112              and supress dialogs to configure gpg. */          if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
113                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);
116            return -1;
117        }
118        return 0;
119  }  }
120    
121    
# Line 77  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];
127      char tmp[128];      char tmp[128];
128            
129      /* XXX: no gpgme.dbg is created. */      /* XXX: no gpgme.dbg is created. */
130      if (val > 0) {      if (val > 0) {
131          GetTempPath (sizeof (tmp)-1, tmp);          GetTempPath (DIM (tmp)-1, tmp);
132          _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);          _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
133          putenv (buf);          putenv (buf);
134      }      }
135      else      else
# Line 91  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 = NULL;  
   
     /* 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 123  gpg_prefs_ok (void) Line 152  gpg_prefs_ok (void)
152          }          }
153      }      }
154      free_if_alloc (p);      free_if_alloc (p);
155      p = get_reg_entry_gpg4win (NULL);          p = get_reg_entry_gpg4win (NULL);
156      if (!p || dir_exist_check (p) != 0) {      if (!p || dir_exist_check (p) != 0) {
157          free_if_alloc (p);          free_if_alloc (p);
158          p = get_reg_entry_gpg ("HomeDir");          p = get_reg_entry_gpg ("HomeDir");
# Line 144  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};
     char *file;  
     int i;  
176    
177      for (i=0; files[i] != NULL; i++) {      for (int i=0; files[i] != NULL; i++) {
178          file = make_filename (homedir, files[i], NULL);          char *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 166  load_gpg_env (void) Line 193  load_gpg_env (void)
193      SECURITY_ATTRIBUTES sec_attr;      SECURITY_ATTRIBUTES sec_attr;
194      char *p;      char *p;
195      char *pkr;      char *pkr;
196        int err = 0;
197    
198      p = get_reg_entry_gpg4win ("gpg.exe");      p = get_reg_entry_gpg4win ("gpg.exe");
199      if (!p)      if (!p)
# Line 185  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 194  load_gpg_env (void) Line 223  load_gpg_env (void)
223      check_readonly_attr (p);      check_readonly_attr (p);
224      pkr = make_filename (p, "pubring", "gpg");      pkr = make_filename (p, "pubring", "gpg");
225      free_if_alloc (p);      free_if_alloc (p);
226      if (!pkr)      if (get_file_size (pkr) == 0)
227          return -1;          err = -1;
228      if (get_file_size (pkr) == 0) {      free_if_alloc (pkr);
229          free_if_alloc (pkr);      return err;
         return -1;  
     }  
     return 0;  
230  }  }
231    
232    
233  /* check if the default key from the gpg.conf file is available in the  /* check if the default key from the gpg.conf file is available in the
234     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
235  static int  static int
236  check_default_key (gpg_keycache_t kc)  check_default_key (void)
237  {  {
238      gpgme_key_t key;      gpgme_key_t key;
239      gpgme_error_t err = gpg_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[512];          (key->revoked || key->expired)) {
264      char currdir[256];          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 == NULL)  
             return NULL;  
         strncpy (currdir, cmd, sizeof (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 267  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      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */      
296      if (ma > 1 || pa >= 3)      // TODO: smart card support needs to be revamped
297        // and adjusted according to newer OpenPGP cards.
298        /*
299        if ((ma > 1 || pa >= 4) && pcsc_available ())
300          scard_support = 1;          scard_support = 1;
301        */
302        scard_support = 0;
303        
304      gpgver[0] = ma;      gpgver[0] = ma;
305      gpgver[1] = mi;      gpgver[1] = mi;
306      gpgver[2] = pa;      gpgver[2] = pa;
# Line 289  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;  
   
     /* 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 346  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 362  check_for_empty_keyrings (bool pub_only) Line 332  check_for_empty_keyrings (bool pub_only)
332  }  }
333    
334    
 /* Enable the mobility mode. */  
 static int  
 enable_mobile_mode (void)  
 {  
     if (dir_exist_check ("temp") != 0) {  
         if (!CreateDirectory ("temp", NULL)) {  
             MessageBox (NULL, "Could not create mobile temp directory",  
                         "WinPT Mobile Error", MB_ERR);  
             return -1;  
         }  
     }  
   
     memset (&reg_prefs, 0, sizeof (reg_prefs));  
     reg_prefs.always_trust = 0;  
     reg_prefs.auto_backup = 0;  
     reg_prefs.cache_time = 0;  
     reg_prefs.expert = 0;  
     reg_prefs.kserv_conf = m_strdup ("keyserver.conf");  
     reg_prefs.no_zip_mmedia = 1;  
     reg_prefs.word_wrap = 80;  
     reg_prefs.use_viewer = 0; /* XXX */  
     return 0;  
 }  
   
   
 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 (sizeof temp -1, temp);      GetTempPath (DIM (temp) -1, temp);
344      _snprintf (output, sizeof 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);
347      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);      MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
# Line 428  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;
358      int n = 0;      int n;
359    
360        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 440  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 449  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        if (!check_os_version ())
410            return 0;
411        
412      glob_hinst = hinst;      glob_hinst = hinst;
413        
414        /* Allow to shutdown the process, for instance by an installer */
415      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
416          hwnd = FindWindow ("WinPT", "WinPT");          hwnd = FindWindow ("WinPT", "WinPT");
417          if (hwnd != NULL)          if (hwnd != NULL)
418              PostMessage (hwnd, WM_DESTROY, 0, 0);              PostMessage (hwnd, WM_DESTROY, 0, 0);
419          return 0;          return 0;
420      }      }    
421    
422      #ifdef _DEBUG      get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
423      gpg_set_debug_mode (1);      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], &ptdver[2], &ptdver[3]);
424      debug = 1;      if (!ec && (ptdver[0] != ver[0] || ptdver[1] != ver[1] || ptdver[2] != ver[2])) {
     #endif  
   
     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])) {  
425          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
426                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
427                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
# Line 480  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 429  WinMain (HINSTANCE hinst, HINSTANCE hpre
429          return 0;          return 0;
430      }      }
431    
     if (gpg_md_selftest ()) {  
         msg_box (NULL, _("Cryptographic selftest failed."),  
                  _("WinPT Error"), MB_ERR);  
         return 0;  
     }  
   
432      s = gpgme_check_version (NEED_GPGME_VERSION);      s = gpgme_check_version (NEED_GPGME_VERSION);
433      if (!s || !*s) {      if (!s || !*s) {
434          msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),          msg_box (GetDesktopWindow (),
435                     _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
436                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
437          return 0;          return 0;
438      }      }
# Line 496  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 440  WinMain (HINSTANCE hinst, HINSTANCE hpre
440      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
441      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
442          winpt_inst_found = 1;          winpt_inst_found = 1;
   
     if (cmdline && stristr (cmdline, "--mobile")) {  
         msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",  
                  "WinPT", MB_INFO);  
         mobile_mode_active = 1;  
     }  
443            
444      set_default_keyserver ();      gettext_set_user_domain ();
445      load_gettext ();  
446      admin_user = user_is_admin ();      regist_inst_gnupg (1);
447        regist_inst_winpt (1, &created);
     if (!mobile_mode_active) {  
         regist_inst_gnupg (1);  
         regist_inst_winpt (1, &created);  
     }  
     else {  
         if (enable_mobile_mode ())  
             return 0;  
         created = 1; /* Disable registry writing */  
     }  
448    
449      if (!created) {      if (!created) {
450          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
         reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */  
451          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
452          gnupg_load_config ();          reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
453            if (gnupg_load_config () == -2)
454                msg_box (GetDesktopWindow (),
455                         _("The gpg.conf file contains the 'textmode' option\n"
456                           "which leads to broken binary output during decryption.\n"
457                           "If this is on purpose, just continue otherwise the option should be disabled."),
458                         _("WinPT Error"), MB_ERR);
459      }      }
460    
461      if (is_gpg4win_installed ())      if (is_gpg4win_installed ())
462          load_gpg_env (); /* XXX: check return code. */          load_gpg_env (); /* TODO: check return code. */
463    
464      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
465      if (rc) {      if (rc) {
466            char *p;
467    
468          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
469                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
470                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
# Line 537  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 473  WinMain (HINSTANCE hinst, HINSTANCE hpre
473                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
474                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
475                                NULL);                                NULL);
476          if (s != NULL) {          if (s != NULL && (p=strrchr (s, '\\'))) {
477              size_t n;              char *path = substr (s, 0, (p-s));
478              char *p = strrchr (s, '\\');  
479              if (!p)              set_reg_entry_gpg ("HomeDir", path);
480                  BUG (0);              free_if_alloc (path);
             n = p - s;  
             if (n) {  
                 char *file = new char[n+1];  
                 if (!file)  
                     BUG (NULL);  
                 memset (file, 0, n);  
                 memcpy (file, s, n);  
                 file[n] = '\0';          
                 set_reg_entry_gpg ("HomeDir", file);  
                 free_if_alloc (file);  
                 gnupg_check_homedir (); /* change gpgProgram if needed */  
             }  
481          }          }
482          else {          else {
483              msg_box (NULL, _("GPG home directory could not be determined."),              msg_box (GetDesktopWindow (),
484                         _("GPG home directory could not be determined."),
485                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
486              goto start;              goto start;
487          }          }
# Line 564  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 489  WinMain (HINSTANCE hinst, HINSTANCE hpre
489    
490      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
491      if (rc) {      if (rc) {
492          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (GetDesktopWindow (),
493                               "Do you want to start the GPG preferences to "                       _("Could not find the GPG binary (gpg.exe).\n"
494                               "correct  this problem?"), _("WinPT Error"),                         "Do you want to start the GPG preferences to "
495                               MB_INFO|MB_YESNO) == IDYES)                         "correct  this problem?"), _("WinPT Error"),
496                         MB_INFO|MB_YESNO) == IDYES)
497              start_gpgprefs = 1;              start_gpgprefs = 1;
498          else {          else {
499              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (),
500                         winpt_strerror (rc), _("WinPT Error"), MB_ERR);
501              return 0;              return 0;
502          }          }
503      }      }
# Line 578  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 505  WinMain (HINSTANCE hinst, HINSTANCE hpre
505      rc = gnupg_access_files ();      rc = gnupg_access_files ();
506      if (!start_gpgprefs && rc) {      if (!start_gpgprefs && rc) {
507          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
508              ec = msg_box (NULL,              ec = msg_box (GetDesktopWindow (),
509                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
510                    "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"
511                    "Continue if you want WinPT to offer you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
# Line 587  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 514  WinMain (HINSTANCE hinst, HINSTANCE hpre
514                  first_start = 1;                  first_start = 1;
515          }          }
516          if (!first_start) {          if (!first_start) {
517              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
518              return 0;              return 0;
519          }          }
520      }      }
# Line 596  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 523  WinMain (HINSTANCE hinst, HINSTANCE hpre
523    
524      if (!first_start) {      if (!first_start) {
525          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
526          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
527              gpg_read_only = 1;              gpg_read_only = 1;
528          else if (rc)          else if (rc)
529              return 0;              return 0;
# Line 609  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 536  WinMain (HINSTANCE hinst, HINSTANCE hpre
536          return 0;          return 0;
537      }      }
538    
539      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      rc = kserver_load_conf ();
540          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,      if (rc)
541                              GetDesktopWindow(), space_wipefrees_dlg_proc, 0,          msg_box (GetDesktopWindow (), winpt_strerror (rc),
542                              _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);                   _("Keyserver"), MB_ERR);
         free_gnupg_table ();  
         return 0;  
     }  
   
     load_keyserver_conf (cmdline? 1 : 0);  
543    
544      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
545                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
546          /* If an instance of WinPT is running, just send the command          /* If an instance of WinPT is running, just send the command
547             to open the key manager. Otherwise start a new instance.             to open the key manager. Otherwise start a new instance. */
          */  
548          HWND tray = FindWindow ("WinPT", "WinPT");          HWND tray = FindWindow ("WinPT", "WinPT");
549          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
550              start_manager = ID_WINPT_KEY;              start_manager = ID_WINPT_KEY;
# Line 654  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 575  WinMain (HINSTANCE hinst, HINSTANCE hpre
575      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
576      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
577      if (rc == FALSE) {      if (rc == FALSE) {
578          msg_box (NULL, _("Could not register window class"),          msg_box (GetDesktopWindow (), _("Could not register window class"),
579                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
580          free_gnupg_table ();          free_gnupg_table ();
581          return 0;          return 0;
# Line 668  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 589  WinMain (HINSTANCE hinst, HINSTANCE hpre
589                           hinst,                           hinst,
590                           NULL);                           NULL);
591      if (hwnd == NULL) {      if (hwnd == NULL) {
592          msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);          msg_box (GetDesktopWindow (),
593                     _("Could not create window"),
594                     _("WinPT Error"), MB_ERR);
595          free_gnupg_table ();          free_gnupg_table ();
596          return 0;          return 0;
597      }      }
# Line 688  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 611  WinMain (HINSTANCE hinst, HINSTANCE hpre
611          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
612                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
613          if (check_for_empty_keyrings (true))          if (check_for_empty_keyrings (true))
614              first_start = 1; /* The public keyring is empty! */              first_start = 1; /* The public keyring is empty. */
615      }      }
616    
617      if (first_start) {      if (first_start) {
# Line 720  start: Line 643  start:
643              }              }
644              break;              break;
645    
646            case SETUP_EXISTING:
647                rc = gnupg_import_keypair ();
648                if (rc) {
649                    msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
650                    goto start;
651                }
652                break;
653    
654            case SETUP_CARDGEN:
655                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
656                                     h, card_keygen_dlg_proc, 0);
657                if (!rc)
658                    goto start;
659                break;
660    
661          case 0: /* Cancel/Abort. */          case 0: /* Cancel/Abort. */
662          default:          default:
663              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 730  start: Line 668  start:
668          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
669              DestroyWindow (hwnd);              DestroyWindow (hwnd);
670              free_gnupg_table ();              free_gnupg_table ();
671                keycache_release (1);
672              return 0;              return 0;
673          }          }
         if (!is_gpg4win_installed ()) {  
             select_language ();  
             load_gettext ();  
         }  
674      }      }
675      else {      else {
676          gpg_keycache_t c, sec_c;          gpg_keycache_t c;
677          update_keycache (hwnd);          if (update_keycache (hwnd)) {
678                DestroyWindow (hwnd);
679                free_gnupg_table ();
680                keycache_release (1);
681                return 0;
682            }
683            /* XXX: rewrite this part. */
684          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
685          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
686              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
687                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
688                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
689              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"              ec = msg_box (GetDesktopWindow (),
690                                    "Do you want to start the GPG preferences dialog?"),                            _("It seems that GPG is not configured properly.\n"
691                              "WinPT", MB_INFO|MB_YESNO);                              "Do you want to start the GPG preferences dialog?"),
692                              "WinPT", MB_INFO|MB_YESNO);
693              if (ec == IDYES) {              if (ec == IDYES) {
694                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,                  DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
695                                  gpgprefs_dlg_proc, 0);                                  gpgprefs_dlg_proc, 0);
# Line 757  start: Line 698  start:
698              else {              else {
699                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
700                  free_gnupg_table ();                  free_gnupg_table ();
701                    keycache_release (1);
702                  return 0;                  return 0;
703              }              }
704          }          }      
705          sec_c = keycache_get_ctx (0);          if (check_default_key ()) {
         if (check_default_key (sec_c)) {  
706              char *p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
707              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
708                       _("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"
709                         "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"
710                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
711              set_gnupg_default_key (NULL);              set_gnupg_default_key (NULL);
712                free_if_alloc (p);
713          }          }
714          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
715              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
716                              elgamal_warn_dlg_proc, 0);                              elgamal_warn_dlg_proc, 0);
717      }      }
718      
719      if (start_manager)      if (start_manager)
720          PostMessage (hwnd, WM_COMMAND, start_manager, 0);          PostMessage (hwnd, WM_COMMAND, start_manager, 0);
721    
# Line 785  start: Line 727  start:
727              DispatchMessage (&msg);              DispatchMessage (&msg);
728          }          }
729      }      }
730                
731      return 0;      return 0;
732  }  }
Legend:
Removed from v.248  
changed lines
  Added in v.355
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26