← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/pidgin/intrepid-proposed

« back to all changes in this revision

Viewing changes to libpurple/plugins/perl/common/Certificate.xs

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-09-16 22:13:07 UTC
  • mto: This revision was merged to the branch mainline in revision 28.
  • Revision ID: james.westby@ubuntu.com-20080916221307-plkfuu6a8of5ocr3
Tags: upstream-2.5.1
Import upstream version 2.5.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpurple/plugins/perl/common/Certificate.xs
 
1
#include "module.h"
 
2
 
 
3
struct cb_data {
 
4
        SV *cb;
 
5
        SV *user_data;
 
6
};
 
7
 
 
8
static void cb_cert_verify(PurpleCertificateVerificationStatus st, struct cb_data *d) {
 
9
        dSP;
 
10
 
 
11
        ENTER;
 
12
        SAVETMPS;
 
13
 
 
14
        PUSHMARK(SP);
 
15
 
 
16
        XPUSHs(sv_2mortal(newSViv(st)));
 
17
        XPUSHs(d->user_data);
 
18
 
 
19
        PUTBACK;
 
20
 
 
21
        call_sv(d->cb, G_VOID | G_EVAL);
 
22
 
 
23
        if(SvTRUE(ERRSV)) {
 
24
                STRLEN l_a;
 
25
                purple_debug_warning("perl", "Failed to run 'certificate verify' callback: %s\n", SvPV(ERRSV, l_a));
 
26
        }
 
27
 
 
28
        FREETMPS;
 
29
        LEAVE;
 
30
 
 
31
        SvREFCNT_dec(d->cb);
 
32
        SvREFCNT_dec(d->user_data);
 
33
 
 
34
        g_free(d);
 
35
}
 
36
 
 
37
MODULE = Purple::Certificate  PACKAGE = Purple::Certificate  PREFIX = purple_certificate_
 
38
PROTOTYPES: ENABLE
 
39
 
 
40
BOOT:
 
41
{
 
42
        HV *stash = gv_stashpv("Purple::Certificate", 1);
 
43
 
 
44
        static const constiv *civ, const_iv[] = {
 
45
#define const_iv(name) {#name, (IV)PURPLE_CERTIFICATE_##name}
 
46
                const_iv(INVALID),
 
47
                const_iv(VALID),
 
48
        };
 
49
 
 
50
        for (civ = const_iv + sizeof(const_iv) / sizeof(const_iv[0]); civ-- > const_iv; )
 
51
                newCONSTSUB(stash, (char *)civ->name, newSViv(civ->iv));
 
52
}
 
53
 
 
54
void
 
55
purple_certificate_add_ca_search_path(path)
 
56
        const char* path
 
57
 
 
58
gboolean
 
59
purple_certificate_check_subject_name(crt, name)
 
60
        Purple::Certificate crt
 
61
        const gchar* name
 
62
 
 
63
Purple::Certificate
 
64
purple_certificate_copy(crt)
 
65
        Purple::Certificate crt
 
66
 
 
67
void
 
68
purple_certificate_destroy(crt)
 
69
        Purple::Certificate crt
 
70
 
 
71
void
 
72
purple_certificate_display_x509(crt)
 
73
        Purple::Certificate crt
 
74
 
 
75
## changed order of arguments, so that $cert->export($file) could be used
 
76
gboolean
 
77
purple_certificate_export(crt, filename)
 
78
        const gchar* filename
 
79
        Purple::Certificate crt
 
80
        C_ARGS:
 
81
                filename, crt
 
82
 
 
83
Purple::Certificate::Pool
 
84
purple_certificate_find_pool(scheme_name, pool_name)
 
85
        const gchar* scheme_name
 
86
        const gchar* pool_name
 
87
 
 
88
Purple::Certificate::Scheme
 
89
purple_certificate_find_scheme(name)
 
90
        const gchar* name
 
91
 
 
92
Purple::Certificate::Verifier
 
93
purple_certificate_find_verifier(scheme_name, ver_name)
 
94
        const gchar* scheme_name
 
95
        const gchar* ver_name
 
96
 
 
97
Purple::Handle
 
