/[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 2 by twoaday, Mon Jan 31 11:02:21 2005 UTC revision 24 by twoaday, Sat Oct 8 10:43:08 2005 UTC
# Line 1  Line 1 
1  /* wptGPGME.cpp - WinPT GPGME interface  /* wptGPGME.cpp - WinPT GPGME interface
2   *      Copyright (C) 2001-2004 Timo Schulz   *      Copyright (C) 2001-2005 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 41  void progress_cleanup (progress_filter_s Line 41  void progress_cleanup (progress_filter_s
41  static gpgme_keycache_t pub = NULL;  static gpgme_keycache_t pub = NULL;
42  static gpgme_keycache_t sec = NULL;  static gpgme_keycache_t sec = NULL;
43  static unsigned int reload = 0;  static unsigned int reload = 0;
44    static char *gpg_secring = NULL;
45    
46  void  void
47  keycache_reload (HWND dlg)  keycache_reload (HWND dlg)
48  {        {      
49      refresh_cache_s rcs = {0};      refresh_cache_s rcs;
50    
51        memset (&rcs, 0, sizeof rcs);
52      rcs.kr_reload = rcs.kr_update = 1;      rcs.kr_reload = rcs.kr_update = 1;
53      rcs.tr_update = 1;      rcs.tr_update = 0;
54      DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                                              DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                                        
55                      keycache_dlg_proc, (LPARAM)&rcs );                      keycache_dlg_proc, (LPARAM)&rcs);
56  } /* keycache_reload */  } /* keycache_reload */
57    
58  void  void
# Line 60  keycache_release (void) Line 61  keycache_release (void)
61      int n = gpgme_keycache_count (pub);      int n = gpgme_keycache_count (pub);
62      char tmpbuf[64];      char tmpbuf[64];
63    
64        /* XXX: update the value when the cache has changed. */
65      sprintf (tmpbuf, "%d", n);      sprintf (tmpbuf, "%d", n);
66      set_reg_key (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys", tmpbuf);      set_reg_key (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys", tmpbuf);
67    
68      if (pub) {      if (pub) {
69          gpgme_keycache_release( pub );          gpgme_keycache_release (pub);
70          pub = NULL;          pub = NULL;
71      }      }
72      if (sec) {      if (sec) {
73          gpgme_keycache_release( sec );          gpgme_keycache_release (sec);
74          sec = NULL;          sec = NULL;
75      }      }
76  } /* keycache_release */  } /* keycache_release */
77    
78    
79  gpgme_error_t  gpgme_error_t
80  keycache_init( const char *pubring, const char * secring )  keycache_update (int is_sec, const char *keyid)
81    {
82        gpgme_keycache_t ctx = pub;
83        gpgme_error_t err;
84    
85        if (is_sec)
86            ctx = sec;
87        err =  gpgme_keycache_update_key (ctx, is_sec, pub, keyid);
88        if (is_sec)
89            gpgme_keycache_prepare_single (ctx, keyid, NULL, gpg_secring);
90        return err;
91    }
92    
93    /* XXX: cache_keyring_names must be called then the GPG homedir changes! */
94    
95    gpgme_error_t
96    keycache_init (const char *pubring, const char * secring)
97  {  {
98      struct progress_filter_s pfx;      struct progress_filter_s pfx;
99      gpgme_error_t err;      gpgme_error_t err;
100      int val = 0;      int val = 0;
101      char * p;      char * p;
102    
103        if (secring != NULL) {
104            free_if_alloc (gpg_secring);
105            gpg_secring = get_gnupg_keyring (0, NO_STRICT);
106        }
107    
108      if (reload) {      if (reload) {
109          keycache_release ();          keycache_release ();
110          reload = 0;          reload = 0;
111      }      }
112      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "nKeys");
113      if (p && *p != ' ')      if (p && *p != ' ') {
     {  
114          val = atoi (p);          val = atoi (p);
115          free_if_alloc (p);          free_if_alloc (p);
116          memset (&pfx, 0, sizeof pfx);          memset (&pfx, 0, sizeof (pfx));
117      }      }
118    
119      err = gpgme_keycache_new (&pub);      err = gpgme_keycache_new (&pub);
# Line 131  keycache_get_reload( void ) Line 153  keycache_get_reload( void )
153    
154    
155  gpgme_keycache_t  gpgme_keycache_t
156  keycache_get_ctx( int is_pub )  keycache_get_ctx (int is_pub)
157  {  {
158      return is_pub? pub : sec;      return is_pub? pub : sec;
159  } /* keycache_get_ctx */  } /* keycache_get_ctx */
160    
161    
162  static int  static int
163  get_key( const char *keyid, gpgme_key_t *r_key, int secret )  get_key (const char *keyid, gpgme_key_t *r_key, struct keycache_s **c, int secret)
164  {  {
165      gpgme_keycache_t cache;      gpgme_keycache_t cache;
166      gpgme_error_t err;      gpgme_error_t err;
# Line 148  get_key( const char *keyid, gpgme_key_t Line 170  get_key( const char *keyid, gpgme_key_t
170          return WPTERR_GENERAL;          return WPTERR_GENERAL;
171      if( r_key )      if( r_key )
172          *r_key = NULL;          *r_key = NULL;
173      cache = keycache_get_ctx( mode );      cache = keycache_get_ctx (mode);
174      if( !cache )      if( !cache )
175          BUG( NULL );          BUG( NULL );
176      err = gpgme_keycache_find_key( cache, keyid, 0, r_key );      if (!c)
177            err = gpgme_keycache_find_key( cache, keyid, 0, r_key );
178        else
179            err = gpgme_keycache_find_key2 (cache, keyid, 0, r_key, c);
180      if( err )      if( err )
181          return WPTERR_GENERAL;          return WPTERR_GENERAL;
182      return 0;      return 0;
# Line 177  get_key2( const char * keyid, gpgme_key_ Line 202  get_key2( const char * keyid, gpgme_key_
202          return NULL;          return NULL;
203      }      }
204      gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */      gpg_iobuf_ioctl( inp, 3, 1, NULL ); /* disable cache */
205      rc = gpgme_getkey_bykeyid( inp, keyid, r_key );      /*rc = gpgme_getkey_bykeyid( inp, keyid, r_key ); XXX */
206        rc=0;
207    
208      gpg_iobuf_close( inp );      gpg_iobuf_close( inp );
209      free_if_alloc( p );      free_if_alloc( p );
# Line 186  get_key2( const char * keyid, gpgme_key_ Line 212  get_key2( const char * keyid, gpgme_key_
212    
213    
214  int  int
215  get_pubkey( const char *keyid, gpgme_key_t *ret_key )  winpt_get_pubkey (const char *keyid, winpt_key_s *k)
216    {
217        int rc;
218        
219        rc = get_key (keyid, &k->ctx, &k->ext, 0);
220        if (rc)
221            return rc;
222        k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;
223        k->is_protected = k->ext->gloflags.is_protected;
224        k->keyid = k->ctx->subkeys->keyid;
225        k->uid = k->ctx->uids->uid;
226        return rc;
227    }
228    
229    
230    int
231    winpt_get_seckey (const char *keyid, winpt_key_s *k)
232    {
233        int rc;
234        rc = get_key (keyid, &k->ctx, &k->ext, 1);
235        if (rc)
236            return rc;
237        k->is_v3 = k->ctx->subkeys->pubkey_algo == GPGME_PK_RSA && strlen (k->ctx->subkeys->fpr) == 32;
238        k->is_protected = k->ext->gloflags.is_protected;
239        k->keyid = k->ctx->subkeys->keyid;
240        k->uid = k->ctx->uids->uid;
241        return rc;
242    }
243    
244    
245    int
246    get_pubkey (const char *keyid, gpgme_key_t *ret_key)
247  {  {
248      int rc = 0;      int rc = 0;
249    
250      if( pub && sec )      if (pub && sec)
251          rc = get_key( keyid, ret_key, 0 );          rc = get_key (keyid, ret_key, NULL, 0);
252      else      else
253          rc = get_key2( keyid, ret_key, 0 );          rc = get_key2 (keyid, ret_key, 0);
254      return rc;      return rc;
255  } /* get_pubkey */  } /* get_pubkey */
256    
# Line 204  get_seckey( const char *keyid, gpgme_key Line 261  get_seckey( const char *keyid, gpgme_key
261      int rc = 0;      int rc = 0;
262    
263      if( pub && sec )      if( pub && sec )
264          rc = get_key( keyid, ret_skey, 1 );          rc = get_key( keyid, ret_skey, NULL, 1 );
265      else      else
266          rc = get_key2( keyid, ret_skey, 1 );          rc = get_key2( keyid, ret_skey, 1 );
267      return rc;      return rc;
# Line 222  count_insecure_elgkeys (void) Line 279  count_insecure_elgkeys (void)
279      if (!pc)      if (!pc)
280          BUG (0);          BUG (0);
281      while (!gpgme_keycache_next_key (pc, 0, &key)) {      while (!gpgme_keycache_next_key (pc, 0, &key)) {
282          if (gpgme_key_get_ulong_attr (key, GPGME_ATTR_ALGO, NULL, 0)          if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
             == GPGME_PK_ELG_ES)  
283              n++;              n++;
284      }      }
285      gpgme_keycache_rewind (pc);      gpgme_keycache_rewind (pc);
Legend:
Removed from v.2  
changed lines
  Added in v.24
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26