[catacomb-perl] / key.xs

# ---?---
#
# $Id$
#
# Key-management interface
#
# (c) 2001 Straylight/Edgeware
#

#----- Licensing notice -----------------------------------------------------
#
# This file is part of the Perl interface to Catacomb.
#
# Catacomb/Perl is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# Catacomb/Perl is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Catacomb/Perl; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

MODULE = Catacomb PACKAGE = Catacomb::Key PREFIX = key_

bool
key_chkident(me, p)
	SV *me
	char *p
	C_ARGS:
	p

bool
key_chkcomment(me, p)
	SV *me
	char *p
	C_ARGS:
	p

time_t
exp(k)
	Key *k
	CODE:
	RETVAL = k->k->exp;
	OUTPUT:
	RETVAL

time_t
del(k)
	Key *k
	CODE:
	RETVAL = k->k->del;
	OUTPUT:
	RETVAL

Key_Data *
data(k)
	Key *k
	CODE:
	RETVAL = &k->k->k;
	OUTPUT:
	RETVAL

char *
comment(k)
	Key *k
	CODE:
	RETVAL = k->k->c;
	OUTPUT:
	RETVAL

U32
id(k)
	Key *k
	CODE:
	RETVAL = k->k->id;
	OUTPUT:
	RETVAL

char *
tag(k)
	Key *k
	CODE:
	RETVAL = k->k->tag;
	OUTPUT:
	RETVAL

char *
type(k)
	Key *k
	CODE:
	RETVAL = k->k->type;
	OUTPUT:
	RETVAL

KeyErr
key_setcomment(k, p)
	Key *k
	char *p
	C_ARGS:
	k->kf, k->k, p

KeyErr
key_settag(k, p)
	Key *k
	char *p
	C_ARGS:
	k->kf, k->k, p

KeyErr
key_delete(k)
	Key *k
	C_ARGS:
	k->kf, k->k

SV *
fulltag(k)
	Key *k
	PREINIT:
	dstr d = DSTR_INIT;
	CODE:
	key_fulltag(k->k, &d);
	RETVAL = newSVpv(d.buf, d.len);
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

const char *
key_getattr(k, a)
	Key *k
	char *a
	C_ARGS:
	k->kf, k->k, a

KeyErr
key_putattr(k, a, v)
	Key *k
	char *a
	char *v
	C_ARGS:
	k->kf, k->k, a, v

void
attrlist(k)
	Key *k
	PREINIT:
	key_attriter i;
	const char *a, *v;
	PPCODE:
	for (key_mkattriter(&i, k->k); key_nextattr(&i, &a, &v); )
	  XPUSHs(sv_2mortal(newSVpv((char *)a, strlen(a))));

bool
expiredp(k)
	Key *k
	CODE:
	RETVAL = key_expired(k->k);
	OUTPUT:
	RETVAL

KeyErr
key_expire(k)
	Key *k
	C_ARGS:
	k->kf, k->k

KeyErr
key_used(k, t)
	Key *k
	time_t t
	C_ARGS:
	k->kf, k->k, t

bool
fingerprint(k, h, kfiltstr)
	Key *k
	ghash *h
	char *kfiltstr
	PREINIT:
	key_filter kfilt;
	dstr d = DSTR_INIT;
	CODE:
	if (!kfiltstr)
	  kfilt.f = kfilt.m = 0;
	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	  croak("bad filter string `%s'", kfiltstr);
	RETVAL = key_fingerprint(k->k, h, &kfilt);
	OUTPUT:
	RETVAL

const char *
key_strerror(me, err)
	SV *me
	int err
	C_ARGS:
	err

MODULE = Catacomb PACKAGE = Catacomb::Key::Data PREFIX = key_

Key_Data *
_new(me)
	SV *me
	CODE:
	RETVAL = CREATE(key_data);
	RETVAL->e = 0;
	RETVAL->u.k.k = 0;
	RETVAL->u.k.sz = 0;
	OUTPUT:
	RETVAL

