Update for new keydata interface.

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

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(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

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 = 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 *
DESTROY(ki)
	Key_FileIter *ki
	CODE:
	keyfile_dec(ki->kf);
	DESTROY(ki);
	XSRETURN_YES;

#----- That's all, folks ----------------------------------------------------