[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_

SV *
DESTROY(k)
	Key *k
	CODE:
	keyfile_dec(k->kf);
	DESTROY(k);
	XSRETURN_YES;

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_DataImpl *
_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->kf, k->k, p

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

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

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

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

KeyErr
putattr(k, a, v = &PL_sv_undef)
	Key *k
	char *a
	SV *v
	PREINIT:
	char *vv;
	STRLEN len;
	CODE:
	if (!SvOK(v))
	  vv = 0;
	else
	  vv = SvPV(v, len);
	RETVAL = key_putattr(&k->kf->kf, k->k, a, vv);
	OUTPUT:
	RETVAL

Key_AttrIter *
attriter(k)
	Key *k
	CODE:
	RETVAL = CREATE(Key_AttrIter);
	key_mkattriter(&RETVAL->i, k->k);
	RETVAL->kf = k->kf;
	k->kf->ref++;
	OUTPUT:
	RETVAL

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

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

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

bool
key_fingerprint(k, h, kf = 0)
	Key *k
	ghash *h
	Key_Filter *kf
	C_ARGS:
	k->k, h, kf

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

MODULE = Catacomb PACKAGE = Catacomb::Key::AttrIter

void
next(i)
	Key_AttrIter *i
	PREINIT:
	const char *a, *v;
	PPCODE:
	if (key_nextattr(&i->i, &a, &v)) {
	  XPUSHs(sv_2mortal(newSVpv(a, 0)));
	  if (GIMME_V == G_ARRAY)
	    XPUSHs(sv_2mortal(newSVpv(v, 0)));
	}

SV *
DESTROY(i)
	Key_AttrIter *i
	CODE:
	keyfile_dec(i->kf);
	DESTROY(i);
	XSRETURN_YES;

MODULE = Catacomb PACKAGE = Catacomb::Key::Filter

Key_Filter *
new(me, f = 0, m = 0)
	SV *me
	SV *f
	SV *m
	PREINIT:
	char *p;
	STRLEN len;
	CODE:
	RETVAL = CREATE(Key_Filter);
	if (!f || !SvOK(f))
	  RETVAL->f = RETVAL->m = 0;
	else if (m) {
	  RETVAL->f = SvUV(f);
	  RETVAL->m = SvUV(m);
	} else {
	  p = SvPV(f, len);
	  if (key_readflags(p, 0, &RETVAL->f, &RETVAL->m)) {
	    DESTROY(RETVAL);
	    RETVAL = 0;
	  }
	}
	OUTPUT:
	RETVAL

SV *
DESTROY(kf)
	Key_Filter *kf
	CODE:
	if (!kf)
	  XSRETURN_UNDEF;
	DESTROY(kf);
	XSRETURN_YES;

SV *
tostring(kf)
	Key_Filter *kf
	PREINIT:
	dstr d = DSTR_INIT;
	CODE:
	if (!kf)
	  XSRETURN_UNDEF;
	key_writeflags(kf->f, &d);
	RETVAL = newSVpvn(d.buf, d.len);
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

UV
f(kf)
	Key_Filter *kf
	CODE:
	RETVAL = kf ? kf->f : 0;
	OUTPUT:
	RETVAL

UV
m(kf)
	Key_Filter *kf
	CODE:
	RETVAL = kf ? kf->m : 0;
	OUTPUT:
	RETVAL

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

Key_DataImpl *
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 *
free(kd)
	Key_DataImpl *kd
	CODE:
	key_destroy(kd);
	DESTROY(kd);
	XSRETURN_YES;

SV *
clear(kd)
	Key_DataImpl *kd
	CODE:
	key_destroy(kd);
	kd->e = 0;
	kd->u.k.k = 0;
	kd->u.k.sz = 0;
	XSRETURN_YES;

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

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

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

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

SV *
setec(kd, p)
	Key_DataImpl *kd
	ec *p
	CODE:
	key_destroy(kd);
	key_ec(kd, p);
	XSRETURN_YES;

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

SV *
setflags(kd, f)
	Key_DataImpl *kd
	U32 f
	CODE:
	if (f & KF_ENCMASK)
	  croak("can't change encoding flags");
	kd->e = (kd->e & KF_ENCMASK) | (f & ~KF_ENCMASK);
	XSRETURN_YES;

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

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

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

ec *
getec(kd)
	Key_DataImpl *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_DataImpl *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_STRING)
	  croak("key is not string");
	RETVAL = kd->u.p;
	OUTPUT:
	RETVAL

SV *
setstruct(kd)
	Key_DataImpl *kd
	CODE:
	key_destroy(kd);
	key_structure(kd);
	XSRETURN_YES;

Key_DataImpl *
key_structfind(kd, tag)
	Key_DataImpl *kd
	char *tag
	INIT:
	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	  XSRETURN_UNDEF;

Key_DataImpl *
key_structcreate(kd, tag)
	Key_DataImpl *kd
	char *tag
	INIT:
	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	  croak("key is not structured");

