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