ruby-gpgme 1.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/COPYING +340 -0
- data/MANIFEST +12 -0
- data/Makefile +164 -0
- data/README +69 -0
- data/examples/genkey.rb +55 -0
- data/examples/keylist.rb +6 -0
- data/examples/roundtrip.rb +39 -0
- data/examples/sign.rb +29 -0
- data/examples/verify.rb +6 -0
- data/extconf.rb +11 -0
- data/gpgme_n.c +2166 -0
- data/lib/gpgme.rb +1462 -0
- data/lib/gpgme/compat.rb +46 -0
- data/lib/gpgme/constants.rb +164 -0
- metadata +66 -0
data/README
ADDED
@@ -0,0 +1,69 @@
|
|
1
|
+
* What's this?
|
2
|
+
|
3
|
+
Ruby-GPGME is a Ruby language binding of GPGME (GnuPG Made Easy).
|
4
|
+
|
5
|
+
* Requirements
|
6
|
+
|
7
|
+
- Ruby 1.8 or later
|
8
|
+
- GPGME 1.1.2 or later
|
9
|
+
- gpg-agent (optional, but recommended)
|
10
|
+
|
11
|
+
* Installation
|
12
|
+
|
13
|
+
$ ruby extconf.rb
|
14
|
+
$ make
|
15
|
+
$ make install
|
16
|
+
|
17
|
+
* Examples
|
18
|
+
|
19
|
+
examples/genkey.rb Generate a key pair in your keyring.
|
20
|
+
examples/keylist.rb List your keyring like gpg --list-keys.
|
21
|
+
examples/roundtrip.rb Encrypt a plain text and then decrypt it.
|
22
|
+
examples/sign.rb Create a clear text signature.
|
23
|
+
examples/verify.rb Verify a clear text signature given from stdin.
|
24
|
+
|
25
|
+
* API
|
26
|
+
|
27
|
+
Ruby-GPGME provides 3 levels of API. The highest level API is close
|
28
|
+
to the command line interface of GnuPG. The lowest level API is close
|
29
|
+
to the C interface of GPGME.
|
30
|
+
|
31
|
+
** The highest level API
|
32
|
+
|
33
|
+
For example, to create a cleartext signature of the plaintext from stdin
|
34
|
+
can be written as follows.
|
35
|
+
|
36
|
+
$ ruby -rgpgme -e 'GPGME.clearsign($stdin, $stdout)'
|
37
|
+
|
38
|
+
** The lowest level API
|
39
|
+
|
40
|
+
The same example can be rewritten in the lowest level API as follows.
|
41
|
+
|
42
|
+
$ ruby -rgpgme -e <<End
|
43
|
+
ret = Array.new
|
44
|
+
GPGME::gpgme_new(ret)
|
45
|
+
ctx = ret.shift
|
46
|
+
GPGME::gpgme_data_new_from_fd(ret, 0)
|
47
|
+
plain = ret.shift
|
48
|
+
GPGME::gpgme_data_new_from_fd(ret, 1)
|
49
|
+
sig = ret.shift
|
50
|
+
GPGME::gpgme_op_sign(ctx, plain, sig, GPGME::SIG_MODE_CLEAR)
|
51
|
+
End
|
52
|
+
|
53
|
+
As you see, it's much harder to write a program in this API than the
|
54
|
+
highest level API. However, if you are already familier with the C
|
55
|
+
interface of GPGME and/or want to control detailed behavior of GPGME,
|
56
|
+
it might be useful.
|
57
|
+
|
58
|
+
** The mid level API
|
59
|
+
|
60
|
+
There is another API which looks object-oriented. It's easier to use
|
61
|
+
than the lowest level API though, you should first consult the highest
|
62
|
+
level API.
|
63
|
+
|
64
|
+
$ ruby -rgpgme -e <<End
|
65
|
+
ctx = GPGME::Ctx.new
|
66
|
+
plain = GPGME::Data.from_io($stdin)
|
67
|
+
sig = GPGME::Data.from_io($stdout)
|
68
|
+
ctx.sign(plain, sig, GPGME::SIG_MODE_CLEAR)
|
69
|
+
End
|
data/examples/genkey.rb
ADDED
@@ -0,0 +1,55 @@
|
|
1
|
+
#!/usr/bin/env ruby
|
2
|
+
require 'gpgme'
|
3
|
+
|
4
|
+
# If you do not have gpg-agent installed, comment out the following
|
5
|
+
# and set it as :passphrase_callback.
|
6
|
+
#
|
7
|
+
# def passfunc(hook, uid_hint, passphrase_info, prev_was_bad, fd)
|
8
|
+
# $stderr.write("Passphrase for #{uid_hint}: ")
|
9
|
+
# $stderr.flush
|
10
|
+
# begin
|
11
|
+
# system('stty -echo')
|
12
|
+
# io = IO.for_fd(fd, 'w')
|
13
|
+
# io.puts(gets)
|
14
|
+
# io.flush
|
15
|
+
# ensure
|
16
|
+
# (0 ... $_.length).each do |i| $_[i] = ?0 end if $_
|
17
|
+
# system('stty echo')
|
18
|
+
# end
|
19
|
+
# puts
|
20
|
+
# end
|
21
|
+
|
22
|
+
unless ENV['GPG_AGENT_INFO']
|
23
|
+
$stderr.puts("gpg-agent is not running. See the comment in #{$0}.")
|
24
|
+
exit(1)
|
25
|
+
end
|
26
|
+
|
27
|
+
unless ENV['GNUPGHOME']
|
28
|
+
$stderr.write('As GNUPGHOME is not set, the generated key pair will be stored into *your* keyring. Really proceed? (y/N) ')
|
29
|
+
$stderr.flush
|
30
|
+
exit(1) unless gets.chomp == 'y'
|
31
|
+
end
|
32
|
+
|
33
|
+
def progfunc(hook, what, type, current, total)
|
34
|
+
$stderr.write("#{what}: #{current}/#{total}\r")
|
35
|
+
$stderr.flush
|
36
|
+
end
|
37
|
+
|
38
|
+
ctx = GPGME::Ctx.new({:progress_callback => method(:progfunc),
|
39
|
+
# :passphrase_callback => method(:passfunc)
|
40
|
+
})
|
41
|
+
|
42
|
+
ctx.genkey(<<'EOF', nil, nil)
|
43
|
+
<GnupgKeyParms format="internal">
|
44
|
+
Key-Type: DSA
|
45
|
+
Key-Length: 1024
|
46
|
+
Subkey-Type: ELG-E
|
47
|
+
Subkey-Length: 1024
|
48
|
+
Name-Real: Joe Tester
|
49
|
+
Name-Comment: with stupid passphrase
|
50
|
+
Name-Email: joe@foo.bar
|
51
|
+
Expire-Date: 0
|
52
|
+
Passphrase: abc
|
53
|
+
</GnupgKeyParms>
|
54
|
+
EOF
|
55
|
+
$stderr.puts
|
data/examples/keylist.rb
ADDED
@@ -0,0 +1,39 @@
|
|
1
|
+
#!/usr/bin/env ruby
|
2
|
+
require 'gpgme'
|
3
|
+
|
4
|
+
# If you do not have gpg-agent installed, comment out the following
|
5
|
+
# and set it as :passphrase_callback.
|
6
|
+
#
|
7
|
+
# def passfunc(hook, uid_hint, passphrase_info, prev_was_bad, fd)
|
8
|
+
# $stderr.write("Passphrase for #{uid_hint}: ")
|
9
|
+
# $stderr.flush
|
10
|
+
# begin
|
11
|
+
# system('stty -echo')
|
12
|
+
# io = IO.for_fd(fd, 'w')
|
13
|
+
# io.puts(gets)
|
14
|
+
# io.flush
|
15
|
+
# ensure
|
16
|
+
# (0 ... $_.length).each do |i| $_[i] = ?0 end if $_
|
17
|
+
# system('stty echo')
|
18
|
+
# end
|
19
|
+
# puts
|
20
|
+
# end
|
21
|
+
|
22
|
+
unless ENV['GPG_AGENT_INFO']
|
23
|
+
$stderr.puts("gpg-agent is not running. See the comment in #{$0}.")
|
24
|
+
exit(1)
|
25
|
+
end
|
26
|
+
|
27
|
+
plain = 'test test test'
|
28
|
+
puts("Plaintext:\n#{plain}")
|
29
|
+
|
30
|
+
# Perform symmetric encryption on PLAIN.
|
31
|
+
cipher = GPGME::encrypt(nil, plain, {:armor => true
|
32
|
+
# :passphrase_callback => method(:passfunc)
|
33
|
+
})
|
34
|
+
puts("Ciphertext:\n#{cipher}")
|
35
|
+
|
36
|
+
plain = GPGME::decrypt(cipher, {
|
37
|
+
# :passphrase_callback => method(:passfunc)
|
38
|
+
})
|
39
|
+
puts("Plaintext:\n#{plain}")
|
data/examples/sign.rb
ADDED
@@ -0,0 +1,29 @@
|
|
1
|
+
#!/usr/bin/env ruby
|
2
|
+
require 'gpgme'
|
3
|
+
|
4
|
+
# If you do not have gpg-agent installed, comment out the following
|
5
|
+
# and set it as :passphrase_callback.
|
6
|
+
#
|
7
|
+
# def passfunc(hook, uid_hint, passphrase_info, prev_was_bad, fd)
|
8
|
+
# $stderr.write("Passphrase for #{uid_hint}: ")
|
9
|
+
# $stderr.flush
|
10
|
+
# begin
|
11
|
+
# system('stty -echo')
|
12
|
+
# io = IO.for_fd(fd, 'w')
|
13
|
+
# io.puts(gets)
|
14
|
+
# io.flush
|
15
|
+
# ensure
|
16
|
+
# (0 ... $_.length).each do |i| $_[i] = ?0 end if $_
|
17
|
+
# system('stty echo')
|
18
|
+
# end
|
19
|
+
# puts
|
20
|
+
# end
|
21
|
+
|
22
|
+
unless ENV['GPG_AGENT_INFO']
|
23
|
+
$stderr.puts("gpg-agent is not running. See the comment in #{$0}.")
|
24
|
+
exit(1)
|
25
|
+
end
|
26
|
+
|
27
|
+
puts GPGME::clearsign('test test test', {
|
28
|
+
# :passphrase_callback => method(:passfunc)
|
29
|
+
})
|
data/examples/verify.rb
ADDED
data/extconf.rb
ADDED
data/gpgme_n.c
ADDED
@@ -0,0 +1,2166 @@
|
|
1
|
+
/* gpgme_n.c -- low level interface to GPGME
|
2
|
+
Copyright (C) 2003,2006,2007 Daiki Ueno
|
3
|
+
|
4
|
+
This file is a part of Ruby-GPGME.
|
5
|
+
|
6
|
+
This program is free software; you can redistribute it and/or modify
|
7
|
+
it under the terms of the GNU General Public License as published by
|
8
|
+
the Free Software Foundation; either version 2, or (at your option)
|
9
|
+
any later version.
|
10
|
+
|
11
|
+
This program is distributed in the hope that it will be useful,
|
12
|
+
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
13
|
+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
14
|
+
GNU General Public License for more details.
|
15
|
+
|
16
|
+
You should have received a copy of the GNU General Public License
|
17
|
+
along with GNU Emacs; see the file COPYING. If not, write to the
|
18
|
+
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
19
|
+
Boston, MA 02110-1301, USA. */
|
20
|
+
|
21
|
+
/* This file is (semi) automatically generated, though it was written
|
22
|
+
by hand. There are simple rules to edit this file.
|
23
|
+
|
24
|
+
1. Each symbol exported from this module is either a class, a module
|
25
|
+
function, or a constant. No instance methods are defined here.
|
26
|
+
2. Each symbol exported from this module follows the same naming
|
27
|
+
convention as the GPGME API. That is, symbol names are followed
|
28
|
+
by `gpgme_' for functions are followed by `GPGME_' or `GPG_' for
|
29
|
+
constants.
|
30
|
+
3. Output arguments are wrapped in arrays. For example, the 1st
|
31
|
+
argument of `gpgme_data_new' has type `gpgme_data_t *' to store the
|
32
|
+
newly created gpgme_data_t object. The corresponding ruby
|
33
|
+
interface uses an empty array to passing it to the caller. */
|
34
|
+
|
35
|
+
#include "ruby.h"
|
36
|
+
#include "gpgme.h"
|
37
|
+
#include <errno.h>
|
38
|
+
|
39
|
+
#define RUBY_GPGME_WORKAROUND_KEYLIST_NEXT
|
40
|
+
|
41
|
+
#ifdef RUBY_GPGME_WORKAROUND_KEYLIST_NEXT
|
42
|
+
#define CHECK_KEYLIST_IN_PROGRESS(vctx) \
|
43
|
+
if (rb_iv_get (vctx, "ruby_gpgme_keylist_in_progress") != Qtrue) \
|
44
|
+
return LONG2NUM(gpgme_error (GPG_ERR_INV_STATE))
|
45
|
+
#define CHECK_KEYLIST_NOT_IN_PROGRESS(vctx) \
|
46
|
+
if (rb_iv_get (vctx, "ruby_gpgme_keylist_in_progress") == Qtrue) \
|
47
|
+
return LONG2NUM(gpgme_error (GPG_ERR_INV_STATE))
|
48
|
+
#define SET_KEYLIST_IN_PROGRESS(vctx) \
|
49
|
+
rb_iv_set (vctx, "ruby_gpgme_keylist_in_progress", Qtrue)
|
50
|
+
#define RESET_KEYLIST_IN_PROGRESS(vctx) \
|
51
|
+
rb_iv_set (vctx, "ruby_gpgme_keylist_in_progress", Qfalse)
|
52
|
+
#else
|
53
|
+
#define CHECK_KEYLIST_IN_PROGRESS(vctx)
|
54
|
+
#define CHECK_KEYLIST_NOT_IN_PROGRESS(vctx)
|
55
|
+
#define SET_KEYLIST_IN_PROGRESS(vctx)
|
56
|
+
#define RESET_KEYLIST_IN_PROGRESS(vctx)
|
57
|
+
#endif
|
58
|
+
|
59
|
+
/* StringValuePtr is not available in 1.6. */
|
60
|
+
#ifndef StringValuePtr
|
61
|
+
#define StringValuePtr(str) RSTRING(str)->ptr
|
62
|
+
#endif
|
63
|
+
|
64
|
+
/* STR2CSTR is obsoleted in 1.8. */
|
65
|
+
#ifndef StringValueCStr
|
66
|
+
#define StringValueCStr STR2CSTR
|
67
|
+
#endif
|
68
|
+
|
69
|
+
/* RARRAY_LEN is not available in 1.8. */
|
70
|
+
#ifndef RARRAY_LEN
|
71
|
+
#define RARRAY_LEN(a) RARRAY(a)->len
|
72
|
+
#endif
|
73
|
+
|
74
|
+
/* RARRAY_PTR is not available in 1.8. */
|
75
|
+
#ifndef RARRAY_PTR
|
76
|
+
#define RARRAY_PTR(a) RARRAY(a)->ptr
|
77
|
+
#endif
|
78
|
+
|
79
|
+
#define WRAP_GPGME_DATA(dh) \
|
80
|
+
Data_Wrap_Struct(cData, 0, gpgme_data_release, dh) \
|
81
|
+
/* `gpgme_data_t' is typedef'ed as `struct gpgme_data *'. */
|
82
|
+
#define UNWRAP_GPGME_DATA(vdh, dh) \
|
83
|
+
Data_Get_Struct(vdh, struct gpgme_data, dh);
|
84
|
+
|
85
|
+
#define WRAP_GPGME_CTX(ctx) \
|
86
|
+
Data_Wrap_Struct(cCtx, 0, gpgme_release, ctx) \
|
87
|
+
/* `gpgme_ctx_t' is typedef'ed as `struct gpgme_context *'. */
|
88
|
+
#define UNWRAP_GPGME_CTX(vctx, ctx) \
|
89
|
+
Data_Get_Struct(vctx, struct gpgme_context, ctx)
|
90
|
+
|
91
|
+
#define WRAP_GPGME_KEY(key) \
|
92
|
+
Data_Wrap_Struct(cKey, 0, gpgme_key_release, key) \
|
93
|
+
/* `gpgme_key_t' is typedef'ed as `struct _gpgme_key *'. */
|
94
|
+
#define UNWRAP_GPGME_KEY(vkey, key) \
|
95
|
+
Data_Get_Struct(vkey, struct _gpgme_key, key)
|
96
|
+
|
97
|
+
#define WRAP_GPGME_TRUST_ITEM(item) \
|
98
|
+
Data_Wrap_Struct(cTrustItem, 0, gpgme_trust_item_unref, item) \
|
99
|
+
/* `gpgme_trust_item_t' is typedef'ed as `struct _gpgme_trust_item *'. */
|
100
|
+
#define UNWRAP_GPGME_TRUST_ITEM(vitem, item) \
|
101
|
+
Data_Get_Struct(vitem, struct _gpgme_trust_item, item)
|
102
|
+
|
103
|
+
static VALUE cEngineInfo,
|
104
|
+
cCtx,
|
105
|
+
cData,
|
106
|
+
cKey,
|
107
|
+
cSubKey,
|
108
|
+
cUserID,
|
109
|
+
cKeySig,
|
110
|
+
cInvalidKey,
|
111
|
+
cNewSignature,
|
112
|
+
cSignature,
|
113
|
+
cSigNotation,
|
114
|
+
cTrustItem,
|
115
|
+
cDecryptResult,
|
116
|
+
cVerifyResult,
|
117
|
+
cSignResult,
|
118
|
+
cEncryptResult,
|
119
|
+
cImportStatus,
|
120
|
+
cImportResult;
|
121
|
+
|
122
|
+
static VALUE
|
123
|
+
rb_s_gpgme_check_version (VALUE dummy, VALUE vreq)
|
124
|
+
{
|
125
|
+
const char *result = gpgme_check_version (NIL_P(vreq) ? NULL :
|
126
|
+
StringValueCStr(vreq));
|
127
|
+
return result ? rb_str_new2 (result) : Qnil;
|
128
|
+
}
|
129
|
+
|
130
|
+
static VALUE
|
131
|
+
rb_s_gpgme_engine_check_version (VALUE dummy, VALUE vproto)
|
132
|
+
{
|
133
|
+
gpgme_error_t err = gpgme_engine_check_version (NUM2INT(vproto));
|
134
|
+
return LONG2NUM(err);
|
135
|
+
}
|
136
|
+
|
137
|
+
static VALUE
|
138
|
+
rb_s_gpgme_get_engine_info (VALUE dummy, VALUE rinfo)
|
139
|
+
{
|
140
|
+
gpgme_engine_info_t info;
|
141
|
+
gpgme_error_t err;
|
142
|
+
|
143
|
+
err = gpgme_get_engine_info (&info);
|
144
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
145
|
+
{
|
146
|
+
for (; info; info = info->next)
|
147
|
+
{
|
148
|
+
VALUE vinfo = rb_class_new_instance (0, NULL, cEngineInfo);
|
149
|
+
rb_iv_set (vinfo, "@protocol", INT2FIX(info->protocol));
|
150
|
+
if (info->file_name)
|
151
|
+
rb_iv_set (vinfo, "@file_name", rb_str_new2 (info->file_name));
|
152
|
+
if (info->version)
|
153
|
+
rb_iv_set (vinfo, "@version", rb_str_new2 (info->version));
|
154
|
+
if (info->req_version)
|
155
|
+
rb_iv_set (vinfo, "@req_version", rb_str_new2 (info->req_version));
|
156
|
+
rb_ary_store (rinfo, 0, vinfo);
|
157
|
+
}
|
158
|
+
}
|
159
|
+
return LONG2NUM(err);
|
160
|
+
}
|
161
|
+
|
162
|
+
static VALUE
|
163
|
+
rb_s_gpgme_pubkey_algo_name (VALUE dummy, VALUE valgo)
|
164
|
+
{
|
165
|
+
const char *name = gpgme_pubkey_algo_name (NUM2INT(valgo));
|
166
|
+
if (name)
|
167
|
+
return rb_str_new2 (name);
|
168
|
+
return Qnil;
|
169
|
+
}
|
170
|
+
|
171
|
+
static VALUE
|
172
|
+
rb_s_gpgme_hash_algo_name (VALUE dummy, VALUE valgo)
|
173
|
+
{
|
174
|
+
const char *name = gpgme_hash_algo_name (NUM2INT(valgo));
|
175
|
+
if (name)
|
176
|
+
return rb_str_new2 (name);
|
177
|
+
return Qnil;
|
178
|
+
}
|
179
|
+
|
180
|
+
static VALUE
|
181
|
+
rb_s_gpgme_err_code (VALUE dummy, VALUE verr)
|
182
|
+
{
|
183
|
+
return INT2FIX(gpgme_err_code (NUM2LONG(verr)));
|
184
|
+
}
|
185
|
+
|
186
|
+
static VALUE
|
187
|
+
rb_s_gpgme_err_source (VALUE dummy, VALUE verr)
|
188
|
+
{
|
189
|
+
return INT2FIX(gpgme_err_source (NUM2LONG(verr)));
|
190
|
+
}
|
191
|
+
|
192
|
+
static VALUE
|
193
|
+
rb_s_gpgme_strerror (VALUE dummy, VALUE verr)
|
194
|
+
{
|
195
|
+
return rb_str_new2 (gpgme_strerror (NUM2LONG(verr)));
|
196
|
+
}
|
197
|
+
|
198
|
+
static VALUE
|
199
|
+
rb_s_gpgme_data_new (VALUE dummy, VALUE rdh)
|
200
|
+
{
|
201
|
+
gpgme_data_t dh;
|
202
|
+
gpgme_error_t err = gpgme_data_new (&dh);
|
203
|
+
|
204
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
205
|
+
rb_ary_store (rdh, 0, WRAP_GPGME_DATA(dh));
|
206
|
+
return LONG2NUM(err);
|
207
|
+
}
|
208
|
+
|
209
|
+
static VALUE
|
210
|
+
rb_s_gpgme_data_new_from_mem (VALUE dummy, VALUE rdh, VALUE vbuffer,
|
211
|
+
VALUE vsize)
|
212
|
+
{
|
213
|
+
gpgme_data_t dh;
|
214
|
+
VALUE vdh;
|
215
|
+
size_t size = NUM2UINT(vsize);
|
216
|
+
gpgme_error_t err;
|
217
|
+
|
218
|
+
if (RSTRING_LEN(vbuffer) < size)
|
219
|
+
rb_raise (rb_eArgError, "argument out of range");
|
220
|
+
|
221
|
+
err = gpgme_data_new_from_mem (&dh, StringValuePtr(vbuffer), size, 1);
|
222
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
223
|
+
{
|
224
|
+
vdh = WRAP_GPGME_DATA(dh);
|
225
|
+
rb_ary_store (rdh, 0, vdh);
|
226
|
+
}
|
227
|
+
return LONG2NUM(err);
|
228
|
+
}
|
229
|
+
|
230
|
+
static VALUE
|
231
|
+
rb_s_gpgme_data_new_from_fd (VALUE dummy, VALUE rdh, VALUE vfd)
|
232
|
+
{
|
233
|
+
gpgme_data_t dh;
|
234
|
+
gpgme_error_t err = gpgme_data_new_from_fd (&dh, NUM2INT(vfd));
|
235
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
236
|
+
rb_ary_store (rdh, 0, WRAP_GPGME_DATA(dh));
|
237
|
+
return LONG2NUM(err);
|
238
|
+
}
|
239
|
+
|
240
|
+
static ssize_t
|
241
|
+
read_cb (void *handle, void *buffer, size_t size)
|
242
|
+
{
|
243
|
+
VALUE vcb = (VALUE)handle, vcbs, vhook_value, vbuffer;
|
244
|
+
|
245
|
+
vcbs = RARRAY(vcb)->ptr[0];
|
246
|
+
vhook_value = RARRAY(vcb)->ptr[1];
|
247
|
+
|
248
|
+
vbuffer = rb_funcall (vcbs, rb_intern ("read"), 2, vhook_value,
|
249
|
+
LONG2NUM(size));
|
250
|
+
if (NIL_P(vbuffer))
|
251
|
+
return 0;
|
252
|
+
memcpy (buffer, StringValuePtr(vbuffer), RSTRING_LEN(vbuffer));
|
253
|
+
return RSTRING_LEN(vbuffer);
|
254
|
+
}
|
255
|
+
|
256
|
+
static ssize_t
|
257
|
+
write_cb (void *handle, const void *buffer, size_t size)
|
258
|
+
{
|
259
|
+
VALUE vcb = (VALUE)handle, vcbs, vhook_value, vbuffer, vnwrite;
|
260
|
+
|
261
|
+
vcbs = RARRAY(vcb)->ptr[0];
|
262
|
+
vhook_value = RARRAY(vcb)->ptr[1];
|
263
|
+
vbuffer = rb_str_new (buffer, size);
|
264
|
+
|
265
|
+
vnwrite = rb_funcall (vcbs, rb_intern ("write"), 3,
|
266
|
+
vhook_value, vbuffer, LONG2NUM(size));
|
267
|
+
return NUM2LONG(vnwrite);
|
268
|
+
}
|
269
|
+
|
270
|
+
static off_t
|
271
|
+
seek_cb (void *handle, off_t offset, int whence)
|
272
|
+
{
|
273
|
+
VALUE vcb = (VALUE)handle, vcbs, vhook_value, vpos;
|
274
|
+
ID id_seek = rb_intern ("seek");
|
275
|
+
|
276
|
+
vcbs = RARRAY(vcb)->ptr[0];
|
277
|
+
vhook_value = RARRAY(vcb)->ptr[1];
|
278
|
+
|
279
|
+
if (rb_respond_to (vcbs, id_seek))
|
280
|
+
{
|
281
|
+
vpos = rb_funcall (vcbs, id_seek, 3,
|
282
|
+
vhook_value, LONG2NUM(offset), INT2FIX(whence));
|
283
|
+
return NUM2LONG(vpos);
|
284
|
+
}
|
285
|
+
errno = ENOSYS;
|
286
|
+
return -1;
|
287
|
+
}
|
288
|
+
|
289
|
+
static struct gpgme_data_cbs cbs =
|
290
|
+
{
|
291
|
+
.read = read_cb,
|
292
|
+
.write = write_cb,
|
293
|
+
.seek = seek_cb,
|
294
|
+
.release = NULL
|
295
|
+
};
|
296
|
+
|
297
|
+
static VALUE
|
298
|
+
rb_s_gpgme_data_new_from_cbs (VALUE dummy, VALUE rdh, VALUE vcbs,
|
299
|
+
VALUE vhandle)
|
300
|
+
{
|
301
|
+
gpgme_data_t dh;
|
302
|
+
gpgme_error_t err;
|
303
|
+
VALUE vcbs_handle = rb_ary_new ();
|
304
|
+
|
305
|
+
rb_ary_push (vcbs_handle, vcbs);
|
306
|
+
rb_ary_push (vcbs_handle, vhandle);
|
307
|
+
|
308
|
+
err = gpgme_data_new_from_cbs (&dh, &cbs, (void*)vcbs_handle);
|
309
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
310
|
+
{
|
311
|
+
VALUE vdh = WRAP_GPGME_DATA(dh);
|
312
|
+
/* Keep a reference to avoid GC. */
|
313
|
+
rb_iv_set (vdh, "@cbs_handle", vcbs_handle);
|
314
|
+
rb_ary_store (rdh, 0, vdh);
|
315
|
+
}
|
316
|
+
return LONG2NUM(err);
|
317
|
+
}
|
318
|
+
|
319
|
+
static VALUE
|
320
|
+
rb_s_gpgme_data_read (VALUE dummy, VALUE vdh, VALUE vlength)
|
321
|
+
{
|
322
|
+
gpgme_data_t dh;
|
323
|
+
ssize_t length = NUM2LONG(vlength), nread;
|
324
|
+
void *buffer;
|
325
|
+
VALUE vbuffer = Qnil;
|
326
|
+
|
327
|
+
UNWRAP_GPGME_DATA(vdh, dh);
|
328
|
+
|
329
|
+
buffer = ALLOC_N (char, length);
|
330
|
+
nread = gpgme_data_read (dh, buffer, length);
|
331
|
+
if (nread > 0)
|
332
|
+
vbuffer = rb_str_new (buffer, nread);
|
333
|
+
xfree (buffer);
|
334
|
+
if (nread < 0)
|
335
|
+
rb_sys_fail ("rb_s_gpgme_data_read");
|
336
|
+
return vbuffer;
|
337
|
+
}
|
338
|
+
|
339
|
+
static VALUE
|
340
|
+
rb_s_gpgme_data_seek (VALUE dummy, VALUE vdh, VALUE voffset, VALUE vwhence)
|
341
|
+
{
|
342
|
+
gpgme_data_t dh;
|
343
|
+
off_t pos;
|
344
|
+
|
345
|
+
UNWRAP_GPGME_DATA(vdh, dh);
|
346
|
+
pos = gpgme_data_seek (dh, NUM2LONG(voffset), NUM2INT(vwhence));
|
347
|
+
if (pos < 0)
|
348
|
+
rb_sys_fail ("rb_s_gpgme_data_seek");
|
349
|
+
return LONG2NUM(pos);
|
350
|
+
}
|
351
|
+
|
352
|
+
static VALUE
|
353
|
+
rb_s_gpgme_data_write (VALUE dummy, VALUE vdh, VALUE vbuf, VALUE vlen)
|
354
|
+
{
|
355
|
+
gpgme_data_t dh;
|
356
|
+
ssize_t nwrite;
|
357
|
+
|
358
|
+
UNWRAP_GPGME_DATA(vdh, dh);
|
359
|
+
nwrite = gpgme_data_write (dh, StringValuePtr(vbuf), NUM2UINT(vlen));
|
360
|
+
if (nwrite < 0)
|
361
|
+
rb_sys_fail ("rb_s_gpgme_data_write");
|
362
|
+
return LONG2NUM(nwrite);
|
363
|
+
}
|
364
|
+
|
365
|
+
static VALUE
|
366
|
+
rb_s_gpgme_data_get_encoding (VALUE dummy, VALUE vdh)
|
367
|
+
{
|
368
|
+
gpgme_data_t dh;
|
369
|
+
gpgme_error_t err;
|
370
|
+
|
371
|
+
UNWRAP_GPGME_DATA(vdh, dh);
|
372
|
+
err = gpgme_data_get_encoding (dh);
|
373
|
+
return LONG2NUM(err);
|
374
|
+
}
|
375
|
+
|
376
|
+
static VALUE
|
377
|
+
rb_s_gpgme_data_set_encoding (VALUE dummy, VALUE vdh, VALUE venc)
|
378
|
+
{
|
379
|
+
gpgme_data_t dh;
|
380
|
+
gpgme_error_t err;
|
381
|
+
|
382
|
+
UNWRAP_GPGME_DATA(vdh, dh);
|
383
|
+
err = gpgme_data_set_encoding (dh, NUM2INT(venc));
|
384
|
+
return LONG2NUM(err);
|
385
|
+
}
|
386
|
+
|
387
|
+
static VALUE
|
388
|
+
rb_s_gpgme_new (VALUE dummy, VALUE rctx)
|
389
|
+
{
|
390
|
+
gpgme_ctx_t ctx;
|
391
|
+
gpgme_error_t err = gpgme_new (&ctx);
|
392
|
+
|
393
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
394
|
+
rb_ary_store (rctx, 0, WRAP_GPGME_CTX(ctx));
|
395
|
+
return LONG2NUM(err);
|
396
|
+
}
|
397
|
+
|
398
|
+
static VALUE
|
399
|
+
rb_s_gpgme_set_protocol (VALUE dummy, VALUE vctx, VALUE vproto)
|
400
|
+
{
|
401
|
+
gpgme_ctx_t ctx;
|
402
|
+
gpgme_error_t err;
|
403
|
+
|
404
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
405
|
+
err = gpgme_set_protocol (ctx, NUM2INT(vproto));
|
406
|
+
return LONG2NUM(err);
|
407
|
+
}
|
408
|
+
|
409
|
+
static VALUE
|
410
|
+
rb_s_gpgme_get_protocol (VALUE dummy, VALUE vctx)
|
411
|
+
{
|
412
|
+
gpgme_ctx_t ctx;
|
413
|
+
gpgme_protocol_t proto;
|
414
|
+
|
415
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
416
|
+
proto = gpgme_get_protocol (ctx);
|
417
|
+
return INT2FIX(proto);
|
418
|
+
}
|
419
|
+
|
420
|
+
static VALUE
|
421
|
+
rb_s_gpgme_set_armor (VALUE dummy, VALUE vctx, VALUE vyes)
|
422
|
+
{
|
423
|
+
gpgme_ctx_t ctx;
|
424
|
+
|
425
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
426
|
+
gpgme_set_armor (ctx, NUM2INT(vyes));
|
427
|
+
|
428
|
+
return Qnil;
|
429
|
+
}
|
430
|
+
|
431
|
+
static VALUE
|
432
|
+
rb_s_gpgme_get_armor (VALUE dummy, VALUE vctx)
|
433
|
+
{
|
434
|
+
gpgme_ctx_t ctx;
|
435
|
+
int yes;
|
436
|
+
|
437
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
438
|
+
yes = gpgme_get_armor (ctx);
|
439
|
+
return INT2FIX(yes);
|
440
|
+
}
|
441
|
+
|
442
|
+
static VALUE
|
443
|
+
rb_s_gpgme_set_textmode (VALUE dummy, VALUE vctx, VALUE vyes)
|
444
|
+
{
|
445
|
+
gpgme_ctx_t ctx;
|
446
|
+
|
447
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
448
|
+
gpgme_set_textmode (ctx, NUM2INT(vyes));
|
449
|
+
return Qnil;
|
450
|
+
}
|
451
|
+
|
452
|
+
static VALUE
|
453
|
+
rb_s_gpgme_get_textmode (VALUE dummy, VALUE vctx)
|
454
|
+
{
|
455
|
+
gpgme_ctx_t ctx;
|
456
|
+
int yes;
|
457
|
+
|
458
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
459
|
+
yes = gpgme_get_textmode (ctx);
|
460
|
+
return INT2FIX(yes);
|
461
|
+
}
|
462
|
+
|
463
|
+
static VALUE
|
464
|
+
rb_s_gpgme_set_include_certs (VALUE dummy, VALUE vctx, VALUE vnr_of_certs)
|
465
|
+
{
|
466
|
+
gpgme_ctx_t ctx;
|
467
|
+
|
468
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
469
|
+
gpgme_set_include_certs (ctx, NUM2INT(vnr_of_certs));
|
470
|
+
return Qnil;
|
471
|
+
}
|
472
|
+
|
473
|
+
static VALUE
|
474
|
+
rb_s_gpgme_get_include_certs (VALUE dummy, VALUE vctx)
|
475
|
+
{
|
476
|
+
gpgme_ctx_t ctx;
|
477
|
+
gpgme_error_t err;
|
478
|
+
|
479
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
480
|
+
err = gpgme_get_include_certs (ctx);
|
481
|
+
return LONG2NUM(err);
|
482
|
+
}
|
483
|
+
|
484
|
+
static VALUE
|
485
|
+
rb_s_gpgme_set_keylist_mode (VALUE dummy, VALUE vctx, VALUE vmode)
|
486
|
+
{
|
487
|
+
gpgme_ctx_t ctx;
|
488
|
+
gpgme_error_t err;
|
489
|
+
|
490
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
491
|
+
err = gpgme_set_keylist_mode (ctx, NUM2INT(vmode));
|
492
|
+
return LONG2NUM(err);
|
493
|
+
}
|
494
|
+
|
495
|
+
static VALUE
|
496
|
+
rb_s_gpgme_get_keylist_mode (VALUE dummy, VALUE vctx)
|
497
|
+
{
|
498
|
+
gpgme_ctx_t ctx;
|
499
|
+
int mode;
|
500
|
+
|
501
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
502
|
+
mode = gpgme_get_keylist_mode (ctx);
|
503
|
+
return INT2FIX(mode);
|
504
|
+
}
|
505
|
+
|
506
|
+
static gpgme_error_t
|
507
|
+
passphrase_cb (void *hook, const char *uid_hint, const char *passphrase_info,
|
508
|
+
int prev_was_bad, int fd)
|
509
|
+
{
|
510
|
+
VALUE vcb = (VALUE)hook, vpassfunc, vhook_value;
|
511
|
+
|
512
|
+
vpassfunc = RARRAY(vcb)->ptr[0];
|
513
|
+
vhook_value = RARRAY(vcb)->ptr[1];
|
514
|
+
|
515
|
+
rb_funcall (vpassfunc, rb_intern ("call"), 5,
|
516
|
+
vhook_value,
|
517
|
+
uid_hint ? rb_str_new2 (uid_hint) : Qnil,
|
518
|
+
passphrase_info ? rb_str_new2 (passphrase_info) : Qnil,
|
519
|
+
INT2FIX(prev_was_bad),
|
520
|
+
INT2NUM(fd));
|
521
|
+
return gpgme_err_make (GPG_ERR_SOURCE_USER_1, GPG_ERR_NO_ERROR);
|
522
|
+
}
|
523
|
+
|
524
|
+
static VALUE
|
525
|
+
rb_s_gpgme_set_passphrase_cb (VALUE dummy, VALUE vctx, VALUE vpassfunc,
|
526
|
+
VALUE vhook_value)
|
527
|
+
{
|
528
|
+
gpgme_ctx_t ctx;
|
529
|
+
VALUE vcb = rb_ary_new ();
|
530
|
+
|
531
|
+
rb_ary_push (vcb, vpassfunc);
|
532
|
+
rb_ary_push (vcb, vhook_value);
|
533
|
+
/* Keep a reference to avoid GC. */
|
534
|
+
rb_iv_set (vctx, "@passphrase_cb", vcb);
|
535
|
+
|
536
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
537
|
+
gpgme_set_passphrase_cb (ctx, passphrase_cb, (void*)vcb);
|
538
|
+
return Qnil;
|
539
|
+
}
|
540
|
+
|
541
|
+
static VALUE
|
542
|
+
rb_s_gpgme_get_passphrase_cb (VALUE dummy, VALUE vctx, VALUE rpassfunc,
|
543
|
+
VALUE rhook_value)
|
544
|
+
{
|
545
|
+
VALUE vcb = rb_iv_get (vctx, "@passphrase_cb");
|
546
|
+
|
547
|
+
/* No need to call gpgme_get_passphrase_cb. */
|
548
|
+
rb_ary_store (rpassfunc, 0, RARRAY(vcb)->ptr[0]);
|
549
|
+
rb_ary_store (rhook_value, 0, RARRAY(vcb)->ptr[1]);
|
550
|
+
return Qnil;
|
551
|
+
}
|
552
|
+
|
553
|
+
static void
|
554
|
+
progress_cb (void *hook, const char *what, int type, int current, int total)
|
555
|
+
{
|
556
|
+
VALUE vcb = (VALUE)hook, vprogfunc, vhook_value;
|
557
|
+
|
558
|
+
vprogfunc = RARRAY(vcb)->ptr[0];
|
559
|
+
vhook_value = RARRAY(vcb)->ptr[1];
|
560
|
+
|
561
|
+
rb_funcall (vprogfunc, rb_intern ("call"), 5, vhook_value,
|
562
|
+
rb_str_new2 (what), INT2NUM(type), INT2NUM(current),
|
563
|
+
INT2NUM(total));
|
564
|
+
}
|
565
|
+
|
566
|
+
static VALUE
|
567
|
+
rb_s_gpgme_set_progress_cb (VALUE dummy, VALUE vctx, VALUE vprogfunc,
|
568
|
+
VALUE vhook_value)
|
569
|
+
{
|
570
|
+
gpgme_ctx_t ctx;
|
571
|
+
VALUE vcb = rb_ary_new ();
|
572
|
+
|
573
|
+
rb_ary_push (vcb, vprogfunc);
|
574
|
+
rb_ary_push (vcb, vhook_value);
|
575
|
+
/* Keep a reference to avoid GC. */
|
576
|
+
rb_iv_set (vctx, "@progress_cb", vcb);
|
577
|
+
|
578
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
579
|
+
gpgme_set_progress_cb (ctx, progress_cb, (void*)vcb);
|
580
|
+
|
581
|
+
return Qnil;
|
582
|
+
}
|
583
|
+
|
584
|
+
static VALUE
|
585
|
+
rb_s_gpgme_get_progress_cb (VALUE dummy, VALUE vctx, VALUE rprogfunc,
|
586
|
+
VALUE rhook_value)
|
587
|
+
{
|
588
|
+
VALUE vcb = rb_iv_get (vctx, "@progress_cb");
|
589
|
+
rb_ary_store (rprogfunc, 0, RARRAY(vcb)->ptr[0]);
|
590
|
+
rb_ary_store (rhook_value, 0, RARRAY(vcb)->ptr[1]);
|
591
|
+
return Qnil;
|
592
|
+
}
|
593
|
+
|
594
|
+
static VALUE
|
595
|
+
rb_s_gpgme_set_locale (VALUE dummy, VALUE vctx, VALUE vcategory, VALUE vvalue)
|
596
|
+
{
|
597
|
+
gpgme_ctx_t ctx;
|
598
|
+
gpgme_error_t err;
|
599
|
+
|
600
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
601
|
+
|
602
|
+
err = gpgme_set_locale (ctx, NUM2INT(vcategory), StringValueCStr(vvalue));
|
603
|
+
return LONG2NUM(err);
|
604
|
+
}
|
605
|
+
|
606
|
+
static VALUE
|
607
|
+
rb_s_gpgme_op_keylist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
|
608
|
+
VALUE vsecret_only)
|
609
|
+
{
|
610
|
+
gpgme_ctx_t ctx;
|
611
|
+
gpgme_error_t err;
|
612
|
+
|
613
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
614
|
+
|
615
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
616
|
+
|
617
|
+
err = gpgme_op_keylist_start (ctx, NIL_P(vpattern) ? NULL :
|
618
|
+
StringValueCStr(vpattern),
|
619
|
+
NUM2INT(vsecret_only));
|
620
|
+
if (gpgme_err_code (err) == GPG_ERR_NO_ERROR)
|
621
|
+
SET_KEYLIST_IN_PROGRESS(vctx);
|
622
|
+
return LONG2NUM(err);
|
623
|
+
}
|
624
|
+
|
625
|
+
static VALUE
|
626
|
+
rb_s_gpgme_op_keylist_ext_start (VALUE dummy, VALUE vctx, VALUE vpattern,
|
627
|
+
VALUE vsecret_only)
|
628
|
+
{
|
629
|
+
gpgme_ctx_t ctx;
|
630
|
+
const char **pattern = NULL;
|
631
|
+
int i, err;
|
632
|
+
|
633
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
634
|
+
|
635
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
636
|
+
|
637
|
+
if (!NIL_P(vpattern))
|
638
|
+
{
|
639
|
+
/* Convert RARRAY into `const char *' array. */
|
640
|
+
pattern = ALLOC_N(const char *, RARRAY_LEN(vpattern) + 1);
|
641
|
+
for (i = 0; i<RARRAY_LEN(vpattern); i++)
|
642
|
+
pattern[i] = StringValueCStr(RARRAY_PTR(vpattern)[i]);
|
643
|
+
pattern[RARRAY_LEN(vpattern)] = NULL;
|
644
|
+
}
|
645
|
+
|
646
|
+
err = gpgme_op_keylist_ext_start (ctx, pattern, NUM2INT(vsecret_only), 0);
|
647
|
+
if (gpgme_err_code (err) == GPG_ERR_NO_ERROR)
|
648
|
+
SET_KEYLIST_IN_PROGRESS(vctx);
|
649
|
+
if (pattern)
|
650
|
+
xfree (pattern);
|
651
|
+
return LONG2NUM(err);
|
652
|
+
}
|
653
|
+
|
654
|
+
static VALUE
|
655
|
+
save_gpgme_key_attrs (VALUE vkey, gpgme_key_t key)
|
656
|
+
{
|
657
|
+
VALUE vsubkeys, vuids;
|
658
|
+
gpgme_subkey_t subkey;
|
659
|
+
gpgme_user_id_t user_id;
|
660
|
+
|
661
|
+
rb_iv_set (vkey, "@keylist_mode", INT2FIX(key->keylist_mode));
|
662
|
+
rb_iv_set (vkey, "@revoked", INT2FIX(key->revoked));
|
663
|
+
rb_iv_set (vkey, "@expired", INT2FIX(key->expired));
|
664
|
+
rb_iv_set (vkey, "@disabled", INT2FIX(key->disabled));
|
665
|
+
rb_iv_set (vkey, "@invalid", INT2FIX(key->invalid));
|
666
|
+
rb_iv_set (vkey, "@can_encrypt", INT2FIX(key->can_encrypt));
|
667
|
+
rb_iv_set (vkey, "@can_sign", INT2FIX(key->can_sign));
|
668
|
+
rb_iv_set (vkey, "@can_certify", INT2FIX(key->can_certify));
|
669
|
+
rb_iv_set (vkey, "@can_authenticate", INT2FIX(key->can_authenticate));
|
670
|
+
rb_iv_set (vkey, "@secret", INT2FIX(key->secret));
|
671
|
+
rb_iv_set (vkey, "@protocol", INT2FIX(key->protocol));
|
672
|
+
if (key->issuer_serial)
|
673
|
+
rb_iv_set (vkey, "@issuer_serial", rb_str_new2 (key->issuer_serial));
|
674
|
+
if (key->issuer_name)
|
675
|
+
rb_iv_set (vkey, "@issuer_name", rb_str_new2 (key->issuer_name));
|
676
|
+
if (key->chain_id)
|
677
|
+
rb_iv_set (vkey, "@chain_id", rb_str_new2 (key->chain_id));
|
678
|
+
rb_iv_set (vkey, "@owner_trust", INT2FIX(key->owner_trust));
|
679
|
+
vsubkeys = rb_ary_new ();
|
680
|
+
rb_iv_set (vkey, "@subkeys", vsubkeys);
|
681
|
+
for (subkey = key->subkeys; subkey; subkey = subkey->next)
|
682
|
+
{
|
683
|
+
VALUE vsubkey = rb_class_new_instance(0, NULL, cSubKey);
|
684
|
+
rb_iv_set (vsubkey, "@revoked", INT2FIX(subkey->revoked));
|
685
|
+
rb_iv_set (vsubkey, "@expired", INT2FIX(subkey->expired));
|
686
|
+
rb_iv_set (vsubkey, "@disabled", INT2FIX(subkey->disabled));
|
687
|
+
rb_iv_set (vsubkey, "@invalid", INT2FIX(subkey->invalid));
|
688
|
+
rb_iv_set (vsubkey, "@can_encrypt", INT2FIX(subkey->can_encrypt));
|
689
|
+
rb_iv_set (vsubkey, "@can_sign", INT2FIX(subkey->can_sign));
|
690
|
+
rb_iv_set (vsubkey, "@can_certify", INT2FIX(subkey->can_certify));
|
691
|
+
rb_iv_set (vsubkey, "@can_authenticate",
|
692
|
+
INT2FIX(subkey->can_authenticate));
|
693
|
+
rb_iv_set (vsubkey, "@secret", INT2FIX(subkey->secret));
|
694
|
+
rb_iv_set (vsubkey, "@pubkey_algo", INT2FIX(subkey->pubkey_algo));
|
695
|
+
rb_iv_set (vsubkey, "@length", UINT2NUM(subkey->length));
|
696
|
+
rb_iv_set (vsubkey, "@keyid", rb_str_new2 (subkey->keyid));
|
697
|
+
if (subkey->fpr)
|
698
|
+
rb_iv_set (vsubkey, "@fpr", rb_str_new2 (subkey->fpr));
|
699
|
+
rb_iv_set (vsubkey, "@timestamp", LONG2NUM(subkey->timestamp));
|
700
|
+
rb_iv_set (vsubkey, "@expires", LONG2NUM(subkey->expires));
|
701
|
+
rb_ary_push (vsubkeys, vsubkey);
|
702
|
+
}
|
703
|
+
vuids = rb_ary_new ();
|
704
|
+
rb_iv_set (vkey, "@uids", vuids);
|
705
|
+
for (user_id = key->uids; user_id; user_id = user_id->next)
|
706
|
+
{
|
707
|
+
VALUE vuser_id = rb_class_new_instance(0, NULL, cUserID), vsignatures;
|
708
|
+
rb_iv_set (vuser_id, "@revoked", INT2FIX(user_id->revoked));
|
709
|
+
rb_iv_set (vuser_id, "@invalid", INT2FIX(user_id->invalid));
|
710
|
+
rb_iv_set (vuser_id, "@validity", INT2FIX(user_id->validity));
|
711
|
+
rb_iv_set (vuser_id, "@uid", rb_str_new2 (user_id->uid));
|
712
|
+
rb_iv_set (vuser_id, "@name", rb_str_new2 (user_id->name));
|
713
|
+
rb_iv_set (vuser_id, "@comment", rb_str_new2 (user_id->comment));
|
714
|
+
rb_iv_set (vuser_id, "@email", rb_str_new2 (user_id->email));
|
715
|
+
|
716
|
+
vsignatures = rb_ary_new ();
|
717
|
+
rb_iv_set (vuser_id, "@signatures", vsignatures);
|
718
|
+
gpgme_key_sig_t key_sig;
|
719
|
+
for (key_sig = user_id->signatures; key_sig; key_sig = key_sig->next)
|
720
|
+
{
|
721
|
+
VALUE vkey_sig = rb_class_new_instance(0, NULL, cKeySig);
|
722
|
+
rb_iv_set (vkey_sig, "@revoked", INT2FIX(key_sig->revoked));
|
723
|
+
rb_iv_set (vkey_sig, "@expired", INT2FIX(key_sig->expired));
|
724
|
+
rb_iv_set (vkey_sig, "@invalid", INT2FIX(key_sig->invalid));
|
725
|
+
rb_iv_set (vkey_sig, "@exportable", INT2FIX(key_sig->exportable));
|
726
|
+
rb_iv_set (vkey_sig, "@pubkey_algo", INT2FIX(key_sig->pubkey_algo));
|
727
|
+
rb_iv_set (vkey_sig, "@keyid", rb_str_new2 (key_sig->keyid));
|
728
|
+
rb_iv_set (vkey_sig, "@timestamp", LONG2NUM(key_sig->timestamp));
|
729
|
+
rb_iv_set (vkey_sig, "@expires", LONG2NUM(key_sig->expires));
|
730
|
+
rb_ary_push (vsignatures, vkey_sig);
|
731
|
+
}
|
732
|
+
rb_ary_push (vuids, vuser_id);
|
733
|
+
}
|
734
|
+
return vkey;
|
735
|
+
}
|
736
|
+
|
737
|
+
static VALUE
|
738
|
+
rb_s_gpgme_op_keylist_next (VALUE dummy, VALUE vctx, VALUE rkey)
|
739
|
+
{
|
740
|
+
gpgme_ctx_t ctx;
|
741
|
+
gpgme_key_t key;
|
742
|
+
gpgme_error_t err;
|
743
|
+
|
744
|
+
CHECK_KEYLIST_IN_PROGRESS(vctx);
|
745
|
+
|
746
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
747
|
+
|
748
|
+
err = gpgme_op_keylist_next (ctx, &key);
|
749
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
750
|
+
{
|
751
|
+
VALUE vkey = WRAP_GPGME_KEY(key);
|
752
|
+
save_gpgme_key_attrs (vkey, key);
|
753
|
+
rb_ary_store (rkey, 0, vkey);
|
754
|
+
}
|
755
|
+
return LONG2NUM(err);
|
756
|
+
}
|
757
|
+
|
758
|
+
static VALUE
|
759
|
+
rb_s_gpgme_op_keylist_end (VALUE dummy, VALUE vctx)
|
760
|
+
{
|
761
|
+
gpgme_ctx_t ctx;
|
762
|
+
gpgme_error_t err;
|
763
|
+
|
764
|
+
CHECK_KEYLIST_IN_PROGRESS(vctx);
|
765
|
+
|
766
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
767
|
+
|
768
|
+
err = gpgme_op_keylist_end (ctx);
|
769
|
+
RESET_KEYLIST_IN_PROGRESS(vctx);
|
770
|
+
return LONG2NUM(err);
|
771
|
+
}
|
772
|
+
|
773
|
+
static VALUE
|
774
|
+
rb_s_gpgme_get_key (VALUE dummy, VALUE vctx, VALUE vfpr, VALUE rkey,
|
775
|
+
VALUE vsecret)
|
776
|
+
{
|
777
|
+
gpgme_ctx_t ctx;
|
778
|
+
gpgme_error_t err;
|
779
|
+
gpgme_key_t key;
|
780
|
+
|
781
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
782
|
+
err = gpgme_get_key (ctx, StringValueCStr(vfpr), &key, NUM2INT(vsecret));
|
783
|
+
|
784
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
785
|
+
{
|
786
|
+
VALUE vkey = WRAP_GPGME_KEY(key);
|
787
|
+
save_gpgme_key_attrs (vkey, key);
|
788
|
+
rb_ary_store (rkey, 0, vkey);
|
789
|
+
}
|
790
|
+
return LONG2NUM(err);
|
791
|
+
}
|
792
|
+
|
793
|
+
static VALUE
|
794
|
+
rb_s_gpgme_key_ref (VALUE dummy, VALUE vkey)
|
795
|
+
{
|
796
|
+
gpgme_key_t key;
|
797
|
+
|
798
|
+
UNWRAP_GPGME_KEY(vkey, key);
|
799
|
+
gpgme_key_ref (key);
|
800
|
+
return Qnil;
|
801
|
+
}
|
802
|
+
|
803
|
+
static VALUE
|
804
|
+
rb_s_gpgme_key_unref (VALUE dummy, VALUE vkey)
|
805
|
+
{
|
806
|
+
gpgme_key_t key;
|
807
|
+
|
808
|
+
UNWRAP_GPGME_KEY(vkey, key);
|
809
|
+
gpgme_key_unref (key);
|
810
|
+
return Qnil;
|
811
|
+
}
|
812
|
+
|
813
|
+
static VALUE
|
814
|
+
rb_s_gpgme_op_genkey (VALUE dummy, VALUE vctx, VALUE vparms, VALUE vpubkey,
|
815
|
+
VALUE vseckey)
|
816
|
+
{
|
817
|
+
gpgme_ctx_t ctx;
|
818
|
+
gpgme_data_t pubkey = NULL, seckey = NULL;
|
819
|
+
gpgme_error_t err;
|
820
|
+
|
821
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
822
|
+
|
823
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
824
|
+
if (!NIL_P(vpubkey))
|
825
|
+
UNWRAP_GPGME_DATA(vpubkey, pubkey);
|
826
|
+
if (!NIL_P(vseckey))
|
827
|
+
UNWRAP_GPGME_DATA(vseckey, seckey);
|
828
|
+
|
829
|
+
err = gpgme_op_genkey (ctx, StringValueCStr(vparms), pubkey, seckey);
|
830
|
+
return LONG2NUM(err);
|
831
|
+
}
|
832
|
+
|
833
|
+
static VALUE
|
834
|
+
rb_s_gpgme_op_genkey_start (VALUE dummy, VALUE vctx, VALUE vparms,
|
835
|
+
VALUE vpubkey, VALUE vseckey)
|
836
|
+
{
|
837
|
+
gpgme_ctx_t ctx;
|
838
|
+
gpgme_data_t pubkey = NULL, seckey = NULL;
|
839
|
+
gpgme_error_t err;
|
840
|
+
|
841
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
842
|
+
|
843
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
844
|
+
if (!NIL_P(vpubkey))
|
845
|
+
UNWRAP_GPGME_DATA(vpubkey, pubkey);
|
846
|
+
if (!NIL_P(vseckey))
|
847
|
+
UNWRAP_GPGME_DATA(vseckey, seckey);
|
848
|
+
|
849
|
+
err = gpgme_op_genkey_start (ctx, StringValueCStr(vparms), pubkey, seckey);
|
850
|
+
return LONG2NUM(err);
|
851
|
+
}
|
852
|
+
|
853
|
+
static VALUE
|
854
|
+
rb_s_gpgme_op_export (VALUE dummy, VALUE vctx, VALUE vpattern, VALUE vreserved,
|
855
|
+
VALUE vkeydata)
|
856
|
+
{
|
857
|
+
gpgme_ctx_t ctx;
|
858
|
+
gpgme_data_t keydata;
|
859
|
+
gpgme_error_t err;
|
860
|
+
|
861
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
862
|
+
|
863
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
864
|
+
UNWRAP_GPGME_DATA(vkeydata, keydata);
|
865
|
+
|
866
|
+
err = gpgme_op_export (ctx, StringValueCStr(vpattern), NUM2UINT(vreserved),
|
867
|
+
keydata);
|
868
|
+
return LONG2NUM(err);
|
869
|
+
}
|
870
|
+
|
871
|
+
static VALUE
|
872
|
+
rb_s_gpgme_op_export_start (VALUE dummy, VALUE vctx, VALUE vpattern,
|
873
|
+
VALUE vreserved, VALUE vkeydata)
|
874
|
+
{
|
875
|
+
gpgme_ctx_t ctx;
|
876
|
+
gpgme_data_t keydata;
|
877
|
+
gpgme_error_t err;
|
878
|
+
|
879
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
880
|
+
|
881
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
882
|
+
UNWRAP_GPGME_DATA(vkeydata, keydata);
|
883
|
+
|
884
|
+
err = gpgme_op_export_start (ctx, StringValueCStr(vpattern),
|
885
|
+
NUM2UINT(vreserved), keydata);
|
886
|
+
return LONG2NUM(err);
|
887
|
+
}
|
888
|
+
|
889
|
+
static VALUE
|
890
|
+
rb_s_gpgme_op_import (VALUE dummy, VALUE vctx, VALUE vkeydata)
|
891
|
+
{
|
892
|
+
gpgme_ctx_t ctx;
|
893
|
+
gpgme_data_t keydata;
|
894
|
+
gpgme_error_t err;
|
895
|
+
|
896
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
897
|
+
|
898
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
899
|
+
UNWRAP_GPGME_DATA(vkeydata, keydata);
|
900
|
+
|
901
|
+
err = gpgme_op_import (ctx, keydata);
|
902
|
+
return LONG2NUM(err);
|
903
|
+
}
|
904
|
+
|
905
|
+
static VALUE
|
906
|
+
rb_s_gpgme_op_import_start (VALUE dummy, VALUE vctx, VALUE vkeydata)
|
907
|
+
{
|
908
|
+
gpgme_ctx_t ctx;
|
909
|
+
gpgme_data_t keydata;
|
910
|
+
gpgme_error_t err;
|
911
|
+
|
912
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
913
|
+
|
914
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
915
|
+
UNWRAP_GPGME_DATA(vkeydata, keydata);
|
916
|
+
|
917
|
+
err = gpgme_op_import_start (ctx, keydata);
|
918
|
+
return LONG2NUM(err);
|
919
|
+
}
|
920
|
+
|
921
|
+
static VALUE
|
922
|
+
rb_s_gpgme_op_import_result (VALUE dummy, VALUE vctx)
|
923
|
+
{
|
924
|
+
gpgme_ctx_t ctx;
|
925
|
+
gpgme_import_result_t result;
|
926
|
+
gpgme_import_status_t status;
|
927
|
+
VALUE vresult, vimports;
|
928
|
+
|
929
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
930
|
+
|
931
|
+
result = gpgme_op_import_result (ctx);
|
932
|
+
vresult = rb_class_new_instance (0, NULL, cImportResult);
|
933
|
+
rb_iv_set (vresult, "@considered", INT2NUM(result->considered));
|
934
|
+
rb_iv_set (vresult, "@no_user_id", INT2NUM(result->no_user_id));
|
935
|
+
rb_iv_set (vresult, "@imported", INT2NUM(result->imported));
|
936
|
+
rb_iv_set (vresult, "@imported_rsa", INT2NUM(result->imported_rsa));
|
937
|
+
rb_iv_set (vresult, "@unchanged", INT2NUM(result->unchanged));
|
938
|
+
rb_iv_set (vresult, "@new_user_ids", INT2NUM(result->new_user_ids));
|
939
|
+
rb_iv_set (vresult, "@new_sub_keys", INT2NUM(result->new_sub_keys));
|
940
|
+
rb_iv_set (vresult, "@new_signatures", INT2NUM(result->new_signatures));
|
941
|
+
rb_iv_set (vresult, "@new_revocations", INT2NUM(result->new_revocations));
|
942
|
+
rb_iv_set (vresult, "@secret_read", INT2NUM(result->secret_read));
|
943
|
+
rb_iv_set (vresult, "@secret_imported", INT2NUM(result->secret_imported));
|
944
|
+
rb_iv_set (vresult, "@secret_unchanged", INT2NUM(result->secret_unchanged));
|
945
|
+
rb_iv_set (vresult, "@not_imported", INT2NUM(result->not_imported));
|
946
|
+
vimports = rb_ary_new ();
|
947
|
+
rb_iv_set (vresult, "@imports", vimports);
|
948
|
+
for (status = result->imports; status;
|
949
|
+
status = status->next)
|
950
|
+
{
|
951
|
+
VALUE vstatus =
|
952
|
+
rb_class_new_instance (0, NULL, cImportStatus);
|
953
|
+
rb_iv_set (vstatus, "@fpr", rb_str_new2 (status->fpr));
|
954
|
+
rb_iv_set (vstatus, "@result", LONG2NUM(status->result));
|
955
|
+
rb_iv_set (vstatus, "@status", UINT2NUM(status->status));
|
956
|
+
rb_ary_push (vimports, vstatus);
|
957
|
+
}
|
958
|
+
return vresult;
|
959
|
+
}
|
960
|
+
|
961
|
+
static VALUE
|
962
|
+
rb_s_gpgme_op_delete (VALUE dummy, VALUE vctx, VALUE vkey, VALUE vallow_secret)
|
963
|
+
{
|
964
|
+
gpgme_ctx_t ctx;
|
965
|
+
gpgme_key_t key;
|
966
|
+
gpgme_error_t err;
|
967
|
+
|
968
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
969
|
+
|
970
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
971
|
+
UNWRAP_GPGME_KEY(vkey, key);
|
972
|
+
|
973
|
+
err = gpgme_op_delete (ctx, key, NUM2INT(vallow_secret));
|
974
|
+
return LONG2NUM(err);
|
975
|
+
}
|
976
|
+
|
977
|
+
static VALUE
|
978
|
+
rb_s_gpgme_op_delete_start (VALUE dummy, VALUE vctx, VALUE vkey,
|
979
|
+
VALUE vallow_secret)
|
980
|
+
{
|
981
|
+
gpgme_ctx_t ctx;
|
982
|
+
gpgme_key_t key;
|
983
|
+
gpgme_error_t err;
|
984
|
+
|
985
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
986
|
+
|
987
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
988
|
+
UNWRAP_GPGME_KEY(vkey, key);
|
989
|
+
|
990
|
+
err = gpgme_op_delete_start (ctx, key, NUM2INT(vallow_secret));
|
991
|
+
return LONG2NUM(err);
|
992
|
+
}
|
993
|
+
|
994
|
+
static VALUE
|
995
|
+
rb_s_gpgme_op_trustlist_start (VALUE dummy, VALUE vctx, VALUE vpattern,
|
996
|
+
VALUE vmax_level)
|
997
|
+
{
|
998
|
+
gpgme_ctx_t ctx;
|
999
|
+
gpgme_error_t err;
|
1000
|
+
|
1001
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1002
|
+
|
1003
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1004
|
+
err = gpgme_op_trustlist_start (ctx, StringValueCStr(vpattern),
|
1005
|
+
NUM2INT(vmax_level));
|
1006
|
+
return LONG2NUM(err);
|
1007
|
+
}
|
1008
|
+
|
1009
|
+
static VALUE
|
1010
|
+
rb_s_gpgme_op_trustlist_next (VALUE dummy, VALUE vctx, VALUE ritem)
|
1011
|
+
{
|
1012
|
+
gpgme_ctx_t ctx;
|
1013
|
+
gpgme_trust_item_t item;
|
1014
|
+
gpgme_error_t err;
|
1015
|
+
VALUE vitem;
|
1016
|
+
|
1017
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1018
|
+
|
1019
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1020
|
+
|
1021
|
+
err = gpgme_op_trustlist_next (ctx, &item);
|
1022
|
+
if (gpgme_err_code(err) == GPG_ERR_NO_ERROR)
|
1023
|
+
{
|
1024
|
+
vitem = WRAP_GPGME_TRUST_ITEM(item);
|
1025
|
+
rb_iv_set (vitem, "@keyid", rb_str_new2 (item->keyid));
|
1026
|
+
rb_iv_set (vitem, "@type", INT2FIX(item->type));
|
1027
|
+
rb_iv_set (vitem, "@level", INT2FIX(item->level));
|
1028
|
+
if (item->owner_trust)
|
1029
|
+
rb_iv_set (vitem, "@owner_trust", rb_str_new2 (item->owner_trust));
|
1030
|
+
rb_iv_set (vitem, "@validity", rb_str_new2 (item->validity));
|
1031
|
+
if (item->name)
|
1032
|
+
rb_iv_set (vitem, "@name", rb_str_new2 (item->name));
|
1033
|
+
rb_ary_store (ritem, 0, vitem);
|
1034
|
+
}
|
1035
|
+
return LONG2NUM(err);
|
1036
|
+
}
|
1037
|
+
|
1038
|
+
static VALUE
|
1039
|
+
rb_s_gpgme_op_trustlist_end (VALUE dummy, VALUE vctx)
|
1040
|
+
{
|
1041
|
+
gpgme_ctx_t ctx;
|
1042
|
+
gpgme_error_t err;
|
1043
|
+
|
1044
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1045
|
+
|
1046
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1047
|
+
|
1048
|
+
err = gpgme_op_trustlist_end (ctx);
|
1049
|
+
return LONG2NUM(err);
|
1050
|
+
}
|
1051
|
+
|
1052
|
+
static VALUE
|
1053
|
+
rb_s_gpgme_op_decrypt (VALUE dummy, VALUE vctx, VALUE vcipher, VALUE vplain)
|
1054
|
+
{
|
1055
|
+
gpgme_ctx_t ctx;
|
1056
|
+
gpgme_data_t cipher, plain;
|
1057
|
+
gpgme_error_t err;
|
1058
|
+
|
1059
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1060
|
+
|
1061
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1062
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1063
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1064
|
+
|
1065
|
+
err = gpgme_op_decrypt (ctx, cipher, plain);
|
1066
|
+
return LONG2NUM(err);
|
1067
|
+
}
|
1068
|
+
|
1069
|
+
static VALUE
|
1070
|
+
rb_s_gpgme_op_decrypt_start (VALUE dummy, VALUE vctx, VALUE vcipher,
|
1071
|
+
VALUE vplain)
|
1072
|
+
{
|
1073
|
+
gpgme_ctx_t ctx;
|
1074
|
+
gpgme_data_t cipher, plain;
|
1075
|
+
gpgme_error_t err;
|
1076
|
+
|
1077
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1078
|
+
|
1079
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1080
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1081
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1082
|
+
|
1083
|
+
err = gpgme_op_decrypt_start (ctx, cipher, plain);
|
1084
|
+
return LONG2NUM(err);
|
1085
|
+
}
|
1086
|
+
|
1087
|
+
static VALUE
|
1088
|
+
rb_s_gpgme_op_decrypt_result (VALUE dummy, VALUE vctx)
|
1089
|
+
{
|
1090
|
+
gpgme_ctx_t ctx;
|
1091
|
+
gpgme_decrypt_result_t result;
|
1092
|
+
VALUE vresult;
|
1093
|
+
|
1094
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1095
|
+
|
1096
|
+
result = gpgme_op_decrypt_result (ctx);
|
1097
|
+
vresult = rb_class_new_instance (0, NULL, cDecryptResult);
|
1098
|
+
if (result->unsupported_algorithm)
|
1099
|
+
rb_iv_set (vresult, "@unsupported_algorithm",
|
1100
|
+
rb_str_new2 (result->unsupported_algorithm));
|
1101
|
+
rb_iv_set (vresult, "@wrong_key_usage", INT2FIX(result->wrong_key_usage));
|
1102
|
+
return vresult;
|
1103
|
+
}
|
1104
|
+
|
1105
|
+
static VALUE
|
1106
|
+
rb_s_gpgme_op_verify (VALUE dummy, VALUE vctx, VALUE vsig, VALUE vsigned_text,
|
1107
|
+
VALUE vplain)
|
1108
|
+
{
|
1109
|
+
gpgme_ctx_t ctx;
|
1110
|
+
gpgme_data_t sig, signed_text = NULL, plain = NULL;
|
1111
|
+
gpgme_error_t err;
|
1112
|
+
|
1113
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1114
|
+
|
1115
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1116
|
+
UNWRAP_GPGME_DATA(vsig, sig);
|
1117
|
+
if (!NIL_P(vsigned_text))
|
1118
|
+
UNWRAP_GPGME_DATA(vsigned_text, signed_text);
|
1119
|
+
if (!NIL_P(vplain))
|
1120
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1121
|
+
|
1122
|
+
err = gpgme_op_verify (ctx, sig, signed_text, plain);
|
1123
|
+
return LONG2NUM(err);
|
1124
|
+
}
|
1125
|
+
|
1126
|
+
static VALUE
|
1127
|
+
rb_s_gpgme_op_verify_start (VALUE dummy, VALUE vctx, VALUE vsig,
|
1128
|
+
VALUE vsigned_text, VALUE vplain)
|
1129
|
+
{
|
1130
|
+
gpgme_ctx_t ctx;
|
1131
|
+
gpgme_data_t sig, signed_text = NULL, plain = NULL;
|
1132
|
+
gpgme_error_t err;
|
1133
|
+
|
1134
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1135
|
+
|
1136
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1137
|
+
UNWRAP_GPGME_DATA(vsig, sig);
|
1138
|
+
if (!NIL_P(vsigned_text))
|
1139
|
+
UNWRAP_GPGME_DATA(vsigned_text, signed_text);
|
1140
|
+
if (!NIL_P(vplain))
|
1141
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1142
|
+
|
1143
|
+
err = gpgme_op_verify_start (ctx, sig, signed_text, plain);
|
1144
|
+
return LONG2NUM(err);
|
1145
|
+
}
|
1146
|
+
|
1147
|
+
static VALUE
|
1148
|
+
rb_s_gpgme_op_verify_result (VALUE dummy, VALUE vctx)
|
1149
|
+
{
|
1150
|
+
gpgme_ctx_t ctx;
|
1151
|
+
gpgme_verify_result_t verify_result;
|
1152
|
+
gpgme_signature_t signature;
|
1153
|
+
VALUE vverify_result, vsignatures = rb_ary_new ();
|
1154
|
+
|
1155
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1156
|
+
|
1157
|
+
verify_result = gpgme_op_verify_result (ctx);
|
1158
|
+
vverify_result = rb_class_new_instance(0, NULL, cVerifyResult);
|
1159
|
+
rb_iv_set (vverify_result, "@signatures", vsignatures);
|
1160
|
+
for (signature = verify_result->signatures; signature;
|
1161
|
+
signature = signature->next)
|
1162
|
+
{
|
1163
|
+
VALUE vsignature = rb_class_new_instance(0, NULL, cSignature),
|
1164
|
+
vnotations = rb_ary_new ();
|
1165
|
+
gpgme_sig_notation_t notation;
|
1166
|
+
rb_iv_set (vsignature, "@summary", INT2FIX(signature->summary));
|
1167
|
+
rb_iv_set (vsignature, "@fpr", rb_str_new2 (signature->fpr));
|
1168
|
+
rb_iv_set (vsignature, "@status", LONG2NUM(signature->status));
|
1169
|
+
rb_iv_set (vsignature, "@notations", vnotations);
|
1170
|
+
for (notation = signature->notations; notation;
|
1171
|
+
notation = notation->next)
|
1172
|
+
{
|
1173
|
+
VALUE vnotation = rb_class_new_instance(0, NULL, cSigNotation);
|
1174
|
+
rb_iv_set (vnotation, "@name", rb_str_new2 (notation->name));
|
1175
|
+
rb_iv_set (vnotation, "@value", rb_str_new2 (notation->value));
|
1176
|
+
rb_ary_push (vnotations, vnotation);
|
1177
|
+
}
|
1178
|
+
rb_iv_set (vsignature, "@timestamp", ULONG2NUM(signature->timestamp));
|
1179
|
+
rb_iv_set (vsignature, "@exp_timestamp",
|
1180
|
+
ULONG2NUM(signature->exp_timestamp));
|
1181
|
+
rb_iv_set (vsignature, "@wrong_key_usage",
|
1182
|
+
INT2FIX(signature->wrong_key_usage));
|
1183
|
+
rb_iv_set (vsignature, "@validity", INT2FIX(signature->validity));
|
1184
|
+
rb_iv_set (vsignature, "@validity_reason",
|
1185
|
+
LONG2NUM(signature->validity_reason));
|
1186
|
+
rb_ary_push (vsignatures, vsignature);
|
1187
|
+
}
|
1188
|
+
return vverify_result;
|
1189
|
+
}
|
1190
|
+
|
1191
|
+
static VALUE
|
1192
|
+
rb_s_gpgme_op_decrypt_verify (VALUE dummy, VALUE vctx, VALUE vcipher,
|
1193
|
+
VALUE vplain)
|
1194
|
+
{
|
1195
|
+
gpgme_ctx_t ctx;
|
1196
|
+
gpgme_data_t cipher, plain;
|
1197
|
+
gpgme_error_t err;
|
1198
|
+
|
1199
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1200
|
+
|
1201
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1202
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1203
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1204
|
+
|
1205
|
+
err = gpgme_op_decrypt_verify (ctx, cipher, plain);
|
1206
|
+
return LONG2NUM(err);
|
1207
|
+
}
|
1208
|
+
|
1209
|
+
static VALUE
|
1210
|
+
rb_s_gpgme_op_decrypt_verify_start (VALUE dummy, VALUE vctx, VALUE vcipher,
|
1211
|
+
VALUE vplain)
|
1212
|
+
{
|
1213
|
+
gpgme_ctx_t ctx;
|
1214
|
+
gpgme_data_t cipher, plain;
|
1215
|
+
gpgme_error_t err;
|
1216
|
+
|
1217
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1218
|
+
|
1219
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1220
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1221
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1222
|
+
|
1223
|
+
err = gpgme_op_decrypt_verify_start (ctx, cipher, plain);
|
1224
|
+
return LONG2NUM(err);
|
1225
|
+
}
|
1226
|
+
|
1227
|
+
static VALUE
|
1228
|
+
rb_s_gpgme_signers_clear (VALUE dummy, VALUE vctx)
|
1229
|
+
{
|
1230
|
+
gpgme_ctx_t ctx;
|
1231
|
+
|
1232
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1233
|
+
gpgme_signers_clear (ctx);
|
1234
|
+
return Qnil;
|
1235
|
+
}
|
1236
|
+
|
1237
|
+
static VALUE
|
1238
|
+
rb_s_gpgme_signers_add (VALUE dummy, VALUE vctx, VALUE vkey)
|
1239
|
+
{
|
1240
|
+
gpgme_ctx_t ctx;
|
1241
|
+
gpgme_key_t key;
|
1242
|
+
gpgme_error_t err;
|
1243
|
+
|
1244
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1245
|
+
UNWRAP_GPGME_KEY(vkey, key);
|
1246
|
+
|
1247
|
+
err = gpgme_signers_add (ctx, key);
|
1248
|
+
return LONG2NUM(err);
|
1249
|
+
}
|
1250
|
+
|
1251
|
+
static VALUE
|
1252
|
+
rb_s_gpgme_signers_enum (VALUE dummy, VALUE vctx, VALUE vseq)
|
1253
|
+
{
|
1254
|
+
gpgme_ctx_t ctx;
|
1255
|
+
gpgme_key_t key;
|
1256
|
+
|
1257
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1258
|
+
|
1259
|
+
key = gpgme_signers_enum (ctx, NUM2INT(vseq));
|
1260
|
+
if (!key)
|
1261
|
+
return Qnil;
|
1262
|
+
return WRAP_GPGME_KEY(key);
|
1263
|
+
}
|
1264
|
+
|
1265
|
+
static VALUE
|
1266
|
+
rb_s_gpgme_op_sign (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
|
1267
|
+
VALUE vmode)
|
1268
|
+
{
|
1269
|
+
gpgme_ctx_t ctx;
|
1270
|
+
gpgme_data_t plain, sig;
|
1271
|
+
gpgme_error_t err;
|
1272
|
+
|
1273
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1274
|
+
|
1275
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1276
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1277
|
+
UNWRAP_GPGME_DATA(vsig, sig);
|
1278
|
+
|
1279
|
+
err = gpgme_op_sign (ctx, plain, sig, NUM2INT(vmode));
|
1280
|
+
return LONG2NUM(err);
|
1281
|
+
}
|
1282
|
+
|
1283
|
+
static VALUE
|
1284
|
+
rb_s_gpgme_op_sign_start (VALUE dummy, VALUE vctx, VALUE vplain, VALUE vsig,
|
1285
|
+
VALUE vmode)
|
1286
|
+
{
|
1287
|
+
gpgme_ctx_t ctx;
|
1288
|
+
gpgme_data_t plain, sig;
|
1289
|
+
gpgme_error_t err;
|
1290
|
+
|
1291
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1292
|
+
|
1293
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1294
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1295
|
+
UNWRAP_GPGME_DATA(vsig, sig);
|
1296
|
+
|
1297
|
+
err = gpgme_op_sign_start (ctx, plain, sig, NUM2INT(vmode));
|
1298
|
+
return LONG2NUM(err);
|
1299
|
+
}
|
1300
|
+
|
1301
|
+
static VALUE
|
1302
|
+
rb_s_gpgme_op_sign_result (VALUE dummy, VALUE vctx)
|
1303
|
+
{
|
1304
|
+
gpgme_ctx_t ctx;
|
1305
|
+
gpgme_sign_result_t result;
|
1306
|
+
gpgme_invalid_key_t invalid_key;
|
1307
|
+
gpgme_new_signature_t new_signature;
|
1308
|
+
VALUE vresult, vinvalid_signers, vsignatures;
|
1309
|
+
|
1310
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1311
|
+
|
1312
|
+
result = gpgme_op_sign_result (ctx);
|
1313
|
+
vresult = rb_class_new_instance (0, NULL, cSignResult);
|
1314
|
+
vinvalid_signers = rb_ary_new ();
|
1315
|
+
rb_iv_set (vresult, "@invalid_signers", vinvalid_signers);
|
1316
|
+
for (invalid_key = result->invalid_signers; invalid_key;
|
1317
|
+
invalid_key = invalid_key->next)
|
1318
|
+
{
|
1319
|
+
VALUE vinvalid_key =
|
1320
|
+
rb_class_new_instance (0, NULL, cInvalidKey);
|
1321
|
+
rb_iv_set (vinvalid_key, "@fpr", rb_str_new2 (invalid_key->fpr));
|
1322
|
+
rb_iv_set (vinvalid_key, "@reason", LONG2NUM(invalid_key->reason));
|
1323
|
+
rb_ary_push (vinvalid_signers, vinvalid_key);
|
1324
|
+
}
|
1325
|
+
vsignatures = rb_ary_new ();
|
1326
|
+
rb_iv_set (vresult, "@signatures", vsignatures);
|
1327
|
+
for (new_signature = result->signatures; new_signature;
|
1328
|
+
new_signature = new_signature->next)
|
1329
|
+
{
|
1330
|
+
VALUE vnew_signature =
|
1331
|
+
rb_class_new_instance (0, NULL, cNewSignature);
|
1332
|
+
rb_iv_set (vnew_signature, "@type", INT2FIX(new_signature->type));
|
1333
|
+
rb_iv_set (vnew_signature, "@pubkey_algo",
|
1334
|
+
INT2FIX(new_signature->pubkey_algo));
|
1335
|
+
rb_iv_set (vnew_signature, "@hash_algo",
|
1336
|
+
INT2FIX(new_signature->hash_algo));
|
1337
|
+
rb_iv_set (vnew_signature, "@sig_class",
|
1338
|
+
UINT2NUM(new_signature->sig_class));
|
1339
|
+
rb_iv_set (vnew_signature, "@timestamp",
|
1340
|
+
LONG2NUM(new_signature->timestamp));
|
1341
|
+
rb_iv_set (vnew_signature, "@fpr", rb_str_new2 (new_signature->fpr));
|
1342
|
+
rb_ary_push (vsignatures, vnew_signature);
|
1343
|
+
}
|
1344
|
+
return vresult;
|
1345
|
+
}
|
1346
|
+
|
1347
|
+
static VALUE
|
1348
|
+
rb_s_gpgme_op_encrypt (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
|
1349
|
+
VALUE vplain, VALUE vcipher)
|
1350
|
+
{
|
1351
|
+
gpgme_ctx_t ctx;
|
1352
|
+
gpgme_key_t *recp = NULL;
|
1353
|
+
gpgme_data_t plain, cipher;
|
1354
|
+
gpgme_error_t err;
|
1355
|
+
|
1356
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1357
|
+
|
1358
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1359
|
+
/* If RECP is `NULL', symmetric rather than public key encryption is
|
1360
|
+
performed. */
|
1361
|
+
if (!NIL_P(vrecp))
|
1362
|
+
{
|
1363
|
+
int i;
|
1364
|
+
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
|
1365
|
+
for (i = 0; i < RARRAY_LEN(vrecp); i++)
|
1366
|
+
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
|
1367
|
+
recp[i] = NULL;
|
1368
|
+
}
|
1369
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1370
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1371
|
+
|
1372
|
+
err = gpgme_op_encrypt (ctx, recp, NUM2INT(vflags), plain, cipher);
|
1373
|
+
if (recp)
|
1374
|
+
xfree (recp);
|
1375
|
+
return LONG2NUM(err);
|
1376
|
+
}
|
1377
|
+
|
1378
|
+
static VALUE
|
1379
|
+
rb_s_gpgme_op_encrypt_start (VALUE dummy, VALUE vctx, VALUE vrecp,
|
1380
|
+
VALUE vflags, VALUE vplain, VALUE vcipher)
|
1381
|
+
{
|
1382
|
+
gpgme_ctx_t ctx;
|
1383
|
+
gpgme_key_t *recp = NULL;
|
1384
|
+
gpgme_data_t plain, cipher;
|
1385
|
+
gpgme_error_t err;
|
1386
|
+
|
1387
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1388
|
+
|
1389
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1390
|
+
/* If RECP is `NULL', symmetric rather than public key encryption is
|
1391
|
+
performed. */
|
1392
|
+
if (!NIL_P(vrecp))
|
1393
|
+
{
|
1394
|
+
int i;
|
1395
|
+
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
|
1396
|
+
for (i = 0; i < RARRAY_LEN(vrecp); i++)
|
1397
|
+
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
|
1398
|
+
recp[i] = NULL;
|
1399
|
+
}
|
1400
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1401
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1402
|
+
|
1403
|
+
err = gpgme_op_encrypt_start (ctx, recp, NUM2INT(vflags), plain, cipher);
|
1404
|
+
if (recp)
|
1405
|
+
xfree (recp);
|
1406
|
+
return LONG2NUM(err);
|
1407
|
+
}
|
1408
|
+
|
1409
|
+
static VALUE
|
1410
|
+
rb_s_gpgme_op_encrypt_result (VALUE dummy, VALUE vctx)
|
1411
|
+
{
|
1412
|
+
gpgme_ctx_t ctx;
|
1413
|
+
gpgme_encrypt_result_t result;
|
1414
|
+
gpgme_invalid_key_t invalid_key;
|
1415
|
+
VALUE vresult, vinvalid_recipients;
|
1416
|
+
|
1417
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1418
|
+
|
1419
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1420
|
+
|
1421
|
+
result = gpgme_op_encrypt_result (ctx);
|
1422
|
+
vresult = rb_class_new_instance (0, NULL, cEncryptResult);
|
1423
|
+
vinvalid_recipients = rb_ary_new ();
|
1424
|
+
rb_iv_set (vresult, "@invalid_recipients", vinvalid_recipients);
|
1425
|
+
for (invalid_key = result->invalid_recipients; invalid_key;
|
1426
|
+
invalid_key = invalid_key->next)
|
1427
|
+
{
|
1428
|
+
VALUE vinvalid_key =
|
1429
|
+
rb_class_new_instance (0, NULL, cInvalidKey);
|
1430
|
+
rb_iv_set (vinvalid_key, "@fpr", rb_str_new2 (invalid_key->fpr));
|
1431
|
+
rb_iv_set (vinvalid_key, "@reason", LONG2NUM(invalid_key->reason));
|
1432
|
+
rb_ary_push (vinvalid_recipients, vinvalid_key);
|
1433
|
+
}
|
1434
|
+
return vresult;
|
1435
|
+
}
|
1436
|
+
|
1437
|
+
static VALUE
|
1438
|
+
rb_s_gpgme_op_encrypt_sign (VALUE dummy, VALUE vctx, VALUE vrecp, VALUE vflags,
|
1439
|
+
VALUE vplain, VALUE vcipher)
|
1440
|
+
{
|
1441
|
+
gpgme_ctx_t ctx;
|
1442
|
+
gpgme_key_t *recp = NULL;
|
1443
|
+
gpgme_data_t plain, cipher;
|
1444
|
+
gpgme_error_t err;
|
1445
|
+
|
1446
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1447
|
+
|
1448
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1449
|
+
/* If RECP is `NULL', symmetric rather than public key encryption is
|
1450
|
+
performed. */
|
1451
|
+
if (!NIL_P(vrecp))
|
1452
|
+
{
|
1453
|
+
int i;
|
1454
|
+
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
|
1455
|
+
for (i = 0; i < RARRAY_LEN(vrecp); i++)
|
1456
|
+
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
|
1457
|
+
recp[i] = NULL;
|
1458
|
+
}
|
1459
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1460
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1461
|
+
|
1462
|
+
err = gpgme_op_encrypt_sign (ctx, recp, NUM2INT(vflags), plain, cipher);
|
1463
|
+
if (recp)
|
1464
|
+
xfree (recp);
|
1465
|
+
return LONG2NUM(err);
|
1466
|
+
}
|
1467
|
+
|
1468
|
+
static VALUE
|
1469
|
+
rb_s_gpgme_op_encrypt_sign_start (VALUE dummy, VALUE vctx, VALUE vrecp,
|
1470
|
+
VALUE vflags, VALUE vplain, VALUE vcipher)
|
1471
|
+
{
|
1472
|
+
gpgme_ctx_t ctx;
|
1473
|
+
gpgme_key_t *recp = NULL;
|
1474
|
+
gpgme_data_t plain, cipher;
|
1475
|
+
gpgme_error_t err;
|
1476
|
+
|
1477
|
+
CHECK_KEYLIST_NOT_IN_PROGRESS(vctx);
|
1478
|
+
|
1479
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1480
|
+
/* If RECP is `NULL', symmetric rather than public key encryption is
|
1481
|
+
performed. */
|
1482
|
+
if (!NIL_P(vrecp))
|
1483
|
+
{
|
1484
|
+
int i;
|
1485
|
+
recp = ALLOC_N(gpgme_key_t, RARRAY_LEN(vrecp) + 1);
|
1486
|
+
for (i = 0; i < RARRAY_LEN(vrecp); i++)
|
1487
|
+
UNWRAP_GPGME_KEY(RARRAY_PTR(vrecp)[i], recp[i]);
|
1488
|
+
recp[i] = NULL;
|
1489
|
+
}
|
1490
|
+
UNWRAP_GPGME_DATA(vplain, plain);
|
1491
|
+
UNWRAP_GPGME_DATA(vcipher, cipher);
|
1492
|
+
|
1493
|
+
err = gpgme_op_encrypt_sign_start (ctx, recp, NUM2INT(vflags), plain,
|
1494
|
+
cipher);
|
1495
|
+
if (recp)
|
1496
|
+
xfree (recp);
|
1497
|
+
return LONG2NUM(err);
|
1498
|
+
}
|
1499
|
+
|
1500
|
+
static VALUE
|
1501
|
+
rb_s_gpgme_wait (VALUE dummy, VALUE vctx, VALUE rstatus, VALUE vhang)
|
1502
|
+
{
|
1503
|
+
gpgme_ctx_t ctx = NULL, ret;
|
1504
|
+
gpgme_error_t status;
|
1505
|
+
|
1506
|
+
/* The CTX argument can be `NULL'. In that case, `gpgme_wait' waits
|
1507
|
+
for any context to complete its operation. */
|
1508
|
+
if (!NIL_P(vctx))
|
1509
|
+
UNWRAP_GPGME_CTX(vctx, ctx);
|
1510
|
+
|
1511
|
+
ret = gpgme_wait (ctx, &status, NUM2INT(vhang));
|
1512
|
+
if (ret)
|
1513
|
+
{
|
1514
|
+
rb_ary_store (rstatus, 0, INT2NUM(status));
|
1515
|
+
if (ret != ctx)
|
1516
|
+
vctx = WRAP_GPGME_CTX(ret);
|
1517
|
+
return vctx;
|
1518
|
+
}
|
1519
|
+
return Qnil;
|
1520
|
+
}
|
1521
|
+
|
1522
|
+
void
|
1523
|
+
Init_gpgme_n (void)
|
1524
|
+
{
|
1525
|
+
VALUE mGPGME;
|
1526
|
+
|
1527
|
+
mGPGME = rb_define_module ("GPGME");
|
1528
|
+
|
1529
|
+
rb_define_module_function (mGPGME, "gpgme_check_version",
|
1530
|
+
rb_s_gpgme_check_version, 1);
|
1531
|
+
rb_define_module_function (mGPGME, "gpgme_engine_check_version",
|
1532
|
+
rb_s_gpgme_engine_check_version, 1);
|
1533
|
+
rb_define_module_function (mGPGME, "gpgme_get_engine_info",
|
1534
|
+
rb_s_gpgme_get_engine_info, 1);
|
1535
|
+
|
1536
|
+
rb_define_module_function (mGPGME, "gpgme_pubkey_algo_name",
|
1537
|
+
rb_s_gpgme_pubkey_algo_name, 1);
|
1538
|
+
rb_define_module_function (mGPGME, "gpgme_hash_algo_name",
|
1539
|
+
rb_s_gpgme_hash_algo_name, 1);
|
1540
|
+
|
1541
|
+
rb_define_module_function (mGPGME, "gpgme_err_code",
|
1542
|
+
rb_s_gpgme_err_code, 1);
|
1543
|
+
rb_define_module_function (mGPGME, "gpgme_err_source",
|
1544
|
+
rb_s_gpgme_err_source, 1);
|
1545
|
+
rb_define_module_function (mGPGME, "gpgme_strerror",
|
1546
|
+
rb_s_gpgme_strerror, 1);
|
1547
|
+
|
1548
|
+
cEngineInfo =
|
1549
|
+
rb_define_class_under (mGPGME, "EngineInfo", rb_cObject);
|
1550
|
+
cCtx =
|
1551
|
+
rb_define_class_under (mGPGME, "Ctx", rb_cObject);
|
1552
|
+
cData =
|
1553
|
+
rb_define_class_under (mGPGME, "Data", rb_cObject);
|
1554
|
+
cKey =
|
1555
|
+
rb_define_class_under (mGPGME, "Key", rb_cObject);
|
1556
|
+
cSubKey =
|
1557
|
+
rb_define_class_under (mGPGME, "SubKey", rb_cObject);
|
1558
|
+
cUserID =
|
1559
|
+
rb_define_class_under (mGPGME, "UserID", rb_cObject);
|
1560
|
+
cKeySig =
|
1561
|
+
rb_define_class_under (mGPGME, "KeySig", rb_cObject);
|
1562
|
+
cDecryptResult =
|
1563
|
+
rb_define_class_under (mGPGME, "DecryptResult", rb_cObject);
|
1564
|
+
cVerifyResult =
|
1565
|
+
rb_define_class_under (mGPGME, "VerifyResult", rb_cObject);
|
1566
|
+
cSignResult =
|
1567
|
+
rb_define_class_under (mGPGME, "SignResult", rb_cObject);
|
1568
|
+
cEncryptResult =
|
1569
|
+
rb_define_class_under (mGPGME, "EncryptResult", rb_cObject);
|
1570
|
+
cSignature =
|
1571
|
+
rb_define_class_under (mGPGME, "Signature", rb_cObject);
|
1572
|
+
cSigNotation =
|
1573
|
+
rb_define_class_under (mGPGME, "SigNotation", rb_cObject);
|
1574
|
+
cTrustItem =
|
1575
|
+
rb_define_class_under (mGPGME, "TrustItem", rb_cObject);
|
1576
|
+
cInvalidKey =
|
1577
|
+
rb_define_class_under (mGPGME, "InvalidKey", rb_cObject);
|
1578
|
+
cNewSignature =
|
1579
|
+
rb_define_class_under (mGPGME, "NewSignature", rb_cObject);
|
1580
|
+
cImportResult =
|
1581
|
+
rb_define_class_under (mGPGME, "ImportResult", rb_cObject);
|
1582
|
+
cImportStatus =
|
1583
|
+
rb_define_class_under (mGPGME, "ImportStatus", rb_cObject);
|
1584
|
+
|
1585
|
+
/* Creating Data Buffers
|
1586
|
+
*
|
1587
|
+
* gpgme_data_new_from_filepart is not currently supported.
|
1588
|
+
*/
|
1589
|
+
rb_define_module_function (mGPGME, "gpgme_data_new",
|
1590
|
+
rb_s_gpgme_data_new, 1);
|
1591
|
+
rb_define_module_function (mGPGME, "gpgme_data_new_from_mem",
|
1592
|
+
rb_s_gpgme_data_new_from_mem, 3);
|
1593
|
+
rb_define_module_function (mGPGME, "gpgme_data_new_from_fd",
|
1594
|
+
rb_s_gpgme_data_new_from_fd, 2);
|
1595
|
+
rb_define_module_function (mGPGME, "gpgme_data_new_from_cbs",
|
1596
|
+
rb_s_gpgme_data_new_from_cbs, 3);
|
1597
|
+
|
1598
|
+
/* Manipulating Data Buffers */
|
1599
|
+
rb_define_module_function (mGPGME, "gpgme_data_read",
|
1600
|
+
rb_s_gpgme_data_read, 2);
|
1601
|
+
rb_define_module_function (mGPGME, "gpgme_data_seek",
|
1602
|
+
rb_s_gpgme_data_seek, 3);
|
1603
|
+
rb_define_module_function (mGPGME, "gpgme_data_write",
|
1604
|
+
rb_s_gpgme_data_write, 3);
|
1605
|
+
rb_define_module_function (mGPGME, "gpgme_data_get_encoding",
|
1606
|
+
rb_s_gpgme_data_get_encoding, 1);
|
1607
|
+
rb_define_module_function (mGPGME, "gpgme_data_set_encoding",
|
1608
|
+
rb_s_gpgme_data_set_encoding, 2);
|
1609
|
+
|
1610
|
+
/* Creating Contexts */
|
1611
|
+
rb_define_module_function (mGPGME, "gpgme_new",
|
1612
|
+
rb_s_gpgme_new, 1);
|
1613
|
+
|
1614
|
+
/* Context Attributes */
|
1615
|
+
rb_define_module_function (mGPGME, "gpgme_set_protocol",
|
1616
|
+
rb_s_gpgme_set_protocol, 2);
|
1617
|
+
rb_define_module_function (mGPGME, "gpgme_get_protocol",
|
1618
|
+
rb_s_gpgme_get_protocol, 1);
|
1619
|
+
rb_define_module_function (mGPGME, "gpgme_set_armor",
|
1620
|
+
rb_s_gpgme_set_armor, 2);
|
1621
|
+
rb_define_module_function (mGPGME, "gpgme_get_armor",
|
1622
|
+
rb_s_gpgme_get_armor, 1);
|
1623
|
+
rb_define_module_function (mGPGME, "gpgme_set_textmode",
|
1624
|
+
rb_s_gpgme_set_textmode, 2);
|
1625
|
+
rb_define_module_function (mGPGME, "gpgme_get_textmode",
|
1626
|
+
rb_s_gpgme_get_textmode, 1);
|
1627
|
+
rb_define_module_function (mGPGME, "gpgme_set_include_certs",
|
1628
|
+
rb_s_gpgme_set_include_certs, 2);
|
1629
|
+
rb_define_module_function (mGPGME, "gpgme_get_include_certs",
|
1630
|
+
rb_s_gpgme_get_include_certs, 1);
|
1631
|
+
rb_define_module_function (mGPGME, "gpgme_set_keylist_mode",
|
1632
|
+
rb_s_gpgme_set_keylist_mode, 2);
|
1633
|
+
rb_define_module_function (mGPGME, "gpgme_get_keylist_mode",
|
1634
|
+
rb_s_gpgme_get_keylist_mode, 1);
|
1635
|
+
rb_define_module_function (mGPGME, "gpgme_set_passphrase_cb",
|
1636
|
+
rb_s_gpgme_set_passphrase_cb, 3);
|
1637
|
+
rb_define_module_function (mGPGME, "gpgme_get_passphrase_cb",
|
1638
|
+
rb_s_gpgme_get_passphrase_cb, 3);
|
1639
|
+
rb_define_module_function (mGPGME, "gpgme_set_progress_cb",
|
1640
|
+
rb_s_gpgme_set_progress_cb, 3);
|
1641
|
+
rb_define_module_function (mGPGME, "gpgme_get_progress_cb",
|
1642
|
+
rb_s_gpgme_get_progress_cb, 3);
|
1643
|
+
rb_define_module_function (mGPGME, "gpgme_set_locale",
|
1644
|
+
rb_s_gpgme_set_locale, 3);
|
1645
|
+
|
1646
|
+
/* Key Management */
|
1647
|
+
rb_define_module_function (mGPGME, "gpgme_op_keylist_start",
|
1648
|
+
rb_s_gpgme_op_keylist_start, 3);
|
1649
|
+
rb_define_module_function (mGPGME, "gpgme_op_keylist_ext_start",
|
1650
|
+
rb_s_gpgme_op_keylist_ext_start, 4);
|
1651
|
+
rb_define_module_function (mGPGME, "gpgme_op_keylist_next",
|
1652
|
+
rb_s_gpgme_op_keylist_next, 2);
|
1653
|
+
rb_define_module_function (mGPGME, "gpgme_op_keylist_end",
|
1654
|
+
rb_s_gpgme_op_keylist_end, 1);
|
1655
|
+
rb_define_module_function (mGPGME, "gpgme_get_key",
|
1656
|
+
rb_s_gpgme_get_key, 4);
|
1657
|
+
rb_define_module_function (mGPGME, "gpgme_key_ref",
|
1658
|
+
rb_s_gpgme_key_ref, 1);
|
1659
|
+
rb_define_module_function (mGPGME, "gpgme_key_unref",
|
1660
|
+
rb_s_gpgme_key_unref, 1);
|
1661
|
+
rb_define_module_function (mGPGME, "gpgme_op_genkey",
|
1662
|
+
rb_s_gpgme_op_genkey, 4);
|
1663
|
+
rb_define_module_function (mGPGME, "gpgme_op_genkey_start",
|
1664
|
+
rb_s_gpgme_op_genkey_start, 4);
|
1665
|
+
rb_define_module_function (mGPGME, "gpgme_op_export",
|
1666
|
+
rb_s_gpgme_op_export, 4);
|
1667
|
+
rb_define_module_function (mGPGME, "gpgme_op_export_start",
|
1668
|
+
rb_s_gpgme_op_export_start, 3);
|
1669
|
+
rb_define_module_function (mGPGME, "gpgme_op_import",
|
1670
|
+
rb_s_gpgme_op_import, 2);
|
1671
|
+
rb_define_module_function (mGPGME, "gpgme_op_import_start",
|
1672
|
+
rb_s_gpgme_op_import_start, 2);
|
1673
|
+
rb_define_module_function (mGPGME, "gpgme_op_import_result",
|
1674
|
+
rb_s_gpgme_op_import_result, 1);
|
1675
|
+
rb_define_module_function (mGPGME, "gpgme_op_delete",
|
1676
|
+
rb_s_gpgme_op_delete, 3);
|
1677
|
+
rb_define_module_function (mGPGME, "gpgme_op_delete_start",
|
1678
|
+
rb_s_gpgme_op_delete_start, 3);
|
1679
|
+
|
1680
|
+
/* Trust Item Management */
|
1681
|
+
rb_define_module_function (mGPGME, "gpgme_op_trustlist_start",
|
1682
|
+
rb_s_gpgme_op_trustlist_start, 3);
|
1683
|
+
rb_define_module_function (mGPGME, "gpgme_op_trustlist_next",
|
1684
|
+
rb_s_gpgme_op_trustlist_next, 2);
|
1685
|
+
rb_define_module_function (mGPGME, "gpgme_op_trustlist_end",
|
1686
|
+
rb_s_gpgme_op_trustlist_end, 1);
|
1687
|
+
|
1688
|
+
/* Decrypt */
|
1689
|
+
rb_define_module_function (mGPGME, "gpgme_op_decrypt",
|
1690
|
+
rb_s_gpgme_op_decrypt, 3);
|
1691
|
+
rb_define_module_function (mGPGME, "gpgme_op_decrypt_start",
|
1692
|
+
rb_s_gpgme_op_decrypt_start, 3);
|
1693
|
+
rb_define_module_function (mGPGME, "gpgme_op_decrypt_result",
|
1694
|
+
rb_s_gpgme_op_decrypt_result, 1);
|
1695
|
+
|
1696
|
+
/* Verify */
|
1697
|
+
rb_define_module_function (mGPGME, "gpgme_op_verify",
|
1698
|
+
rb_s_gpgme_op_verify, 4);
|
1699
|
+
rb_define_module_function (mGPGME, "gpgme_op_verify_start",
|
1700
|
+
rb_s_gpgme_op_verify_start, 4);
|
1701
|
+
rb_define_module_function (mGPGME, "gpgme_op_verify_result",
|
1702
|
+
rb_s_gpgme_op_verify_result, 1);
|
1703
|
+
|
1704
|
+
/* Decrypt and Verify */
|
1705
|
+
rb_define_module_function (mGPGME, "gpgme_op_decrypt_verify",
|
1706
|
+
rb_s_gpgme_op_decrypt_verify, 3);
|
1707
|
+
rb_define_module_function (mGPGME, "gpgme_op_decrypt_verify_start",
|
1708
|
+
rb_s_gpgme_op_decrypt_verify_start, 3);
|
1709
|
+
|
1710
|
+
/* Sign */
|
1711
|
+
rb_define_module_function (mGPGME, "gpgme_signers_clear",
|
1712
|
+
rb_s_gpgme_signers_clear, 1);
|
1713
|
+
rb_define_module_function (mGPGME, "gpgme_signers_add",
|
1714
|
+
rb_s_gpgme_signers_add, 2);
|
1715
|
+
rb_define_module_function (mGPGME, "gpgme_signers_enum",
|
1716
|
+
rb_s_gpgme_signers_enum, 2);
|
1717
|
+
rb_define_module_function (mGPGME, "gpgme_op_sign",
|
1718
|
+
rb_s_gpgme_op_sign, 4);
|
1719
|
+
rb_define_module_function (mGPGME, "gpgme_op_sign_start",
|
1720
|
+
rb_s_gpgme_op_sign_start, 4);
|
1721
|
+
rb_define_module_function (mGPGME, "gpgme_op_sign_result",
|
1722
|
+
rb_s_gpgme_op_sign_result, 1);
|
1723
|
+
|
1724
|
+
/* Encrypt */
|
1725
|
+
rb_define_module_function (mGPGME, "gpgme_op_encrypt",
|
1726
|
+
rb_s_gpgme_op_encrypt, 5);
|
1727
|
+
rb_define_module_function (mGPGME, "gpgme_op_encrypt_start",
|
1728
|
+
rb_s_gpgme_op_encrypt_start, 5);
|
1729
|
+
rb_define_module_function (mGPGME, "gpgme_op_encrypt_result",
|
1730
|
+
rb_s_gpgme_op_encrypt_result, 1);
|
1731
|
+
rb_define_module_function (mGPGME, "gpgme_op_encrypt_sign",
|
1732
|
+
rb_s_gpgme_op_encrypt_sign, 5);
|
1733
|
+
rb_define_module_function (mGPGME, "gpgme_op_encrypt_sign_start",
|
1734
|
+
rb_s_gpgme_op_encrypt_sign_start, 5);
|
1735
|
+
|
1736
|
+
/* Run Control */
|
1737
|
+
rb_define_module_function (mGPGME, "gpgme_wait",
|
1738
|
+
rb_s_gpgme_wait, 3);
|
1739
|
+
|
1740
|
+
/* gpgme_pubkey_algo_t */
|
1741
|
+
rb_define_const (mGPGME, "GPGME_PK_RSA", INT2FIX(GPGME_PK_RSA));
|
1742
|
+
rb_define_const (mGPGME, "GPGME_PK_DSA", INT2FIX(GPGME_PK_DSA));
|
1743
|
+
rb_define_const (mGPGME, "GPGME_PK_ELG", INT2FIX(GPGME_PK_ELG));
|
1744
|
+
rb_define_const (mGPGME, "GPGME_PK_ELG_E", INT2FIX(GPGME_PK_ELG_E));
|
1745
|
+
|
1746
|
+
/* gpgme_hash_algo_t */
|
1747
|
+
rb_define_const (mGPGME, "GPGME_MD_MD5", INT2FIX(GPGME_MD_MD5));
|
1748
|
+
rb_define_const (mGPGME, "GPGME_MD_SHA1", INT2FIX(GPGME_MD_SHA1));
|
1749
|
+
rb_define_const (mGPGME, "GPGME_MD_RMD160", INT2FIX(GPGME_MD_RMD160));
|
1750
|
+
rb_define_const (mGPGME, "GPGME_MD_MD2", INT2FIX(GPGME_MD_MD2));
|
1751
|
+
rb_define_const (mGPGME, "GPGME_MD_TIGER", INT2FIX(GPGME_MD_TIGER));
|
1752
|
+
rb_define_const (mGPGME, "GPGME_MD_HAVAL", INT2FIX(GPGME_MD_HAVAL));
|
1753
|
+
rb_define_const (mGPGME, "GPGME_MD_SHA256", INT2FIX(GPGME_MD_SHA256));
|
1754
|
+
rb_define_const (mGPGME, "GPGME_MD_SHA384", INT2FIX(GPGME_MD_SHA384));
|
1755
|
+
rb_define_const (mGPGME, "GPGME_MD_SHA512", INT2FIX(GPGME_MD_SHA512));
|
1756
|
+
rb_define_const (mGPGME, "GPGME_MD_MD4", INT2FIX(GPGME_MD_MD4));
|
1757
|
+
rb_define_const (mGPGME, "GPGME_MD_CRC32", INT2FIX(GPGME_MD_CRC32));
|
1758
|
+
rb_define_const (mGPGME, "GPGME_MD_CRC32_RFC1510",
|
1759
|
+
INT2FIX(GPGME_MD_CRC32_RFC1510));
|
1760
|
+
rb_define_const (mGPGME, "GPGME_MD_CRC24_RFC2440",
|
1761
|
+
INT2FIX(GPGME_MD_CRC24_RFC2440));
|
1762
|
+
|
1763
|
+
/* gpgme_err_code_t */
|
1764
|
+
rb_define_const (mGPGME, "GPG_ERR_EOF",
|
1765
|
+
INT2FIX(GPG_ERR_EOF));
|
1766
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_ERROR",
|
1767
|
+
INT2FIX(GPG_ERR_NO_ERROR));
|
1768
|
+
rb_define_const (mGPGME, "GPG_ERR_GENERAL",
|
1769
|
+
INT2FIX(GPG_ERR_GENERAL));
|
1770
|
+
rb_define_const (mGPGME, "GPG_ERR_ENOMEM",
|
1771
|
+
INT2FIX(GPG_ERR_ENOMEM));
|
1772
|
+
rb_define_const (mGPGME, "GPG_ERR_INV_VALUE",
|
1773
|
+
INT2FIX(GPG_ERR_INV_VALUE));
|
1774
|
+
rb_define_const (mGPGME, "GPG_ERR_UNUSABLE_PUBKEY",
|
1775
|
+
INT2FIX(GPG_ERR_UNUSABLE_PUBKEY));
|
1776
|
+
rb_define_const (mGPGME, "GPG_ERR_UNUSABLE_SECKEY",
|
1777
|
+
INT2FIX(GPG_ERR_UNUSABLE_SECKEY));
|
1778
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_DATA",
|
1779
|
+
INT2FIX(GPG_ERR_NO_DATA));
|
1780
|
+
rb_define_const (mGPGME, "GPG_ERR_CONFLICT",
|
1781
|
+
INT2FIX(GPG_ERR_CONFLICT));
|
1782
|
+
rb_define_const (mGPGME, "GPG_ERR_NOT_IMPLEMENTED",
|
1783
|
+
INT2FIX(GPG_ERR_NOT_IMPLEMENTED));
|
1784
|
+
rb_define_const (mGPGME, "GPG_ERR_DECRYPT_FAILED",
|
1785
|
+
INT2FIX(GPG_ERR_DECRYPT_FAILED));
|
1786
|
+
rb_define_const (mGPGME, "GPG_ERR_BAD_PASSPHRASE",
|
1787
|
+
INT2FIX(GPG_ERR_BAD_PASSPHRASE));
|
1788
|
+
rb_define_const (mGPGME, "GPG_ERR_KEY_EXPIRED",
|
1789
|
+
INT2FIX(GPG_ERR_KEY_EXPIRED));
|
1790
|
+
rb_define_const (mGPGME, "GPG_ERR_SIG_EXPIRED",
|
1791
|
+
INT2FIX(GPG_ERR_SIG_EXPIRED));
|
1792
|
+
rb_define_const (mGPGME, "GPG_ERR_CANCELED",
|
1793
|
+
INT2FIX(GPG_ERR_CANCELED));
|
1794
|
+
rb_define_const (mGPGME, "GPG_ERR_INV_ENGINE",
|
1795
|
+
INT2FIX(GPG_ERR_INV_ENGINE));
|
1796
|
+
rb_define_const (mGPGME, "GPG_ERR_AMBIGUOUS_NAME",
|
1797
|
+
INT2FIX(GPG_ERR_AMBIGUOUS_NAME));
|
1798
|
+
rb_define_const (mGPGME, "GPG_ERR_WRONG_KEY_USAGE",
|
1799
|
+
INT2FIX(GPG_ERR_WRONG_KEY_USAGE));
|
1800
|
+
rb_define_const (mGPGME, "GPG_ERR_CERT_REVOKED",
|
1801
|
+
INT2FIX(GPG_ERR_CERT_REVOKED));
|
1802
|
+
rb_define_const (mGPGME, "GPG_ERR_CERT_EXPIRED",
|
1803
|
+
INT2FIX(GPG_ERR_CERT_EXPIRED));
|
1804
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_CRL_KNOWN",
|
1805
|
+
INT2FIX(GPG_ERR_NO_CRL_KNOWN));
|
1806
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_POLICY_MATCH",
|
1807
|
+
INT2FIX(GPG_ERR_NO_POLICY_MATCH));
|
1808
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_SECKEY",
|
1809
|
+
INT2FIX(GPG_ERR_NO_SECKEY));
|
1810
|
+
rb_define_const (mGPGME, "GPG_ERR_MISSING_CERT",
|
1811
|
+
INT2FIX(GPG_ERR_MISSING_CERT));
|
1812
|
+
rb_define_const (mGPGME, "GPG_ERR_BAD_CERT_CHAIN",
|
1813
|
+
INT2FIX(GPG_ERR_BAD_CERT_CHAIN));
|
1814
|
+
rb_define_const (mGPGME, "GPG_ERR_UNSUPPORTED_ALGORITHM",
|
1815
|
+
INT2FIX(GPG_ERR_UNSUPPORTED_ALGORITHM));
|
1816
|
+
rb_define_const (mGPGME, "GPG_ERR_BAD_SIGNATURE",
|
1817
|
+
INT2FIX(GPG_ERR_BAD_SIGNATURE));
|
1818
|
+
rb_define_const (mGPGME, "GPG_ERR_NO_PUBKEY",
|
1819
|
+
INT2FIX(GPG_ERR_NO_PUBKEY));
|
1820
|
+
|
1821
|
+
/* gpgme_err_source_t */
|
1822
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_UNKNOWN",
|
1823
|
+
INT2FIX(GPG_ERR_SOURCE_UNKNOWN));
|
1824
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_GPGME",
|
1825
|
+
INT2FIX(GPG_ERR_SOURCE_GPGME));
|
1826
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_GPG",
|
1827
|
+
INT2FIX(GPG_ERR_SOURCE_GPG));
|
1828
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_GPGSM",
|
1829
|
+
INT2FIX(GPG_ERR_SOURCE_GPGSM));
|
1830
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_GCRYPT",
|
1831
|
+
INT2FIX(GPG_ERR_SOURCE_GCRYPT));
|
1832
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_GPGAGENT",
|
1833
|
+
INT2FIX(GPG_ERR_SOURCE_GPGAGENT));
|
1834
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_PINENTRY",
|
1835
|
+
INT2FIX(GPG_ERR_SOURCE_PINENTRY));
|
1836
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_SCD",
|
1837
|
+
INT2FIX(GPG_ERR_SOURCE_SCD));
|
1838
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_KEYBOX",
|
1839
|
+
INT2FIX(GPG_ERR_SOURCE_KEYBOX));
|
1840
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_USER_1",
|
1841
|
+
INT2FIX(GPG_ERR_SOURCE_USER_1));
|
1842
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_USER_2",
|
1843
|
+
INT2FIX(GPG_ERR_SOURCE_USER_2));
|
1844
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_USER_3",
|
1845
|
+
INT2FIX(GPG_ERR_SOURCE_USER_3));
|
1846
|
+
rb_define_const (mGPGME, "GPG_ERR_SOURCE_USER_4",
|
1847
|
+
INT2FIX(GPG_ERR_SOURCE_USER_4));
|
1848
|
+
|
1849
|
+
/* gpgme_data_encoding_t */
|
1850
|
+
rb_define_const (mGPGME, "GPGME_DATA_ENCODING_NONE",
|
1851
|
+
INT2FIX(GPGME_DATA_ENCODING_NONE));
|
1852
|
+
rb_define_const (mGPGME, "GPGME_DATA_ENCODING_BINARY",
|
1853
|
+
INT2FIX(GPGME_DATA_ENCODING_BINARY));
|
1854
|
+
rb_define_const (mGPGME, "GPGME_DATA_ENCODING_BASE64",
|
1855
|
+
INT2FIX(GPGME_DATA_ENCODING_BASE64));
|
1856
|
+
rb_define_const (mGPGME, "GPGME_DATA_ENCODING_ARMOR",
|
1857
|
+
INT2FIX(GPGME_DATA_ENCODING_ARMOR));
|
1858
|
+
|
1859
|
+
/* gpgme_sig_stat_t */
|
1860
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_NONE",
|
1861
|
+
INT2FIX(GPGME_SIG_STAT_NONE));
|
1862
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_GOOD",
|
1863
|
+
INT2FIX(GPGME_SIG_STAT_GOOD));
|
1864
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_BAD",
|
1865
|
+
INT2FIX(GPGME_SIG_STAT_BAD));
|
1866
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_NOKEY",
|
1867
|
+
INT2FIX(GPGME_SIG_STAT_NOKEY));
|
1868
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_NOSIG",
|
1869
|
+
INT2FIX(GPGME_SIG_STAT_NOSIG));
|
1870
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_ERROR",
|
1871
|
+
INT2FIX(GPGME_SIG_STAT_ERROR));
|
1872
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_DIFF",
|
1873
|
+
INT2FIX(GPGME_SIG_STAT_DIFF));
|
1874
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_GOOD_EXP",
|
1875
|
+
INT2FIX(GPGME_SIG_STAT_GOOD_EXP));
|
1876
|
+
rb_define_const (mGPGME, "GPGME_SIG_STAT_GOOD_EXPKEY",
|
1877
|
+
INT2FIX(GPGME_SIG_STAT_GOOD_EXPKEY));
|
1878
|
+
|
1879
|
+
/* gpgme_sigsum_t */
|
1880
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_VALID",
|
1881
|
+
INT2FIX(GPGME_SIGSUM_VALID));
|
1882
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_GREEN",
|
1883
|
+
INT2FIX(GPGME_SIGSUM_GREEN));
|
1884
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_RED",
|
1885
|
+
INT2FIX(GPGME_SIGSUM_RED));
|
1886
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_KEY_REVOKED",
|
1887
|
+
INT2FIX(GPGME_SIGSUM_KEY_REVOKED));
|
1888
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_KEY_EXPIRED",
|
1889
|
+
INT2FIX(GPGME_SIGSUM_KEY_EXPIRED));
|
1890
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_SIG_EXPIRED",
|
1891
|
+
INT2FIX(GPGME_SIGSUM_SIG_EXPIRED));
|
1892
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_KEY_MISSING",
|
1893
|
+
INT2FIX(GPGME_SIGSUM_KEY_MISSING));
|
1894
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_CRL_MISSING",
|
1895
|
+
INT2FIX(GPGME_SIGSUM_CRL_MISSING));
|
1896
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_CRL_TOO_OLD",
|
1897
|
+
INT2FIX(GPGME_SIGSUM_CRL_TOO_OLD));
|
1898
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_BAD_POLICY",
|
1899
|
+
INT2FIX(GPGME_SIGSUM_BAD_POLICY));
|
1900
|
+
rb_define_const (mGPGME, "GPGME_SIGSUM_SYS_ERROR",
|
1901
|
+
INT2FIX(GPGME_SIGSUM_SYS_ERROR));
|
1902
|
+
|
1903
|
+
/* gpgme_sig_mode_t */
|
1904
|
+
rb_define_const (mGPGME, "GPGME_SIG_MODE_NORMAL",
|
1905
|
+
INT2FIX(GPGME_SIG_MODE_NORMAL));
|
1906
|
+
rb_define_const (mGPGME, "GPGME_SIG_MODE_DETACH",
|
1907
|
+
INT2FIX(GPGME_SIG_MODE_DETACH));
|
1908
|
+
rb_define_const (mGPGME, "GPGME_SIG_MODE_CLEAR",
|
1909
|
+
INT2FIX(GPGME_SIG_MODE_CLEAR));
|
1910
|
+
|
1911
|
+
/* gpgme_attr_t */
|
1912
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEYID",
|
1913
|
+
INT2FIX(GPGME_ATTR_KEYID));
|
1914
|
+
rb_define_const (mGPGME, "GPGME_ATTR_FPR",
|
1915
|
+
INT2FIX(GPGME_ATTR_FPR));
|
1916
|
+
rb_define_const (mGPGME, "GPGME_ATTR_ALGO",
|
1917
|
+
INT2FIX(GPGME_ATTR_ALGO));
|
1918
|
+
rb_define_const (mGPGME, "GPGME_ATTR_LEN",
|
1919
|
+
INT2FIX(GPGME_ATTR_LEN));
|
1920
|
+
rb_define_const (mGPGME, "GPGME_ATTR_CREATED",
|
1921
|
+
INT2FIX(GPGME_ATTR_CREATED));
|
1922
|
+
rb_define_const (mGPGME, "GPGME_ATTR_EXPIRE",
|
1923
|
+
INT2FIX(GPGME_ATTR_EXPIRE));
|
1924
|
+
rb_define_const (mGPGME, "GPGME_ATTR_OTRUST",
|
1925
|
+
INT2FIX(GPGME_ATTR_OTRUST));
|
1926
|
+
rb_define_const (mGPGME, "GPGME_ATTR_USERID",
|
1927
|
+
INT2FIX(GPGME_ATTR_USERID));
|
1928
|
+
rb_define_const (mGPGME, "GPGME_ATTR_NAME",
|
1929
|
+
INT2FIX(GPGME_ATTR_NAME));
|
1930
|
+
rb_define_const (mGPGME, "GPGME_ATTR_EMAIL",
|
1931
|
+
INT2FIX(GPGME_ATTR_EMAIL));
|
1932
|
+
rb_define_const (mGPGME, "GPGME_ATTR_COMMENT",
|
1933
|
+
INT2FIX(GPGME_ATTR_COMMENT));
|
1934
|
+
rb_define_const (mGPGME, "GPGME_ATTR_VALIDITY",
|
1935
|
+
INT2FIX(GPGME_ATTR_VALIDITY));
|
1936
|
+
rb_define_const (mGPGME, "GPGME_ATTR_LEVEL",
|
1937
|
+
INT2FIX(GPGME_ATTR_LEVEL));
|
1938
|
+
rb_define_const (mGPGME, "GPGME_ATTR_TYPE",
|
1939
|
+
INT2FIX(GPGME_ATTR_TYPE));
|
1940
|
+
rb_define_const (mGPGME, "GPGME_ATTR_IS_SECRET",
|
1941
|
+
INT2FIX(GPGME_ATTR_IS_SECRET));
|
1942
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEY_REVOKED",
|
1943
|
+
INT2FIX(GPGME_ATTR_KEY_REVOKED));
|
1944
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEY_INVALID",
|
1945
|
+
INT2FIX(GPGME_ATTR_KEY_INVALID));
|
1946
|
+
rb_define_const (mGPGME, "GPGME_ATTR_UID_REVOKED",
|
1947
|
+
INT2FIX(GPGME_ATTR_UID_REVOKED));
|
1948
|
+
rb_define_const (mGPGME, "GPGME_ATTR_UID_INVALID",
|
1949
|
+
INT2FIX(GPGME_ATTR_UID_INVALID));
|
1950
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEY_CAPS",
|
1951
|
+
INT2FIX(GPGME_ATTR_KEY_CAPS));
|
1952
|
+
rb_define_const (mGPGME, "GPGME_ATTR_CAN_ENCRYPT",
|
1953
|
+
INT2FIX(GPGME_ATTR_CAN_ENCRYPT));
|
1954
|
+
rb_define_const (mGPGME, "GPGME_ATTR_CAN_SIGN",
|
1955
|
+
INT2FIX(GPGME_ATTR_CAN_SIGN));
|
1956
|
+
rb_define_const (mGPGME, "GPGME_ATTR_CAN_CERTIFY",
|
1957
|
+
INT2FIX(GPGME_ATTR_CAN_CERTIFY));
|
1958
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEY_EXPIRED",
|
1959
|
+
INT2FIX(GPGME_ATTR_KEY_EXPIRED));
|
1960
|
+
rb_define_const (mGPGME, "GPGME_ATTR_KEY_DISABLED",
|
1961
|
+
INT2FIX(GPGME_ATTR_KEY_DISABLED));
|
1962
|
+
rb_define_const (mGPGME, "GPGME_ATTR_SERIAL",
|
1963
|
+
INT2FIX(GPGME_ATTR_SERIAL));
|
1964
|
+
rb_define_const (mGPGME, "GPGME_ATTR_ISSUER",
|
1965
|
+
INT2FIX(GPGME_ATTR_ISSUER));
|
1966
|
+
rb_define_const (mGPGME, "GPGME_ATTR_CHAINID",
|
1967
|
+
INT2FIX(GPGME_ATTR_CHAINID));
|
1968
|
+
rb_define_const (mGPGME, "GPGME_ATTR_SIG_STATUS",
|
1969
|
+
INT2FIX(GPGME_ATTR_SIG_STATUS));
|
1970
|
+
rb_define_const (mGPGME, "GPGME_ATTR_ERRTOK",
|
1971
|
+
INT2FIX(GPGME_ATTR_ERRTOK));
|
1972
|
+
rb_define_const (mGPGME, "GPGME_ATTR_SIG_SUMMARY",
|
1973
|
+
INT2FIX(GPGME_ATTR_SIG_SUMMARY));
|
1974
|
+
|
1975
|
+
/* gpgme_validity_t */
|
1976
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_UNKNOWN",
|
1977
|
+
INT2FIX(GPGME_VALIDITY_UNKNOWN));
|
1978
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_UNDEFINED",
|
1979
|
+
INT2FIX(GPGME_VALIDITY_UNDEFINED));
|
1980
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_NEVER",
|
1981
|
+
INT2FIX(GPGME_VALIDITY_NEVER));
|
1982
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_MARGINAL",
|
1983
|
+
INT2FIX(GPGME_VALIDITY_MARGINAL));
|
1984
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_FULL",
|
1985
|
+
INT2FIX(GPGME_VALIDITY_FULL));
|
1986
|
+
rb_define_const (mGPGME, "GPGME_VALIDITY_ULTIMATE",
|
1987
|
+
INT2FIX(GPGME_VALIDITY_ULTIMATE));
|
1988
|
+
|
1989
|
+
/* gpgme_protocol_t */
|
1990
|
+
rb_define_const (mGPGME, "GPGME_PROTOCOL_OpenPGP",
|
1991
|
+
INT2FIX(GPGME_PROTOCOL_OpenPGP));
|
1992
|
+
rb_define_const (mGPGME, "GPGME_PROTOCOL_CMS",
|
1993
|
+
INT2FIX(GPGME_PROTOCOL_CMS));
|
1994
|
+
|
1995
|
+
/* gpgme_status_code_t */
|
1996
|
+
rb_define_const (mGPGME, "GPGME_STATUS_EOF",
|
1997
|
+
INT2FIX(GPGME_STATUS_EOF));
|
1998
|
+
/* mkstatus starts here */
|
1999
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ENTER",
|
2000
|
+
INT2FIX(GPGME_STATUS_ENTER));
|
2001
|
+
rb_define_const (mGPGME, "GPGME_STATUS_LEAVE",
|
2002
|
+
INT2FIX(GPGME_STATUS_LEAVE));
|
2003
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ABORT",
|
2004
|
+
INT2FIX(GPGME_STATUS_ABORT));
|
2005
|
+
|
2006
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GOODSIG",
|
2007
|
+
INT2FIX(GPGME_STATUS_GOODSIG));
|
2008
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BADSIG",
|
2009
|
+
INT2FIX(GPGME_STATUS_BADSIG));
|
2010
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ERRSIG",
|
2011
|
+
INT2FIX(GPGME_STATUS_ERRSIG));
|
2012
|
+
|
2013
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BADARMOR",
|
2014
|
+
INT2FIX(GPGME_STATUS_BADARMOR));
|
2015
|
+
|
2016
|
+
rb_define_const (mGPGME, "GPGME_STATUS_RSA_OR_IDEA",
|
2017
|
+
INT2FIX(GPGME_STATUS_RSA_OR_IDEA));
|
2018
|
+
rb_define_const (mGPGME, "GPGME_STATUS_KEYEXPIRED",
|
2019
|
+
INT2FIX(GPGME_STATUS_KEYEXPIRED));
|
2020
|
+
rb_define_const (mGPGME, "GPGME_STATUS_KEYREVOKED",
|
2021
|
+
INT2FIX(GPGME_STATUS_KEYREVOKED));
|
2022
|
+
|
2023
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUST_UNDEFINED",
|
2024
|
+
INT2FIX(GPGME_STATUS_TRUST_UNDEFINED));
|
2025
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUST_NEVER",
|
2026
|
+
INT2FIX(GPGME_STATUS_TRUST_NEVER));
|
2027
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUST_MARGINAL",
|
2028
|
+
INT2FIX(GPGME_STATUS_TRUST_MARGINAL));
|
2029
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUST_FULLY",
|
2030
|
+
INT2FIX(GPGME_STATUS_TRUST_FULLY));
|
2031
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUST_ULTIMATE",
|
2032
|
+
INT2FIX(GPGME_STATUS_TRUST_ULTIMATE));
|
2033
|
+
|
2034
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SHM_INFO",
|
2035
|
+
INT2FIX(GPGME_STATUS_SHM_INFO));
|
2036
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SHM_GET",
|
2037
|
+
INT2FIX(GPGME_STATUS_SHM_GET));
|
2038
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SHM_GET_BOOL",
|
2039
|
+
INT2FIX(GPGME_STATUS_SHM_GET_BOOL));
|
2040
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SHM_GET_HIDDEN",
|
2041
|
+
INT2FIX(GPGME_STATUS_SHM_GET_HIDDEN));
|
2042
|
+
|
2043
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NEED_PASSPHRASE",
|
2044
|
+
INT2FIX(GPGME_STATUS_NEED_PASSPHRASE));
|
2045
|
+
rb_define_const (mGPGME, "GPGME_STATUS_VALIDSIG",
|
2046
|
+
INT2FIX(GPGME_STATUS_VALIDSIG));
|
2047
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SIG_ID",
|
2048
|
+
INT2FIX(GPGME_STATUS_SIG_ID));
|
2049
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ENC_TO",
|
2050
|
+
INT2FIX(GPGME_STATUS_ENC_TO));
|
2051
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NODATA",
|
2052
|
+
INT2FIX(GPGME_STATUS_NODATA));
|
2053
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BAD_PASSPHRASE",
|
2054
|
+
INT2FIX(GPGME_STATUS_BAD_PASSPHRASE));
|
2055
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NO_PUBKEY",
|
2056
|
+
INT2FIX(GPGME_STATUS_NO_PUBKEY));
|
2057
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NO_SECKEY",
|
2058
|
+
INT2FIX(GPGME_STATUS_NO_SECKEY));
|
2059
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NEED_PASSPHRASE_SYM",
|
2060
|
+
INT2FIX(GPGME_STATUS_NEED_PASSPHRASE_SYM));
|
2061
|
+
rb_define_const (mGPGME, "GPGME_STATUS_DECRYPTION_FAILED",
|
2062
|
+
INT2FIX(GPGME_STATUS_DECRYPTION_FAILED));
|
2063
|
+
rb_define_const (mGPGME, "GPGME_STATUS_DECRYPTION_OKAY",
|
2064
|
+
INT2FIX(GPGME_STATUS_DECRYPTION_OKAY));
|
2065
|
+
rb_define_const (mGPGME, "GPGME_STATUS_MISSING_PASSPHRASE",
|
2066
|
+
INT2FIX(GPGME_STATUS_MISSING_PASSPHRASE));
|
2067
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GOOD_PASSPHRASE",
|
2068
|
+
INT2FIX(GPGME_STATUS_GOOD_PASSPHRASE));
|
2069
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GOODMDC",
|
2070
|
+
INT2FIX(GPGME_STATUS_GOODMDC));
|
2071
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BADMDC",
|
2072
|
+
INT2FIX(GPGME_STATUS_BADMDC));
|
2073
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ERRMDC",
|
2074
|
+
INT2FIX(GPGME_STATUS_ERRMDC));
|
2075
|
+
rb_define_const (mGPGME, "GPGME_STATUS_IMPORTED",
|
2076
|
+
INT2FIX(GPGME_STATUS_IMPORTED));
|
2077
|
+
rb_define_const (mGPGME, "GPGME_STATUS_IMPORT_RES",
|
2078
|
+
INT2FIX(GPGME_STATUS_IMPORT_RES));
|
2079
|
+
rb_define_const (mGPGME, "GPGME_STATUS_FILE_START",
|
2080
|
+
INT2FIX(GPGME_STATUS_FILE_START));
|
2081
|
+
rb_define_const (mGPGME, "GPGME_STATUS_FILE_DONE",
|
2082
|
+
INT2FIX(GPGME_STATUS_FILE_DONE));
|
2083
|
+
rb_define_const (mGPGME, "GPGME_STATUS_FILE_ERROR",
|
2084
|
+
INT2FIX(GPGME_STATUS_FILE_ERROR));
|
2085
|
+
|
2086
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BEGIN_DECRYPTION",
|
2087
|
+
INT2FIX(GPGME_STATUS_BEGIN_DECRYPTION));
|
2088
|
+
rb_define_const (mGPGME, "GPGME_STATUS_END_DECRYPTION",
|
2089
|
+
INT2FIX(GPGME_STATUS_END_DECRYPTION));
|
2090
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BEGIN_ENCRYPTION",
|
2091
|
+
INT2FIX(GPGME_STATUS_BEGIN_ENCRYPTION));
|
2092
|
+
rb_define_const (mGPGME, "GPGME_STATUS_END_ENCRYPTION",
|
2093
|
+
INT2FIX(GPGME_STATUS_END_ENCRYPTION));
|
2094
|
+
|
2095
|
+
rb_define_const (mGPGME, "GPGME_STATUS_DELETE_PROBLEM",
|
2096
|
+
INT2FIX(GPGME_STATUS_DELETE_PROBLEM));
|
2097
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GET_BOOL",
|
2098
|
+
INT2FIX(GPGME_STATUS_GET_BOOL));
|
2099
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GET_LINE",
|
2100
|
+
INT2FIX(GPGME_STATUS_GET_LINE));
|
2101
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GET_HIDDEN",
|
2102
|
+
INT2FIX(GPGME_STATUS_GET_HIDDEN));
|
2103
|
+
rb_define_const (mGPGME, "GPGME_STATUS_GOT_IT",
|
2104
|
+
INT2FIX(GPGME_STATUS_GOT_IT));
|
2105
|
+
rb_define_const (mGPGME, "GPGME_STATUS_PROGRESS",
|
2106
|
+
INT2FIX(GPGME_STATUS_PROGRESS));
|
2107
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SIG_CREATED",
|
2108
|
+
INT2FIX(GPGME_STATUS_SIG_CREATED));
|
2109
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SESSION_KEY",
|
2110
|
+
INT2FIX(GPGME_STATUS_SESSION_KEY));
|
2111
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NOTATION_NAME",
|
2112
|
+
INT2FIX(GPGME_STATUS_NOTATION_NAME));
|
2113
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NOTATION_DATA",
|
2114
|
+
INT2FIX(GPGME_STATUS_NOTATION_DATA));
|
2115
|
+
rb_define_const (mGPGME, "GPGME_STATUS_POLICY_URL",
|
2116
|
+
INT2FIX(GPGME_STATUS_POLICY_URL));
|
2117
|
+
rb_define_const (mGPGME, "GPGME_STATUS_BEGIN_STREAM",
|
2118
|
+
INT2FIX(GPGME_STATUS_BEGIN_STREAM));
|
2119
|
+
rb_define_const (mGPGME, "GPGME_STATUS_END_STREAM",
|
2120
|
+
INT2FIX(GPGME_STATUS_END_STREAM));
|
2121
|
+
rb_define_const (mGPGME, "GPGME_STATUS_KEY_CREATED",
|
2122
|
+
INT2FIX(GPGME_STATUS_KEY_CREATED));
|
2123
|
+
rb_define_const (mGPGME, "GPGME_STATUS_USERID_HINT",
|
2124
|
+
INT2FIX(GPGME_STATUS_USERID_HINT));
|
2125
|
+
rb_define_const (mGPGME, "GPGME_STATUS_UNEXPECTED",
|
2126
|
+
INT2FIX(GPGME_STATUS_UNEXPECTED));
|
2127
|
+
rb_define_const (mGPGME, "GPGME_STATUS_INV_RECP",
|
2128
|
+
INT2FIX(GPGME_STATUS_INV_RECP));
|
2129
|
+
rb_define_const (mGPGME, "GPGME_STATUS_NO_RECP",
|
2130
|
+
INT2FIX(GPGME_STATUS_NO_RECP));
|
2131
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ALREADY_SIGNED",
|
2132
|
+
INT2FIX(GPGME_STATUS_ALREADY_SIGNED));
|
2133
|
+
rb_define_const (mGPGME, "GPGME_STATUS_SIGEXPIRED",
|
2134
|
+
INT2FIX(GPGME_STATUS_SIGEXPIRED));
|
2135
|
+
rb_define_const (mGPGME, "GPGME_STATUS_EXPSIG",
|
2136
|
+
INT2FIX(GPGME_STATUS_EXPSIG));
|
2137
|
+
rb_define_const (mGPGME, "GPGME_STATUS_EXPKEYSIG",
|
2138
|
+
INT2FIX(GPGME_STATUS_EXPKEYSIG));
|
2139
|
+
rb_define_const (mGPGME, "GPGME_STATUS_TRUNCATED",
|
2140
|
+
INT2FIX(GPGME_STATUS_TRUNCATED));
|
2141
|
+
rb_define_const (mGPGME, "GPGME_STATUS_ERROR",
|
2142
|
+
INT2FIX(GPGME_STATUS_ERROR));
|
2143
|
+
|
2144
|
+
/* The available keylist mode flags. */
|
2145
|
+
rb_define_const (mGPGME, "GPGME_KEYLIST_MODE_LOCAL",
|
2146
|
+
INT2FIX(GPGME_KEYLIST_MODE_LOCAL));
|
2147
|
+
rb_define_const (mGPGME, "GPGME_KEYLIST_MODE_EXTERN",
|
2148
|
+
INT2FIX(GPGME_KEYLIST_MODE_EXTERN));
|
2149
|
+
rb_define_const (mGPGME, "GPGME_KEYLIST_MODE_SIGS",
|
2150
|
+
INT2FIX(GPGME_KEYLIST_MODE_SIGS));
|
2151
|
+
rb_define_const (mGPGME, "GPGME_KEYLIST_MODE_VALIDATE",
|
2152
|
+
INT2FIX(GPGME_KEYLIST_MODE_VALIDATE));
|
2153
|
+
|
2154
|
+
/* The available flags for status field of gpgme_import_status_t. */
|
2155
|
+
rb_define_const (mGPGME, "GPGME_IMPORT_NEW", INT2FIX(GPGME_IMPORT_NEW));
|
2156
|
+
rb_define_const (mGPGME, "GPGME_IMPORT_UID", INT2FIX(GPGME_IMPORT_UID));
|
2157
|
+
rb_define_const (mGPGME, "GPGME_IMPORT_SIG", INT2FIX(GPGME_IMPORT_SIG));
|
2158
|
+
rb_define_const (mGPGME, "GPGME_IMPORT_SUBKEY",
|
2159
|
+
INT2FIX(GPGME_IMPORT_SUBKEY));
|
2160
|
+
rb_define_const (mGPGME, "GPGME_IMPORT_SECRET",
|
2161
|
+
INT2FIX(GPGME_IMPORT_SECRET));
|
2162
|
+
|
2163
|
+
/* The available flags for gpgme_op_encrypt. */
|
2164
|
+
rb_define_const (mGPGME, "GPGME_ENCRYPT_ALWAYS_TRUST",
|
2165
|
+
INT2FIX(GPGME_ENCRYPT_ALWAYS_TRUST));
|
2166
|
+
}
|