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
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 *
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 *
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
RETVAL
Key *
-newkey(kf, id, type, exp)
+newkey(kf, id, type, exp = KEXP_FOREVER)
Key_File *kf
U32 id
const char *type
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;
}
OUTPUT:
RETVAL
-
Key_FileIter *
iterate(kf)
~mdw / catacomb-perl / blobdiff