Key_StructIter *
structiter(kd)
	Key_DataImpl *kd
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	  croak("key is not structured");
	RETVAL = CREATE(Key_StructIter);
	sym_mkiter(RETVAL, &kd->u.s);
	OUTPUT:
	RETVAL

SV *
structdel(kd, tag)
	Key_DataImpl *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;
	key_destroy(&ks->k);
	sym_remove(&kd->u.s, ks);
	XSRETURN_YES;

bool
key_match(kd, kf)
	Key_DataImpl *kd
	Key_Filter *kf

bool
set(kd, kkd, kf = 0)
	Key_DataImpl *kd
	Key_DataImpl *kkd
	Key_Filter *kf
	CODE:
	key_destroy(kd);
	kd->e = 0;
	kd->u.k.k = 0;
	kd->u.k.sz = 0;
	RETVAL = key_copy(kd, kkd, kf);
	OUTPUT:
	RETVAL

Key_DataImpl *
lock(kd, key)
	Key_DataImpl *kd
	SV *key
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	if ((kd->e & KF_ENCMASK) == KENC_ENCRYPT)
	  croak("already encrypted");
	RETVAL = CREATE(Key_DataImpl);
	p = SvPV(key, len);
	key_lock(RETVAL, kd, p, len);
	OUTPUT:
	RETVAL

Key_DataImpl *
unlock(kd, key)
	Key_DataImpl *kd
	SV *key
	PREINIT:
	STRLEN len;
	char *p;
	int rc;
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	  croak("not encrypted");
	RETVAL = CREATE(Key_DataImpl);
	p = SvPV(key, len);
	if ((rc = key_unlock(RETVAL, kd, p, len)) != 0) {
	  DESTROY(RETVAL);
	  keyerr(rc);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key_DataImpl *
plock(kd, tag)
	Key_DataImpl *kd
	char *tag
	PREINIT:
	int rc;
	CODE:
	if ((kd->e & KF_ENCMASK) == KENC_ENCRYPT)
	  croak("already encrypted");
	RETVAL = CREATE(Key_DataImpl);
	if ((rc = key_plock(tag, kd, RETVAL)) != 0) {
	  DESTROY(RETVAL);
	  keyerr(rc);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key_DataImpl *
punlock(kd, tag)
	Key_DataImpl *kd
	char *tag
	PREINIT:
	int rc;
	CODE:
	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	  croak("not encrypted");
	RETVAL = CREATE(Key_DataImpl);
	if ((rc = key_punlock(tag, kd, RETVAL)) != 0) {
	  DESTROY(RETVAL);
	  keyerr(rc);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

void
read(me, p)
	SV *me
	char *p
	PREINIT:
	key_data *kd;
	char *pp;
	PPCODE:
	kd = CREATE(key_data);
	if (key_read(p, kd, &pp))
	  DESTROY(kd);
	else {
	  XPUSHs(RET(kd, "Catacomb::Key::DataImpl"));
	  if (GIMME_V == G_ARRAY)
	    XPUSHs(sv_2mortal(newSVpvn(pp, strlen(pp))));
	}

SV *
write(kd, kf = 0)
	Key_DataImpl *kd
	Key_Filter *kf
	PREINIT:
	dstr d = DSTR_INIT;
	CODE:
	if (key_write(kd, &d, kf))
	  RETVAL = newSVpvn(d.buf, d.len);
	else
	  RETVAL = &PL_sv_undef;
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

Key_DataImpl *
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, kf = 0)
	Key_DataImpl *kd
	Key_Filter *kf
	PREINIT:
	dstr d = DSTR_INIT;
	CODE:
	if (key_encode(kd, &d, kf))
	  RETVAL = newSVpvn(d.buf, d.len);
	else
	  RETVAL = &PL_sv_undef;
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Key::StructIter

SV *
next(i)
	Key_StructIter *i
	PREINIT:
	key_struct *s;
	CODE:
	if ((s = sym_next(i)) == 0)
	  XSRETURN_UNDEF;
	RETVAL = newSVpvn(SYM_NAME(s), SYM_LEN(s));
	OUTPUT:
	RETVAL

SV *
DESTROY(i)
	Key_StructIter *i
	CODE:
	DESTROY(i);
	XSRETURN_YES;

MODULE = Catacomb PACKAGE = Catacomb::Key::Data

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 = newSVpvn(d.buf, d.len);
	dstr_destroy(&d);
	OUTPUT:
	RETVAL

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

Key_File *
new(me, file, how = KOPEN_READ, report = &PL_sv_undef)
	SV *me
	char *file
	unsigned how
	SV *report
	CODE:
	RETVAL = CREATE(key_file);
	if (key_open(&RETVAL->kf, file, how, keyreport, report)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

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

KeyErr
merge(kf, name, fp, report = &PL_sv_undef)
	Key_File *kf
	char *name
	FILE *fp
	SV *report
	CODE:
	RETVAL = key_merge(&kf->kf, name, fp, keyreport, report);
	OUTPUT:
	RETVAL

bool
key_extract(kf, k, fp, kfilt = 0)
	Key_File *kf
	Key *k
	FILE *fp
	Key_Filter *kfilt
	C_ARGS:
	&kf->kf, k->k, fp, kfilt

int
key_save(kf)
	Key_File *kf
	C_ARGS:
	&kf->kf

Key *
bytype(kf, type)
	Key_File *kf
	char *type
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_bytype(&kf->kf, type)) != 0) {
	  kf->ref++;
	  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->kf, id)) != 0) {
	  kf->ref++;
	  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->kf, tag)) != 0) {
	  kf->ref++;
	  RETVAL->kf = kf;
	} else {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

Key *
newkey(kf, id, type, exp)
	Key_File *kf
	U32 id
	const char *type
	time_t exp
	PREINIT:
	int err;
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_new(&kf->kf, id, type, exp, &err)) == 0) {
	  DESTROY(RETVAL);
	  keyerr(err);
	  RETVAL = 0;
	} else {
	  kf->ref++;
	  RETVAL->kf = kf;
	}
	OUTPUT:
	RETVAL
	

