/[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 109 by twoaday, Fri Dec 2 07:32:13 2005 UTC revision 211 by twoaday, Sun May 7 12:36:48 2006 UTC
# Line 41  Line 41 
41  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);
42  void progress_cleanup (progress_filter_s * pfx);  void progress_cleanup (progress_filter_s * pfx);
43    
44    /* Global GPG key cache contexts. */
45  static gpg_keycache_t pub = NULL;  static gpg_keycache_t pub = NULL;
46  static gpg_keycache_t sec = NULL;  static gpg_keycache_t sec = NULL;
 static unsigned int reload = 0;  
47  static char *gpg_secring = NULL;  static char *gpg_secring = NULL;
48    
49    
# Line 81  keycache_release (int cleanup) Line 81  keycache_release (int cleanup)
81          gpg_keycache_release (sec);          gpg_keycache_release (sec);
82          sec = NULL;          sec = NULL;
83      }      }
84      if (cleanup) {      if (cleanup)
85          if (gpg_secring)          safe_free (gpg_secring);
             free (gpg_secring);  
         gpg_secring = NULL;  
     }  
86  }  }
87    
88    
# Line 105  keycache_update (int is_sec, const char Line 102  keycache_update (int is_sec, const char
102      return err;      return err;
103  }  }
104    
 /* XXX: cache_keyring_names must be called then the GPG homedir changes! */  
105    
106  /* Initialize both cache contexts. Use @pubring for the public  /* Initialize both cache contexts. Use @pubring for the public
107     keyring and @secring for the secret keyring. */     keyring and @secring for the secret keyring. */
# Line 121  keycache_init (const char *pubring, cons Line 117  keycache_init (const char *pubring, cons
117          free_if_alloc (gpg_secring);          free_if_alloc (gpg_secring);
118          gpg_secring = get_gnupg_keyring (0, NO_STRICT);          gpg_secring = get_gnupg_keyring (0, NO_STRICT);
119      }      }
120        
     if (reload) {  
         keycache_release (0);  
         reload = 0;  
     }  
121      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");
122      if (p && *p != ' ') {      if (p && *p != ' ') {
123          val = atoi (p);          val = atoi (p);
124          free_if_alloc (p);          free_if_alloc (p);      
         memset (&pfx, 0, sizeof (pfx));  
125      }      }
126    
127        memset (&pfx, 0, sizeof (pfx));
128        /* Release old contexts first. */
129        keycache_release (0);
130    
131      err = gpg_keycache_new (&pub);      err = gpg_keycache_new (&pub);
132      if (err)      if (err)
133          return err;          return err;
# Line 142  keycache_init (const char *pubring, cons Line 137  keycache_init (const char *pubring, cons
137      if (!err)      if (!err)
138          err = gpg_keycache_init (pub, NULL, 0);          err = gpg_keycache_init (pub, NULL, 0);
139      if (!err)      if (!err)
140          err = gpg_keycache_init( sec, NULL, 1 );          err = gpg_keycache_init (sec, NULL, 1);
141      if( !err && pubring && *pubring )      if (!err && pubring && *pubring)
142          err = gpg_keycache_prepare( pub, pubring, NULL );          err = gpg_keycache_prepare (pub, pubring, NULL);
143      if( !err && secring && * secring )      if (!err && secring && * secring)
144          err = gpg_keycache_prepare( sec, NULL, secring );          err = gpg_keycache_prepare (sec, NULL, secring);
145      if (!err)      if (!err)
146          gpg_keycache_sync (pub, sec);          gpg_keycache_sync (pub, sec);
147      if (val != 0)      if (val != 0)
# Line 155  keycache_init (const char *pubring, cons Line 150  keycache_init (const char *pubring, cons
150  }  }
151    
152    
 /* If @val = 1 indicate to reload the cache. */  
 void  
 keycache_set_reload (int val)  
 {  
     reload = val;  
 }  
   
   
 /* Return the reload cache flag. */  
 int  
 keycache_get_reload (void)  
 {  
     return reload;  
 }  
   
   
