X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-perl/blobdiff_plain/bdf77f6dbd9205c70639fb682059e4ba0761c767..bfdf19cbde6d9f5cdb740d258fcc439a4a412ab0:/key.xs

diff --git a/key.xs b/key.xs
index d14ad70..db58921 100644
--- a/key.xs
+++ b/key.xs
@@ -65,11 +65,21 @@ del(k)
 	OUTPUT:
 	RETVAL
 
-Key_DataImpl *
-_data(k)
+Key_Data *
+data(k)
 	Key *k
 	CODE:
-	RETVAL = &k->k->k;
+	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
 
@@ -296,366 +306,345 @@ m(kf)
 	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
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data PREFIX = key_
 
 SV *
-free(kd)
-	Key_DataImpl *kd
+DESTROY(kd)
+	Key_Data *kd
 	CODE:
-	key_destroy(kd);
-	DESTROY(kd);
+	key_drop(kd);
 	XSRETURN_YES;
 
-SV *
-clear(kd)
-	Key_DataImpl *kd
+U32
+flags(kd)
+	Key_Data *kd
 	CODE:
-	key_destroy(kd);
-	kd->e = 0;
-	kd->u.k.k = 0;
-	kd->u.k.sz = 0;
-	XSRETURN_YES;
+	RETVAL = kd->e;
+	OUTPUT:	
+	RETVAL
 
-SV *
-setbinary(kd, sv)
-	Key_DataImpl *kd
-	SV *sv
+void
+readflags(me, p)
+	SV *me
+	char *p
 	PREINIT:
-	char *p;
-	STRLEN len;
-	CODE:
-	p = SvPV(sv, len);
-	key_destroy(kd);
-	key_binary(kd, p, len);
-	XSRETURN_YES;
+	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 *
-setencrypted(kd, sv)
-	Key_DataImpl *kd
-	SV *sv
+getflags(me, f)
+	SV *me
+	U32 f
 	PREINIT:
-	char *p;
-	STRLEN len;
+	dstr d = DSTR_INIT;
 	CODE:
-	p = SvPV(sv, len);
-	key_destroy(kd);
-	key_encrypted(kd, p, len);
-	XSRETURN_YES;
+	key_writeflags(f, &d);
+	RETVAL = newSVpvn(d.buf, d.len);
+	dstr_destroy(&d);
+	OUTPUT:
+	RETVAL
 
 SV *
-setmp(kd, x)
-	Key_DataImpl *kd
-	mp *x
+setflags(kd, f)
+	Key_Data *kd
+	U32 f
 	CODE:
-	key_destroy(kd);
-	key_mp(kd, x);
+	kd->e = (kd->e & KF_ENCMASK) | (f & ~KF_ENCMASK);
 	XSRETURN_YES;
 
-SV *
-setstring(kd, p)
-	Key_DataImpl *kd
+void
+read(me, p)
+	SV *me
 	char *p
-	CODE:
-	key_destroy(kd);
-	key_string(kd, p);
-	XSRETURN_YES;
+	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 *
-setec(kd, p)
-	Key_DataImpl *kd
-	ec *p
-	CODE:
-	key_destroy(kd);
-	key_ec(kd, p);
-	XSRETURN_YES;
-
-U32
-flags(kd)
-	Key_DataImpl *kd
+write(kd, kf = 0)
+	Key_Data *kd
+	Key_Filter *kf
+	PREINIT:
+	dstr d = DSTR_INIT;
 	CODE:
-	RETVAL = kd->e;
-	OUTPUT:	
+	if (key_write(kd, &d, kf))
+	  RETVAL = newSVpvn(d.buf, d.len);
+	else
+	  RETVAL = &PL_sv_undef;
+	dstr_destroy(&d);
+	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
+Key_Data *
+decode(me, sv)
+	SV *me
+	SV *sv
+	PREINIT:
+	char *p;
+	STRLEN len;
 	CODE:
