/[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 168 by twoaday, Fri Jan 27 10:08:10 2006 UTC revision 273 by twoaday, Fri Dec 8 10:22:17 2006 UTC
# Line 40  Line 40 
40  #include "wptContext.h"  #include "wptContext.h"
41  #include "wptCardEdit.h"  #include "wptCardEdit.h"
42  #include "wptCrypto.h"  #include "wptCrypto.h"
43    #include "wptUTF8.h"
44    
45    void remove_crit_file_attrs (const char *fname, int force);
46    BOOL user_is_admin (void);
47    int  pcsc_available (void);
48    
49    /* Global variables. */
50  HINSTANCE glob_hinst;   /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
51  HWND glob_hwnd;         /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
 HWND activ_hwnd;  
52  int scard_support = 0;  int scard_support = 0;
53  int debug = 0;  int debug = 0;
 int mobile = 0;  
54  int gpg_read_only = 0;  int gpg_read_only = 0;
55    int admin_user = 0;
56  char gpgver[3];  char gpgver[3];
57    /* End */
58    
59    
60  /* Load the key cache and rebuild the signature cache. */  /* Load the key cache and rebuild the signature cache. */
61  static void  int
62  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
63  {  {
64      refresh_cache_s rcs = {0};      int err;
65      rcs.kr_reload = 0;      refresh_cache_s rcs;
66      rcs.kr_update = 1;  
67      rcs.tr_update = 1;      /* no need to rebuild the sig cache each time. */
68      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      memset (&rcs, 0, sizeof (rcs));
69        rcs.kring_update = 1;
70        err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
71                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
72        if (err) {
73            char *cfgf = get_gnupg_config ();
74            if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
75                msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
76            free_if_alloc (cfgf);
77            return -1;
78        }
79        return 0;
80  }  }
81    
82    
83  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */  /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
84  void  void
85  gpg_set_debug_mode (int val)  gpg_set_debug_mode (int val)
86  {        {
87      if (val)      static char buf[256];
88          putenv ("GPGME_DEBUG=5:gpgme.dbg");      char tmp[128];
89        
90        /* XXX: no gpgme.dbg is created. */
91        if (val > 0) {
92            GetTempPath (DIM (tmp)-1, tmp);
93            _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
94            putenv (buf);
95        }
96      else      else
97          putenv ("GPGME_DEBUG=");          putenv ("GPGME_DEBUG=");
98  }  }
99    
100    
 /* Return the name of the gettext language file. */  
 static char*  
 get_gettext_lang (void)  
 {      
     char *fname;  
     fname = get_reg_entry_mo ();  
     if (!fname)  
         return NULL;  
     return fname;  
 }  
   
   
101  /* Initialize the gettext sub system. */  /* Initialize the gettext sub system. */
102  static void  static void
103  load_gettext (int prev_inst)  load_gettext (void)
104  {  {
105      char *nls = NULL;      char *nls;
106    
107      nls = get_gettext_lang ();      /* Return the name of the gettext language file. */
108        nls = get_reg_entry_mo ();
109      if (nls != NULL) {      if (nls != NULL) {
110          set_gettext_file ("winpt", nls);          set_gettext_file ("winpt", nls);
111          free_if_alloc (nls);          free_if_alloc (nls);
# Line 114  gpg_prefs_ok (void) Line 125  gpg_prefs_ok (void)
125          p = get_reg_entry_gpg ("gpgProgram");          p = get_reg_entry_gpg ("gpgProgram");
126          if (!p || file_exist_check (p) != 0) {          if (!p || file_exist_check (p) != 0) {
127              free_if_alloc (p);              free_if_alloc (p);
128                log_debug ("gpg_prefs_ok: could not locate gpg.exe");
129              return false;              return false;
130          }          }
131      }      }
132      free_if_alloc (p);      free_if_alloc (p);
133      p = get_reg_entry_gpg4win (NULL);          p = get_reg_entry_gpg4win (NULL);
134      if (!p || dir_exist_check (p) != 0) {      if (!p || dir_exist_check (p) != 0) {
135          free_if_alloc (p);          free_if_alloc (p);
136          p = get_reg_entry_gpg ("HomeDir");          p = get_reg_entry_gpg ("HomeDir");
137          if (!p || dir_exist_check (p) != 0) {          if (!p || dir_exist_check (p) != 0) {
138              free_if_alloc (p);              free_if_alloc (p);
139                log_debug ("gpg_prefs_ok: could not determine home directory");
140              return false;              return false;
141          }          }
142      }      }
# Line 132  gpg_prefs_ok (void) Line 145  gpg_prefs_ok (void)
145  }  }
146    
147    
148    /* Check gpg files if they are read-only and ask the user
149       if this should be corrected. */
150    static void
151    check_readonly_attr (const char *homedir)
152    {
153        const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
154        char *file;
155        int i;
156    
157        for (i=0; files[i] != NULL; i++) {
158            file = make_filename (homedir, files[i], NULL);
159            remove_crit_file_attrs (file, 0);
160            free_if_alloc (file);
161        }
162    }
163    
164    
165  /* Load the GPG environment. On the first start, some  /* Load the GPG environment. On the first start, some
166     checks are performed to find out in what state GPG is.     checks are performed to find out in what state GPG is.
# Line 144  load_gpg_env (void) Line 173  load_gpg_env (void)
173      SECURITY_ATTRIBUTES sec_attr;      SECURITY_ATTRIBUTES sec_attr;
174      char *p;      char *p;
175      char *pkr;      char *pkr;
176        int err = 0;
177    
178      p = get_reg_entry_gpg4win ("gpg.exe");      p = get_reg_entry_gpg4win ("gpg.exe");
179      if (!p)      if (!p)
# Line 169  load_gpg_env (void) Line 199  load_gpg_env (void)
199              return (2);              return (2);
200          }          }
201      }      }
202        check_readonly_attr (p);
203      pkr = make_filename (p, "pubring", "gpg");      pkr = make_filename (p, "pubring", "gpg");
204      free_if_alloc (p);      free_if_alloc (p);
205      if (!pkr)      if (get_file_size (pkr) == 0)
206          return -1;          err = -1;
207      if (get_file_size (pkr) == 0) {      free_if_alloc (pkr);
208          free_if_alloc (pkr);      return err;
         return -1;  
     }  
     return 0;  
209  }  }
210    
211    
212  /* 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
213     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
214  static int  static int
215  check_default_key (gpg_keycache_t kc)  check_default_key (void)
216  {  {
217      gpgme_key_t key;      gpgme_key_t key;
218      gpgme_error_t err = GPG_ERR_NO_ERROR;      gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
219        gpg_keycache_t kc;
220      char *defkey;      char *defkey;
221    
222        kc = keycache_get_ctx (0);
223      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
224      if (defkey)      if (defkey) {
225          err = gpg_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
226      else          if (err) {
227                free_if_alloc (defkey);
228                return -1;
229            }
230        }
231        else {
232            /* Actually this is just a warning but we still continue. */
233          msg_box (NULL, _("No useable secret key found."),          msg_box (NULL, _("No useable secret key found."),
234                   _("WinPT Error"), MB_ERR);                   _("WinPT Warning"), MB_WARN);
235            free_if_alloc (defkey);
236            return 0;
237        }
238    
239        /* Because the secret key listing has no information
240           about the validity/status, we need to check the public key. */
241        kc = keycache_get_ctx (1);
242        if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
243            (key->revoked || key->expired)) {
244            msg_box (NULL, _("Default secret key is unuseable"),
245                     _("WinPT Warning"), MB_ERR);
246            free_if_alloc (defkey);
247            return -1;
248        }
249      free_if_alloc (defkey);      free_if_alloc (defkey);
250      return err? -1 : 0;      return 0;
251  }  }
252    
253    
254  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
255  static const char*  static const char*
256  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char *fname, int use_cwd)
257  {  {
258      static char program[512];      static char program[2*MAX_PATH+1];
259      char currdir[256];      char currdir[MAX_PATH+1];
260      char *cmd = NULL;      char *cmd = NULL;
261      int j;      int j;
262                    
# Line 219  get_prog_part (const char * fname, int u Line 269  get_prog_part (const char * fname, int u
269      }      }
270      else {      else {
271          cmd = GetCommandLine ();          cmd = GetCommandLine ();
272          if (cmd == NULL)          if (!cmd)
273              return NULL;              return NULL;
274          strncpy (currdir, cmd, sizeof (currdir)-1);          strncpy (currdir, cmd, DIM (currdir)-1);
275          j = strlen (currdir);          j = strlen (currdir);
276          while (j--) {          while (j--) {
277              if (currdir[j] == '\\')              if (currdir[j] == '\\')
# Line 239  get_prog_part (const char * fname, int u Line 289  get_prog_part (const char * fname, int u
289  static bool  static bool
290  check_crypto_engine (void)  check_crypto_engine (void)
291  {  {
292      int ma=0, mi=0, pa=0;      int ma = 0, mi = 0, pa = 0;
293      int rc;      int rc;
294    
295      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);      rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
# Line 255  check_crypto_engine (void) Line 305  check_crypto_engine (void)
305                     ma, mi, pa);                     ma, mi, pa);
306          return false;          return false;
307      }      }
308      /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */      /* Enable smart card support for GPG 2 or >= 1.4 */
309      if (ma > 1 || pa >= 3)          if ((ma > 1 || pa >= 4) && pcsc_available ())
310          scard_support = 1;          scard_support = 1;
311    
312      gpgver[0] = ma;      gpgver[0] = ma;
# Line 270  check_crypto_engine (void) Line 320  check_crypto_engine (void)
320     do not show any errors. */     do not show any errors. */
321  static int  static int
322  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
323  {  {    
324        const char *t, *conf;
325      char *buf;      char *buf;
     const char *t;  
326      int rc;      int rc;
327    
328        #ifdef WINPT_MOBILE
329        /* In mobile mode we automatically assume the config file
330           in the current directory. */
331        return kserver_load_conf ("keyserver.conf");
332        #endif
333    
334      /* Create $APPDATA\winpt if needed. */      /* Create $APPDATA\winpt if needed. */
335      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);      buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
336      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {      if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
# Line 288  load_keyserver_conf (int quiet) Line 344  load_keyserver_conf (int quiet)
344      /* Check for $APPDATA\winpt\keyserver.conf */      /* Check for $APPDATA\winpt\keyserver.conf */
345      buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);      buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
346    
347      if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))      conf = get_prog_part ("keyserver.conf", 0);
348          t = get_prog_part ("keyserver.conf", 0);      if (!file_exist_check (conf))
349            t = conf;
350      else      else
351          t = "keyserver.conf";          t = "keyserver.conf";
352      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {      if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
         //log_box (_("Keyserver"), MB_INFO,  
         //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);  
353          if (!CopyFile (t, buf, FALSE)) {          if (!CopyFile (t, buf, FALSE)) {
354              MessageBox (NULL, _("Failed to copy the keyserver.conf"),              MessageBox (NULL, _("Failed to copy the keyserver.conf"),
355                          _("Keyserver"), MB_ERR);                          _("Keyserver"), MB_ERR);
# Line 340  check_for_empty_keyrings (bool pub_only) Line 395  check_for_empty_keyrings (bool pub_only)
395  }  }
396    
397    
398  /* Enable the mobility mode. */  #ifdef WINPT_MOBILE
399  static void  /* Enable the mobile mode if possible.
400       There are some constraints which must be fullfilled.
401       Return value: 0 on success. */
402    static int
403  enable_mobile_mode (void)  enable_mobile_mode (void)
404  {  {
405      memset (&reg_prefs, 0, sizeof (reg_prefs));      static const char *test_fname = "winpt_mobile_test.txt";
406      reg_prefs.always_trust = 0;      FILE *fp;
407      reg_prefs.auto_backup = 0;      char *pubring;
408      reg_prefs.cache_time = 0;      ULARGE_INTEGER caller, total;
409      reg_prefs.expert = 0;      DWORD temp_size;
410      reg_prefs.keylist_mode = 1;  
411      reg_prefs.kserv_conf = m_strdup ("keyserver.conf");      fp = fopen (test_fname, "wb");
412      reg_prefs.no_zip_mmedia = 1;      if (fp == NULL) {
413      reg_prefs.use_tmpfiles = 1;          MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
414      reg_prefs.word_wrap = 80;                            "for the current directory", "WinPT Error", MB_ERR);
415      reg_prefs.use_viewer = 0; /* XXX */              
416            return -1;
417        }
418        fclose (fp);
419        DeleteFile (test_fname);
420        if (file_exist_check ("gpg.exe")) {
421            MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
422                              "as the WinPT program", "WinPT Error", MB_ERR);
423            return -1;
424        }
425        
426        /* Because write operations to the keyring result in a temporary
427           file, we need at least 2 MB plus the size of the keyring for
428           free space. */
429        pubring = get_gnupg_keyring (1);
430        temp_size = get_file_size (pubring) + 2097152;
431        free_if_alloc (pubring);
432    
433        if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
434            caller.LowPart < temp_size) {
435            log_box ("WinPT Error", MB_ERR,
436                     "The mobile mode needs at least %lu KB for temporary files",
437                     temp_size/1024);
438            return -1;
439        }
440    
441        /* XXX: shall we check for 'temp-directory' in the gpg.conf? */
442    
443        return 0;
444    }
445    #endif
446    
447    
448    /* Set the default keyserver for this instance. */
449    void
450    set_default_keyserver (void)
451    {
452        char *host = get_reg_entry_keyserver ("Default");
453        char *str_port = get_reg_entry_keyserver ("Default_Port");
454        WORD port = HKP_PORT;
455    
456        if (!host)
457            keyserver_set_default (NULL, 0);
458        else {
459            if (str_port && *str_port)
460                port = atoi (str_port);
461            keyserver_set_default (host, port);
462        }
463        free_if_alloc (host);
464        free_if_alloc (str_port);
465    }
466    
467    
468    /* Display info message that WinPT is now in debug mode. */
469    void
470    winpt_debug_msg (void)
471    {      
472        char output[512];
473        char temp[128];
474            
475        GetTempPath (DIM (temp) -1, temp);
476        _snprintf (output, DIM (output)-1,
477            "The GPGME output file is %sgpgme.dbg\n"
478            "The WinPT output file is %swinpt.log\n", temp, temp);
479        MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
480    }
481    
482    
483    /* Search for insecure ElGamal keys and return the
484       number of founded keys. */
485    static int
486    count_insecure_elgkeys (void)
487    {
488        gpg_keycache_t pc;
489        gpgme_key_t key;
490        int n = 0;
491    
492        pc = keycache_get_ctx (1);
493        while (!gpg_keycache_next_key (pc, 0, &key)) {
494            if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
495                n++;
496        }
497        gpg_keycache_rewind (pc);
498        return n;
499  }  }
500    
501    
# Line 367  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 508  WinMain (HINSTANCE hinst, HINSTANCE hpre
508      MSG msg;      MSG msg;
509      HWND hwnd = NULL;      HWND hwnd = NULL;
510      WORD ver[3], ptdver[4];      WORD ver[3], ptdver[4];
511        const char *s;
512      int rc, ec, created = 0;      int rc, ec, created = 0;
513      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
514      int winpt_inst_found = 0;      int winpt_inst_found = 0;
515      int start_manager = 0;      int start_manager = 0;    
516      const char *s;  
517    #ifdef WINPT_MOBILE
518        /* Do not continue in case of problems. */
519        if (enable_mobile_mode ())
520            return 0;
521    #endif
522    
523      glob_hinst = hinst;      glob_hinst = hinst;
524      if (cmdline && stristr (cmdline, "--stop")) {      if (cmdline && stristr (cmdline, "--stop")) {
# Line 381  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 528  WinMain (HINSTANCE hinst, HINSTANCE hpre
528          return 0;          return 0;
529      }      }
530    
     /*  
     OSVERSIONINFO osinf;  
     memset (&osinf, 0, sizeof (osinf));  
     if (GetVersionEx (&osinf) &&  
         osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&  
         osinf.dwMinorVersion == 0) {  
         msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",  
                  "WinPT Warning", MB_INFO);  
     }  
     */  
   