Key_FileIter *
iterate(kf)
	Key_File *kf
	CODE:
	RETVAL = CREATE(Key_FileIter);
	key_mkiter(&RETVAL->i, &kf->kf);
	RETVAL->kf = kf;
	kf->ref++;
	OUTPUT:	
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Key::FileIter

Key *
next(ki)
	Key_FileIter *ki
	CODE:
	RETVAL = CREATE(Key);
	if ((RETVAL->k = key_next(&ki->i)) == 0) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	} else {
	  RETVAL->kf = ki->kf;
	  ki->kf->ref++;
	}
	OUTPUT:
	RETVAL

SV *
DESTROY(ki)
	Key_FileIter *ki
	CODE:
	keyfile_dec(ki->kf);
	DESTROY(ki);
	XSRETURN_YES;

#----- 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
fcd15e0b	30	SV *
	31	DESTROY(k)
	32	Key *k
	33	CODE:
	34	keyfile_dec(k->kf);
	35	DESTROY(k);
	36	XSRETURN_YES;
	37
a1a90aaf	38	bool
	39	key_chkident(me, p)
	40	SV *me
	41	char *p
	42	C_ARGS:
	43	p
	44
	45	bool
	46	key_chkcomment(me, p)
	47	SV *me
	48	char *p
	49	C_ARGS:
	50	p
	51
	52	time_t
	53	exp(k)
	54	Key *k
	55	CODE:
	56	RETVAL = k->k->exp;
	57	OUTPUT:
	58	RETVAL
	59
	60	time_t
	61	del(k)
	62	Key *k
	63	CODE:
	64	RETVAL = k->k->del;
	65	OUTPUT:
	66	RETVAL
	67
fcd15e0b	68	Key_DataImpl *
fcd15e0b	69	_data(k)
a1a90aaf	70	Key *k
	71	CODE:
	72	RETVAL = &k->k->k;
	73	OUTPUT:
	74	RETVAL
	75
	76	char *
	77	comment(k)
	78	Key *k
	79	CODE:
	80	RETVAL = k->k->c;
	81	OUTPUT:
	82	RETVAL
	83
	84	U32
	85	id(k)
	86	Key *k
	87	CODE:
	88	RETVAL = k->k->id;
	89	OUTPUT:
	90	RETVAL
	91
	92	char *
	93	tag(k)
	94	Key *k
	95	CODE:
	96	RETVAL = k->k->tag;
	97	OUTPUT:
	98	RETVAL
	99
	100	char *
	101	type(k)
	102	Key *k
	103	CODE:
	104	RETVAL = k->k->type;
	105	OUTPUT:
	106	RETVAL
	107
	108	KeyErr
	109	key_setcomment(k, p)
	110	Key *k
	111	char *p
	112	C_ARGS:
fcd15e0b	113	&k->kf->kf, k->k, p
a1a90aaf	114
	115	KeyErr
	116	key_settag(k, p)
	117	Key *k
	118	char *p
	119	C_ARGS:
fcd15e0b	120	&k->kf->kf, k->k, p
a1a90aaf	121
	122	KeyErr
	123	key_delete(k)
	124	Key *k
	125	C_ARGS:
fcd15e0b	126	&k->kf->kf, k->k
a1a90aaf	127
	128	SV *
	129	fulltag(k)
	130	Key *k
	131	PREINIT:
	132	dstr d = DSTR_INIT;
	133	CODE:
	134	key_fulltag(k->k, &d);
fcd15e0b	135	RETVAL = newSVpvn(d.buf, d.len);
a1a90aaf	136	dstr_destroy(&d);
	137	OUTPUT:
	138	RETVAL
	139
	140	const char *
	141	key_getattr(k, a)
	142	Key *k
	143	char *a
	144	C_ARGS:
fcd15e0b	145	&k->kf->kf, k->k, a
a1a90aaf	146
a1a90aaf	147	KeyErr
fcd15e0b	148	putattr(k, a, v = &PL_sv_undef)
a1a90aaf	149	Key *k
a1a90aaf	150	char *a
fcd15e0b	151	SV *v
	152	PREINIT:
	153	char *vv;
	154	STRLEN len;
	155	CODE:
	156	if (!SvOK(v))
	157	vv = 0;
	158	else
	159	vv = SvPV(v, len);
	160	RETVAL = key_putattr(&k->kf->kf, k->k, a, vv);
	161	OUTPUT:
	162	RETVAL
