/[winpt]/trunk/Src/wptGPGME.cpp
ViewVC logotype

Diff of /trunk/Src/wptGPGME.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 23 by twoaday, Fri Sep 30 10:10:16 2005 UTC revision 25 by twoaday, Wed Oct 12 10:04:26 2005 UTC
# Line 38  Line 38 
38  BOOL CALLBACK  keycache_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam);  BOOL CALLBACK  keycache_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam);
39  void progress_cleanup (progress_filter_s * pfx);  void progress_cleanup (progress_filter_s * pfx);
40    
41  static gpgme_keycache_t pub = NULL;  static gpg_keycache_t pub = NULL;
42  static gpgme_keycache_t sec = NULL;  static gpg_keycache_t sec = NULL;
43  static unsigned int reload = 0;  static unsigned int reload = 0;
44  static char *gpg_secring = NULL;  static char *gpg_secring = NULL;
45    
46    
47    /* Reload the key cache. */
48  void  void
49  keycache_reload (HWND dlg)  keycache_reload (HWND dlg)
50  {        {      
# Line 53  keycache_reload (HWND dlg) Line 55  keycache_reload (HWND dlg)
55      rcs.tr_update = 0;      rcs.tr_update = 0;
56      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                                              DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                                        
57                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
58  } /* keycache_reload */  }
59    
60    
61    /* Release both key cache objects. If @cleanup is 1,
62       also release other global structs. */
63  void  void
64  keycache_release (void)  keycache_release (int cleanup)
65  {  {
66      int n = gpgme_keycache_count (pub);      int n = gpg_keycache_get_size (pub);
67      char tmpbuf[64];      char tmpbuf[64];
68    
69      /* XXX: update the value when the cache has changed. */      /* XXX: update the value when the cache has changed. */
# Line 66  keycache_release (void) Line 71  keycache_release (void)
71      set_reg_key (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys", tmpbuf);      set_reg_key (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys", tmpbuf);
72    
73      if (pub) {      if (pub) {
74          gpgme_keycache_release (pub);          gpg_keycache_release (pub);
75          pub = NULL;          pub = NULL;
76      }      }
77      if (sec) {      if (sec) {
78          gpgme_keycache_release (sec);          gpg_keycache_release (sec);
79          sec = NULL;          sec = NULL;
80      }      }
81  } /* keycache_release */      if (cleanup) {
82            if (gpg_secring)
83                free (gpg_secring);
84            gpg_secring = NULL;
85        }
86    }
87    
88    
89    /* Update the key with the keyid @keyid in the key cache.
90       If @is_sec is 1, the secret key cache is used. */
91  gpgme_error_t  gpgme_error_t
92  keycache_update (int is_sec, const char *keyid)  keycache_update (int is_sec, const char *keyid)
93  {  {
94      gpgme_keycache_t ctx = pub;      gpg_keycache_t ctx = pub;
95      gpgme_error_t err;      gpgme_error_t err;
96    
97      if (is_sec)      if (is_sec)
98          ctx = sec;          ctx = sec;
99      err =  gpgme_keycache_update_key (ctx, is_sec, pub, keyid);      err = gpg_keycache_update_key (ctx, is_sec, pub, keyid);
100      if (is_sec)      if (is_sec)
101          gpgme_keycache_prepare_single (ctx, keyid, NULL, gpg_secring);          gpg_keycache_prepare_single (ctx, keyid, NULL, gpg_secring);
102      return err;      return err;
103  }  }
104    
# Line 106  keycache_init (const char *pubring, cons Line 118  keycache_init (const char *pubring, cons
118      }      }
119    
120      if (reload) {      if (reload) {
121          keycache_release ();          keycache_release (0);
122          reload = 0;          reload = 0;
123      }      }
124      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");
# Line 116  keycache_init (const char *pubring, cons Line 128  keycache_init (const char *pubring, cons
128          memset (&pfx, 0, sizeof (pfx));          memset (&pfx, 0, sizeof (pfx));
129      }      }
130    
131      err = gpgme_keycache_new (&pub);      err = gpg_keycache_new (&pub);
132      if (err)      if (err)
133          return err;          return err;
134      if (val != 0)      if (val != 0)
135          gpgme_keycache_set_cb (pub, progress_callback, &pfx, val);          gpg_keycache_set_cb (pub, progress_callback, &pfx, val);
136      err = gpgme_keycache_new (&sec);      err = gpg_keycache_new (&sec);
137      if (!err)      if (!err)
138          err = gpgme_keycache_init (pub, NULL, 0);          err = gpg_keycache_init (pub, NULL, 0);
139      if (!err)      if (!err)
140          err = gpgme_keycache_init( sec, NULL, 1 );          err = gpg_keycache_init( sec, NULL, 1 );
141      if( !err && pubring && *pubring )      if( !err && pubring && *pubring )
142          err = gpgme_keycache_prepare( pub, pubring, NULL );          err = gpg_keycache_prepare( pub, pubring, NULL );
143      if( !err && secring && * secring )      if( !err && secring && * secring )
144          err = gpgme_keycache_prepare( sec, NULL, secring );          err = gpg_keycache_prepare( sec, NULL, secring );
145      if (!err)      if (!err)
146          gpgme_keycache_sync (pub, sec);          gpg_keycache_sync (pub, sec);
147      if (val != 0)      if (val != 0)
148          progress_cleanup (&pfx);          progress_cleanup (&pfx);
149      return err;      return err;
# Line 152  keycache_get_reload( void ) Line 164  keycache_get_reload( void )
164  } /* keycache_get_reload */  } /* keycache_get_reload */
165    
166    
167  gpgme_keycache_t  gpg_keycache_t
168  keycache_get_ctx (int is_pub)  keycache_get_ctx (int is_pub)
169  {  {
170      return is_pub? pub : sec;      return is_pub? pub : sec;
171  } /* keycache_get_ctx */  }
172    
173    
174    /* Get the GPG key with keyid @keyid from the cache. Return it
175       in @r_key on success. */
176  static int  static int
177  get_key (const char *keyid, gpgme_key_t *r_key, struct keycache_s **c, int secret)  get_key_from_cache (const char *keyid, gpgme_key_t *r_key,
178                        struct keycache_s **c, int secret)
179  {  {
180      gpgme_keycache_t cache;      gpg_keycache_t cache;
181      gpgme_error_t err;      gpgme_error_t err;
182      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;
183    
184      if( !keyid )      if (!keyid)
185          return WPTERR_GENERAL;          return WPTERR_GENERAL;
186      if( r_key )      if (r_key)
187          *r_key = NULL;          *r_key = NULL;
188      cache = keycache_get_ctx (mode);      cache = keycache_get_ctx (mode);
189      if( !cache )      if (!cache)
190          BUG( NULL );          BUG( NULL );
191      if (!c)      if (!c)
192          err = gpgme_keycache_find_key( cache, keyid, 0, r_key );          err = gpg_keycache_find_key (cache, keyid, 0, r_key);
193      else      else
194          err = gpgme_keycache_find_key2 (cache, keyid, 0, r_key, c);          err = gpg_keycache_find_key2 (cache, keyid, 0, r_key, c);
195      if( err )      return err? WPTERR_GENERAL : 0;
196          return WPTERR_GENERAL;  }
     return 0;  
 } /* get_key */  
