# ---?---
#
# $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 ----------------------------------------------------