X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-perl/blobdiff_plain/660b443cc58d4dd4e92730104429fb64d78c7075..9b46ee0d9f144189d9df836347402c3b3df97936:/key.xs

diff --git a/key.xs b/key.xs
index 603cce3..db58921 100644
--- a/key.xs
+++ b/key.xs
@@ -1,6 +1,6 @@
 # ---?---
 #
-# $Id: key.xs,v 1.1 2004/04/02 18:04:01 mdw Exp $
+# $Id$
 #
 # Key-management interface
 #
@@ -25,26 +25,660 @@
 # along with Catacomb/Perl; if not, write to the Free Software Foundation,
 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
-#----- Revision history -----------------------------------------------------
-#
-# $Log: key.xs,v $
-# Revision 1.1  2004/04/02 18:04:01  mdw
-# Initial checkin.
-#
+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_Data *
+data(k)
+	Key *k
+	CODE:
+	RETVAL = k->k->k;
+	key_incref(RETVAL);
+	OUTPUT:
+	RETVAL
+
+KeyErr
+setdata(k, kd)
+	Key *k
+	Key_Data *kd
+	CODE:
+	RETVAL = key_setkeydata(&k->kf->kf, k->k, kd);
+	OUTPUT:
+	RETVAL
+
+char *
+comment(k)
+	Key *k
+	CODE:
+	RETVAL = k->k->c;
+	OUTPUT:
+	RETVAL
 