a1a90aaf	163
fcd15e0b	164	Key_AttrIter *
fcd15e0b	165	attriter(k)
a1a90aaf	166	Key *k
fcd15e0b	167	CODE:
	168	RETVAL = CREATE(Key_AttrIter);
	169	key_mkattriter(&RETVAL->i, k->k);
	170	RETVAL->kf = k->kf;
	171	k->kf->ref++;
	172	OUTPUT:
	173	RETVAL
a1a90aaf	174
	175	bool
	176	expiredp(k)
	177	Key *k
	178	CODE:
	179	RETVAL = key_expired(k->k);
	180	OUTPUT:
	181	RETVAL
	182
	183	KeyErr
	184	key_expire(k)
	185	Key *k
	186	C_ARGS:
fcd15e0b	187	&k->kf->kf, k->k
a1a90aaf	188
	189	KeyErr
	190	key_used(k, t)
	191	Key *k
	192	time_t t
	193	C_ARGS:
fcd15e0b	194	&k->kf->kf, k->k, t
a1a90aaf	195
a1a90aaf	196	bool
fcd15e0b	197	key_fingerprint(k, h, kf = 0)
a1a90aaf	198	Key *k
a1a90aaf	199	ghash *h
fcd15e0b	200	Key_Filter *kf
	201	C_ARGS:
	202	k->k, h, kf
a1a90aaf	203
	204	const char *
	205	key_strerror(me, err)
	206	SV *me
	207	int err
	208	C_ARGS:
	209	err
	210
fcd15e0b	211	MODULE = Catacomb PACKAGE = Catacomb::Key::AttrIter
	212
	213	void
	214	next(i)
	215	Key_AttrIter *i
	216	PREINIT:
	217	const char a, v;
	218	PPCODE:
	219	if (key_nextattr(&i->i, &a, &v)) {
	220	XPUSHs(sv_2mortal(newSVpv(a, 0)));
	221	if (GIMME_V == G_ARRAY)
	222	XPUSHs(sv_2mortal(newSVpv(v, 0)));
	223	}
	224
	225	SV *
	226	DESTROY(i)
	227	Key_AttrIter *i
	228	CODE:
	229	keyfile_dec(i->kf);
	230	DESTROY(i);
	231	XSRETURN_YES;
	232
	233	MODULE = Catacomb PACKAGE = Catacomb::Key::Filter
	234
	235	Key_Filter *
	236	new(me, f = 0, m = 0)
	237	SV *me
	238	SV *f
	239	SV *m
	240	PREINIT:
	241	char *p;
	242	STRLEN len;
	243	CODE:
	244	RETVAL = CREATE(Key_Filter);
	245	if (!f \|\| !SvOK(f))
	246	RETVAL->f = RETVAL->m = 0;
	247	else if (m) {
	248	RETVAL->f = SvUV(f);
	249	RETVAL->m = SvUV(m);
	250	} else {
	251	p = SvPV(f, len);
	252	if (key_readflags(p, 0, &RETVAL->f, &RETVAL->m)) {
	253	DESTROY(RETVAL);
	254	RETVAL = 0;
	255	}
	256	}
	257	OUTPUT:
	258	RETVAL
	259
	260	SV *
	261	DESTROY(kf)
	262	Key_Filter *kf
	263	CODE:
	264	if (!kf)
	265	XSRETURN_UNDEF;
	266	DESTROY(kf);
	267	XSRETURN_YES;
	268
	269	SV *
	270	tostring(kf)
	271	Key_Filter *kf
	272	PREINIT:
	273	dstr d = DSTR_INIT;
	274	CODE:
275	if (!kf)
276	XSRETURN_UNDEF;
277	key_writeflags(kf->f, &d);
278	RETVAL = newSVpvn(d.buf, d.len);
279	dstr_destroy(&d);
280	OUTPUT:
281	RETVAL
282
283	UV
284	f(kf)
285	Key_Filter *kf
286	CODE:
287	RETVAL = kf ? kf->f : 0;
288	OUTPUT:
289	RETVAL
a1a90aaf	290
fcd15e0b	291	UV
	292	m(kf)
	293	Key_Filter *kf
	294	CODE:
	295	RETVAL = kf ? kf->m : 0;
	296	OUTPUT:
	297	RETVAL
	298
	299	MODULE = Catacomb PACKAGE = Catacomb::Key::DataImpl PREFIX = key_
	300
	301	Key_DataImpl *
	302	new(me)
a1a90aaf	303	SV *me
	304	CODE:
	305	RETVAL = CREATE(key_data);
	306	RETVAL->e = 0;
	307	RETVAL->u.k.k = 0;
	308	RETVAL->u.k.sz = 0;
	309	OUTPUT:
	310	RETVAL
	311
	312	SV *