-	if ((kd->e & KF_ENCMASK) != KENC_BINARY)
-	  croak("key is not binary");
-	RETVAL = newSVpvn(kd->u.k.k, kd->u.k.sz);
+	p = SvPV(sv, len);
+	RETVAL = key_decode(p, len);
 	OUTPUT:
 	RETVAL
 
 SV *
-getencrypted(kd)
-	Key_DataImpl *kd
+encode(kd, kf = 0)
+	Key_Data *kd
+	Key_Filter *kf
+	PREINIT:
+	dstr d = DSTR_INIT;
 	CODE:
-	if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
-	  croak("key is not encrypted");
-	RETVAL = newSVpvn(kd->u.k.k, kd->u.k.sz);
+	if (key_encode(kd, &d, kf))
+	  RETVAL = newSVpvn(d.buf, d.len);
+	else
+	  RETVAL = &PL_sv_undef;
+	dstr_destroy(&d);
 	OUTPUT:
 	RETVAL
 
-mp *
-getmp(kd)
-	Key_DataImpl *kd
+Key_Data *
+lock(kd, key)
+	Key_Data *kd
+	SV *key
+	PREINIT:
+	STRLEN len;
+	char *p;
 	CODE:
-	if ((kd->e & KF_ENCMASK) != KENC_MP)
-	  croak("key is not bignum");
-	RETVAL = MP_COPY(kd->u.m);
+	p = SvPV(key, len);
+	key_lock(&RETVAL, kd, p, len);
 	OUTPUT:
 	RETVAL
 
-ec *
-getec(kd)
-	Key_DataImpl *kd
+Key_Data *
+plock(kd, tag)
+	Key_Data *kd
+	char *tag
+	PREINIT:
+	int rc;
 	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);
+	if ((rc = key_plock(&RETVAL, kd, tag)) != 0) {
+	  keyerr(rc);
+	  RETVAL = 0;
+	}
 	OUTPUT:
 	RETVAL
 
-char *
-getstring(kd)
-	Key_DataImpl *kd
+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:
-	if ((kd->e & KF_ENCMASK) != KENC_STRING)
-	  croak("key is not string");
-	RETVAL = kd->u.p;
+	p = SvPV(sv, len);
+	RETVAL = key_newbinary(f, p, len);
 	OUTPUT:
 	RETVAL
 
 SV *
-setstruct(kd)
-	Key_DataImpl *kd
+bin(kd)
+	Key_Data *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;
+	RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
+	OUTPUT:
+	RETVAL
 
-Key_DataImpl *
-key_structcreate(kd, tag)
-	Key_DataImpl *kd
-	char *tag
-	INIT:
-	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
-	  croak("key is not structured");
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Encrypted PREFIX = key_
 
-Key_StructIter *
-structiter(kd)
-	Key_DataImpl *kd
+Key_Data *
+new(me, sv, f = 0)
+	SV *me
+	SV *sv
+	unsigned f
+	PREINIT:
+	char *p;
+	STRLEN len;
 	CODE:
-	if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
-	  croak("key is not structured");
-	RETVAL = CREATE(Key_StructIter);
-	sym_mkiter(RETVAL, &kd->u.s);
+	p = SvPV(sv, len);
+	RETVAL = key_newencrypted(f, p, len);
 	OUTPUT:
 	RETVAL
 
 SV *
-structdel(kd, tag)
-	Key_DataImpl *kd
-	char *tag
-	PREINIT:
-	key_struct *ks;
+ct(kd)
+	Key_Data *kd
 	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);
+	RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
 	OUTPUT:
 	RETVAL
 
-Key_DataImpl *
+SV *
 lock(kd, key)
-	Key_DataImpl *kd
+	Key_Data *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
+	croak("already encrypted");
+
+SV *
+plock(kd, tag)
+	Key_Data *kd
+	char *tag
+	CODE:
+	croak("already encrypted");
 
-Key_DataImpl *
+Key_Data *
 unlock(kd, key)
-	Key_DataImpl *kd
+	Key_Data *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);
+	if ((rc = key_unlock(&RETVAL, kd, p, len)) != 0) {
 	  keyerr(rc);
 	  RETVAL = 0;
 	}
 	OUTPUT:
 	RETVAL
 