531      #ifdef _DEBUG      #ifdef _DEBUG
532      gpg_set_debug_mode (1);      gpg_set_debug_mode (1);
533      debug = 1;      debug = 1;
534      #endif      #endif
535    
536      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);      get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
537      get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],      ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],  
538                                   &ptdver[2], &ptdver[3]);                                   &ptdver[2], &ptdver[3]);
539      /* XXX      
540      if (ptdver[0] != ver[0] || ptdver[1] != ver[1]|| ptdver[2] != ver[2]) {      if (!ec && (ptdver[0] != ver[0] ||
541                    ptdver[1] != ver[1] ||
542                    ptdver[2] != ver[2])) {
543          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
544                   _("The PTD.dll file has a different version than WinPT.exe\n"                   _("The PTD.dll file has a different version than WinPT.exe\n"
545                     "Please update the PTD.dll to version %d.%d.%d"),                     "Please update the PTD.dll to version %d.%d.%d"),
546                     ver[0], ver[1], ver[2]);                     ver[0], ver[1], ver[2]);
547          return 0;          return 0;
548      }      }
     */  
549    
550      if (gpg_md_selftest ()) {      if (gpg_md_selftest ()) {
551          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
# Line 426  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 563  WinMain (HINSTANCE hinst, HINSTANCE hpre
563      CreateMutex (NULL, TRUE, PGM_NAME);      CreateMutex (NULL, TRUE, PGM_NAME);
564      if (GetLastError () == ERROR_ALREADY_EXISTS)      if (GetLastError () == ERROR_ALREADY_EXISTS)
565          winpt_inst_found = 1;          winpt_inst_found = 1;
566        
567        set_default_keyserver ();
568        load_gettext ();
569        admin_user = user_is_admin ();
570    
571      if (cmdline && stristr (cmdline, "--mobile")) {      regist_inst_gnupg (1);
572          msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",      regist_inst_winpt (1, &created);
                  "WinPT", MB_INFO);  
         mobile = 1;  
     }  
   
     set_default_kserver ();  
     load_gettext (winpt_inst_found);  
   
     if (!mobile) {  
         regist_inst_gnupg (1);  
         regist_inst_winpt (1, &created);  
     }  
     else {  
         enable_mobile_mode ();  
         /* XXX: ask for GPG path */  
         created = 1; /* Disable registry writing */  
     }  
573    
574      if (!created) {      if (!created) {
575          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
         reg_prefs.use_tmpfiles = 1; /* default */  
         reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */  
576          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
577          if (!reg_prefs.no_hotkeys)          reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
578              hotkeys_modify ();          if (gnupg_load_config () == -2)
579          gnupg_load_config ();              msg_box (NULL, _("The gpg.conf file contains the 'textmode' option\n"
580      }                               "which leads to broken binary output during decryption.\n"
581      else { /* default settings. */                               "If this is on purpose, just continue otherwise the option should be disabled."),
582          reg_prefs.keylist_mode = 1;                              _("WinPT Error"), MB_ERR);
583      }      }
584    
585      if (is_gpg4win_installed ())      if (is_gpg4win_installed ())
# Line 464  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 587  WinMain (HINSTANCE hinst, HINSTANCE hpre
587    
588      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
589      if (rc) {      if (rc) {
590            char *p;
591    
592          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
593                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
594                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
# Line 472  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 597  WinMain (HINSTANCE hinst, HINSTANCE hpre
597                                _("Select GPG Public Keyring"),                                _("Select GPG Public Keyring"),
598                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",                                "GPG Keyrings (*.gpg)\0*.gpg\0\0",
599                                NULL);                                NULL);
600          if (s != NULL) {          if (s != NULL && (p=strrchr (s, '\\'))) {
601              size_t n;              char *path = substr (s, 0, (p-s));
602              char *p = strrchr (s, '\\');  
603              if (!p)              set_reg_entry_gpg ("HomeDir", path);
604                  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 */  
             }  
605          }          }
606          else {          else {
607              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determined."),
608                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
609              goto start;              goto start;
610          }          }
# Line 516  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 629  WinMain (HINSTANCE hinst, HINSTANCE hpre
629              ec = msg_box (NULL,              ec = msg_box (NULL,
630                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
631                    "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"
632                    "Continue if you want that WinPT offers you more choices.\n"),                    "Continue if you want WinPT to offer you more choices.\n"),
633                    "WinPT", MB_INFO|MB_YESNO);                    "WinPT", MB_INFO|MB_YESNO);
634              if (ec == IDYES)              if (ec == IDYES)
635                  first_start = 1;                  first_start = 1;
# Line 531  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 644  WinMain (HINSTANCE hinst, HINSTANCE hpre
644    
645      if (!first_start) {      if (!first_start) {
646          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
647          if (rc && rc == 2)          if (rc && rc == 2) /* 2 means read-only mode. */
648              gpg_read_only = 1;              gpg_read_only = 1;
649          else if (rc)          else if (rc)
650              return 0;              return 0;
# Line 557  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 670  WinMain (HINSTANCE hinst, HINSTANCE hpre
670      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
671                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
672          /* If an instance of WinPT is running, just send the command          /* If an instance of WinPT is running, just send the command
673             to open the key manager. Otherwise start a new instance.             to open the key manager. Otherwise start a new instance. */
          */  
674          HWND tray = FindWindow ("WinPT", "WinPT");          HWND tray = FindWindow ("WinPT", "WinPT");
675          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
676              start_manager = ID_WINPT_KEY;              start_manager = ID_WINPT_KEY;
# Line 579  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 691  WinMain (HINSTANCE hinst, HINSTANCE hpre
691          return 0;          return 0;
692      }      }
693    
694      if (cmdline) {      #ifndef WINPT_MOBILE
695          if (stristr (cmdline, "--enable-debug") ||      if (cmdline && (stristr (cmdline, "--enable-debug") ||
696              stristr (cmdline, "--debug")) {                      stristr (cmdline, "--debug"))) {
697              gpg_set_debug_mode (1);          gpg_set_debug_mode (1);
698              winpt_debug_msg ();          winpt_debug_msg ();
699              debug = 1;          debug = 1;
         }  
700      }      }
701        #endif
702    
703      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
704      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
# Line 625  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 737  WinMain (HINSTANCE hinst, HINSTANCE hpre
737          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
738                          gpgprefs_dlg_proc, 0);                          gpgprefs_dlg_proc, 0);
739          if (check_for_empty_keyrings (true))          if (check_for_empty_keyrings (true))
740              first_start = 1; /* The public keyring is empty! */              first_start = 1; /* The public keyring is empty. */
741      }      }
742    
743      if (first_start) {      if (first_start) {
# Line 657  start: Line 769  start:
769              }              }
770              break;              break;
771    
772            case SETUP_CARDGEN:
773                rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
774                                     h, card_keygen_dlg_proc, 0);
775                if (!rc)
776                    goto start;
777                break;
778    
779          case 0: /* Cancel/Abort. */          case 0: /* Cancel/Abort. */
780          default:          default:
781              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 667  start: Line 786  start:
786          if (!check_crypto_engine ()) {          if (!check_crypto_engine ()) {
787              DestroyWindow (hwnd);              DestroyWindow (hwnd);
788              free_gnupg_table ();              free_gnupg_table ();
789                keycache_release (1);
790              return 0;              return 0;
791          }          }
792            if (!is_gpg4win_installed ()) {
793                select_language ();
794                load_gettext ();
795            }
796      }      }
797      else {      else {
798          gpg_keycache_t c;          gpg_keycache_t c;
799          update_keycache (hwnd);          if (update_keycache (hwnd)) {
800                DestroyWindow (hwnd);
801                free_gnupg_table ();
802                keycache_release (1);
803                return 0;
804            }
805            /* XXX: rewrite this part. */
806          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
807          if (!c || !gpg_keycache_get_size (c)) {          if (!gpg_keycache_get_size (c)) {
             gnupg_display_error ();  
808              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
809                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
810                               _("WinPT Error"), MB_ERR);                               _("WinPT Error"), MB_ERR);
811              ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"              ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"
812                                    "Do you want to start the GPG preferences dialog?"),                                    "Do you want to start the GPG preferences dialog?"),
813                              "WinPT", MB_INFO|MB_YESNO);                              "WinPT", MB_INFO|MB_YESNO);
814              if (ec == IDYES) {              if (ec == IDYES) {
# Line 690  start: Line 819  start:
819              else {              else {
820                  DestroyWindow (hwnd);                  DestroyWindow (hwnd);
821                  free_gnupg_table ();                  free_gnupg_table ();
822                    keycache_release (1);
823                  return 0;                  return 0;
824              }              }
825          }          }      
826          if (check_default_key (c)) {          if (check_default_key ()) {
827              char *p = get_gnupg_default_key ();              char *p = get_gnupg_default_key ();
828              log_box (_("WinPT Error"), MB_ERR,              log_box (_("WinPT Error"), MB_ERR,
829                       _("Default key from the GPG options file could not be found.\n"                       _("Default key (from the GPG config file) could not be found or is unuseable.\n"
830                         "Please check your gpg.conf (options) to correct this:\n\n"                         "The default key will be resetted and can be set later in the Key Manager again.\n\n"
831                         "%s: public key not found."), p? p : "[null]");                         "%s: secret key not found."), p? p : "?");
832                set_gnupg_default_key (NULL);
833              free_if_alloc (p);              free_if_alloc (p);
             DestroyWindow (hwnd);  
             free_gnupg_table ();  
             return 0;  
834          }          }
835          if (count_insecure_elgkeys ())          if (count_insecure_elgkeys ())
836              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,

Legend:
Removed from v.168  
changed lines
  Added in v.273

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26