fcd15e0b	313	free(kd)
	314	Key_DataImpl *kd
	315	CODE:
	316	key_destroy(kd);
	317	DESTROY(kd);
	318	XSRETURN_YES;
	319
	320	SV *
	321	clear(kd)
	322	Key_DataImpl *kd
a1a90aaf	323	CODE:
a1a90aaf	324	key_destroy(kd);
fcd15e0b	325	kd->e = 0;
	326	kd->u.k.k = 0;
	327	kd->u.k.sz = 0;
a1a90aaf	328	XSRETURN_YES;
	329
	330	SV *
	331	setbinary(kd, sv)
fcd15e0b	332	Key_DataImpl *kd
a1a90aaf	333	SV *sv
	334	PREINIT:
	335	char *p;
	336	STRLEN len;
	337	CODE:
	338	p = SvPV(sv, len);
fcd15e0b	339	key_destroy(kd);
a1a90aaf	340	key_binary(kd, p, len);
	341	XSRETURN_YES;
	342
	343	SV *
	344	setencrypted(kd, sv)
fcd15e0b	345	Key_DataImpl *kd
a1a90aaf	346	SV *sv
	347	PREINIT:
	348	char *p;
	349	STRLEN len;
	350	CODE:
	351	p = SvPV(sv, len);
fcd15e0b	352	key_destroy(kd);
a1a90aaf	353	key_encrypted(kd, p, len);
	354	XSRETURN_YES;
	355
	356	SV *
	357	setmp(kd, x)
fcd15e0b	358	Key_DataImpl *kd
a1a90aaf	359	mp *x
a1a90aaf	360	CODE:
fcd15e0b	361	key_destroy(kd);
a1a90aaf	362	key_mp(kd, x);
	363	XSRETURN_YES;
	364
	365	SV *
	366	setstring(kd, p)
fcd15e0b	367	Key_DataImpl *kd
a1a90aaf	368	char *p
a1a90aaf	369	CODE:
fcd15e0b	370	key_destroy(kd);
a1a90aaf	371	key_string(kd, p);
	372	XSRETURN_YES;
	373
	374	SV *
	375	setec(kd, p)
fcd15e0b	376	Key_DataImpl *kd
fcd15e0b	377	ec *p
a1a90aaf	378	CODE:
fcd15e0b	379	key_destroy(kd);
a1a90aaf	380	key_ec(kd, p);
	381	XSRETURN_YES;
	382
	383	U32
	384	flags(kd)
fcd15e0b	385	Key_DataImpl *kd
a1a90aaf	386	CODE:
	387	RETVAL = kd->e;
	388	OUTPUT:
	389	RETVAL
	390
	391	SV *
fcd15e0b	392	setflags(kd, f)
	393	Key_DataImpl *kd
	394	U32 f
	395	CODE:
	396	if (f & KF_ENCMASK)
	397	croak("can't change encoding flags");
	398	kd->e = (kd->e & KF_ENCMASK) \| (f & ~KF_ENCMASK);
	399	XSRETURN_YES;
	400
	401	SV *
a1a90aaf	402	getbinary(kd)
fcd15e0b	403	Key_DataImpl *kd
a1a90aaf	404	CODE:
	405	if ((kd->e & KF_ENCMASK) != KENC_BINARY)
	406	croak("key is not binary");
fcd15e0b	407	RETVAL = newSVpvn(kd->u.k.k, kd->u.k.sz);
a1a90aaf	408	OUTPUT:
	409	RETVAL
	410
	411	SV *
	412	getencrypted(kd)
fcd15e0b	413	Key_DataImpl *kd
a1a90aaf	414	CODE:
	415	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	416	croak("key is not encrypted");
fcd15e0b	417	RETVAL = newSVpvn(kd->u.k.k, kd->u.k.sz);
a1a90aaf	418	OUTPUT:
	419	RETVAL
	420
	421	mp *
	422	getmp(kd)
fcd15e0b	423	Key_DataImpl *kd
a1a90aaf	424	CODE:
	425	if ((kd->e & KF_ENCMASK) != KENC_MP)
	426	croak("key is not bignum");
fcd15e0b	427	RETVAL = MP_COPY(kd->u.m);
a1a90aaf	428	OUTPUT:
	429	RETVAL
	430
fcd15e0b	431	ec *
a1a90aaf	432	getec(kd)
fcd15e0b	433	Key_DataImpl *kd
a1a90aaf	434	CODE:
	435	if ((kd->e & KF_ENCMASK) != KENC_EC)
	436	croak("key is not a curve point");
	437	RETVAL = CREATE(ec);
	438	EC_CREATE(RETVAL);
	439	EC_COPY(RETVAL, &kd->u.e);
	440	OUTPUT:
	441	RETVAL
	442
	443	char *
	444	getstring(kd)
fcd15e0b	445	Key_DataImpl *kd
a1a90aaf	446	CODE:
	447	if ((kd->e & KF_ENCMASK) != KENC_STRING)
	448	croak("key is not string");
	449	RETVAL = kd->u.p;
	450	OUTPUT:
	451	RETVAL
	452
	453	SV *
	454	setstruct(kd)
