+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;