197    
198    
199    /* Get GPG key with keyid @keyid directly from GPG and return
200       it in @r_key on success. */
201  static int  static int
202  get_key2( const char * keyid, gpgme_key_t * r_key, int secret )  get_key_directly (const char *keyid, gpgme_key_t *r_key, int secret)
203  {  {
204      gpg_iobuf_t inp;      gpgme_ctx_t ctx;
205      char * p;      gpgme_error_t err;
     int rc;  
   
     p = get_gnupg_keyring (1, !NO_STRICT);  
     if( !p )  
         BUG( NULL );  
   
     inp = gpg_iobuf_open( p );  
     if( !inp ) {  
         const char *s = winpt_strerror( WPTERR_FILE_OPEN );  
         log_box( _("WinPT Error"), 0, "%s: %s", p, s );  
         free_if_alloc( p );  
         return NULL;  
     }  
     gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */  
     rc = gpgme_getkey_bykeyid( inp, keyid, r_key );  
206    
207      gpg_iobuf_close( inp );      err = gpgme_new (&ctx);
208      free_if_alloc( p );      if (err)
209      return rc;          return WPTERR_GENERAL;
210  } /* get_key2 */      err = gpgme_get_key (ctx, keyid, r_key, secret);
211        gpgme_release (ctx);
212        return err? WPTERR_GENERAL : 0;
213    }
214    
215    
216  int  int
# Line 215  winpt_get_pubkey (const char *keyid, win Line 218  winpt_get_pubkey (const char *keyid, win
218  {  {
219      int rc;      int rc;
220            
221      rc = get_key (keyid, &k->ctx, &k->ext, 0);      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 0);
222      if (rc)      if (rc)
223          return rc;          return rc;
224      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;
# Line 230  int Line 233  int
233  winpt_get_seckey (const char *keyid, winpt_key_s *k)  winpt_get_seckey (const char *keyid, winpt_key_s *k)
234  {  {
235      int rc;      int rc;
236      rc = get_key (keyid, &k->ctx, &k->ext, 1);      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 1);
237      if (rc)      if (rc)
238          return rc;          return rc;
239      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;
# Line 247  get_pubkey (const char *keyid, gpgme_key Line 250  get_pubkey (const char *keyid, gpgme_key
250      int rc = 0;      int rc = 0;
251    
252      if (pub && sec)      if (pub && sec)
253          rc = get_key (keyid, ret_key, NULL, 0);          rc = get_key_from_cache (keyid, ret_key, NULL, 0);
254      else      else
255          rc = get_key2 (keyid, ret_key, 0);          rc = get_key_directly (keyid, ret_key, 0);
256      return rc;      return rc;
257  } /* get_pubkey */  }
258    
259    
260  int  int
261  get_seckey( const char *keyid, gpgme_key_t *ret_skey )  get_seckey (const char *keyid, gpgme_key_t *ret_skey)
262  {  {
263      int rc = 0;      int rc = 0;
264    
265      if( pub && sec )      if (pub && sec)
266          rc = get_key( keyid, ret_skey, NULL, 1 );          rc = get_key_from_cache (keyid, ret_skey, NULL, 1);
267      else      else
268          rc = get_key2( keyid, ret_skey, 1 );          rc = get_key_directly (keyid, ret_skey, 1);
269      return rc;      return rc;
270  } /* get_seckey */  }
271    
272    
273    /* Search for insecure ElGamal keys and return the
274       number of founded keys. */
275  int  int
276  count_insecure_elgkeys (void)  count_insecure_elgkeys (void)
277  {  {
278      gpgme_keycache_t pc;      gpg_keycache_t pc;
279      gpgme_key_t key;      gpgme_key_t key;
280      int n=0;      int n=0;
281    
282      pc = keycache_get_ctx (1);      pc = keycache_get_ctx (1);
283      if (!pc)      if (!pc)
284          BUG (0);          BUG (0);
285      while (!gpgme_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
286          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
287              n++;              n++;
288      }      }
289      gpgme_keycache_rewind (pc);      gpg_keycache_rewind (pc);
290      return n;      return n;
291  }  }
Legend:
Removed from v.23  
changed lines
  Added in v.25
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26