98
purple_certificate_get_handle()
 
99
 
 
100
gchar_own*
 
101
purple_certificate_get_issuer_unique_id(crt)
 
102
        Purple::Certificate crt
 
103
 
 
104
gchar_own*
 
105
purple_certificate_get_subject_name(crt)
 
106
        Purple::Certificate crt
 
107
 
 
108
gchar_own*
 
109
purple_certificate_get_unique_id(crt)
 
110
        Purple::Certificate crt
 
111
 
 
112
Purple::Certificate
 
113
purple_certificate_import(scheme, filename)
 
114
        Purple::Certificate::Scheme scheme
 
115
        const gchar* filename
 
116
 
 
117
gboolean
 
118
purple_certificate_register_pool(pool)
 
119
        Purple::Certificate::Pool pool
 
120
 
 
121
gboolean
 
122
purple_certificate_register_scheme(scheme)
 
123
        Purple::Certificate::Scheme scheme
 
124
 
 
125
gboolean
 
126
purple_certificate_register_verifier(vr)
 
127
        Purple::Certificate::Verifier vr
 
128
 
 
129
gboolean
 
130
purple_certificate_signed_by(crt, issuer)
 
131
        Purple::Certificate crt
 
132
        Purple::Certificate issuer
 
133
 
 
134
gboolean
 
135
purple_certificate_unregister_pool(pool)
 
136
        Purple::Certificate::Pool pool
 
137
 
 
138
gboolean
 
139
purple_certificate_unregister_scheme(scheme)
 
140
        Purple::Certificate::Scheme scheme
 
141
 
 
142
gboolean
 
143
purple_certificate_unregister_verifier(vr)
 
144
        Purple::Certificate::Verifier vr
 
145
 
 
146
void
 
147
purple_certificate_verify_complete(vrq, st)
 
148
        Purple::Certificate::VerificationRequest vrq
 
149
        Purple::Certificate::VerificationStatus st
 
150
 
 
151
gboolean
 
152
purple_certificate_get_times(crt, OUTLIST time_t activation, OUTLIST time_t expiration)
 
153
        Purple::Certificate crt
 
154
        PROTOTYPE: $
 
155
 
 
156
void
 
157
purple_certificate_destroy_list(...)
 
158
        PREINIT:
 
159
        GList* l = NULL;
 
160
        int i = 0;
 
161
        CODE:
 
162
                for(i = 0; i < items; i++) { /* PurpleCertificate */
 
163
                        l = g_list_prepend(l, purple_perl_ref_object(ST(i)));
 
164
                }
 
165
                purple_certificate_destroy_list(l);
 
166
 
 
167
void
 
168
purple_certificate_get_pools()
 
169
        PREINIT:
 
170
                GList *l;
 
171
        PPCODE:
 
172
                for(l = purple_certificate_get_pools(); l; l = l->next) {
 
173
                        XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Certificate::Pool")));
 
174
                }
 
175
 
 
176
void
 
177
purple_certificate_get_schemes()
 
178
        PREINIT:
 
179
                GList *l;
 
180
        PPCODE:
 
181
                for(l = purple_certificate_get_schemes(); l; l = l->next) {
 
182
                        XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Certificate::Scheme")));
 
183
                }
 
184
 
 
185
void
 
186
purple_certificate_get_verifiers()
 
187
        PREINIT:
 
188
                GList *l;
 
189
        PPCODE:
 
190
                for(l = purple_certificate_get_verifiers(); l; l = l->next) {
 
191
                        XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Certificate::Verifier")));
 
192
                }
 
193
 
 
194
void
 
195
purple_certificate_check_signature_chain(...)
 
196
        PREINIT:
 
197
                GList *l = NULL;
 
198
                gboolean ret;
 
199
                int i;
 
200
        PPCODE:
 
201
                for(i = 0; i < items; i++) { /* PurpleCertificate */
 
202
                        l = g_list_prepend(l, purple_perl_ref_object(ST(i)));
 
203
                }
 
204
                l = g_list_reverse(l);
 
205
                ret = purple_certificate_check_signature_chain(l);
 
206
                g_list_free(l);
 