153  /* Return the public cache context if @is_pub is set  /* Return the public cache context if @is_pub is set
154     the secre cache context otherwise. */     the secre cache context otherwise. */
155  gpg_keycache_t  gpg_keycache_t
156  keycache_get_ctx (int is_pub)  keycache_get_ctx (int is_pub)
157  {  {
158      return is_pub? pub : sec;      gpg_keycache_t ctx;
159    
160        ctx = is_pub? pub : sec;
161        if (!ctx)
162            BUG (0);
163        return ctx;
164  }  }
165    
166    
167  /* Get the GPG key with keyid @keyid from the cache. Return it  /* Get the GPG key with keyid @keyid from the cache. Return it
168     in @r_key on success. */     in @r_key on success. */
169  static int  static gpgme_error_t
170  get_key_from_cache (const char *keyid, gpgme_key_t *r_key,  get_key_from_cache (const char *keyid, gpgme_key_t *r_key,
171                      struct keycache_s **c, int secret)                      struct keycache_s **c, int secret)
172  {  {
# Line 191  get_key_from_cache (const char *keyid, g Line 175  get_key_from_cache (const char *keyid, g
175      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;      int mode = secret? KEYCACHE_PRV : KEYCACHE_PUB;
176    
177      if (!keyid)      if (!keyid)
178          return WPTERR_GENERAL;          return gpg_error (GPG_ERR_INV_VALUE);
179      if (r_key)      if (r_key)
180          *r_key = NULL;          *r_key = NULL;
181      cache = keycache_get_ctx (mode);      cache = keycache_get_ctx (mode);
     if (!cache)  
         BUG( NULL );  
182      if (!c)      if (!c)
183          err = gpg_keycache_find_key (cache, keyid, 0, r_key);          err = gpg_keycache_find_key (cache, keyid, 0, r_key);
184      else      else
185          err = gpg_keycache_find_key2 (cache, keyid, 0, r_key, c);          err = gpg_keycache_find_key2 (cache, keyid, 0, r_key, c);
186      return err? WPTERR_GENERAL : 0;      return err;
187  }  }
188    
189    
190  /* Get GPG key with keyid @keyid directly from GPG and return  /* Get GPG key with keyid @keyid directly from GPG and return
191     it in @r_key on success. */     it in @r_key on success. */
192  static int  static gpgme_error_t
193  get_key_directly (const char *keyid, gpgme_key_t *r_key, int secret)  get_key_directly (const char *keyid, gpgme_key_t *r_key, int secret)
194  {  {
195      gpgme_ctx_t ctx;      gpgme_ctx_t ctx;
# Line 215  get_key_directly (const char *keyid, gpg Line 197  get_key_directly (const char *keyid, gpg
197    
198      err = gpgme_new (&ctx);      err = gpgme_new (&ctx);
199      if (err)      if (err)
200          return WPTERR_GENERAL;          return err;
201      err = gpgme_get_key (ctx, keyid, r_key, secret);      err = gpgme_get_key (ctx, keyid, r_key, secret);
202      gpgme_release (ctx);      gpgme_release (ctx);
203      return err? WPTERR_GENERAL : 0;      return err;
204  }  }
205    
206    
207  /* Search the public key with @keyid as the keyid in the cache and  /* Search the public key with @keyid as the keyid in the cache and
208     return the item in @k. */     return the item in @k. */
209  int  gpgme_error_t
210  winpt_get_pubkey (const char *keyid, winpt_key_s *k)  winpt_get_pubkey (const char *keyid, winpt_key_s *k)
211  {  {
212      int rc;      gpgme_error_t err;
213            
214      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 0);      err = get_key_from_cache (keyid, &k->ctx, &k->ext, 0);
215      if (rc)      if (err)
216          return rc;          return err;
217      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&
218                  strlen (k->ctx->subkeys->fpr) == 32;                  strlen (k->ctx->subkeys->fpr) == 32;
219      k->is_protected = k->ext->gloflags.is_protected;      k->is_protected = k->ext->gloflags.is_protected;
220      k->keyid = k->ctx->subkeys->keyid;      k->keyid = k->ctx->subkeys->keyid;
221      k->uid = k->ctx->uids->uid;      k->uid = k->ctx->uids->uid;
222      return rc;      return 0;
223  }  }
224    
225    
226  int  gpgme_error_t
227  winpt_get_seckey (const char *keyid, winpt_key_s *k)  winpt_get_seckey (const char *keyid, winpt_key_s *k)
228  {  {
229      int rc;      gpgme_error_t err;
230      rc = get_key_from_cache (keyid, &k->ctx, &k->ext, 1);  
231      if (rc)      err = get_key_from_cache (keyid, &k->ctx, &k->ext, 1);
232          return rc;      if (err)
233            return err;
234      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&      k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA &&
235                  strlen (k->ctx->subkeys->fpr) == 32;                  strlen (k->ctx->subkeys->fpr) == 32;
236      k->is_protected = k->ext->gloflags.is_protected;      k->is_protected = k->ext->gloflags.is_protected;
237      k->keyid = k->ctx->subkeys->keyid;      k->keyid = k->ctx->subkeys->keyid;
238      k->uid = k->ctx->uids->uid;      k->uid = k->ctx->uids->uid;
239      return rc;      return 0;
240  }  }
241    
242    
243  int  gpgme_error_t
244  get_pubkey (const char *keyid, gpgme_key_t *ret_key)  get_pubkey (const char *keyid, gpgme_key_t *ret_key)
245  {  {
246      int rc;      gpgme_error_t rc;
247    
248      if (pub && sec)      if (pub && sec)
249          rc = get_key_from_cache (keyid, ret_key, NULL, 0);          rc = get_key_from_cache (keyid, ret_key, NULL, 0);
# Line 270  get_pubkey (const char *keyid, gpgme_key Line 253  get_pubkey (const char *keyid, gpgme_key
253  }  }
254    
255    
256  int  gpgme_error_t
257  get_seckey (const char *keyid, gpgme_key_t *ret_skey)  get_seckey (const char *keyid, gpgme_key_t *ret_skey)
258  {  {
259      int rc;      gpgme_error_t rc;
260    
261      if (pub && sec)      if (pub && sec)
262          rc = get_key_from_cache (keyid, ret_skey, NULL, 1);          rc = get_key_from_cache (keyid, ret_skey, NULL, 1);
# Line 293  count_insecure_elgkeys (void) Line 276  count_insecure_elgkeys (void)
276      int n=0;      int n=0;
277    
278      pc = keycache_get_ctx (1);      pc = keycache_get_ctx (1);
     if (!pc)  
         BUG (0);  
279      while (!gpg_keycache_next_key (pc, 0, &key)) {      while (!gpg_keycache_next_key (pc, 0, &key)) {
280          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
281              n++;              n++;
# Line 343  get_gpg_sigstat (gpgme_sigsum_t sum) Line 324  get_gpg_sigstat (gpgme_sigsum_t sum)
324    
325      return gpg_sigstat[sigsum_to_index (sum) % mask];      return gpg_sigstat[sigsum_to_index (sum) % mask];
326  }  }
327    
328    
329    /* Check if the secret keyring contains at least one
330       key with ultimate trust.
331       Return value: 0 on success. */
332    int
333    check_ultimate_trusted_key (void)
334    {
335        struct keycache_s *n;
336    
337        for (n = sec->item; n; n = n->next) {
338            if (n->pubpart &&
339                n->pubpart->key->owner_trust == GPGME_VALIDITY_ULTIMATE)
340            return 0;
341        }
342        return -1;
343    }
Legend:
Removed from v.109  
changed lines
  Added in v.211
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26