Much wider support for Catacomb in all its glory.

[catacomb-perl] / algorithms.xs

diff --git a/algorithms.xs b/algorithms.xs
index 6001d9dc6b71232133ce483f52883cbdff61a041..6a01f15b0a9d79163179697551f91a4627594071 100644 (file)
--- a/algorithms.xs
+++ b/algorithms.xs
@@ -25,16 +25,22 @@
 # 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::CipherClass
-
-PROTOTYPES: DISABLE
+MODULE = Catacomb PACKAGE = Catacomb::PRPClass
 
-gccipher *
+PRPClass *
 find(me, name)
        SV *me
        char *name
-       CODE:
-       RETVAL = (gccipher *)gcipher_byname(name);
+       PREINIT:
+       int i;
+       CODE:
+       RETVAL = 0;
+       for (i = 0; prptab[i]; i++) {
+         if (strcmp(name, prptab[i]->name) == 0) {
+           RETVAL = prptab[i];
+           break;
+         }
+       }
        OUTPUT:
        RETVAL
 
@@ -42,11 +48,117 @@ SV *
 list(me)
        SV *me
        PREINIT:
-       const gccipher *const *cc;
-       SV *sv;
+       int i;
        PPCODE:
-       for (cc = gciphertab; *cc; cc++)
-         XPUSHs(RET((gccipher *)*cc, "Catacomb::CipherClass"));
+       for (i = 0; prptab[i]; i++)
+         XPUSHs(RET(prptab[i], "Catacomb::PRPClass"));
+
+keysize *
+keysz(p)
+       PRPClass *p
+       CODE:
+       RETVAL = p->ksz;
+       OUTPUT:
+       RETVAL
+
+char *
+name(p)
+       PRPClass *p
+       CODE:
+       RETVAL = p->name;
+       OUTPUT:
+       RETVAL
+
+UV
+blksz(p)
+       PRPClass *p
+       CODE:
+       RETVAL = p->blksz;
+       OUTPUT:
+       RETVAL
+
+PRP *
+init(p, k)
+       PRPClass *p
+       SV *k
+       PREINIT:
+       char *pp;
+       STRLEN len;
+       CODE:
+       pp = SvPV(k, len);
+       if (keysz(len, p->ksz) != len)
+         croak("key size mismatch");
+       RETVAL = sub_alloc(sizeof(PRP) + p->ctxsz);
+       RETVAL->c = p;
+       p->init(RETVAL + 1, pp, len);
+       OUTPUT:
+       RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::PRP
+
+SV *
+DESTROY(p)
+       PRP *p
+       CODE:
+       sub_free(p, sizeof(PRP) + p->c->ctxsz);
+       XSRETURN_YES;
+
+SV *
+eblk(p, x)
+       PRP *p
+       SV *x
+       PREINIT:
+       char *pp;
+       STRLEN len;
+       CODE:
+       pp = SvPV(x, len);
+       if (len != p->c->blksz)
+         croak("block size mismatch");
+       RETVAL = NEWSV(0, p->c->blksz);
+       p->c->eblk(p + 1, pp, SvPVX(RETVAL));
+       SvPOK_on(RETVAL);
+       SvCUR_set(RETVAL, p->c->blksz);
+       OUTPUT:
+       RETVAL
+
+SV *
+dblk(p, x)
+       PRP *p
+       SV *x
+       PREINIT:
+       char *pp;
+       STRLEN len;
+       CODE:
+       pp = SvPV(x, len);
+       if (len != p->c->blksz)
+         croak("block size mismatch");
+       RETVAL = NEWSV(0, p->c->blksz);
+       p->c->dblk(p + 1, pp, SvPVX(RETVAL));
+       SvPOK_on(RETVAL);
+       SvCUR_set(RETVAL, p->c->blksz);
+       OUTPUT:
+       RETVAL
+
+PRPClass *
+class(p)
+       PRP *p
+       CODE:
+       RETVAL = p->c;
+       OUTPUT:
+       RETVAL
+
+MODULE = Catacomb PACKAGE = Catacomb::CipherClass
+
+PROTOTYPES: DISABLE
+
+gccipher *
+find(me, name)
+       SV *me
+       char *name
+       CODE:
+       RETVAL = (gccipher *)gcipher_byname(name);
+       OUTPUT:
+       RETVAL
 
 keysize *
 keysz(cc)
@@ -96,7 +208,7 @@ DESTROY(c)
        gcipher *c
        CODE:
        c->ops->destroy(c);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 encrypt(c, plain)
@@ -144,14 +256,14 @@ setiv(c, iv)
                c->ops->c->name, (unsigned long)c->ops->c->blksz);
        }
        c->ops->setiv(c, p);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 bdry(c)
        gcipher *c
        CODE:
        c->ops->bdry(c);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 gccipher *
 class(c)