SV *
destroy(kd)
	Key_Data *kd
	CODE:
	key_destroy(kd);
	XSRETURN_YES;

SV *
setbinary(kd, sv)
	Key_Data *kd
	SV *sv
	PREINIT:
	char *p;
	STRLEN len;
	CODE:
	p = SvPV(sv, len);
	key_binary(kd, p, len);
	XSRETURN_YES;

SV *
setencrypted(kd, sv)
	Key_Data *kd
	SV *sv
	PREINIT:
	char *p;
	STRLEN len;
	CODE:
	p = SvPV(sv, len);
	key_encrypted(kd, p, len);
	XSRETURN_YES;

SV *
setmp(kd, x)
	Key_Data *kd
	mp *x
	CODE:
	key_mp(kd, x);
	XSRETURN_YES;

SV *
setstring(kd, p)
	Key_Data *kd
	char *p
	CODE:
	key_string(kd, p);
	XSRETURN_YES;

SV *
setec(kd, p)
	Key_Data *kd
	EC_Point *p
	CODE:
	key_ec(kd, p);
	XSRETURN_YES;

U32
flags(kd)
	Key_Data *kd
	CODE:
	RETVAL = kd->e;
	OUTPUT:	
	RETVAL

SV *
getbinary(kd)
	Key_Data *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_BINARY)
	  croak("key is not binary");
	RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
	OUTPUT:
	RETVAL

SV *
getencrypted(kd)
	Key_Data *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	  croak("key is not encrypted");
	RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
	OUTPUT:
	RETVAL

mp *
getmp(kd)
	Key_Data *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_MP)
	  croak("key is not bignum");
	RETVAL = kd->u.m;
	OUTPUT:
	RETVAL

EC_Point *
getec(kd)
	Key_Data *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_EC)
	  croak("key is not a curve point");
	RETVAL = CREATE(ec);
	EC_CREATE(RETVAL);
	EC_COPY(RETVAL, &kd->u.e);
	OUTPUT:
	RETVAL

char *
getstring(kd)
	Key_Data *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_STRING)
	  croak("key is not string");
	RETVAL = kd->u.p;
	OUTPUT:
	RETVAL

SV *
setstruct(kd)
	Key_Data *kd
	CODE:
	key_structure(kd);
	XSRETURN_YES;

Key_Data *
key_structfind(kd, tag)
	Key_Data *kd
	char *tag

Key_Data *
key_structcreate(kd, tag)
	Key_Data *kd
	char *tag

void
getstruct(kd)
	Key_Data *kd
	PREINIT:
	sym_iter i;
	key_struct *ks;
	PPCODE:
	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	  croak("key is not structured");
	for (sym_mkiter(&i, &kd->u.s); ks = sym_next(&i); )
	  XPUSHs(RET(&ks->k, "Catacomb::Key::Data"));

SV *
structdel(kd, tag)
	Key_Data *kd
	char *tag
	PREINIT:
	key_struct *ks;
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	  croak("key is not structured");
	if ((ks = sym_find(&kd->u.s, tag, -1, 0, 0)) == 0)
	  XSRETURN_UNDEF;
	sym_remove(&kd->u.s, ks);
	XSRETURN_YES;

void
readflags(me, p)
	SV *me
	char *p
	PREINIT:
	unsigned f, m;
	PPCODE:
	if (key_readflags(p, &p, &f, &m) || *p)
	  croak("bad flags string");
	XPUSHs(sv_2mortal(newSVuv(m)));
	XPUSHs(sv_2mortal(newSVuv(f)));

SV *
getflags(me, f)
	SV *me
	U32 f
	PREINIT:
	dstr d = DSTR_INIT;
	CODE:
	key_writeflags(f, &d);
	RETVAL = newSVpv(d.buf, d.len);
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

