/[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 47 by werner, Mon Oct 31 14:04:59 2005 UTC revision 208 by twoaday, Mon May 1 12:22:18 2006 UTC
# Line 17  Line 17 
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19   */   */
   
20  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
21  #include <config.h>  #include <config.h>
22  #endif  #endif
23    
24  #include <sys/types.h>  #include <sys/types.h>
 #include <sys/types.h>  
25  #include <windows.h>  #include <windows.h>
26    
27  #include "resource.h"  #include "resource.h"
# Line 45  void progress_cleanup (progress_filter_s Line 43  void progress_cleanup (progress_filter_s
43    
44  static gpg_keycache_t pub = NULL;  static gpg_keycache_t pub = NULL;
45  static gpg_keycache_t sec = NULL;  static gpg_keycache_t sec = NULL;
 static unsigned int reload = 0;  
46  static char *gpg_secring = NULL;  static char *gpg_secring = NULL;
47    
48    
# Line 107  keycache_update (int is_sec, const char Line 104  keycache_update (int is_sec, const char
104      return err;      return err;
105  }  }
106    
 /* XXX: cache_keyring_names must be called then the GPG homedir changes! */  
107    
108  /* Initialize both cache contexts. Use @pubring for the public  /* Initialize both cache contexts. Use @pubring for the public
109     keyring and @secring for the secret keyring. */     keyring and @secring for the secret keyring. */
# Line 123  keycache_init (const char *pubring, cons Line 119  keycache_init (const char *pubring, cons
119          free_if_alloc (gpg_secring);          free_if_alloc (gpg_secring);
120          gpg_secring = get_gnupg_keyring (0, NO_STRICT);          gpg_secring = get_gnupg_keyring (0, NO_STRICT);
121      }      }
122        
     if (reload) {  
         keycache_release (0);  
         reload = 0;  
     }  
123      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");
124      if (p && *p != ' ') {      if (p && *p != ' ') {
125          val = atoi (p);          val = atoi (p);
126          free_if_alloc (p);          free_if_alloc (p);      
         memset (&pfx, 0, sizeof (pfx));  
127      }      }
128    
129        memset (&pfx, 0, sizeof (pfx));
130        /* Release old contexts first. */
131        keycache_release (0);
132    
133      err = gpg_keycache_new (&pub);      err = gpg_keycache_new (&pub);
134      if (err)      if (err)
135          return err;          return err;
# Line 144  keycache_init (const char *pubring, cons Line 139  keycache_init (const char *pubring, cons
139      if (!err)      if (!err)
140          err = gpg_keycache_init (pub, NULL, 0);          err = gpg_keycache_init (pub, NULL, 0);
141      if (!err)      if (!err)
142          err = gpg_keycache_init( sec, NULL, 1 );          err = gpg_keycache_init (sec, NULL, 1);
143      if( !err && pubring && *pubring )      if (!err && pubring && *pubring)
144          err = gpg_keycache_prepare( pub, pubring, NULL );          err = gpg_keycache_prepare (pub, pubring, NULL);
145      if( !err && secring && * secring )      if (!err && secring && * secring)
146          err = gpg_keycache_prepare( sec, NULL, secring );          err = gpg_keycache_prepare (sec, NULL, secring);
147      if (!err)      if (!err)
148          gpg_keycache_sync (pub, sec);          gpg_keycache_sync (pub, sec);
149      if (val != 0)      if (val != 0)
# Line 157  keycache_init (const char *pubring, cons Line 152  keycache_init (const char *pubring, cons
152  }  }
153    
154    
 /* 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;  
 }  
   
   
155  /* Return the public cache context if @is_pub is set  /* Return the public cache context if @is_pub is set
156     the secre cache context otherwise. */     the secre cache context otherwise. */
157  gpg_keycache_t  gpg_keycache_t
158  keycache_get_ctx (int is_pub)  keycache_get_ctx (int is_pub)
159  {  {
160      return is_pub? pub : sec;      gpg_keycache_t ctx;
161    
162        ctx = is_pub? pub : sec;
163        if (!ctx)
164            BUG (0);
165        return ctx;
166  }  }
167    
168    
# Line 198  get_key_from_cache (const char *keyid, g Line 182  get_key_from_cache (const char *keyid, g
182          *r_key = NULL;          *r_key = NULL;
183      cache = keycache_get_ctx (mode);      cache = keycache_get_ctx (mode);
184      if (!cache)      if (!cache)
185          BUG( NULL );          BUG (0);
186      if (!c)      if (!c)
187          err = gpg_keycache_find_key (cache, keyid, 0, r_key);          err = gpg_keycache_find_key (cache, keyid, 0, r_key);
188      else      else
# Line 304  count_insecure_elgkeys (void) Line 288  count_insecure_elgkeys (void)
288      gpg_keycache_rewind (pc);      gpg_keycache_rewind (pc);
289      return n;      return n;
290  }  }
291    
292    
293    
294    /* Map the signature summary in @sum to signature status table index.
295       Return value: index to table. */
296    static int
297    sigsum_to_index (gpgme_sigsum_t sum)
298    {
299        if ((sum & GPGME_SIGSUM_VALID) && (sum & GPGME_SIGSUM_KEY_REVOKED))
300            return 7;
301        if ((sum & GPGME_SIGSUM_VALID) && (sum & GPGME_SIGSUM_SIG_EXPIRED))
302            return 6;
303        if (sum & GPGME_SIGSUM_GREEN)
304            return 1;
305        else if (sum & GPGME_SIGSUM_RED)
306            return 2;
307        else if (sum & GPGME_SIGSUM_KEY_MISSING)
308            return 3;
309        return 0;
310    }
311    
312    
313    /* Return a humand readable description for the signature status @sum. */
314    const char*
315    get_gpg_sigstat (gpgme_sigsum_t sum)
316    {
317        const char *gpg_sigstat[] = {
318            _("Error during verification process."),
319            _("The signature is good."),
320            _("The signature is BAD!"),
321            _("The signature could not be checked due to a missing key."),
322            _("No valid OpenPGP signature."),
323            _("Signature Error"),
324            _("Good Signature (Expired Key)"),
325            _("Good Signature (Revoked Key)"),
326            NULL
327        };
328        const unsigned int mask = 8;
329    
330        return gpg_sigstat[sigsum_to_index (sum) % mask];
331    }
332    
333    
334    /* Check if the secret keyring contains at least one
335       key with ultimate trust.
336       Return value: 0 on success. */
337    int
338    check_ultimate_trusted_key (void)
339    {
340        struct keycache_s *n;
341    
342        for (n = sec->item; n; n = n->next) {
343            if (n->pubpart &&
344                n->pubpart->key->owner_trust == GPGME_VALIDITY_ULTIMATE)
345            return 0;
346        }
347        return -1;
348    }
Legend:
Removed from v.47  
changed lines
  Added in v.208
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26