@@ -172,16 +284,6 @@ find(me, name)
        OUTPUT:
        RETVAL
 
-SV *
-list(me)
-       SV *me
-       PREINIT:
-       const gchash *const *hc;
-       SV *sv;
-       PPCODE:
-       for (hc = ghashtab; *hc; hc++)
-         XPUSHs(RET((gchash *)*hc, "Catacomb::HashClass"));
-
 size_t
 hashsz(hc)
        gchash *hc
@@ -213,7 +315,7 @@ DESTROY(h)
        ghash *h
        CODE:
        h->ops->destroy(h);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 hash(h, sv)
@@ -225,7 +327,7 @@ hash(h, sv)
        CODE:
        p = SvPV(sv, len);
        h->ops->hash(h, p, len);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 done(h)
@@ -270,7 +372,6 @@ list(me)
        SV *me
        PREINIT:
        const gcMAC *const *mc;
-       SV *sv;
        PPCODE:
        for (mc = gmactab; *mc; mc++)
          XPUSHs(RET((gcMAC *)*mc, "Catacomb::MACClass"));
@@ -323,7 +424,7 @@ DESTROY(m)
        gMAC *m
        CODE:
        m->ops->destroy(m);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 ghash *
 init(m)
@@ -351,7 +452,7 @@ seedint(r, seed)
        if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDUINT32))
          croak("rng `%s' doesn't support `seedint'", r->ops->name);
        r->ops->misc(r, GRAND_SEEDUINT32, seed);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 seedblock(r, seed)
@@ -365,7 +466,7 @@ seedblock(r, seed)
          croak("rng `%s' doesn't support `seedblock'", r->ops->name);
        p = SvPV(seed, len);
        r->ops->misc(r, GRAND_SEEDBLOCK, p, len);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 seedmp(r, seed)
@@ -375,7 +476,7 @@ seedmp(r, seed)
        if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDMP))
          croak("rng `%s' doesn't support `seedmp'", r->ops->name);
        r->ops->misc(r, GRAND_SEEDMP, seed);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 seedrand(r, seed)
@@ -385,7 +486,7 @@ seedrand(r, seed)
        if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDRAND))
          croak("rng `%s' doesn't support `seedrand'", r->ops->name);
        r->ops->misc(r, GRAND_SEEDRAND, seed);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 U32
 raw(r)
@@ -506,14 +607,14 @@ gate(r)
        Rand_True *r
        CODE:
        r->ops->misc(r, RAND_GATE);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 stretch(r)
        Rand_True *r
        CODE:
        r->ops->misc(r, RAND_STRETCH);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 key(r, k)
@@ -525,14 +626,14 @@ key(r, k)
        CODE:
        p = SvPV(k, len);
        r->ops->misc(r, RAND_KEY, p, len);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 noisesrc(r)
        Rand_True *r
        CODE:
        r->ops->misc(r, RAND_NOISESRC, &noise_source);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 seed(r, bits = 160)
@@ -540,7 +641,7 @@ seed(r, bits = 160)
        int bits
        CODE:
        r->ops->misc(r, RAND_SEED, bits);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 MODULE = Catacomb PACKAGE = Catacomb::Rand::Fib
 
@@ -585,7 +686,7 @@ passes(r, n)
        unsigned n
        CODE:
        r->ops->misc(r, DSARAND_PASSES, n);
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 SV *
 seed(r)
@@ -635,7 +736,8 @@ new(me, k, n = 0)
 MODULE = Catacomb PACKAGE = Catacomb::Rand::MGF
 
 SV *
-new(name, k)
+new(me, name, k)
+       SV *me
        char *name
        SV *k
        CODE:
@@ -643,16 +745,11 @@ new(name, k)
        OUTPUT:
        RETVAL
 
-void
-list(me)
-       SV *me
-       PPCODE:
-       listrand(mgftab);
-
 MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter
 
 SV *
-new(name, k)
+new(me, name, k)
+       SV *me
        char *name
        SV *k
        CODE:
@@ -660,16 +757,11 @@ new(name, k)
        OUTPUT:
        RETVAL
 
-void
-list(me)
-       SV *me
-       PPCODE:
-       listrand(ctrtab);
-
 MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB
 
 SV *
-new(name, k)
+new(me, name, k)
+       SV *me
        char *name
        SV *k
        CODE:
@@ -677,18 +769,12 @@ new(name, k)
        OUTPUT:
        RETVAL
 
-void
-list(me)
-       SV *me
-       PPCODE:
-       listrand(ofbtab);
-
 MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic
 
 SV *
 DESTROY(r)
        grand *r
        CODE:
-       XSRETURN_UNDEF;
+       XSRETURN_YES;
 
 #----- That's all, folks ----------------------------------------------------