207
                if(ret) XSRETURN_YES;
 
208
                XSRETURN_NO;
 
209
 
 
210
SV*
 
211
purple_certificate_get_fingerprint_sha1(crt)
 
212
        Purple::Certificate crt
 
213
        PREINIT:
 
214
                GByteArray *gba = NULL;
 
215
        CODE:
 
216
                gba = purple_certificate_get_fingerprint_sha1(crt);
 
217
                RETVAL = newSVpv(gba->data, gba->len);
 
218
                g_byte_array_free(gba, TRUE);
 
219
        OUTPUT:
 
220
                RETVAL
 
221
 
 
222
void
 
223
purple_certificate_verify(verifier, subject_name, cert_chain, cb, cb_data)
 
224
        Purple::Certificate::Verifier verifier
 
225
        const gchar* subject_name
 
226
        AV* cert_chain
 
227
        CV *cb
 
228
        SV *cb_data
 
229
        PREINIT:
 
230
                GList *l = NULL;
 
231
                int len = 0, i = 0;
 
232
                struct cb_data *d = NULL;
 
233
        PPCODE:
 
234
                len = av_len(cert_chain) + 1;
 
235
                for(i = 0; i < len; i++) {
 
236
                        SV **sv = av_fetch(cert_chain, i, 0);
 
237
                        if(!sv || !purple_perl_is_ref_object(*sv)) {
 
238
                                g_list_free(l);
 
239
                                warn("Purple::Certificate::verify: cert_chain: non-purple object in array...");
 
240
                                XSRETURN_UNDEF;
 
241
                        }
 
242
                        l = g_list_prepend(l, purple_perl_ref_object(*sv));
 
243
                }
 
244
                l = g_list_reverse(l);
 
245
 
 
246
                d = g_new0(struct cb_data, 1);
 
247
                d->cb = newSVsv(ST(3));
 
248
                d->user_data = newSVsv(cb_data);
 
249
                
 
250
                purple_certificate_verify(verifier, subject_name, l, (PurpleCertificateVerifiedCallback) cb_cert_verify, d);
 
251
 
 
252
                g_list_free(l);
 
253
 
 
254
MODULE = Purple::Certificate  PACKAGE = Purple::Certificate::Pool  PREFIX = purple_certificate_pool_
 
255
PROTOTYPES: ENABLE
 
256
 
 
257
void
 
258
purple_certificate_pool_get_idlist(pool)
 
259
        Purple::Certificate::Pool pool
 
260
        PREINIT:
 
261
                GList *l, *b;
 
262
        PPCODE:
 
263
                b = purple_certificate_pool_get_idlist(pool);
 
264
                for(l = b; l; l = l->next) {
 
265
                        XPUSHs(sv_2mortal(newSVpv(l->data, 0)));
 
266
                }
 
267
                purple_certificate_pool_destroy_idlist(b);
 
268
 
 
269
gboolean
 
270
purple_certificate_pool_contains(pool, id)
 
271
        Purple::Certificate::Pool pool
 
272
        const gchar* id
 
273
 
 
274
gboolean
 
275
purple_certificate_pool_delete(pool, id)
 
276
        Purple::Certificate::Pool pool
 
277
        const gchar* id
 
278
 
 
279
Purple::Certificate::Scheme
 
280
purple_certificate_pool_get_scheme(pool)
 
281
        Purple::Certificate::Pool pool
 
282
 
 
283
gchar_own*
 
284
purple_certificate_pool_mkpath(pool, id)
 
285
        Purple::Certificate::Pool pool
 
286
        const gchar* id
 
287
 
 
288
Purple::Certificate
 
289
purple_certificate_pool_retrieve(pool, id)
 
290
        Purple::Certificate::Pool pool
 
291
        const gchar* id
 
292
 
 
293
gboolean
 
294
purple_certificate_pool_store(pool, id, crt)
 
295
        Purple::Certificate::Pool pool
 
296
        const gchar* id
 
297
        Purple::Certificate crt
 
298
 
 
299
gboolean
 
300
purple_certificate_pool_usable(pool)
 
301
        Purple::Certificate::Pool pool
 
302