fcd15e0b	455	Key_DataImpl *kd
a1a90aaf	456	CODE:
fcd15e0b	457	key_destroy(kd);
a1a90aaf	458	key_structure(kd);
	459	XSRETURN_YES;
	460
fcd15e0b	461	Key_DataImpl *
a1a90aaf	462	key_structfind(kd, tag)
fcd15e0b	463	Key_DataImpl *kd
a1a90aaf	464	char *tag
fcd15e0b	465	INIT:
	466	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	467	XSRETURN_UNDEF;
a1a90aaf	468
fcd15e0b	469	Key_DataImpl *
a1a90aaf	470	key_structcreate(kd, tag)
fcd15e0b	471	Key_DataImpl *kd
a1a90aaf	472	char *tag
fcd15e0b	473	INIT:
	474	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	475	croak("key is not structured");
a1a90aaf	476
fcd15e0b	477	Key_StructIter *
	478	structiter(kd)
	479	Key_DataImpl *kd
	480	CODE:
a1a90aaf	481	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
a1a90aaf	482	croak("key is not structured");
fcd15e0b	483	RETVAL = CREATE(Key_StructIter);
	484	sym_mkiter(RETVAL, &kd->u.s);
	485	OUTPUT:
	486	RETVAL
a1a90aaf	487
	488	SV *
	489	structdel(kd, tag)
fcd15e0b	490	Key_DataImpl *kd
a1a90aaf	491	char *tag
	492	PREINIT:
	493	key_struct *ks;
	494	CODE:
	495	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
	496	croak("key is not structured");
	497	if ((ks = sym_find(&kd->u.s, tag, -1, 0, 0)) == 0)
	498	XSRETURN_UNDEF;
fcd15e0b	499	key_destroy(&ks->k);
a1a90aaf	500	sym_remove(&kd->u.s, ks);
	501	XSRETURN_YES;
	502
fcd15e0b	503	bool
	504	key_match(kd, kf)
	505	Key_DataImpl *kd
	506	Key_Filter *kf
a1a90aaf	507
fcd15e0b	508	bool
	509	set(kd, kkd, kf = 0)
	510	Key_DataImpl *kd
	511	Key_DataImpl *kkd
	512	Key_Filter *kf
	513	CODE:
	514	key_destroy(kd);
	515	kd->e = 0;
	516	kd->u.k.k = 0;
	517	kd->u.k.sz = 0;
	518	RETVAL = key_copy(kd, kkd, kf);
	519	OUTPUT:
	520	RETVAL
	521
	522	Key_DataImpl *
	523	lock(kd, key)
	524	Key_DataImpl *kd
	525	SV *key
a1a90aaf	526	PREINIT:
fcd15e0b	527	STRLEN len;
fcd15e0b	528	char *p;
a1a90aaf	529	CODE:
fcd15e0b	530	if ((kd->e & KF_ENCMASK) == KENC_ENCRYPT)
	531	croak("already encrypted");
	532	RETVAL = CREATE(Key_DataImpl);
	533	p = SvPV(key, len);
	534	key_lock(RETVAL, kd, p, len);
a1a90aaf	535	OUTPUT:
	536	RETVAL
	537
fcd15e0b	538	Key_DataImpl *
	539	unlock(kd, key)
	540	Key_DataImpl *kd
	541	SV *key
a1a90aaf	542	PREINIT:
fcd15e0b	543	STRLEN len;
	544	char *p;
	545	int rc;
a1a90aaf	546	CODE:
fcd15e0b	547	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	548	croak("not encrypted");
	549	RETVAL = CREATE(Key_DataImpl);
	550	p = SvPV(key, len);
	551	if ((rc = key_unlock(RETVAL, kd, p, len)) != 0) {
a1a90aaf	552	DESTROY(RETVAL);
fcd15e0b	553	keyerr(rc);
a1a90aaf	554	RETVAL = 0;
	555	}
	556	OUTPUT:
	557	RETVAL
	558
fcd15e0b	559	Key_DataImpl *
a1a90aaf	560	plock(kd, tag)
fcd15e0b	561	Key_DataImpl *kd
a1a90aaf	562	char *tag
fcd15e0b	563	PREINIT:
fcd15e0b	564	int rc;
a1a90aaf	565	CODE:
fcd15e0b	566	if ((kd->e & KF_ENCMASK) == KENC_ENCRYPT)
	567	croak("already encrypted");
	568	RETVAL = CREATE(Key_DataImpl);
	569	if ((rc = key_plock(tag, kd, RETVAL)) != 0) {
a1a90aaf	570	DESTROY(RETVAL);
fcd15e0b	571	keyerr(rc);
a1a90aaf	572	RETVAL = 0;
	573	}
	574	OUTPUT:
	575	RETVAL
	576
