ruby-gpgme 1.0.5 → 1.0.6

data/MANIFEST

@@ -4,6 +4,7 @@ lib/gpgme/constants.rb
 COPYING
 COPYING.LESSER
 README
+THANKS
 extconf.rb
 gpgme_n.c
 examples/genkey.rb

data/THANKS

@@ -0,0 +1,13 @@
+Ruby-GPGME was originally written by Daiki Ueno.  Other people
+contributed by reporting problems, suggesting various improvements or
+submitting actual code.  Here is a list of those people.  Help us keep
+it complete and free of errors.
+
+
+
+Carl Corliss
+Kris Nuttycombe
+Marc Dequènes
+Rob Pitt
+Rory McKinley
+Sam Hall

data/gpgme_n.c

@@ -80,6 +80,11 @@
 #define RARRAY_PTR(a) RARRAY(a)->ptr
 #endif
 
+/* RSTRING_LEN is not available in 1.8.5. */
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+
 #define WRAP_GPGME_DATA(dh)					\
   Data_Wrap_Struct(cData, 0, gpgme_data_release, dh)
 /* `gpgme_data_t' is typedef'ed as `struct gpgme_data *'. */
@@ -414,6 +419,19 @@ rb_s_gpgme_new (VALUE dummy, VALUE rctx)
   return LONG2NUM(err);
 }
 
+static VALUE
+rb_s_gpgme_release (VALUE dummy, VALUE vctx)
+{
+  gpgme_ctx_t ctx;
+
+  UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
+  gpgme_release (ctx);
+  DATA_PTR(vctx) = NULL;
+  return Qnil;
+}
+
 static VALUE
 rb_s_gpgme_set_protocol (VALUE dummy, VALUE vctx, VALUE vproto)
 {
@@ -421,6 +439,8 @@ rb_s_gpgme_set_protocol (VALUE dummy, VALUE vctx, VALUE vproto)
   gpgme_error_t err;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   err = gpgme_set_protocol (ctx, NUM2INT(vproto));
   return LONG2NUM(err);
 }
@@ -432,6 +452,8 @@ rb_s_gpgme_get_protocol (VALUE dummy, VALUE vctx)
   gpgme_protocol_t proto;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   proto = gpgme_get_protocol (ctx);
   return INT2FIX(proto);
 }
@@ -442,6 +464,8 @@ rb_s_gpgme_set_armor (VALUE dummy, VALUE vctx, VALUE vyes)
   gpgme_ctx_t ctx;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_set_armor (ctx, NUM2INT(vyes));
 
   return Qnil;
@@ -454,6 +478,8 @@ rb_s_gpgme_get_armor (VALUE dummy, VALUE vctx)
   int yes;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   yes = gpgme_get_armor (ctx);
   return INT2FIX(yes);
 }
@@ -464,6 +490,8 @@ rb_s_gpgme_set_textmode (VALUE dummy, VALUE vctx, VALUE vyes)
   gpgme_ctx_t ctx;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_set_textmode (ctx, NUM2INT(vyes));
   return Qnil;
 }     
@@ -475,6 +503,8 @@ rb_s_gpgme_get_textmode (VALUE dummy, VALUE vctx)
   int yes;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   yes = gpgme_get_textmode (ctx);
   return INT2FIX(yes);
 }     
@@ -485,6 +515,8 @@ rb_s_gpgme_set_include_certs (VALUE dummy, VALUE vctx, VALUE vnr_of_certs)
   gpgme_ctx_t ctx;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_set_include_certs (ctx, NUM2INT(vnr_of_certs));
   return Qnil;
 }
@@ -496,6 +528,8 @@ rb_s_gpgme_get_include_certs (VALUE dummy, VALUE vctx)
   gpgme_error_t err;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   err = gpgme_get_include_certs (ctx);
   return LONG2NUM(err);
 }
@@ -507,6 +541,8 @@ rb_s_gpgme_set_keylist_mode (VALUE dummy, VALUE vctx, VALUE vmode)
   gpgme_error_t err;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   err = gpgme_set_keylist_mode (ctx, NUM2INT(vmode));
   return LONG2NUM(err);
 }