-Key_DataImpl *
-plock(kd, tag)
-	Key_DataImpl *kd
+Key_Data *
+punlock(kd, tag)
+	Key_Data *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);
+	if ((rc = key_punlock(&RETVAL, kd, tag)) != 0) {
 	  keyerr(rc);
 	  RETVAL = 0;
 	}
 	OUTPUT:
 	RETVAL
 
-Key_DataImpl *
-punlock(kd, tag)
-	Key_DataImpl *kd
-	char *tag
-	PREINIT:
-	int rc;
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::MP PREFIX = key_
+
+Key_Data *
+new(me, x, f = 0)
+	SV *me
+	mp *x
+	unsigned f
 	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;
-	}
+	RETVAL = key_newmp(f, x);
 	OUTPUT:
 	RETVAL
 
-void
-read(me, p)
+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
-	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))));
-	}
+	ec *p
+	unsigned f
+	CODE:
+	RETVAL = key_newec(f, p);
+	OUTPUT:
+	RETVAL
 
-SV *
-write(kd, kf = 0)
-	Key_DataImpl *kd
-	Key_Filter *kf
-	PREINIT:
-	dstr d = DSTR_INIT;
+ec *
+ec(kd)
+	Key_Data *kd
 	CODE:
-	if (key_write(kd, &d, kf))
-	  RETVAL = newSVpvn(d.buf, d.len);
-	else
-	  RETVAL = &PL_sv_undef;
-	dstr_destroy(&d);
+	RETVAL = CREATE(ec);
+	EC_CREATE(RETVAL);
+	EC_COPY(RETVAL, &kd->u.e);
 	OUTPUT:
 	RETVAL
 
-Key_DataImpl *
-decode(me, sv)
+MODULE = Catacomb PACKAGE = Catacomb::Key::Data::String PREFIX = key_
+
+Key_Data *
+new(me, p, f = 0)
 	SV *me
-	SV *sv
-	PREINIT:
-	char *p;
-	STRLEN len;
+	char *p
+	unsigned f
 	CODE:
-	p = SvPV(sv, len);
-	RETVAL = CREATE(key_data);
-	if (key_decode(p, len, RETVAL)) {
-	  DESTROY(RETVAL);
-	  RETVAL = 0;
-	}
+	RETVAL = key_newstring(f, p);
 	OUTPUT:
 	RETVAL
 
-SV *
-encode(kd, kf = 0)
-	Key_DataImpl *kd
-	Key_Filter *kf
-	PREINIT:
-	dstr d = DSTR_INIT;
+char *
+str(kd)
+	Key_Data *kd
 	CODE:
-	if (key_encode(kd, &d, kf))
-	  RETVAL = newSVpvn(d.buf, d.len);
-	else
-	  RETVAL = &PL_sv_undef;
-	dstr_destroy(&d);
+	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 *
@@ -679,31 +668,6 @@ DESTROY(i)
 
 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 *
@@ -748,6 +712,41 @@ key_extract(kf, k, fp, kfilt = 0)
 	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
@@ -803,7 +802,7 @@ bytag(kf, tag)
 	RETVAL
 
 Key *
-newkey(kf, id, type, exp)
+newkey(kf, id, type, exp = KEXP_FOREVER)
 	Key_File *kf
 	U32 id
 	const char *type
@@ -812,7 +811,7 @@ newkey(kf, id, type, exp)
 	int err;
 	CODE:
 	RETVAL = CREATE(Key);
-	if ((RETVAL->k = key_new(&kf->kf, id, type, exp, &err)) == 0) {
+	if ((err = key_new(&kf->kf, id, type, exp, &RETVAL->k)) == 0) {
 	  DESTROY(RETVAL);
 	  keyerr(err);
 	  RETVAL = 0;
@@ -822,7 +821,6 @@ newkey(kf, id, type, exp)
 	}
 	OUTPUT:
 	RETVAL
-	
 
 Key_FileIter *
 iterate(kf)