fcd15e0b	577	Key_DataImpl *
a1a90aaf	578	punlock(kd, tag)
fcd15e0b	579	Key_DataImpl *kd
a1a90aaf	580	char *tag
fcd15e0b	581	PREINIT:
fcd15e0b	582	int rc;
a1a90aaf	583	CODE:
fcd15e0b	584	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
	585	croak("not encrypted");
	586	RETVAL = CREATE(Key_DataImpl);
	587	if ((rc = key_punlock(tag, kd, RETVAL)) != 0) {
a1a90aaf	588	DESTROY(RETVAL);
fcd15e0b	589	keyerr(rc);
a1a90aaf	590	RETVAL = 0;
	591	}
	592	OUTPUT:
	593	RETVAL
	594
fcd15e0b	595	void
a1a90aaf	596	read(me, p)
	597	SV *me
	598	char *p
fcd15e0b	599	PREINIT:
	600	key_data *kd;
	601	char *pp;
	602	PPCODE:
	603	kd = CREATE(key_data);
	604	if (key_read(p, kd, &pp))
	605	DESTROY(kd);
	606	else {
	607	XPUSHs(RET(kd, "Catacomb::Key::DataImpl"));
	608	if (GIMME_V == G_ARRAY)
	609	XPUSHs(sv_2mortal(newSVpvn(pp, strlen(pp))));
a1a90aaf	610	}
a1a90aaf	611
a1a90aaf	612	SV *
fcd15e0b	613	write(kd, kf = 0)
	614	Key_DataImpl *kd
	615	Key_Filter *kf
a1a90aaf	616	PREINIT:
a1a90aaf	617	dstr d = DSTR_INIT;
a1a90aaf	618	CODE:
fcd15e0b	619	if (key_write(kd, &d, kf))
fcd15e0b	620	RETVAL = newSVpvn(d.buf, d.len);
a1a90aaf	621	else
	622	RETVAL = &PL_sv_undef;
	623	dstr_destroy(&d);
	624	OUTPUT:
	625	RETVAL
	626
fcd15e0b	627	Key_DataImpl *
a1a90aaf	628	decode(me, sv)
	629	SV *me
	630	SV *sv
	631	PREINIT:
	632	char *p;
	633	STRLEN len;
	634	CODE:
	635	p = SvPV(sv, len);
	636	RETVAL = CREATE(key_data);
	637	if (key_decode(p, len, RETVAL)) {
	638	DESTROY(RETVAL);
	639	RETVAL = 0;
	640	}
	641	OUTPUT:
	642	RETVAL
	643
	644	SV *
fcd15e0b	645	encode(kd, kf = 0)
	646	Key_DataImpl *kd
	647	Key_Filter *kf
a1a90aaf	648	PREINIT:
a1a90aaf	649	dstr d = DSTR_INIT;
a1a90aaf	650	CODE:
fcd15e0b	651	if (key_encode(kd, &d, kf))
fcd15e0b	652	RETVAL = newSVpvn(d.buf, d.len);
a1a90aaf	653	else
	654	RETVAL = &PL_sv_undef;
	655	dstr_destroy(&d);
	656	OUTPUT:
	657	RETVAL
660b443c	658
fcd15e0b	659	MODULE = Catacomb PACKAGE = Catacomb::Key::StructIter
	660
	661	SV *
	662	next(i)
	663	Key_StructIter *i
	664	PREINIT:
	665	key_struct *s;
	666	CODE:
	667	if ((s = sym_next(i)) == 0)
	668	XSRETURN_UNDEF;
	669	RETVAL = newSVpvn(SYM_NAME(s), SYM_LEN(s));
	670	OUTPUT:
	671	RETVAL
	672
	673	SV *
	674	DESTROY(i)
	675	Key_StructIter *i
	676	CODE:
	677	DESTROY(i);
	678	XSRETURN_YES;
	679
	680	MODULE = Catacomb PACKAGE = Catacomb::Key::Data
	681
	682	void
	683	readflags(me, p)
	684	SV *me
	685	char *p
	686	PREINIT:
	687	unsigned f, m;
	688	PPCODE:
	689	if (key_readflags(p, &p, &f, &m) \|\| *p)
	690	croak("bad flags string");
	691	XPUSHs(sv_2mortal(newSVuv(m)));
	692	XPUSHs(sv_2mortal(newSVuv(f)));
	693
	694	SV *
	695	getflags(me, f)
	696	SV *me
	697	U32 f
	698	PREINIT:
	699	dstr d = DSTR_INIT;
	700	CODE:
	701	key_writeflags(f, &d);
	702	RETVAL = newSVpvn(d.buf, d.len);
	703	dstr_destroy(&d);
	704	OUTPUT:
	705	RETVAL
	706
660b443c	707	MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_
	708
	709	Key_File *
fcd15e0b	710	new(me, file, how = KOPEN_READ, report = &PL_sv_undef)
a1a90aaf	711	SV *me
660b443c	712	char *file
660b443c	713	unsigned how
fcd15e0b	714	SV *report
660b443c	715	CODE:
660b443c	716	RETVAL = CREATE(key_file);
fcd15e0b	717	if (key_open(&RETVAL->kf, file, how, keyreport, report)) {
660b443c	718	DESTROY(RETVAL);
	719	RETVAL = 0;
	720	}
	721	OUTPUT:
	722	RETVAL
	723
	724	SV *
	725	DESTROY(kf)
	726	Key_File *kf
	727	CODE:
fcd15e0b	728	keyfile_dec(kf);
660b443c	729	XSRETURN_UNDEF;
660b443c	730
a1a90aaf	731	KeyErr
fcd15e0b	732	merge(kf, name, fp, report = &PL_sv_undef)
660b443c	733	Key_File *kf
	734	char *name
	735	FILE *fp
fcd15e0b	736	SV *report
660b443c	737	CODE:
fcd15e0b	738	RETVAL = key_merge(&kf->kf, name, fp, keyreport, report);
660b443c	739	OUTPUT:
	740	RETVAL
	741
a1a90aaf	742	bool
fcd15e0b	743	key_extract(kf, k, fp, kfilt = 0)
a1a90aaf	744	Key_File *kf
	745	Key *k
	746	FILE *fp
fcd15e0b	747	Key_Filter *kfilt
	748	C_ARGS:
	749	&kf->kf, k->k, fp, kfilt
a1a90aaf	750
	751	int
	752	key_save(kf)
	753	Key_File *kf
fcd15e0b	754	C_ARGS:
fcd15e0b	755	&kf->kf
a1a90aaf	756
	757	Key *
	758	bytype(kf, type)
	759	Key_File *kf
	760	char *type
	761	CODE:
	762	RETVAL = CREATE(Key);
fcd15e0b	763	if ((RETVAL->k = key_bytype(&kf->kf, type)) != 0) {
fcd15e0b	764	kf->ref++;
a1a90aaf	765	RETVAL->kf = kf;
fcd15e0b	766	} else {
a1a90aaf	767	DESTROY(RETVAL);
	768	RETVAL = 0;
	769	}
	770	OUTPUT:
	771	RETVAL
	772
	773	Key *
	774	byid(kf, id)
	775	Key_File *kf
	776	U32 id
	777	CODE:
	778	RETVAL = CREATE(Key);
fcd15e0b	779	if ((RETVAL->k = key_byid(&kf->kf, id)) != 0) {
fcd15e0b	780	kf->ref++;
a1a90aaf	781	RETVAL->kf = kf;
fcd15e0b	782	} else {
a1a90aaf	783	DESTROY(RETVAL);
	784	RETVAL = 0;
	785	}
	786	OUTPUT:
	787	RETVAL
	788
	789	Key *
	790	bytag(kf, tag)
	791	Key_File *kf
	792	char *tag
	793	CODE:
	794	RETVAL = CREATE(Key);
fcd15e0b	795	if ((RETVAL->k = key_bytag(&kf->kf, tag)) != 0) {
fcd15e0b	796	kf->ref++;
a1a90aaf	797	RETVAL->kf = kf;
fcd15e0b	798	} else {
a1a90aaf	799	DESTROY(RETVAL);
	800	RETVAL = 0;
	801	}
	802	OUTPUT:
	803	RETVAL
	804
fcd15e0b	805	Key *
fcd15e0b	806	newkey(kf, id, type, exp)
a1a90aaf	807	Key_File *kf
fcd15e0b	808	U32 id
	809	const char *type
	810	time_t exp
a1a90aaf	811	PREINIT:
fcd15e0b	812	int err;
	813	CODE:
	814	RETVAL = CREATE(Key);
	815	if ((RETVAL->k = key_new(&kf->kf, id, type, exp, &err)) == 0) {
	816	DESTROY(RETVAL);
	817	keyerr(err);
	818	RETVAL = 0;
	819	} else {
	820	kf->ref++;
	821	RETVAL->kf = kf;
	822	}
	823	OUTPUT:
	824	RETVAL
	825
	826
	827	Key_FileIter *
	828	iterate(kf)
	829	Key_File *kf
	830	CODE:
	831	RETVAL = CREATE(Key_FileIter);
	832	key_mkiter(&RETVAL->i, &kf->kf);
	833	RETVAL->kf = kf;
	834	kf->ref++;
	835	OUTPUT:
	836	RETVAL
	837
	838	MODULE = Catacomb PACKAGE = Catacomb::Key::FileIter
	839
	840	Key *
	841	next(ki)
	842	Key_FileIter *ki
	843	CODE:
	844	RETVAL = CREATE(Key);
	845	if ((RETVAL->k = key_next(&ki->i)) == 0) {
	846	DESTROY(RETVAL);
	847	RETVAL = 0;
	848	} else {
	849	RETVAL->kf = ki->kf;
	850	ki->kf->ref++;
a1a90aaf	851	}
fcd15e0b	852	OUTPUT:
	853	RETVAL
	854
	855	SV *
	856	DESTROY(ki)
	857	Key_FileIter *ki
	858	CODE:
	859	keyfile_dec(ki->kf);
	860	DESTROY(ki);
	861	XSRETURN_YES;
660b443c	862
660b443c	863	#----- That's all, folks ----------------------------------------------------