@@ -518,6 +554,8 @@ rb_s_gpgme_get_keylist_mode (VALUE dummy, VALUE vctx)
   int mode;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   mode = gpgme_get_keylist_mode (ctx);
   return INT2FIX(mode);
 }
@@ -553,6 +591,8 @@ rb_s_gpgme_set_passphrase_cb (VALUE dummy, VALUE vctx, VALUE vpassfunc,
   rb_iv_set (vctx, "@passphrase_cb", vcb);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_set_passphrase_cb (ctx, passphrase_cb, (void*)vcb);
   return Qnil;
 }
@@ -595,6 +635,8 @@ rb_s_gpgme_set_progress_cb (VALUE dummy, VALUE vctx, VALUE vprogfunc,
   rb_iv_set (vctx, "@progress_cb", vcb);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_set_progress_cb (ctx, progress_cb, (void*)vcb);
 
   return Qnil;
@@ -617,6 +659,8 @@ rb_s_gpgme_set_locale (VALUE dummy, VALUE vctx, VALUE vcategory, VALUE vvalue)
   gpgme_error_t err;
   
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_set_locale (ctx, NUM2INT(vcategory), StringValueCStr(vvalue));
   return LONG2NUM(err);
@@ -632,6 +676,8 @@ rb_s_gpgme_op_keylist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_op_keylist_start (ctx, NIL_P(vpattern) ? NULL :
 				StringValueCStr(vpattern),
@@ -652,6 +698,8 @@ rb_s_gpgme_op_keylist_ext_start (VALUE dummy, VALUE vctx, VALUE vpattern,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   if (!NIL_P(vpattern))
     {
@@ -763,6 +811,8 @@ rb_s_gpgme_op_keylist_next (VALUE dummy, VALUE vctx, VALUE rkey)
   CHECK_KEYLIST_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_op_keylist_next (ctx, &key);
   if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
@@ -783,6 +833,8 @@ rb_s_gpgme_op_keylist_end (VALUE dummy, VALUE vctx)
   CHECK_KEYLIST_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_op_keylist_end (ctx);
   RESET_KEYLIST_IN_PROGRESS(vctx);
@@ -798,6 +850,8 @@ rb_s_gpgme_get_key (VALUE dummy, VALUE vctx, VALUE vfpr, VALUE rkey,
   gpgme_key_t key;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   err = gpgme_get_key (ctx, StringValueCStr(vfpr), &key, NUM2INT(vsecret));
 
   if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
@@ -820,6 +874,8 @@ rb_s_gpgme_op_genkey (VALUE dummy, VALUE vctx, VALUE vparms, VALUE vpubkey,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   if (!NIL_P(vpubkey))
     UNWRAP_GPGME_DATA(vpubkey, pubkey);
   if (!NIL_P(vseckey))
@@ -840,6 +896,8 @@ rb_s_gpgme_op_genkey_start (VALUE dummy, VALUE vctx, VALUE vparms,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   if (!NIL_P(vpubkey))
     UNWRAP_GPGME_DATA(vpubkey, pubkey);
   if (!NIL_P(vseckey))
@@ -860,6 +918,8 @@ rb_s_gpgme_op_export (VALUE dummy, VALUE vctx, VALUE vpattern, VALUE vreserved,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vkeydata, keydata);
 
   err = gpgme_op_export (ctx, StringValueCStr(vpattern), NUM2UINT(vreserved),
@@ -878,6 +938,8 @@ rb_s_gpgme_op_export_start (VALUE dummy, VALUE vctx, VALUE vpattern,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vkeydata, keydata);
 
   err = gpgme_op_export_start (ctx, StringValueCStr(vpattern),
@@ -895,6 +957,8 @@ rb_s_gpgme_op_import (VALUE dummy, VALUE vctx, VALUE vkeydata)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vkeydata, keydata);
 
   err = gpgme_op_import (ctx, keydata);
@@ -911,6 +975,8 @@ rb_s_gpgme_op_import_start (VALUE dummy, VALUE vctx, VALUE vkeydata)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vkeydata, keydata);
 
   err = gpgme_op_import_start (ctx, keydata);
@@ -926,6 +992,8 @@ rb_s_gpgme_op_import_result (VALUE dummy, VALUE vctx)
   VALUE vresult, vimports;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   result = gpgme_op_import_result (ctx);
   vresult = rb_class_new_instance (0, NULL, cImportResult);
@@ -967,6 +1035,8 @@ rb_s_gpgme_op_delete (VALUE dummy, VALUE vctx, VALUE vkey, VALUE vallow_secret)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
 
   err = gpgme_op_delete (ctx, key, NUM2INT(vallow_secret));
@@ -984,6 +1054,8 @@ rb_s_gpgme_op_delete_start (VALUE dummy, VALUE vctx, VALUE vkey,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
 
   err = gpgme_op_delete_start (ctx, key, NUM2INT(vallow_secret));
@@ -1010,13 +1082,14 @@ rb_s_gpgme_op_edit (VALUE dummy, VALUE vctx, VALUE vkey,
   gpgme_ctx_t ctx;
   gpgme_key_t key;
   gpgme_data_t out = NULL;
-  void *hook_value = NULL;
   VALUE vcb;
   gpgme_error_t err;
 
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
   if (!NIL_P(vout))
     UNWRAP_GPGME_DATA(vout, out);
@@ -1038,13 +1111,14 @@ rb_s_gpgme_op_edit_start (VALUE dummy, VALUE vctx, VALUE vkey,
   gpgme_ctx_t ctx;
   gpgme_key_t key;
   gpgme_data_t out = NULL;
-  void *hook_value = NULL;
   VALUE vcb;
   gpgme_error_t err;
 
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
   if (!NIL_P(vout))
     UNWRAP_GPGME_DATA(vout, out);
@@ -1066,13 +1140,14 @@ rb_s_gpgme_op_card_edit (VALUE dummy, VALUE vctx, VALUE vkey,
   gpgme_ctx_t ctx;
   gpgme_key_t key;
   gpgme_data_t out = NULL;
-  void *hook_value = NULL;
   VALUE vcb;
   gpgme_error_t err;
 
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
   if (!NIL_P(vout))
     UNWRAP_GPGME_DATA(vout, out);
@@ -1094,13 +1169,14 @@ rb_s_gpgme_op_card_edit_start (VALUE dummy, VALUE vctx, VALUE vkey,
   gpgme_ctx_t ctx;
   gpgme_key_t key;
   gpgme_data_t out = NULL;
-  void *hook_value = NULL;
   VALUE vcb;
   gpgme_error_t err;
 
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
   if (!NIL_P(vout))
     UNWRAP_GPGME_DATA(vout, out);
@@ -1125,6 +1201,8 @@ rb_s_gpgme_op_trustlist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   err = gpgme_op_trustlist_start (ctx, StringValueCStr(vpattern),
 				  NUM2INT(vmax_level));
   return LONG2NUM(err);
@@ -1141,6 +1219,8 @@ rb_s_gpgme_op_trustlist_next (VALUE dummy, VALUE vctx, VALUE ritem)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_op_trustlist_next (ctx, &item);
   if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
@@ -1168,6 +1248,8 @@ rb_s_gpgme_op_trustlist_end (VALUE dummy, VALUE vctx)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   err = gpgme_op_trustlist_end (ctx);
   return LONG2NUM(err);
@@ -1183,6 +1265,8 @@ rb_s_gpgme_op_decrypt (VALUE dummy, VALUE vctx, VALUE vcipher, VALUE vplain)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vcipher, cipher);
   UNWRAP_GPGME_DATA(vplain, plain);
 
@@ -1201,6 +1285,8 @@ rb_s_gpgme_op_decrypt_start (VALUE dummy, VALUE vctx, VALUE vcipher,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vcipher, cipher);
   UNWRAP_GPGME_DATA(vplain, plain);
 
@@ -1216,6 +1302,8 @@ rb_s_gpgme_op_decrypt_result (VALUE dummy, VALUE vctx)
   VALUE vresult;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   result = gpgme_op_decrypt_result (ctx);
   vresult = rb_class_new_instance (0, NULL, cDecryptResult);
@@ -1237,6 +1325,8 @@ rb_s_gpgme_op_verify (VALUE dummy, VALUE vctx, VALUE vsig, VALUE vsigned_text,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vsig, sig);
   if (!NIL_P(vsigned_text))
     UNWRAP_GPGME_DATA(vsigned_text, signed_text);
@@ -1258,6 +1348,8 @@ rb_s_gpgme_op_verify_start (VALUE dummy, VALUE vctx, VALUE vsig,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vsig, sig);
   if (!NIL_P(vsigned_text))
     UNWRAP_GPGME_DATA(vsigned_text, signed_text);
@@ -1277,6 +1369,8 @@ rb_s_gpgme_op_verify_result (VALUE dummy, VALUE vctx)
   VALUE vverify_result, vsignatures = rb_ary_new ();
   
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   verify_result = gpgme_op_verify_result (ctx);
   vverify_result = rb_class_new_instance(0, NULL, cVerifyResult);
@@ -1329,6 +1423,8 @@ rb_s_gpgme_op_decrypt_verify (VALUE dummy, VALUE vctx, VALUE vcipher,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vcipher, cipher);
   UNWRAP_GPGME_DATA(vplain, plain);
 
@@ -1347,6 +1443,8 @@ rb_s_gpgme_op_decrypt_verify_start (VALUE dummy, VALUE vctx, VALUE vcipher,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vcipher, cipher);
   UNWRAP_GPGME_DATA(vplain, plain);
 
@@ -1360,6 +1458,8 @@ rb_s_gpgme_signers_clear (VALUE dummy, VALUE vctx)
   gpgme_ctx_t ctx;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   gpgme_signers_clear (ctx);
   return Qnil;
 }
@@ -1372,6 +1472,8 @@ rb_s_gpgme_signers_add (VALUE dummy, VALUE vctx, VALUE vkey)
   gpgme_error_t err;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_KEY(vkey, key);
 
   err = gpgme_signers_add (ctx, key);
@@ -1385,6 +1487,8 @@ rb_s_gpgme_signers_enum (VALUE dummy, VALUE vctx, VALUE vseq)
   gpgme_key_t key;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   key = gpgme_signers_enum (ctx, NUM2INT(vseq));
   if (!key)
@@ -1403,6 +1507,8 @@ rb_s_gpgme_op_sign (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vplain, plain);
   UNWRAP_GPGME_DATA(vsig, sig);
 
@@ -1421,6 +1527,8 @@ rb_s_gpgme_op_sign_start (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   UNWRAP_GPGME_DATA(vplain, plain);
   UNWRAP_GPGME_DATA(vsig, sig);
 
@@ -1438,6 +1546,8 @@ rb_s_gpgme_op_sign_result (VALUE dummy, VALUE vctx)
   VALUE vresult, vinvalid_signers, vsignatures;
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   result = gpgme_op_sign_result (ctx);
   vresult = rb_class_new_instance (0, NULL, cSignResult);
@@ -1486,6 +1596,8 @@ rb_s_gpgme_op_encrypt (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   /* If RECP is `NULL', symmetric rather than public key encryption is
      performed. */
   if (!NIL_P(vrecp))
@@ -1517,6 +1629,8 @@ rb_s_gpgme_op_encrypt_start (VALUE dummy, VALUE vctx, VALUE vrecp,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   /* If RECP is `NULL', symmetric rather than public key encryption is
      performed. */
   if (!NIL_P(vrecp))
@@ -1547,6 +1661,8 @@ rb_s_gpgme_op_encrypt_result (VALUE dummy, VALUE vctx)
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
 
   result = gpgme_op_encrypt_result (ctx);
   vresult = rb_class_new_instance (0, NULL, cEncryptResult);
@@ -1576,6 +1692,8 @@ rb_s_gpgme_op_encrypt_sign (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   /* If RECP is `NULL', symmetric rather than public key encryption is
      performed. */
   if (!NIL_P(vrecp))
@@ -1607,6 +1725,8 @@ rb_s_gpgme_op_encrypt_sign_start (VALUE dummy, VALUE vctx, VALUE vrecp,
   CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
 
   UNWRAP_GPGME_CTX(vctx, ctx);
+  if (!ctx)
+    rb_raise (rb_eArgError, "released ctx");
   /* If RECP is `NULL', symmetric rather than public key encryption is
      performed. */
   if (!NIL_P(vrecp))
@@ -1636,7 +1756,11 @@ rb_s_gpgme_wait (VALUE dummy, VALUE vctx, VALUE rstatus, VALUE vhang)
   /* The CTX argument can be `NULL'.  In that case, `gpgme_wait' waits
      for any context to complete its operation. */
   if (!NIL_P(vctx))
-    UNWRAP_GPGME_CTX(vctx, ctx);
+    {
+      UNWRAP_GPGME_CTX(vctx, ctx);
+      if (!ctx)
+	rb_raise (rb_eArgError, "released ctx");
+    }
 
   ret = gpgme_wait (ctx, &status, NUM2INT(vhang));
   if (ret)
@@ -1742,6 +1866,8 @@ Init_gpgme_n (void)
   /* Creating Contexts */
   rb_define_module_function (mGPGME, "gpgme_new",
 			     rb_s_gpgme_new, 1);
+  rb_define_module_function (mGPGME, "gpgme_release",
+			     rb_s_gpgme_release, 1);
 
   /* Context Attributes */
   rb_define_module_function (mGPGME, "gpgme_set_protocol",
@@ -1809,9 +1935,9 @@ Init_gpgme_n (void)
   rb_define_module_function (mGPGME, "gpgme_op_edit_start",
 			     rb_s_gpgme_op_edit_start, 5);
   rb_define_module_function (mGPGME, "gpgme_op_card_edit",
-			     rb_s_gpgme_op_edit, 5);
+			     rb_s_gpgme_op_card_edit, 5);
   rb_define_module_function (mGPGME, "gpgme_op_card_edit_start",
-			     rb_s_gpgme_op_edit_start, 5);
+			     rb_s_gpgme_op_card_edit_start, 5);
 
   /* Trust Item Management */
   rb_define_module_function (mGPGME, "gpgme_op_trustlist_start",

data/lib/gpgme.rb

@@ -123,29 +123,30 @@ def GPGME.decrypt(cipher, *args_options)
   args, options = split_args(args_options)
   plain = args[0]
 
-  ctx = GPGME::Ctx.new(options)
-  cipher_data = input_data(cipher)
-  plain_data = output_data(plain)
-  begin
-    ctx.decrypt_verify(cipher_data, plain_data)
-  rescue GPGME::Error::UnsupportedAlgorithm => exc
-    exc.algorithm = ctx.decrypt_result.unsupported_algorithm
-    raise exc
-  rescue GPGME::Error::WrongKeyUsage => exc
-    exc.key_usage = ctx.decrypt_result.wrong_key_usage
-    raise exc
-  end
-
-  verify_result = ctx.verify_result
-  if verify_result && block_given?
-    verify_result.signatures.each do |signature|
-      yield signature
+  GPGME::Ctx.new(options) do |ctx|
+    cipher_data = input_data(cipher)
+    plain_data = output_data(plain)
+    begin
+      ctx.decrypt_verify(cipher_data, plain_data)
+    rescue GPGME::Error::UnsupportedAlgorithm => exc
+      exc.algorithm = ctx.decrypt_result.unsupported_algorithm
+      raise exc
+    rescue GPGME::Error::WrongKeyUsage => exc
+      exc.key_usage = ctx.decrypt_result.wrong_key_usage
+      raise exc
+    end
+
+    verify_result = ctx.verify_result
+    if verify_result && block_given?
+      verify_result.signatures.each do |signature|
+        yield signature
+      end
     end
-  end
 
-  unless plain
-    plain_data.seek(0, IO::SEEK_SET)
-    plain_data.read
+    unless plain
+      plain_data.seek(0, IO::SEEK_SET)
+      plain_data.read
+    end
   end
 end
 
@@ -181,22 +182,23 @@ def GPGME.verify(sig, *args_options) # :yields: signature
   args, options = split_args(args_options)
   signed_text, plain = args
 
-  ctx = GPGME::Ctx.new(options)
-  sig_data = input_data(sig)
-  if signed_text
-    signed_text_data = input_data(signed_text)
-    plain_data = nil
-  else
-    signed_text_data = nil
-    plain_data = output_data(plain)
-  end
-  ctx.verify(sig_data, signed_text_data, plain_data)
-  ctx.verify_result.signatures.each do |signature|
-    yield signature
-  end
-  if !signed_text && !plain
-    plain_data.seek(0, IO::SEEK_SET)
-    plain_data.read
+  GPGME::Ctx.new(options) do |ctx|
+    sig_data = input_data(sig)
+    if signed_text
+      signed_text_data = input_data(signed_text)
+      plain_data = nil
+    else
+      signed_text_data = nil
+      plain_data = output_data(plain)
+    end
+    ctx.verify(sig_data, signed_text_data, plain_data)
+    ctx.verify_result.signatures.each do |signature|
+      yield signature
+    end
+    if !signed_text && !plain
+      plain_data.seek(0, IO::SEEK_SET)
+      plain_data.read
+    end
   end
 end
 
@@ -234,21 +236,22 @@ def GPGME.sign(plain, *args_options)
   args, options = split_args(args_options)
   sig = args[0]
 
-  ctx = GPGME::Ctx.new(options)
-  ctx.add_signer(*resolve_keys(options[:signers], true)) if options[:signers]
-  mode = options[:mode] || GPGME::SIG_MODE_NORMAL
-  plain_data = input_data(plain)
-  sig_data = output_data(sig)
-  begin
-    ctx.sign(plain_data, sig_data, mode)
-  rescue GPGME::Error::UnusableSecretKey => exc
-    exc.keys = ctx.sign_result.invalid_signers
-    raise exc
-  end
+  GPGME::Ctx.new(options) do |ctx|
+    ctx.add_signer(*resolve_keys(options[:signers], true, [:sign])) if options[:signers]
+    mode = options[:mode] || GPGME::SIG_MODE_NORMAL
+    plain_data = input_data(plain)
+    sig_data = output_data(sig)
+    begin
+      ctx.sign(plain_data, sig_data, mode)
+    rescue GPGME::Error::UnusableSecretKey => exc
+      exc.keys = ctx.sign_result.invalid_signers
+      raise exc
+    end
 
-  unless sig
-    sig_data.seek(0, IO::SEEK_SET)
-    sig_data.read
+    unless sig
+      sig_data.seek(0, IO::SEEK_SET)
+      sig_data.read
+    end
   end
 end
 
@@ -353,35 +356,36 @@ def GPGME.encrypt(recipients, plain, *args_options)
   raise ArgumentError, 'wrong number of arguments' if args_options.length > 3
   args, options = split_args(args_options)
   cipher = args[0]
-  recipient_keys = recipients ? resolve_keys(recipients, false) : nil
-
-  ctx = GPGME::Ctx.new(options)
-  plain_data = input_data(plain)
-  cipher_data = output_data(cipher)
-  begin
-    flags = 0
-    if options[:always_trust]
-      flags |= GPGME::ENCRYPT_ALWAYS_TRUST
-    end
-    if options[:sign]
-      if options[:signers]
-        ctx.add_signer(*resolve_keys(options[:signers], true))
+  recipient_keys = recipients ? resolve_keys(recipients, false, [:encrypt]) : nil
+
+  GPGME::Ctx.new(options) do |ctx|
+    plain_data = input_data(plain)
+    cipher_data = output_data(cipher)
+    begin
+      flags = 0
+      if options[:always_trust]
+        flags |= GPGME::ENCRYPT_ALWAYS_TRUST
       end
-      ctx.encrypt_sign(recipient_keys, plain_data, cipher_data, flags)
-    else
-      ctx.encrypt(recipient_keys, plain_data, cipher_data, flags)
-    end
-  rescue GPGME::Error::UnusablePublicKey => exc
-    exc.keys = ctx.encrypt_result.invalid_recipients
-    raise exc
-  rescue GPGME::Error::UnusableSecretKey => exc
-    exc.keys = ctx.sign_result.invalid_signers
-    raise exc
-  end
+      if options[:sign]
+        if options[:signers]
+          ctx.add_signer(*resolve_keys(options[:signers], true, [:sign]))
+        end
+        ctx.encrypt_sign(recipient_keys, plain_data, cipher_data, flags)
+      else
+        ctx.encrypt(recipient_keys, plain_data, cipher_data, flags)
+      end
+    rescue GPGME::Error::UnusablePublicKey => exc
+      exc.keys = ctx.encrypt_result.invalid_recipients
+      raise exc
+    rescue GPGME::Error::UnusableSecretKey => exc
+      exc.keys = ctx.sign_result.invalid_signers
+      raise exc
+    end
 
-  unless cipher
-    cipher_data.seek(0, IO::SEEK_SET)
-    cipher_data.read
+    unless cipher
+      cipher_data.seek(0, IO::SEEK_SET)
+      cipher_data.read
+    end
   end
 end
 
@@ -408,13 +412,14 @@ def GPGME.list_keys(*args_options) # :yields: key
   raise ArgumentError, 'wrong number of arguments' if args_options.length > 3
   args, options = split_args(args_options)
   pattern, secret_only = args
-  ctx = GPGME::Ctx.new
-  if block_given?  
-    ctx.each_key(pattern, secret_only || false) do |key|
-      yield key
+  GPGME::Ctx.new do |ctx|
+    if block_given?  
+      ctx.each_key(pattern, secret_only || false) do |key|
+        yield key
+      end
+    else
+      ctx.keys(pattern, secret_only || false)
     end
-  else
-    ctx.keys(pattern, secret_only || false)
   end
 end
 
@@ -445,12 +450,13 @@ def GPGME.export(*args_options)
   args, options = split_args(args_options)
   pattern, key = args[0]
   key_data = output_data(key)
-  ctx = GPGME::Ctx.new(options)
-  ctx.export_keys(pattern, key_data)
+  GPGME::Ctx.new(options) do |ctx|
+    ctx.export_keys(pattern, key_data)
 
-  unless key
-    key_data.seek(0, IO::SEEK_SET)
-    key_data.read
+    unless key
+      key_data.seek(0, IO::SEEK_SET)
+      key_data.read
+    end
   end
 end
 
@@ -478,9 +484,10 @@ def GPGME.import(*args_options)
   args, options = split_args(args_options)
   key = args[0]
   key_data = input_data(key)
-  ctx = GPGME::Ctx.new(options)
-  ctx.import_keys(key_data)
-  ctx.import_result
+  GPGME::Ctx.new(options) do |ctx|
+    ctx.import_keys(key_data)
+    ctx.import_result
+  end
 end
 
 module GPGME
@@ -499,14 +506,18 @@ module GPGME
   end
   module_function :split_args
 
-  def resolve_keys(keys_or_names, secret_only)
-    ctx = GPGME::Ctx.new
+  def resolve_keys(keys_or_names, secret_only, purposes = Array.new)
     keys = Array.new
     keys_or_names.each do |key_or_name|
       if key_or_name.kind_of? Key
         keys << key_or_name
       elsif key_or_name.kind_of? String
-        keys += ctx.keys(key_or_name, secret_only)
+        GPGME::Ctx.new do |ctx|
+          key = ctx.keys(key_or_name, secret_only).find {|k|
+            k.usable_for?(purposes)
+          }
+          keys << key if key
+        end
       end
     end
     keys
@@ -904,7 +915,15 @@ module GPGME
                                       options[:progress_callback_value])
         end
       end
-      ctx
+      if block_given?
+        begin
+          yield ctx
+        ensure
+          GPGME::gpgme_release(ctx)
+        end
+      else
+        ctx
+      end
     end
 
     # Set the <i>protocol</i> used within this context.
@@ -1246,6 +1265,14 @@ keylist_mode=#{KEYLIST_MODE_NAMES[keylist_mode]}>"
       caps
     end
 
+    def usable_for?(purposes)
+      unless purposes.kind_of? Array
+        purposes = [purposes]
+      end
+      return false if [:revoked, :expired, :disabled, :invalid].include? trust
+      return (purposes - capability).empty?
+    end
+
     def secret?
       @secret == 1
     end
@@ -1306,6 +1333,14 @@ capability=%s, subkeys=%s, uids=%s>",
       caps
     end
 
+    def usable_for?(purposes)
+      unless purposes.kind_of? Array
+        purposes = [purposes]
+      end
+      return false if [:revoked, :expired, :disabled, :invalid].include? trust
+      return (purposes - capability).empty?
+    end
+
     def secret?
       @secret == 1
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-gpgme
 version: !ruby/object:Gem::Version 
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors: 
 - Daiki Ueno
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 +09:00
+date: 2009-06-08 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - MANIFEST
 - Makefile
 - README
+- THANKS
 - extconf.rb
 - gpgme_n.c
 - lib/gpgme.rb