TODO: Find why is this needed. I guess the name compat means it's just backwards compatibility. Consider removing?
TODO find out what it does, can't seem to find a proper parameter that returns something other than nil.
# File lib/gpgme.rb, line 95 def check_version(options = nil) version = nil if options.kind_of?(String) version = options elsif options.include?(:version) version = options[:version] end unless GPGME::gpgme_check_version(version) raise Error::InvalidVersion.new end end
Auxiliary method used by all the library to generate exceptions from error codes returned by the C extension.
# File lib/gpgme.rb, line 33 def error_to_exception(err) case GPGME::gpgme_err_code(err) when GPG_ERR_EOF EOFError.new when GPG_ERR_NO_ERROR nil when GPG_ERR_GENERAL Error::General.new(err) when GPG_ERR_ENOMEM Errno::ENOMEM.new when GPG_ERR_INV_VALUE Error::InvalidValue.new(err) when GPG_ERR_UNUSABLE_PUBKEY Error::UnusablePublicKey.new(err) when GPG_ERR_UNUSABLE_SECKEY Error::UnusableSecretKey.new(err) when GPG_ERR_NO_DATA Error::NoData.new(err) when GPG_ERR_CONFLICT Error::Conflict.new(err) when GPG_ERR_NOT_IMPLEMENTED Error::NotImplemented.new(err) when GPG_ERR_DECRYPT_FAILED Error::DecryptFailed.new(err) when GPG_ERR_BAD_PASSPHRASE Error::BadPassphrase.new(err) when GPG_ERR_CANCELED Error::Canceled.new(err) when GPG_ERR_INV_ENGINE Error::InvalidEngine.new(err) when GPG_ERR_AMBIGUOUS_NAME Error::AmbiguousName.new(err) when GPG_ERR_WRONG_KEY_USAGE Error::WrongKeyUsage.new(err) when GPG_ERR_CERT_REVOKED Error::CertificateRevoked.new(err) when GPG_ERR_CERT_EXPIRED Error::CertificateExpired.new(err) when GPG_ERR_NO_CRL_KNOWN Error::NoCRLKnown.new(err) when GPG_ERR_NO_POLICY_MATCH Error::NoPolicyMatch.new(err) when GPG_ERR_NO_SECKEY Error::NoSecretKey.new(err) when GPG_ERR_MISSING_CERT Error::MissingCertificate.new(err) when GPG_ERR_BAD_CERT_CHAIN Error::BadCertificateChain.new(err) when GPG_ERR_UNSUPPORTED_ALGORITHM Error::UnsupportedAlgorithm.new(err) when GPG_ERR_BAD_SIGNATURE Error::BadSignature.new(err) when GPG_ERR_NO_PUBKEY Error::NoPublicKey.new(err) else Error.new(err) end end
static VALUE
rb_s_gpgme_check_version (VALUE dummy, VALUE vreq)
{
const char *result = gpgme_check_version (NIL_P(vreq) ? NULL :
StringValueCStr(vreq));
return result ? rb_str_new2 (result) : Qnil;
}
static VALUE
rb_s_gpgme_data_get_encoding (VALUE dummy, VALUE vdh)
{
gpgme_data_t dh;
gpgme_error_t err;
UNWRAP_GPGME_DATA(vdh, dh);
err = gpgme_data_get_encoding (dh);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_new (VALUE dummy, VALUE rdh)
{
gpgme_data_t dh;
gpgme_error_t err = gpgme_data_new (&dh);
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
rb_ary_store (rdh, 0, WRAP_GPGME_DATA(dh));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_new_from_cbs (VALUE dummy, VALUE rdh, VALUE vcbs,
VALUE vhandle)
{
gpgme_data_t dh;
gpgme_error_t err;
VALUE vcbs_handle = rb_ary_new ();
rb_ary_push (vcbs_handle, vcbs);
rb_ary_push (vcbs_handle, vhandle);
err = gpgme_data_new_from_cbs (&dh, &cbs, (void*)vcbs_handle);
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
{
VALUE vdh = WRAP_GPGME_DATA(dh);
/* Keep a reference to avoid GC. */
rb_iv_set (vdh, "@cbs_handle", vcbs_handle);
rb_ary_store (rdh, 0, vdh);
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_new_from_fd (VALUE dummy, VALUE rdh, VALUE vfd)
{
gpgme_data_t dh;
gpgme_error_t err = gpgme_data_new_from_fd (&dh, NUM2INT(vfd));
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
rb_ary_store (rdh, 0, WRAP_GPGME_DATA(dh));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_new_from_mem (VALUE dummy, VALUE rdh, VALUE vbuffer,
VALUE vsize)
{
gpgme_data_t dh;
VALUE vdh;
size_t size = NUM2UINT(vsize);
gpgme_error_t err;
if (RSTRING_LEN(vbuffer) < size)
rb_raise (rb_eArgError, "argument out of range");
err = gpgme_data_new_from_mem (&dh, StringValuePtr(vbuffer), size, 1);
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
{
vdh = WRAP_GPGME_DATA(dh);
rb_ary_store (rdh, 0, vdh);
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_read (VALUE dummy, VALUE vdh, VALUE vlength)
{
gpgme_data_t dh;
ssize_t length = NUM2LONG(vlength), nread;
void *buffer;
VALUE vbuffer = Qnil;
UNWRAP_GPGME_DATA(vdh, dh);
buffer = ALLOC_N (char, length);
nread = gpgme_data_read (dh, buffer, length);
if (nread > 0)
vbuffer = rb_str_new (buffer, nread);
xfree (buffer);
if (nread < 0)
rb_sys_fail ("rb_s_gpgme_data_read");
return vbuffer;
}
# File lib/gpgme/compat.rb, line 31 def gpgme_data_rewind(dh) begin GPGME::gpgme_data_seek(dh, 0, IO::SEEK_SET) rescue SystemCallError => e return e.errno end end
static VALUE
rb_s_gpgme_data_seek (VALUE dummy, VALUE vdh, VALUE voffset, VALUE vwhence)
{
gpgme_data_t dh;
off_t pos;
UNWRAP_GPGME_DATA(vdh, dh);
pos = gpgme_data_seek (dh, NUM2LONG(voffset), NUM2INT(vwhence));
if (pos < 0)
rb_sys_fail ("rb_s_gpgme_data_seek");
return LONG2NUM(pos);
}
static VALUE
rb_s_gpgme_data_set_encoding (VALUE dummy, VALUE vdh, VALUE venc)
{
gpgme_data_t dh;
gpgme_error_t err;
UNWRAP_GPGME_DATA(vdh, dh);
err = gpgme_data_set_encoding (dh, NUM2INT(venc));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_data_write (VALUE dummy, VALUE vdh, VALUE vbuf, VALUE vlen)
{
gpgme_data_t dh;
ssize_t nwrite;
UNWRAP_GPGME_DATA(vdh, dh);
nwrite = gpgme_data_write (dh, StringValuePtr(vbuf), NUM2UINT(vlen));
if (nwrite < 0)
rb_sys_fail ("rb_s_gpgme_data_write");
return LONG2NUM(nwrite);
}
static VALUE
rb_s_gpgme_engine_check_version (VALUE dummy, VALUE vproto)
{
gpgme_error_t err = gpgme_engine_check_version (NUM2INT(vproto));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_err_code (VALUE dummy, VALUE verr)
{
return INT2FIX(gpgme_err_code (NUM2LONG(verr)));
}
static VALUE
rb_s_gpgme_err_source (VALUE dummy, VALUE verr)
{
return INT2FIX(gpgme_err_source (NUM2LONG(verr)));
}
static VALUE
rb_s_gpgme_get_armor (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
int yes;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
yes = gpgme_get_armor (ctx);
return INT2FIX(yes);
}
static VALUE
rb_s_gpgme_get_dirinfo (VALUE dummy, VALUE vwhat)
{
const char *result = gpgme_get_dirinfo (StringValueCStr(vwhat));
return result ? rb_str_new2 (result) : Qnil;
}
static VALUE
rb_s_gpgme_get_engine_info (VALUE dummy, VALUE rinfo)
{
gpgme_engine_info_t info;
gpgme_error_t err;
long idx;
err = gpgme_get_engine_info (&info);
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
{
for (idx = 0; info; info = info->next, idx++)
{
VALUE vinfo = rb_class_new_instance (0, NULL, cEngineInfo);
rb_iv_set (vinfo, "@protocol", INT2FIX(info->protocol));
if (info->file_name)
rb_iv_set (vinfo, "@file_name", rb_str_new2 (info->file_name));
if (info->version)
rb_iv_set (vinfo, "@version", rb_str_new2 (info->version));
if (info->req_version)
rb_iv_set (vinfo, "@req_version", rb_str_new2 (info->req_version));
if (info->home_dir)
rb_iv_set (vinfo, "@home_dir", rb_str_new2 (info->home_dir));
rb_ary_store (rinfo, idx, vinfo);
}
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_get_include_certs (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
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);
}
static VALUE
rb_s_gpgme_get_key (VALUE dummy, VALUE vctx, VALUE vfpr, VALUE rkey,
VALUE vsecret)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
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)
{
VALUE vkey = WRAP_GPGME_KEY(key);
save_gpgme_key_attrs (vkey, key);
rb_ary_store (rkey, 0, vkey);
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_get_keylist_mode (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
int mode;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
mode = gpgme_get_keylist_mode (ctx);
return INT2FIX(mode);
}
static VALUE
rb_s_gpgme_get_passphrase_cb (VALUE dummy, VALUE vctx, VALUE rpassfunc,
VALUE rhook_value)
{
VALUE vcb = rb_iv_get (vctx, "@passphrase_cb");
/* No need to call gpgme_get_passphrase_cb. */
rb_ary_store (rpassfunc, 0, RARRAY_PTR(vcb)[0]);
rb_ary_store (rhook_value, 0, RARRAY_PTR(vcb)[1]);
return Qnil;
}
static VALUE
rb_s_gpgme_get_pinentry_mode (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_pinentry_mode_t mode;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
mode = gpgme_get_pinentry_mode (ctx);
return INT2FIX(mode);
}
static VALUE
rb_s_gpgme_get_progress_cb (VALUE dummy, VALUE vctx, VALUE rprogfunc,
VALUE rhook_value)
{
VALUE vcb = rb_iv_get (vctx, "@progress_cb");
rb_ary_store (rprogfunc, 0, RARRAY_PTR(vcb)[0]);
rb_ary_store (rhook_value, 0, RARRAY_PTR(vcb)[1]);
return Qnil;
}
static VALUE
rb_s_gpgme_get_protocol (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
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);
}
static VALUE
rb_s_gpgme_get_textmode (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
int yes;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
yes = gpgme_get_textmode (ctx);
return INT2FIX(yes);
}
static VALUE
rb_s_gpgme_hash_algo_name (VALUE dummy, VALUE valgo)
{
const char *name = gpgme_hash_algo_name (NUM2INT(valgo));
if (name)
return rb_str_new2 (name);
return Qnil;
}
static VALUE
rb_s_gpgme_new (VALUE dummy, VALUE rctx)
{
gpgme_ctx_t ctx;
gpgme_error_t err = gpgme_new (&ctx);
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
rb_ary_store (rctx, 0, WRAP_GPGME_CTX(ctx));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_card_edit (VALUE dummy, VALUE vctx, VALUE vkey,
VALUE veditfunc, VALUE vhook_value, VALUE vout)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_data_t out = 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);
vcb = rb_ary_new ();
rb_ary_push (vcb, veditfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
rb_iv_set (vctx, "@card_edit_cb", vcb);
err = gpgme_op_card_edit (ctx, key, edit_cb, (void *)vcb, out);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_card_edit_start (VALUE dummy, VALUE vctx, VALUE vkey,
VALUE veditfunc, VALUE vhook_value, VALUE vout)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_data_t out = 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);
vcb = rb_ary_new ();
rb_ary_push (vcb, veditfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
rb_iv_set (vctx, "@card_edit_cb", vcb);
err = gpgme_op_card_edit_start (ctx, key, edit_cb, (void *)vcb, out);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_decrypt (VALUE dummy, VALUE vctx, VALUE vcipher, VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t cipher, plain;
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_DATA(vcipher, cipher);
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_decrypt (ctx, cipher, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_decrypt_result (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_decrypt_result_t result;
gpgme_recipient_t recipient;
VALUE vresult, vrecipients;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
result = gpgme_op_decrypt_result (ctx);
if (!result)
rb_raise (rb_eArgError, "no result");
vresult = rb_class_new_instance (0, NULL, cDecryptResult);
if (result->unsupported_algorithm)
rb_iv_set (vresult, "@unsupported_algorithm",
rb_str_new2 (result->unsupported_algorithm));
rb_iv_set (vresult, "@wrong_key_usage", INT2FIX(result->wrong_key_usage));
vrecipients = rb_ary_new ();
rb_iv_set (vresult, "@recipients", vrecipients);
for (recipient = result->recipients; recipient; recipient = recipient->next)
{
VALUE vrecipient = rb_class_new_instance (0, NULL, cRecipient);
rb_iv_set (vrecipient, "@pubkey_algo", INT2FIX(recipient->pubkey_algo));
rb_iv_set (vrecipient, "@keyid", rb_str_new2 (recipient->keyid));
rb_iv_set (vrecipient, "@status", UINT2NUM(recipient->status));
rb_ary_push (vrecipients, vrecipient);
}
if (result->file_name)
rb_iv_set (vresult, "@file_name", rb_str_new2 (result->file_name));
return vresult;
}
static VALUE
rb_s_gpgme_op_decrypt_start (VALUE dummy, VALUE vctx, VALUE vcipher,
VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t cipher, plain;
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_DATA(vcipher, cipher);
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_decrypt_start (ctx, cipher, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_decrypt_verify (VALUE dummy, VALUE vctx, VALUE vcipher,
VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t cipher, plain;
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_DATA(vcipher, cipher);
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_decrypt_verify (ctx, cipher, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_decrypt_verify_start (VALUE dummy, VALUE vctx, VALUE vcipher,
VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t cipher, plain;
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_DATA(vcipher, cipher);
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_decrypt_verify_start (ctx, cipher, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_delete (VALUE dummy, VALUE vctx, VALUE vkey, VALUE vallow_secret)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
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);
err = gpgme_op_delete (ctx, key, NUM2INT(vallow_secret));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_delete_start (VALUE dummy, VALUE vctx, VALUE vkey,
VALUE vallow_secret)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
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);
err = gpgme_op_delete_start (ctx, key, NUM2INT(vallow_secret));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_edit (VALUE dummy, VALUE vctx, VALUE vkey,
VALUE veditfunc, VALUE vhook_value, VALUE vout)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_data_t out = 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);
vcb = rb_ary_new ();
rb_ary_push (vcb, veditfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
rb_iv_set (vctx, "@edit_cb", vcb);
err = gpgme_op_edit (ctx, key, edit_cb, (void *)vcb, out);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_edit_start (VALUE dummy, VALUE vctx, VALUE vkey,
VALUE veditfunc, VALUE vhook_value, VALUE vout)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_data_t out = 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);
vcb = rb_ary_new ();
rb_ary_push (vcb, veditfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
rb_iv_set (vctx, "@edit_cb", vcb);
err = gpgme_op_edit_start (ctx, key, edit_cb, (void *)vcb, out);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_encrypt (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
VALUE vplain, VALUE vcipher)
{
gpgme_ctx_t ctx;
gpgme_key_t *recp = NULL;
gpgme_data_t plain, cipher;
gpgme_error_t err;
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))
{
int i;
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
for (i = 0; i < RARRAY_LEN(vrecp); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
recp[i] = NULL;
}
UNWRAP_GPGME_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vcipher, cipher);
err = gpgme_op_encrypt (ctx, recp, NUM2INT(vflags), plain, cipher);
if (recp)
xfree (recp);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_encrypt_result (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_encrypt_result_t result;
gpgme_invalid_key_t invalid_key;
VALUE vresult, vinvalid_recipients;
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);
if (!result)
rb_raise (rb_eArgError, "no result");
vresult = rb_class_new_instance (0, NULL, cEncryptResult);
vinvalid_recipients = rb_ary_new ();
rb_iv_set (vresult, "@invalid_recipients", vinvalid_recipients);
for (invalid_key = result->invalid_recipients; invalid_key;
invalid_key = invalid_key->next)
{
VALUE vinvalid_key =
rb_class_new_instance (0, NULL, cInvalidKey);
rb_iv_set (vinvalid_key, "@fpr", rb_str_new2 (invalid_key->fpr));
rb_iv_set (vinvalid_key, "@reason", LONG2NUM(invalid_key->reason));
rb_ary_push (vinvalid_recipients, vinvalid_key);
}
return vresult;
}
static VALUE
rb_s_gpgme_op_encrypt_sign (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
VALUE vplain, VALUE vcipher)
{
gpgme_ctx_t ctx;
gpgme_key_t *recp = NULL;
gpgme_data_t plain, cipher;
gpgme_error_t err;
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))
{
int i;
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
for (i = 0; i < RARRAY_LEN(vrecp); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
recp[i] = NULL;
}
UNWRAP_GPGME_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vcipher, cipher);
err = gpgme_op_encrypt_sign (ctx, recp, NUM2INT(vflags), plain, cipher);
if (recp)
xfree (recp);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_encrypt_sign_start (VALUE dummy, VALUE vctx, VALUE vrecp,
VALUE vflags, VALUE vplain, VALUE vcipher)
{
gpgme_ctx_t ctx;
gpgme_key_t *recp = NULL;
gpgme_data_t plain, cipher;
gpgme_error_t err;
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))
{
int i;
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
for (i = 0; i < RARRAY_LEN(vrecp); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
recp[i] = NULL;
}
UNWRAP_GPGME_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vcipher, cipher);
err = gpgme_op_encrypt_sign_start (ctx, recp, NUM2INT(vflags), plain,
cipher);
if (recp)
xfree (recp);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_encrypt_start (VALUE dummy, VALUE vctx, VALUE vrecp,
VALUE vflags, VALUE vplain, VALUE vcipher)
{
gpgme_ctx_t ctx;
gpgme_key_t *recp = NULL;
gpgme_data_t plain, cipher;
gpgme_error_t err;
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))
{
int i;
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
for (i = 0; i < RARRAY_LEN(vrecp); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
recp[i] = NULL;
}
UNWRAP_GPGME_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vcipher, cipher);
err = gpgme_op_encrypt_start (ctx, recp, NUM2INT(vflags), plain, cipher);
if (recp)
xfree (recp);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export (VALUE dummy, VALUE vctx, VALUE vpattern, VALUE vmode,
VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
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_DATA(vkeydata, keydata);
err = gpgme_op_export (ctx, StringValueCStr(vpattern), NUM2UINT(vmode),
keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export_ext (VALUE dummy, VALUE vctx, VALUE vpattern, VALUE vmode,
VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
gpgme_error_t err;
const char **pattern;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
pattern = ALLOC_N(const char *, RARRAY_LEN(vpattern));
for (i = 0; i < RARRAY_LEN(vpattern); i++)
pattern[i] = StringValueCStr(RARRAY_PTR(vpattern)[i]);
UNWRAP_GPGME_DATA(vkeydata, keydata);
err = gpgme_op_export_ext (ctx, pattern, NUM2UINT(vmode), keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export_ext_start (VALUE dummy, VALUE vctx, VALUE vpattern,
VALUE vmode, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
gpgme_error_t err;
const char **pattern;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
pattern = ALLOC_N(const char *, RARRAY_LEN(vpattern));
for (i = 0; i < RARRAY_LEN(vpattern); i++)
pattern[i] = StringValueCStr(RARRAY_PTR(vpattern)[i]);
UNWRAP_GPGME_DATA(vkeydata, keydata);
err = gpgme_op_export_ext_start (ctx, pattern, NUM2UINT(vmode), keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export_keys (VALUE dummy, VALUE vctx, VALUE vkeys,
VALUE vmode, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_key_t *keys;
gpgme_data_t keydata;
gpgme_error_t err;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
keys = ALLOC_N(gpgme_key_t, RARRAY_LEN(vkeys) + 1);
for (i = 0; i < RARRAY_LEN(vkeys); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vkeys)[i], keys[i]);
UNWRAP_GPGME_DATA(vkeydata, keydata);
err = gpgme_op_export_keys (ctx, keys, NUM2UINT(vmode), keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export_keys_start (VALUE dummy, VALUE vctx, VALUE vkeys,
VALUE vmode, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_key_t *keys;
gpgme_data_t keydata;
gpgme_error_t err;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
keys = ALLOC_N(gpgme_key_t, RARRAY_LEN(vkeys) + 1);
for (i = 0; i < RARRAY_LEN(vkeys); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vkeys)[i], keys[i]);
UNWRAP_GPGME_DATA(vkeydata, keydata);
err = gpgme_op_export_keys_start (ctx, keys, NUM2UINT(vmode), keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_export_start (VALUE dummy, VALUE vctx, VALUE vpattern,
VALUE vmode, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
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_DATA(vkeydata, keydata);
err = gpgme_op_export_start (ctx, StringValueCStr(vpattern),
NUM2UINT(vmode), keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_genkey (VALUE dummy, VALUE vctx, VALUE vparms, VALUE vpubkey,
VALUE vseckey)
{
gpgme_ctx_t ctx;
gpgme_data_t pubkey = NULL, seckey = NULL;
gpgme_error_t err;
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))
UNWRAP_GPGME_DATA(vseckey, seckey);
err = gpgme_op_genkey (ctx, StringValueCStr(vparms), pubkey, seckey);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_genkey_start (VALUE dummy, VALUE vctx, VALUE vparms,
VALUE vpubkey, VALUE vseckey)
{
gpgme_ctx_t ctx;
gpgme_data_t pubkey = NULL, seckey = NULL;
gpgme_error_t err;
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))
UNWRAP_GPGME_DATA(vseckey, seckey);
err = gpgme_op_genkey_start (ctx, StringValueCStr(vparms), pubkey, seckey);
return LONG2NUM(err);
}
HAVE_GPGME_OP_EXPORT_KEYS
static VALUE
rb_s_gpgme_op_import (VALUE dummy, VALUE vctx, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
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_DATA(vkeydata, keydata);
err = gpgme_op_import (ctx, keydata);
return LONG2NUM(err);
}
# File lib/gpgme/compat.rb, line 40 def gpgme_op_import_ext(ctx, keydata, nr) err = GPGME::gpgme_op_import(ctx, keydata) if GPGME::gpgme_err_code(err) == GPGME::GPG_ERR_NO_ERROR result = GPGME::gpgme_op_import_result(ctx) nr.push(result.considered) end end
static VALUE
rb_s_gpgme_op_import_keys (VALUE dummy, VALUE vctx, VALUE vkeys)
{
gpgme_ctx_t ctx;
gpgme_key_t *keys;
gpgme_error_t err;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
keys = ALLOC_N(gpgme_key_t, RARRAY_LEN(vkeys) + 1);
for (i = 0; i < RARRAY_LEN(vkeys); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vkeys)[i], keys[i]);
keys[i] = NULL;
err = gpgme_op_import_keys (ctx, keys);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_import_keys_start (VALUE dummy, VALUE vctx, VALUE vkeys)
{
gpgme_ctx_t ctx;
gpgme_key_t *keys;
gpgme_error_t err;
int i;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
keys = ALLOC_N(gpgme_key_t, RARRAY_LEN(vkeys) + 1);
for (i = 0; i < RARRAY_LEN(vkeys); i++)
UNWRAP_GPGME_KEY(RARRAY_PTR(vkeys)[i], keys[i]);
keys[i] = NULL;
err = gpgme_op_import_keys_start (ctx, keys);
return LONG2NUM(err);
}
HAVE_GPGME_OP_EXPORT_KEYS
static VALUE
rb_s_gpgme_op_import_result (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_import_result_t result;
gpgme_import_status_t status;
VALUE vresult, vimports;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
result = gpgme_op_import_result (ctx);
if (!result)
rb_raise (rb_eArgError, "no result");
vresult = rb_class_new_instance (0, NULL, cImportResult);
rb_iv_set (vresult, "@considered", INT2NUM(result->considered));
rb_iv_set (vresult, "@no_user_id", INT2NUM(result->no_user_id));
rb_iv_set (vresult, "@imported", INT2NUM(result->imported));
rb_iv_set (vresult, "@imported_rsa", INT2NUM(result->imported_rsa));
rb_iv_set (vresult, "@unchanged", INT2NUM(result->unchanged));
rb_iv_set (vresult, "@new_user_ids", INT2NUM(result->new_user_ids));
rb_iv_set (vresult, "@new_sub_keys", INT2NUM(result->new_sub_keys));
rb_iv_set (vresult, "@new_signatures", INT2NUM(result->new_signatures));
rb_iv_set (vresult, "@new_revocations", INT2NUM(result->new_revocations));
rb_iv_set (vresult, "@secret_read", INT2NUM(result->secret_read));
rb_iv_set (vresult, "@secret_imported", INT2NUM(result->secret_imported));
rb_iv_set (vresult, "@secret_unchanged", INT2NUM(result->secret_unchanged));
rb_iv_set (vresult, "@not_imported", INT2NUM(result->not_imported));
vimports = rb_ary_new ();
rb_iv_set (vresult, "@imports", vimports);
for (status = result->imports; status;
status = status->next)
{
VALUE vstatus =
rb_class_new_instance (0, NULL, cImportStatus);
rb_iv_set (vstatus, "@fpr", rb_str_new2 (status->fpr));
rb_iv_set (vstatus, "@result", LONG2NUM(status->result));
rb_iv_set (vstatus, "@status", UINT2NUM(status->status));
rb_ary_push (vimports, vstatus);
}
return vresult;
}
static VALUE
rb_s_gpgme_op_import_start (VALUE dummy, VALUE vctx, VALUE vkeydata)
{
gpgme_ctx_t ctx;
gpgme_data_t keydata;
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_DATA(vkeydata, keydata);
err = gpgme_op_import_start (ctx, keydata);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_keylist_end (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
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);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_keylist_ext_start (VALUE dummy, VALUE vctx, VALUE vpattern,
VALUE vsecret_only)
{
gpgme_ctx_t ctx;
const char **pattern = NULL;
int i, err;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
if (!NIL_P(vpattern))
{
/* Convert RARRAY into `const char *' array. */
pattern = ALLOC_N(const char *, RARRAY_LEN(vpattern) + 1);
for (i = 0; i<RARRAY_LEN(vpattern); i++)
pattern[i] = StringValueCStr(RARRAY_PTR(vpattern)[i]);
pattern[RARRAY_LEN(vpattern)] = NULL;
}
err = gpgme_op_keylist_ext_start (ctx, pattern, NUM2INT(vsecret_only), 0);
if (gpgme_err_code (err) == GPG_ERR_NO_ERROR)
SET_KEYLIST_IN_PROGRESS(vctx);
if (pattern)
xfree (pattern);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_keylist_next (VALUE dummy, VALUE vctx, VALUE rkey)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
gpgme_error_t err;
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)
{
VALUE vkey = WRAP_GPGME_KEY(key);
save_gpgme_key_attrs (vkey, key);
rb_ary_store (rkey, 0, vkey);
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_keylist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
VALUE vsecret_only)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
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),
NUM2INT(vsecret_only));
if (gpgme_err_code (err) == GPG_ERR_NO_ERROR)
SET_KEYLIST_IN_PROGRESS(vctx);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_sign (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
VALUE vmode)
{
gpgme_ctx_t ctx;
gpgme_data_t plain, sig;
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_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vsig, sig);
err = gpgme_op_sign (ctx, plain, sig, NUM2INT(vmode));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_sign_result (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_sign_result_t result;
gpgme_invalid_key_t invalid_key;
gpgme_new_signature_t new_signature;
VALUE vresult, vinvalid_signers, vsignatures;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
result = gpgme_op_sign_result (ctx);
if (!result)
rb_raise (rb_eArgError, "no result");
vresult = rb_class_new_instance (0, NULL, cSignResult);
vinvalid_signers = rb_ary_new ();
rb_iv_set (vresult, "@invalid_signers", vinvalid_signers);
for (invalid_key = result->invalid_signers; invalid_key;
invalid_key = invalid_key->next)
{
VALUE vinvalid_key =
rb_class_new_instance (0, NULL, cInvalidKey);
rb_iv_set (vinvalid_key, "@fpr", rb_str_new2 (invalid_key->fpr));
rb_iv_set (vinvalid_key, "@reason", LONG2NUM(invalid_key->reason));
rb_ary_push (vinvalid_signers, vinvalid_key);
}
vsignatures = rb_ary_new ();
rb_iv_set (vresult, "@signatures", vsignatures);
for (new_signature = result->signatures; new_signature;
new_signature = new_signature->next)
{
VALUE vnew_signature =
rb_class_new_instance (0, NULL, cNewSignature);
rb_iv_set (vnew_signature, "@type", INT2FIX(new_signature->type));
rb_iv_set (vnew_signature, "@pubkey_algo",
INT2FIX(new_signature->pubkey_algo));
rb_iv_set (vnew_signature, "@hash_algo",
INT2FIX(new_signature->hash_algo));
rb_iv_set (vnew_signature, "@sig_class",
UINT2NUM(new_signature->sig_class));
rb_iv_set (vnew_signature, "@timestamp",
LONG2NUM(new_signature->timestamp));
rb_iv_set (vnew_signature, "@fpr", rb_str_new2 (new_signature->fpr));
rb_ary_push (vsignatures, vnew_signature);
}
return vresult;
}
static VALUE
rb_s_gpgme_op_sign_start (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
VALUE vmode)
{
gpgme_ctx_t ctx;
gpgme_data_t plain, sig;
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_DATA(vplain, plain);
UNWRAP_GPGME_DATA(vsig, sig);
err = gpgme_op_sign_start (ctx, plain, sig, NUM2INT(vmode));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_spawn (VALUE dummy, VALUE vctx, VALUE vfile,
VALUE vargv, VALUE vdatain, VALUE vdataout,
VALUE vdataerr, VALUE vflags)
{
gpgme_ctx_t ctx;
const char *file;
const char **argv;
gpgme_data_t datain = NULL;
gpgme_data_t dataout = NULL;
gpgme_data_t dataerr = NULL;
gpgme_error_t err;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
file = StringValueCStr(vfile);
if (NIL_P(vargv))
argv = NULL;
else
{
int i;
argv = ALLOC_N(const char *, RARRAY_LEN(vargv) + 1);
for (i = 0; i < RARRAY_LEN(vargv); i++)
argv[i] = StringValueCStr(RARRAY_PTR(vargv)[i]);
argv[i] = NULL;
}
UNWRAP_GPGME_DATA(vdatain, datain);
UNWRAP_GPGME_DATA(vdataout, dataout);
UNWRAP_GPGME_DATA(vdataerr, dataerr);
err = gpgme_op_spawn (ctx, file, argv, datain, dataout, dataerr,
NUM2INT(vflags));
if (argv)
xfree (argv);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_spawn_start (VALUE dummy, VALUE vctx, VALUE vfile,
VALUE vargv, VALUE vdatain, VALUE vdataout,
VALUE vdataerr, VALUE vflags)
{
gpgme_ctx_t ctx;
const char *file;
const char **argv;
gpgme_data_t datain = NULL;
gpgme_data_t dataout = NULL;
gpgme_data_t dataerr = NULL;
gpgme_error_t err;
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
file = StringValueCStr(vfile);
if (NIL_P(vargv))
argv = NULL;
else
{
int i;
argv = ALLOC_N(const char *, RARRAY_LEN(vargv) + 1);
for (i = 0; i < RARRAY_LEN(vargv); i++)
argv[i] = StringValueCStr(RARRAY_PTR(vargv)[i]);
argv[i] = NULL;
}
UNWRAP_GPGME_DATA(vdatain, datain);
UNWRAP_GPGME_DATA(vdataout, dataout);
UNWRAP_GPGME_DATA(vdataerr, dataerr);
err = gpgme_op_spawn_start (ctx, file, argv, datain, dataout, dataerr,
NUM2INT(vflags));
if (argv)
xfree (argv);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_trustlist_end (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
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);
}
static VALUE
rb_s_gpgme_op_trustlist_next (VALUE dummy, VALUE vctx, VALUE ritem)
{
gpgme_ctx_t ctx;
gpgme_trust_item_t item;
gpgme_error_t err;
VALUE vitem;
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)
{
vitem = WRAP_GPGME_TRUST_ITEM(item);
rb_iv_set (vitem, "@keyid", rb_str_new2 (item->keyid));
rb_iv_set (vitem, "@type", INT2FIX(item->type));
rb_iv_set (vitem, "@level", INT2FIX(item->level));
if (item->owner_trust)
rb_iv_set (vitem, "@owner_trust", rb_str_new2 (item->owner_trust));
rb_iv_set (vitem, "@validity", rb_str_new2 (item->validity));
if (item->name)
rb_iv_set (vitem, "@name", rb_str_new2 (item->name));
rb_ary_store (ritem, 0, vitem);
}
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_trustlist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
VALUE vmax_level)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
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);
}
static VALUE
rb_s_gpgme_op_verify (VALUE dummy, VALUE vctx, VALUE vsig, VALUE vsigned_text,
VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t sig, signed_text = NULL, plain = NULL;
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_DATA(vsig, sig);
if (!NIL_P(vsigned_text))
UNWRAP_GPGME_DATA(vsigned_text, signed_text);
if (!NIL_P(vplain))
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_verify (ctx, sig, signed_text, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_op_verify_result (VALUE dummy, VALUE vctx)
{
gpgme_ctx_t ctx;
gpgme_verify_result_t verify_result;
gpgme_signature_t signature;
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);
if (!verify_result)
rb_raise (rb_eArgError, "no result");
vverify_result = rb_class_new_instance(0, NULL, cVerifyResult);
rb_iv_set (vverify_result, "@signatures", vsignatures);
for (signature = verify_result->signatures; signature;
signature = signature->next)
{
VALUE vsignature = rb_class_new_instance(0, NULL, cSignature),
vnotations = rb_ary_new ();
gpgme_sig_notation_t notation;
rb_iv_set (vsignature, "@summary", INT2FIX(signature->summary));
rb_iv_set (vsignature, "@fpr", rb_str_new2 (signature->fpr));
rb_iv_set (vsignature, "@status", LONG2NUM(signature->status));
rb_iv_set (vsignature, "@notations", vnotations);
for (notation = signature->notations; notation;
notation = notation->next)
{
VALUE vnotation = rb_class_new_instance(0, NULL, cSigNotation);
/* The docs say:
* The name of the notation field. If this is NULL, then the member
* value will contain a policy URL. */
if (notation->name == NULL)
rb_iv_set (vnotation, "@name", Qnil);
else
rb_iv_set (vnotation, "@name", rb_str_new2 (notation->name));
rb_iv_set (vnotation, "@value", rb_str_new2 (notation->value));
rb_ary_push (vnotations, vnotation);
}
rb_iv_set (vsignature, "@timestamp", ULONG2NUM(signature->timestamp));
rb_iv_set (vsignature, "@exp_timestamp",
ULONG2NUM(signature->exp_timestamp));
rb_iv_set (vsignature, "@wrong_key_usage",
INT2FIX(signature->wrong_key_usage));
rb_iv_set (vsignature, "@validity", INT2FIX(signature->validity));
rb_iv_set (vsignature, "@validity_reason",
LONG2NUM(signature->validity_reason));
/* PKA related fields were added in 1.1.1. */
#ifdef GPGME_STATUS_PKA_TRUST_BAD
rb_iv_set (vsignature, "@pka_trust", INT2FIX(signature->pka_trust));
rb_iv_set (vsignature, "@pka_address",
rb_str_new2 (signature->pka_address));
#endif
rb_ary_push (vsignatures, vsignature);
}
return vverify_result;
}
static VALUE
rb_s_gpgme_op_verify_start (VALUE dummy, VALUE vctx, VALUE vsig,
VALUE vsigned_text, VALUE vplain)
{
gpgme_ctx_t ctx;
gpgme_data_t sig, signed_text = NULL, plain = NULL;
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_DATA(vsig, sig);
if (!NIL_P(vsigned_text))
UNWRAP_GPGME_DATA(vsigned_text, signed_text);
if (!NIL_P(vplain))
UNWRAP_GPGME_DATA(vplain, plain);
err = gpgme_op_verify_start (ctx, sig, signed_text, plain);
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_pubkey_algo_name (VALUE dummy, VALUE valgo)
{
const char *name = gpgme_pubkey_algo_name (NUM2INT(valgo));
if (name)
return rb_str_new2 (name);
return Qnil;
}
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_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;
}
static VALUE
rb_s_gpgme_set_engine_info (VALUE dummy, VALUE vproto, VALUE vfile_name,
VALUE vhome_dir)
{
gpgme_error_t err = gpgme_set_engine_info (NUM2INT(vproto),
NIL_P(vfile_name) ? NULL :
StringValueCStr(vfile_name),
NIL_P(vhome_dir) ? NULL :
StringValueCStr(vhome_dir));
return LONG2NUM(err);
}
static VALUE
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;
}
static VALUE
rb_s_gpgme_set_keylist_mode (VALUE dummy, VALUE vctx, VALUE vmode)
{
gpgme_ctx_t ctx;
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);
}
static VALUE
rb_s_gpgme_set_locale (VALUE dummy, VALUE vctx, VALUE vcategory, VALUE vvalue)
{
gpgme_ctx_t ctx;
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);
}
static VALUE
rb_s_gpgme_set_passphrase_cb (VALUE dummy, VALUE vctx, VALUE vpassfunc,
VALUE vhook_value)
{
gpgme_ctx_t ctx;
VALUE vcb = rb_ary_new ();
rb_ary_push (vcb, vpassfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
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;
}
static VALUE
rb_s_gpgme_set_pinentry_mode (VALUE dummy, VALUE vctx, VALUE vmode)
{
gpgme_ctx_t ctx;
gpgme_error_t err;
UNWRAP_GPGME_CTX(vctx, ctx);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
err = gpgme_set_pinentry_mode (ctx, NUM2INT(vmode));
return LONG2NUM(err);
}
static VALUE
rb_s_gpgme_set_progress_cb (VALUE dummy, VALUE vctx, VALUE vprogfunc,
VALUE vhook_value)
{
gpgme_ctx_t ctx;
VALUE vcb = rb_ary_new ();
rb_ary_push (vcb, vprogfunc);
rb_ary_push (vcb, vhook_value);
/* Keep a reference to avoid GC. */
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;
}
static VALUE
rb_s_gpgme_set_protocol (VALUE dummy, VALUE vctx, VALUE vproto)
{
gpgme_ctx_t ctx;
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);
}
static VALUE
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;
}
static VALUE
rb_s_gpgme_signers_add (VALUE dummy, VALUE vctx, VALUE vkey)
{
gpgme_ctx_t ctx;
gpgme_key_t key;
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);
return LONG2NUM(err);
}
static VALUE
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;
}
static VALUE
rb_s_gpgme_signers_enum (VALUE dummy, VALUE vctx, VALUE vseq)
{
gpgme_ctx_t ctx;
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)
return Qnil;
return WRAP_GPGME_KEY(key);
}
static VALUE
rb_s_gpgme_strerror (VALUE dummy, VALUE verr)
{
return rb_str_new2 (gpgme_strerror (NUM2LONG(verr)));
}
static VALUE
rb_s_gpgme_wait (VALUE dummy, VALUE vctx, VALUE rstatus, VALUE vhang)
{
gpgme_ctx_t ctx = NULL, ret;
gpgme_error_t status;
/* 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);
if (!ctx)
rb_raise (rb_eArgError, "released ctx");
}
ret = gpgme_wait (ctx, &status, NUM2INT(vhang));
if (ret)
{
rb_ary_store (rstatus, 0, INT2NUM(status));
if (ret != ctx)
vctx = WRAP_GPGME_CTX(ret);
return vctx;
}
return Qnil;
}
# File lib/gpgme/compat.rb, line 31 def gpgme_data_rewind(dh) begin GPGME::gpgme_data_seek(dh, 0, IO::SEEK_SET) rescue SystemCallError => e return e.errno end end
# File lib/gpgme/compat.rb, line 40 def gpgme_op_import_ext(ctx, keydata, nr) err = GPGME::gpgme_op_import(ctx, keydata) if GPGME::gpgme_err_code(err) == GPGME::GPG_ERR_NO_ERROR result = GPGME::gpgme_op_import_result(ctx) nr.push(result.considered) end end