-MODULE = Catacomb PACKAGE = Catacomb::Key
+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::Data PREFIX = key_
+
+SV *
+DESTROY(kd)
+	Key_Data *kd
+	CODE:
+	key_drop(kd);
+	XSRETURN_YES;
+
+U32
+flags(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = kd->e;
+	OUTPUT:	
+	RETVAL
+
+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
+
+SV *
+setflags(kd, f)
+	Key_Data *kd
+	U32 f
+	CODE:
+	kd->e = (kd->e & KF_ENCMASK) | (f & ~KF_ENCMASK);
+	XSRETURN_YES;
+
+void
+read(me, p)
+	SV *me
+	char *p
+	PREINIT:
+	key_data *kd;
+	char *pp;
+	PPCODE:
+	if ((kd = key_read(p, &pp)) != 0) {
+	  XPUSHs(RET(kd, keydata_type(kd)));
+	  if (GIMME_V == G_ARRAY)
+	    XPUSHs(sv_2mortal(newSVpvn(pp, strlen(pp))));
+	}
+
+SV *
+write(kd, kf = 0)
+	Key_Data *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_Data *
+decode(me, sv)
+	SV *me
+	SV *sv
+	PREINIT:
+	char *p;
+	STRLEN len;
+	CODE:
+	p = SvPV(sv, len);
+	RETVAL = key_decode(p, len);
+	OUTPUT:
+	RETVAL
+
+SV *
+encode(kd, kf = 0)
+	Key_Data *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
+
+Key_Data *
+lock(kd, key)
+	Key_Data *kd
+	SV *key
+	PREINIT:
+	STRLEN len;
+	char *p;
+	CODE:
+	p = SvPV(key, len);
+	key_lock(&RETVAL, kd, p, len);
+	OUTPUT:
+	RETVAL
+
+Key_Data *
+plock(kd, tag)
+	Key_Data *kd
+	char *tag
+	PREINIT:
+	int rc;
+	CODE:
+	if ((rc = key_plock(&RETVAL, kd, tag)) != 0) {
+	  keyerr(rc);
+	  RETVAL = 0;
+	}
+	OUTPUT:
+	RETVAL
+
+bool
+key_match(kd, kf)
+	Key_Data *kd
+	Key_Filter *kf
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Binary PREFIX = key_
+
+Key_Data *
+new(me, sv, f = 0)
+	SV *me
+	SV *sv
+	unsigned f
+	PREINIT:
+	char *p;
+	STRLEN len;
+	CODE:
+	p = SvPV(sv, len);
+	RETVAL = key_newbinary(f, p, len);
+	OUTPUT:
+	RETVAL
+
+SV *
+bin(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
+	OUTPUT:
+	RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Encrypted PREFIX = key_
+
+Key_Data *
+new(me, sv, f = 0)
+	SV *me
+	SV *sv
+	unsigned f
+	PREINIT:
+	char *p;
+	STRLEN len;
+	CODE:
+	p = SvPV(sv, len);
+	RETVAL = key_newencrypted(f, p, len);
+	OUTPUT:
+	RETVAL
+
+SV *
+ct(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
+	OUTPUT:
+	RETVAL
+
+SV *
+lock(kd, key)
+	Key_Data *kd
+	SV *key
+	CODE:
+	croak("already encrypted");
+
+SV *
+plock(kd, tag)
+	Key_Data *kd
+	char *tag
+	CODE:
+	croak("already encrypted");
+
+Key_Data *
+unlock(kd, key)
+	Key_Data *kd
+	SV *key
+	PREINIT:
+	STRLEN len;
+	char *p;
+	int rc;
+	CODE:
+	p = SvPV(key, len);
+	if ((rc = key_unlock(&RETVAL, kd, p, len)) != 0) {
+	  keyerr(rc);
+	  RETVAL = 0;
+	}
+	OUTPUT:
+	RETVAL
+
+Key_Data *
+punlock(kd, tag)
+	Key_Data *kd
+	char *tag
+	PREINIT:
+	int rc;
+	CODE:
+	if ((rc = key_punlock(&RETVAL, kd, tag)) != 0) {
+	  keyerr(rc);
+	  RETVAL = 0;
+	}
+	OUTPUT:
+	RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::MP PREFIX = key_
+
+Key_Data *
+new(me, x, f = 0)
+	SV *me
+	mp *x
+	unsigned f
+	CODE:
+	RETVAL = key_newmp(f, x);
+	OUTPUT:
+	RETVAL
+
+mp *
+mp(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = MP_COPY(kd->u.m);
+	OUTPUT:
+	RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::EC PREFIX = key_
+
+Key_Data *
+new(me, p, f = 0)
+	SV *me
+	ec *p
+	unsigned f
+	CODE:
+	RETVAL = key_newec(f, p);
+	OUTPUT:
+	RETVAL
+
+ec *
+ec(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = CREATE(ec);
+	EC_CREATE(RETVAL);
+	EC_COPY(RETVAL, &kd->u.e);
+	OUTPUT:
+	RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::String PREFIX = key_
+
+Key_Data *
+new(me, p, f = 0)
+	SV *me
+	char *p
+	unsigned f
+	CODE:
+	RETVAL = key_newstring(f, p);
+	OUTPUT:
+	RETVAL
+
+char *
+str(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = kd->u.p;
+	OUTPUT:
+	RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Structured PREFIX = key_
+
+Key_Data *
+new()
+	CODE:
+	RETVAL = key_newstruct();
+	OUTPUT:
+	RETVAL
+
+Key_StructIter *
+iterate(kd)
+	Key_Data *kd
+	CODE:
+	RETVAL = CREATE(Key_StructIter);
+	sym_mkiter(RETVAL, &kd->u.s);
+	OUTPUT:
+	RETVAL
+
+Key_Data *
+find(kd, tag)
+	Key_Data *kd
+	char *tag
+	CODE:
+	RETVAL = key_structfind(kd, tag);
+	if (RETVAL) key_incref(RETVAL);
+	OUTPUT:
+	RETVAL
+
+SV *
+del(kd, tag)
+	Key_Data *kd
+	char *tag
+	CODE:
+	key_structset(kd, tag, 0);
+	XSRETURN_YES;
+
+SV *
+set(kd, tag, kdnew = 0)
+	Key_Data *kd
+	char *tag
+	Key_Data *kdnew
+	CODE:
+	key_structset(kd, tag, kdnew);
+	XSRETURN_YES;
+	
+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
 
 MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_
 
 Key_File *
-new(file, how)
+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, file, how, warn_keyreporter, 0)) {
+	if (key_open(&RETVAL->kf, file, how, keyreport, report)) {
 	  DESTROY(RETVAL);
 	  RETVAL = 0;
 	}
@@ -55,20 +689,173 @@ SV *
 DESTROY(kf)
 	Key_File *kf
 	CODE:
-	key_close(kf);
+	keyfile_dec(kf);
 	XSRETURN_UNDEF;
 
-KEYERR
-merge(kf, name, fp)
+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
+
+void
+qtag(kf, tag, kdnew = 0)
+	Key_File *kf
+	char *tag
+	Key_Data *kdnew
+	PREINIT:
+	dstr d = DSTR_INIT;
+	key_data **kd;
+	key_data *okd;
+	key *k;
+	Key *kk;
+	PPCODE:
+	if (key_qtag(&kf->kf, tag, &d, &k, &kd)) {
+	  keyerr(KERR_NOTFOUND);
+	  XSRETURN_UNDEF;
+	}
+	okd = *kd;
+	if (kdnew) {
+	  if (!(kf->kf.f & KF_WRITE)) {
+	    keyerr(KERR_READONLY);
+	    XSRETURN_UNDEF;
+	  }
+	  kf->kf.f |= KF_MODIFIED;
+	  *kd = kdnew;
+	}
+	key_incref(*kd);
+	kk = CREATE(Key);
+	kk->k = k;
+	kk->kf = kf;
+	kf->ref++;
+	XPUSHs(sv_2mortal(newSVpvn(d.buf, d.len)));
+	XPUSHs(RET(kk, "Catacomb::Key"));
+	XPUSHs(RET(okd, keydata_type(okd)));
+	dstr_destroy(&d);
+
+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 = key_merge(kf, name, fp, warn_keyreporter, 0);
+	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 = KEXP_FOREVER)
+	Key_File *kf
+	U32 id
+	const char *type
+	time_t exp
+	PREINIT:
+	int err;
+	CODE:
+	RETVAL = CREATE(Key);
+	if ((err = key_new(&kf->kf, id, type, exp, &RETVAL->k)) == 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 *
-extract
+DESTROY(ki)
+	Key_FileIter *ki
+	CODE:
+	keyfile_dec(ki->kf);
+	DESTROY(ki);
+	XSRETURN_YES;
 
 #----- That's all, folks ----------------------------------------------------