Key_Data *
copy(kd, kfiltstr = 0)
	Key_Data *kd
	char *kfiltstr
	PREINIT:
	key_filter kfilt;
	CODE:
	if (!kfiltstr)
	  kfilt.f = kfilt.m = 0;
	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	  croak("bad filter string `%s'", kfiltstr);
	RETVAL = CREATE(key_data);
	if (!key_copy(RETVAL, kd, &kfilt)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key_Data *
plock(kd, tag)
	Key_Data *kd
	char *tag
	CODE:
	RETVAL = CREATE(Key_Data);
	if (key_plock(tag, kd, RETVAL)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key_Data *
punlock(kd, tag)
	Key_Data *kd
	char *tag
	CODE:
	RETVAL = CREATE(Key_Data);
	if (key_punlock(tag, kd, RETVAL)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key_Data *
read(me, p)
	SV *me
	char *p
	CODE:
	RETVAL = CREATE(key_data);
	if (key_read(p, RETVAL, 0)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

SV *
write(kd, kfiltstr = 0)
	Key_Data *kd
	char *kfiltstr
	PREINIT:
	key_filter kfilt;
	dstr d = DSTR_INIT;
	CODE:
	if (!kfiltstr)
	  kfilt.f = kfilt.m = 0;
	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	  croak("bad filter string `%s'", kfiltstr);
	if (key_write(kd, &d, &kfilt))
	  RETVAL = newSVpv(d.buf, d.len);
	else
	  RETVAL = &PL_sv_undef;
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

Key_Data *
decode(me, sv)
	SV *me
	SV *sv
	PREINIT:
	char *p;
	STRLEN len;
	CODE:
	p = SvPV(sv, len);
	RETVAL = CREATE(key_data);
	if (key_decode(p, len, RETVAL)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

SV *
encode(kd, kfiltstr = 0)
	Key_Data *kd
	char *kfiltstr
	PREINIT:
	key_filter kfilt;
	dstr d = DSTR_INIT;
	CODE:
	if (!kfiltstr)
	  kfilt.f = kfilt.m = 0;
	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	  croak("bad filter string `%s'", kfiltstr);
	if (key_encode(kd, &d, &kfilt))
	  RETVAL = newSVpv(d.buf, d.len);
	else
	  RETVAL = &PL_sv_undef;
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_

Key_File *
new(me, file, how)
	SV *me
	char *file
	unsigned how
	CODE:
	RETVAL = CREATE(key_file);
	if (key_open(RETVAL, file, how, warn_keyreporter, 0)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

SV *
DESTROY(kf)
	Key_File *kf
	CODE:
	key_close(kf);
	DESTROY(kf);
	XSRETURN_UNDEF;

KeyErr
merge(kf, name, fp)
	Key_File *kf
	char *name
	FILE *fp
	CODE:
	RETVAL = key_merge(kf, name, fp, warn_keyreporter, 0);
	OUTPUT:
	RETVAL

bool
extract(kf, k, fp, kfiltstr = 0)
	Key_File *kf
	Key *k
	FILE *fp
	char *kfiltstr
	PREINIT:
	key_filter kfilt;
	CODE:
	if (!kfiltstr)
	  kfilt.f = kfilt.m = 0;
	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	  croak("bad filter string `%s'", kfiltstr);
	RETVAL = key_extract(kf, k->k, fp, &kfilt);
	OUTPUT:
	RETVAL

int
key_save(kf)
	Key_File *kf

void
qtag(kf, tag)
	Key_File *kf
	char *tag
	PREINIT:
	dstr d = DSTR_INIT;
	Key *k;
	key_data *kd;
	PPCODE:
	k = CREATE(Key);
	kd = CREATE(key_data);
	if (key_qtag(kf, tag, &d, &k->k, &kd)) {
	  DESTROY(k);
	  DESTROY(kd);
	  XPUSHs(&PL_sv_undef);
	  XPUSHs(&PL_sv_undef);
	  XPUSHs(&PL_sv_undef);
	} else {
	  k->kf = kf;
	  XPUSHs(sv_2mortal(newSVpv(d.buf, d.len)));
	  XPUSHs(RET(k, "Catacomb::Key"));
	  XPUSHs(RET(k, "Catacomb::Key::Data"));
	}
	dstr_destroy(&d);

Key *
bytype(kf, type)
	Key_File *kf
	char *type
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_bytype(kf, type)) != 0)
	  RETVAL->kf = kf;
	else {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key *
byid(kf, id)
	Key_File *kf
	U32 id
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_byid(kf, id)) != 0)
	  RETVAL->kf = kf;
	else {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key *
bytag(kf, tag)
	Key_File *kf
	char *tag
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_bytag(kf, tag)) != 0)
	  RETVAL->kf = kf;
	else {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

void
list(kf)
	Key_File *kf
	PREINIT:
	key_iter i;
	key *k;
	Key *kk;
	PPCODE:
	for (key_mkiter(&i, kf); k = key_next(&i); ) {
	  kk = CREATE(Key);
	  kk->kf = kf;
	  kk->k = k;
	  XPUSHs(RET(kk, "Catacomb::Key"));
	}

#----- That's all, folks ----------------------------------------------------
Commit	Line	Data
660b443c	1	# ---?---
660b443c	2	#
a1a90aaf	3	# $Id$
660b443c	4	#
	5	# Key-management interface
	6	#
	7	# (c) 2001 Straylight/Edgeware
	8	#
	9
	10	#----- Licensing notice -----------------------------------------------------
	11	#
	12	# This file is part of the Perl interface to Catacomb.
	13	#
	14	# Catacomb/Perl is free software; you can redistribute it and/or modify
	15	# it under the terms of the GNU General Public License as published by
	16	# the Free Software Foundation; either version 2 of the License, or
	17	# (at your option) any later version.
	18	#
	19	# Catacomb/Perl is distributed in the hope that it will be useful,
	20	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	# GNU General Public License for more details.
	23	#
	24	# You should have received a copy of the GNU General Public License
	25	# along with Catacomb/Perl; if not, write to the Free Software Foundation,
	26	# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27
a1a90aaf	28	MODULE = Catacomb PACKAGE = Catacomb::Key PREFIX = key_
660b443c	29
a1a90aaf	30	bool
	31	key_chkident(me, p)
	32	SV *me
	33	char *p
	34	C_ARGS:
	35	p
	36
	37	bool
	38	key_chkcomment(me, p)
	39	SV *me
	40	char *p
	41	C_ARGS:
	42	p
	43
	44	time_t
	45	exp(k)
	46	Key *k
	47	CODE:
	48	RETVAL = k->k->exp;
	49	OUTPUT:
	50	RETVAL
	51
	52	time_t
	53	del(k)
	54	Key *k
	55	CODE:
	56	RETVAL = k->k->del;
	57	OUTPUT:
	58	RETVAL
	59
	60	Key_Data *
	61	data(k)
	62	Key *k
	63	CODE:
	64	RETVAL = &k->k->k;
	65	OUTPUT:
	66	RETVAL
	67
	68	char *
	69	comment(k)
	70	Key *k
	71	CODE:
	72	RETVAL = k->k->c;
	73	OUTPUT:
	74	RETVAL
	75
	76	U32
	77	id(k)
	78	Key *k
	79	CODE:
	80	RETVAL = k->k->id;
	81	OUTPUT:
	82	RETVAL
	83
	84	char *
	85	tag(k)
	86	Key *k
	87	CODE:
	88	RETVAL = k->k->tag;
	89	OUTPUT:
	90	RETVAL
	91
	92	char *
	93	type(k)
94	Key *k
95	CODE:
96	RETVAL = k->k->type;
97	OUTPUT:
98	RETVAL
99
100	KeyErr
101	key_setcomment(k, p)
102	Key *k
103	char *p
104	C_ARGS:
105	k->kf, k->k, p
106
107	KeyErr
108	key_settag(k, p)
109	Key *k
110	char *p
111	C_ARGS:
112	k->kf, k->k, p
113
114	KeyErr
115	key_delete(k)
116	Key *k
117	C_ARGS:
118	k->kf, k->k
119
120	SV *
121	fulltag(k)
122	Key *k
123	PREINIT:
124	dstr d = DSTR_INIT;
125	CODE:
126	key_fulltag(k->k, &d);
127	RETVAL = newSVpv(d.buf, d.len);
128	dstr_destroy(&d);
129	OUTPUT:
130	RETVAL
131
132	const char *
133	key_getattr(k, a)
134	Key *k
135	char *a
136	C_ARGS:
137	k->kf, k->k, a
138
139	KeyErr
140	key_putattr(k, a, v)
141	Key *k
142	char *a
143	char *v
144	C_ARGS:
145	k->kf, k->k, a, v
146
147	void
148	attrlist(k)
149	Key *k
150	PREINIT:
151	key_attriter i;
152	const char a, v;
153	PPCODE:
154	for (key_mkattriter(&i, k->k); key_nextattr(&i, &a, &v); )
155	XPUSHs(sv_2mortal(newSVpv((char *)a, strlen(a))));
156
157	bool
158	expiredp(k)
159	Key *k
160	CODE:
161	RETVAL = key_expired(k->k);
162	OUTPUT:
163	RETVAL
164
165	KeyErr
166	key_expire(k)
167	Key *k
168	C_ARGS:
169	k->kf, k->k
170
171	KeyErr
172	key_used(k, t)
173	Key *k
174	time_t t
175	C_ARGS:
176	k->kf, k->k, t
177
178	bool
179	fingerprint(k, h, kfiltstr)
180	Key *k
181	ghash *h
182	char *kfiltstr
183	PREINIT:
184	key_filter kfilt;
185	dstr d = DSTR_INIT;
186	CODE:
187	if (!kfiltstr)
188	kfilt.f = kfilt.m = 0;
189	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
190	croak("bad filter string `%s'", kfiltstr);
191	RETVAL = key_fingerprint(k->k, h, &kfilt);
192	OUTPUT:
193	RETVAL
194
195	const char *
196	key_strerror(me, err)
197	SV *me
198	int err
199	C_ARGS:
200	err
201
202	MODULE = Catacomb PACKAGE = Catacomb::Key::Data PREFIX = key_
203
204	Key_Data *
205	_new(me)
206	SV *me
207	CODE:
208	RETVAL = CREATE(key_data);
209	RETVAL->e = 0;
210	RETVAL->u.k.k = 0;
211	RETVAL->u.k.sz = 0;
212	OUTPUT:
213	RETVAL
214
215	SV *
216	destroy(kd)
217	Key_Data *kd
218	CODE:
219	key_destroy(kd);
220	XSRETURN_YES;
221
222	SV *
223	setbinary(kd, sv)
224	Key_Data *kd
225	SV *sv
226	PREINIT:
227	char *p;
228	STRLEN len;
229	CODE:
230	p = SvPV(sv, len);
231	key_binary(kd, p, len);
232	XSRETURN_YES;
233
234	SV *
235	setencrypted(kd, sv)
236	Key_Data *kd
237	SV *sv
238	PREINIT:
239	char *p;
240	STRLEN len;
241	CODE:
242	p = SvPV(sv, len);
243	key_encrypted(kd, p, len);
244	XSRETURN_YES;
245
246	SV *
247	setmp(kd, x)
248	Key_Data *kd
249	mp *x
250	CODE:
251	key_mp(kd, x);
252	XSRETURN_YES;
253
254	SV *
255	setstring(kd, p)
256	Key_Data *kd
257	char *p
258	CODE:
259	key_string(kd, p);
260	XSRETURN_YES;
261
262	SV *
263	setec(kd, p)
264	Key_Data *kd
265	EC_Point *p
266	CODE:
267	key_ec(kd, p);
268	XSRETURN_YES;
269
270	U32
271	flags(kd)
272	Key_Data *kd
273	CODE:
274	RETVAL = kd->e;
275	OUTPUT:
276	RETVAL
277
278	SV *
279	getbinary(kd)
280	Key_Data *kd
281	CODE:
282	if ((kd->e & KF_ENCMASK) != KENC_BINARY)
283	croak("key is not binary");
284	RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
285	OUTPUT:
286	RETVAL
287
288	SV *
289	getencrypted(kd)
290	Key_Data *kd
291	CODE:
292	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
293	croak("key is not encrypted");
294	RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
295	OUTPUT:
296	RETVAL
297
298	mp *
299	getmp(kd)
300	Key_Data *kd
301	CODE:
302	if ((kd->e & KF_ENCMASK) != KENC_MP)
303	croak("key is not bignum");
304	RETVAL = kd->u.m;
305	OUTPUT:
306	RETVAL
307
308	EC_Point *
309	getec(kd)
310	Key_Data *kd
311	CODE:
312	if ((kd->e & KF_ENCMASK) != KENC_EC)
313	croak("key is not a curve point");
314	RETVAL = CREATE(ec);
315	EC_CREATE(RETVAL);
316	EC_COPY(RETVAL, &kd->u.e);
317	OUTPUT:
318	RETVAL
319
320	char *
321	getstring(kd)
322	Key_Data *kd
323	CODE:
324	if ((kd->e & KF_ENCMASK) != KENC_STRING)
325	croak("key is not string");
326	RETVAL = kd->u.p;
327	OUTPUT:
328	RETVAL
329
330	SV *
331	setstruct(kd)
332	Key_Data *kd
333	CODE:
334	key_structure(kd);
335	XSRETURN_YES;
336
337	Key_Data *
338	key_structfind(kd, tag)
339	Key_Data *kd
340	char *tag
341
342	Key_Data *
343	key_structcreate(kd, tag)
344	Key_Data *kd
345	char *tag
346
347	void
348	getstruct(kd)
349	Key_Data *kd
350	PREINIT:
351	sym_iter i;
352	key_struct *ks;
353	PPCODE:
354	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
355	croak("key is not structured");
356	for (sym_mkiter(&i, &kd->u.s); ks = sym_next(&i); )
357	XPUSHs(RET(&ks->k, "Catacomb::Key::Data"));
358
359	SV *
360	structdel(kd, tag)
361	Key_Data *kd
362	char *tag
363	PREINIT:
364	key_struct *ks;
365	CODE:
366	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
367	croak("key is not structured");
368	if ((ks = sym_find(&kd->u.s, tag, -1, 0, 0)) == 0)
369	XSRETURN_UNDEF;
370	sym_remove(&kd->u.s, ks);
371	XSRETURN_YES;
372
373	void
374	readflags(me, p)
375	SV *me
376	char *p
377	PREINIT:
378	unsigned f, m;
379	PPCODE:
380	if (key_readflags(p, &p, &f, &m) \|\| *p)
381	croak("bad flags string");
382	XPUSHs(sv_2mortal(newSVuv(m)));
383	XPUSHs(sv_2mortal(newSVuv(f)));
384
385	SV *
386	getflags(me, f)
387	SV *me
388	U32 f
389	PREINIT:
390	dstr d = DSTR_INIT;
391	CODE:
392	key_writeflags(f, &d);
393	RETVAL = newSVpv(d.buf, d.len);
394	dstr_destroy(&d);
395	OUTPUT:
396	RETVAL
397
398	Key_Data *
399	copy(kd, kfiltstr = 0)
400	Key_Data *kd
401	char *kfiltstr
402	PREINIT:
403	key_filter kfilt;
404	CODE:
405	if (!kfiltstr)
406	kfilt.f = kfilt.m = 0;
407	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
408	croak("bad filter string `%s'", kfiltstr);
409	RETVAL = CREATE(key_data);
410	if (!key_copy(RETVAL, kd, &kfilt)) {
411	DESTROY(RETVAL);
412	RETVAL = 0;
413	}
414	OUTPUT:
415	RETVAL
416
417	Key_Data *
418	plock(kd, tag)
419	Key_Data *kd
420	char *tag
421	CODE:
422	RETVAL = CREATE(Key_Data);
423	if (key_plock(tag, kd, RETVAL)) {
424	DESTROY(RETVAL);
425	RETVAL = 0;
426	}
427	OUTPUT:
428	RETVAL
429
430	Key_Data *
431	punlock(kd, tag)
432	Key_Data *kd
433	char *tag
434	CODE:
435	RETVAL = CREATE(Key_Data);
436	if (key_punlock(tag, kd, RETVAL)) {
437	DESTROY(RETVAL);
438	RETVAL = 0;
439	}
440	OUTPUT:
441	RETVAL
442
443	Key_Data *
444	read(me, p)
445	SV *me
446	char *p
447	CODE:
448	RETVAL = CREATE(key_data);
449	if (key_read(p, RETVAL, 0)) {
450	DESTROY(RETVAL);
451	RETVAL = 0;
452	}
453	OUTPUT:
454	RETVAL
455
456	SV *
457	write(kd, kfiltstr = 0)
458	Key_Data *kd
459	char *kfiltstr
460	PREINIT:
461	key_filter kfilt;
462	dstr d = DSTR_INIT;
463	CODE:
464	if (!kfiltstr)
465	kfilt.f = kfilt.m = 0;
466	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
467	croak("bad filter string `%s'", kfiltstr);
468	if (key_write(kd, &d, &kfilt))
469	RETVAL = newSVpv(d.buf, d.len);
470	else
471	RETVAL = &PL_sv_undef;
472	dstr_destroy(&d);
473	OUTPUT:
474	RETVAL
475
476	Key_Data *
477	decode(me, sv)
478	SV *me
479	SV *sv
480	PREINIT:
481	char *p;
482	STRLEN len;
483	CODE:
484	p = SvPV(sv, len);
485	RETVAL = CREATE(key_data);
486	if (key_decode(p, len, RETVAL)) {
487	DESTROY(RETVAL);
488	RETVAL = 0;
489	}
490	OUTPUT:
491	RETVAL
492
493	SV *
494	encode(kd, kfiltstr = 0)
495	Key_Data *kd
496	char *kfiltstr
497	PREINIT:
498	key_filter kfilt;
499	dstr d = DSTR_INIT;
500	CODE:
501	if (!kfiltstr)
502	kfilt.f = kfilt.m = 0;
503	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
504	croak("bad filter string `%s'", kfiltstr);
505	if (key_encode(kd, &d, &kfilt))
506	RETVAL = newSVpv(d.buf, d.len);
507	else
508	RETVAL = &PL_sv_undef;
509	dstr_destroy(&d);
510	OUTPUT:
511	RETVAL
660b443c	512
	513	MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_
	514
	515	Key_File *
a1a90aaf	516	new(me, file, how)
a1a90aaf	517	SV *me
660b443c	518	char *file
	519	unsigned how
	520	CODE:
	521	RETVAL = CREATE(key_file);
	522	if (key_open(RETVAL, file, how, warn_keyreporter, 0)) {
	523	DESTROY(RETVAL);
	524	RETVAL = 0;
	525	}
	526	OUTPUT:
	527	RETVAL
	528
	529	SV *
	530	DESTROY(kf)
	531	Key_File *kf
	532	CODE:
	533	key_close(kf);
a1a90aaf	534	DESTROY(kf);
660b443c	535	XSRETURN_UNDEF;
660b443c	536
a1a90aaf	537	KeyErr
660b443c	538	merge(kf, name, fp)
	539	Key_File *kf
	540	char *name
	541	FILE *fp
	542	CODE:
	543	RETVAL = key_merge(kf, name, fp, warn_keyreporter, 0);
	544	OUTPUT:
	545	RETVAL
	546
a1a90aaf	547	bool
	548	extract(kf, k, fp, kfiltstr = 0)
	549	Key_File *kf
	550	Key *k
	551	FILE *fp
	552	char *kfiltstr
	553	PREINIT:
	554	key_filter kfilt;
	555	CODE:
	556	if (!kfiltstr)
	557	kfilt.f = kfilt.m = 0;
	558	else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
	559	croak("bad filter string `%s'", kfiltstr);
	560	RETVAL = key_extract(kf, k->k, fp, &kfilt);
	561	OUTPUT:
	562	RETVAL
	563
	564	int
	565	key_save(kf)
	566	Key_File *kf
	567
	568	void
	569	qtag(kf, tag)
	570	Key_File *kf
	571	char *tag
	572	PREINIT:
	573	dstr d = DSTR_INIT;
	574	Key *k;
	575	key_data *kd;
	576	PPCODE:
	577	k = CREATE(Key);
	578	kd = CREATE(key_data);
	579	if (key_qtag(kf, tag, &d, &k->k, &kd)) {
	580	DESTROY(k);
	581	DESTROY(kd);
	582	XPUSHs(&PL_sv_undef);
	583	XPUSHs(&PL_sv_undef);
	584	XPUSHs(&PL_sv_undef);
	585	} else {
	586	k->kf = kf;
	587	XPUSHs(sv_2mortal(newSVpv(d.buf, d.len)));
	588	XPUSHs(RET(k, "Catacomb::Key"));
	589	XPUSHs(RET(k, "Catacomb::Key::Data"));
	590	}
	591	dstr_destroy(&d);
	592
	593	Key *
	594	bytype(kf, type)
	595	Key_File *kf
	596	char *type
	597	CODE:
	598	RETVAL = CREATE(Key);
	599	if ((RETVAL->k = key_bytype(kf, type)) != 0)
	600	RETVAL->kf = kf;
	601	else {
	602	DESTROY(RETVAL);
	603	RETVAL = 0;
	604	}
	605	OUTPUT:
	606	RETVAL
	607
	608	Key *
	609	byid(kf, id)
	610	Key_File *kf
611	U32 id
612	CODE:
613	RETVAL = CREATE(Key);
614	if ((RETVAL->k = key_byid(kf, id)) != 0)
615	RETVAL->kf = kf;
616	else {
617	DESTROY(RETVAL);
618	RETVAL = 0;
619	}
620	OUTPUT:
621	RETVAL
622
623	Key *
624	bytag(kf, tag)
625	Key_File *kf
626	char *tag
627	CODE:
628	RETVAL = CREATE(Key);
629	if ((RETVAL->k = key_bytag(kf, tag)) != 0)
630	RETVAL->kf = kf;
631	else {
632	DESTROY(RETVAL);
633	RETVAL = 0;
634	}
635	OUTPUT:
636	RETVAL
637
638	void
639	list(kf)
640	Key_File *kf
641	PREINIT:
642	key_iter i;
643	key *k;
644	Key *kk;
645	PPCODE:
646	for (key_mkiter(&i, kf); k = key_next(&i); ) {
647	kk = CREATE(Key);
648	kk->kf = kf;
649	kk->k = k;
650	XPUSHs(RET(kk, "Catacomb::Key"));
651	}
660b443c	652
660b443c	653	#----- That's all, folks ----------------------------------------------------