660b443c |
1 | # ---?--- |
2 | # |
a1a90aaf |
3 | # $Id$ |
660b443c |
4 | # |
5 | # Interface to crypto algorithms |
6 | # |
7 | # (c) 2001 Straylight/Edgeware |
8 | # |
9 | |
10 | #----- Licensing notice ----------------------------------------------------- |
11 | # |
12 | # This file is part of the Perl interface to Catacomb. |
13 | # |
14 | # Catacomb/Perl is free software; you can redistribute it and/or modify |
15 | # it under the terms of the GNU General Public License as published by |
16 | # the Free Software Foundation; either version 2 of the License, or |
17 | # (at your option) any later version. |
18 | # |
19 | # Catacomb/Perl is distributed in the hope that it will be useful, |
20 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
21 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
22 | # GNU General Public License for more details. |
23 | # |
24 | # You should have received a copy of the GNU General Public License |
25 | # along with Catacomb/Perl; if not, write to the Free Software Foundation, |
26 | # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
27 | |
fcd15e0b |
28 | MODULE = Catacomb PACKAGE = Catacomb::PRPClass |
660b443c |
29 | |
fcd15e0b |
30 | PRPClass * |
660b443c |
31 | find(me, name) |
32 | SV *me |
33 | char *name |
fcd15e0b |
34 | PREINIT: |
35 | int i; |
36 | CODE: |
37 | RETVAL = 0; |
38 | for (i = 0; prptab[i]; i++) { |
39 | if (strcmp(name, prptab[i]->name) == 0) { |
40 | RETVAL = prptab[i]; |
41 | break; |
42 | } |
43 | } |
660b443c |
44 | OUTPUT: |
45 | RETVAL |
46 | |
47 | SV * |
48 | list(me) |
49 | SV *me |
50 | PREINIT: |
fcd15e0b |
51 | int i; |
660b443c |
52 | PPCODE: |
fcd15e0b |
53 | for (i = 0; prptab[i]; i++) |
54 | XPUSHs(RET(prptab[i], "Catacomb::PRPClass")); |
55 | |
56 | keysize * |
57 | keysz(p) |
58 | PRPClass *p |
59 | CODE: |
60 | RETVAL = p->ksz; |
61 | OUTPUT: |
62 | RETVAL |
63 | |
64 | char * |
65 | name(p) |
66 | PRPClass *p |
67 | CODE: |
68 | RETVAL = p->name; |
69 | OUTPUT: |
70 | RETVAL |
71 | |
72 | UV |
73 | blksz(p) |
74 | PRPClass *p |
75 | CODE: |
76 | RETVAL = p->blksz; |
77 | OUTPUT: |
78 | RETVAL |
79 | |
80 | PRP * |
81 | init(p, k) |
82 | PRPClass *p |
83 | SV *k |
84 | PREINIT: |
85 | char *pp; |
86 | STRLEN len; |
87 | CODE: |
88 | pp = SvPV(k, len); |
89 | if (keysz(len, p->ksz) != len) |
90 | croak("key size mismatch"); |
91 | RETVAL = sub_alloc(sizeof(PRP) + p->ctxsz); |
92 | RETVAL->c = p; |
93 | p->init(RETVAL + 1, pp, len); |
94 | OUTPUT: |
95 | RETVAL |
96 | |
97 | MODULE = Catacomb PACKAGE = Catacomb::PRP |
98 | |
99 | SV * |
100 | DESTROY(p) |
101 | PRP *p |
102 | CODE: |
103 | sub_free(p, sizeof(PRP) + p->c->ctxsz); |
104 | XSRETURN_YES; |
105 | |
106 | SV * |
107 | eblk(p, x) |
108 | PRP *p |
109 | SV *x |
110 | PREINIT: |
111 | char *pp; |
112 | STRLEN len; |
113 | CODE: |
114 | pp = SvPV(x, len); |
115 | if (len != p->c->blksz) |
116 | croak("block size mismatch"); |
117 | RETVAL = NEWSV(0, p->c->blksz); |
118 | p->c->eblk(p + 1, pp, SvPVX(RETVAL)); |
119 | SvPOK_on(RETVAL); |
120 | SvCUR_set(RETVAL, p->c->blksz); |
121 | OUTPUT: |
122 | RETVAL |
123 | |
124 | SV * |
125 | dblk(p, x) |
126 | PRP *p |
127 | SV *x |
128 | PREINIT: |
129 | char *pp; |
130 | STRLEN len; |
131 | CODE: |
132 | pp = SvPV(x, len); |
133 | if (len != p->c->blksz) |
134 | croak("block size mismatch"); |
135 | RETVAL = NEWSV(0, p->c->blksz); |
136 | p->c->dblk(p + 1, pp, SvPVX(RETVAL)); |
137 | SvPOK_on(RETVAL); |
138 | SvCUR_set(RETVAL, p->c->blksz); |
139 | OUTPUT: |
140 | RETVAL |
141 | |
142 | PRPClass * |
143 | class(p) |
144 | PRP *p |
145 | CODE: |
146 | RETVAL = p->c; |
147 | OUTPUT: |
148 | RETVAL |
149 | |
150 | MODULE = Catacomb PACKAGE = Catacomb::CipherClass |
151 | |
152 | PROTOTYPES: DISABLE |
153 | |
154 | gccipher * |
155 | find(me, name) |
156 | SV *me |
157 | char *name |
158 | CODE: |
159 | RETVAL = (gccipher *)gcipher_byname(name); |
160 | OUTPUT: |
161 | RETVAL |
660b443c |
162 | |
163 | keysize * |
164 | keysz(cc) |
165 | gccipher *cc |
166 | CODE: |
167 | RETVAL = cc->keysz; |
168 | OUTPUT: |
169 | RETVAL |
170 | |
171 | char * |
172 | name(cc) |
173 | gccipher *cc |
174 | CODE: |
175 | RETVAL = (char *)cc->name; |
176 | OUTPUT: |
177 | RETVAL |
178 | |
179 | size_t |
180 | blksz(cc) |
181 | gccipher *cc |
182 | CODE: |
183 | RETVAL = cc->blksz; |
184 | OUTPUT: |
185 | RETVAL |
186 | |
187 | gcipher * |
188 | init(cc, k) |
189 | gccipher *cc |
190 | SV *k |
191 | PREINIT: |
192 | STRLEN len; |
193 | char *p; |
194 | CODE: |
195 | p = SvPV(k, len); |
196 | if (keysz(len, cc->keysz) != len) { |
197 | croak("bad key size %lu for cipher `%s'", |
198 | (unsigned long)len, cc->name); |
199 | } |
200 | RETVAL = cc->init(p, len); |
201 | OUTPUT: |
202 | RETVAL |
203 | |
204 | MODULE = Catacomb PACKAGE = Catacomb::Cipher |
205 | |
206 | SV * |
207 | DESTROY(c) |
208 | gcipher *c |
209 | CODE: |
210 | c->ops->destroy(c); |
fcd15e0b |
211 | XSRETURN_YES; |
660b443c |
212 | |
213 | SV * |
214 | encrypt(c, plain) |
215 | gcipher *c |
216 | SV *plain |
217 | PREINIT: |
218 | STRLEN len; |
219 | char *p; |
220 | CODE: |
221 | p = SvPV(plain, len); |
222 | RETVAL = NEWSV(0, len ? len : 1); |
223 | c->ops->encrypt(c, p, SvPVX(RETVAL), len); |
224 | SvCUR_set(RETVAL, len); |
225 | SvPOK_on(RETVAL); |
226 | OUTPUT: |
227 | RETVAL |
228 | |
229 | SV * |
bdf77f6d |
230 | fill(c, len) |
231 | gcipher *c |
232 | size_t len; |
233 | CODE: |
234 | RETVAL = NEWSV(0, len ? len : 1); |
235 | memset(SvPVX(RETVAL), 0, len); |
236 | c->ops->encrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len); |
237 | SvCUR_set(RETVAL, len); |
238 | SvPOK_on(RETVAL); |
239 | OUTPUT: |
240 | RETVAL |
241 | |
242 | SV * |
660b443c |
243 | decrypt(c, cipher) |
244 | gcipher *c |
245 | SV *cipher |
246 | PREINIT: |
247 | STRLEN len; |
248 | char *p; |
249 | CODE: |
250 | p = SvPV(cipher, len); |
251 | RETVAL = NEWSV(0, len ? len : 1); |
252 | c->ops->decrypt(c, p, SvPVX(RETVAL), len); |
253 | SvCUR_set(RETVAL, len); |
254 | SvPOK_on(RETVAL); |
255 | OUTPUT: |
256 | RETVAL |
257 | |
258 | SV * |
bdf77f6d |
259 | filldecrypt(c, len) |
260 | gcipher *c |
261 | size_t len; |
262 | CODE: |
263 | RETVAL = NEWSV(0, len ? len : 1); |
264 | memset(SvPVX(RETVAL), 0, len); |
265 | c->ops->decrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len); |
266 | SvCUR_set(RETVAL, len); |
267 | SvPOK_on(RETVAL); |
268 | OUTPUT: |
269 | RETVAL |
270 | |
271 | SV * |
660b443c |
272 | setiv(c, iv) |
273 | gcipher *c |
274 | SV *iv |
275 | PREINIT: |
276 | STRLEN len; |
277 | char *p; |
278 | CODE: |
279 | p = SvPV(iv, len); |
280 | if (c->ops->c->blksz && len != c->ops->c->blksz) { |
281 | croak("IV for block cipher `%s' must be %lu", |
282 | c->ops->c->name, (unsigned long)c->ops->c->blksz); |
283 | } |
284 | c->ops->setiv(c, p); |
fcd15e0b |
285 | XSRETURN_YES; |
660b443c |
286 | |
287 | SV * |
288 | bdry(c) |
289 | gcipher *c |
290 | CODE: |
291 | c->ops->bdry(c); |
fcd15e0b |
292 | XSRETURN_YES; |
660b443c |
293 | |
294 | gccipher * |
295 | class(c) |
296 | gcipher *c |
297 | CODE: |
298 | RETVAL = (gccipher *)c->ops->c; |
299 | OUTPUT: |
300 | RETVAL |
301 | |
302 | MODULE = Catacomb PACKAGE = Catacomb::HashClass |
303 | |
304 | gchash * |
305 | find(me, name) |
306 | SV *me |
307 | char *name |
660b443c |
308 | CODE: |
a1a90aaf |
309 | RETVAL = (gchash *)ghash_byname(name); |
660b443c |
310 | OUTPUT: |
311 | RETVAL |
312 | |
660b443c |
313 | size_t |
314 | hashsz(hc) |
315 | gchash *hc |
316 | CODE: |
317 | RETVAL = hc->hashsz; |
318 | OUTPUT: |
319 | RETVAL |
320 | |
321 | char * |
322 | name(hc) |
323 | gchash *hc |
324 | CODE: |
325 | RETVAL = (char *)hc->name; |
326 | OUTPUT: |
327 | RETVAL |
328 | |
329 | ghash * |
330 | init(hc) |
331 | gchash *hc |
332 | CODE: |
333 | RETVAL = hc->init(); |
334 | OUTPUT: |
335 | RETVAL |
336 | |
337 | MODULE = Catacomb PACKAGE = Catacomb::Hash |
338 | |
339 | SV * |
340 | DESTROY(h) |
341 | ghash *h |
342 | CODE: |
343 | h->ops->destroy(h); |
fcd15e0b |
344 | XSRETURN_YES; |
660b443c |
345 | |
346 | SV * |
347 | hash(h, sv) |
348 | ghash *h |
349 | SV *sv |
350 | PREINIT: |
351 | STRLEN len; |
352 | char *p; |
353 | CODE: |
354 | p = SvPV(sv, len); |
355 | h->ops->hash(h, p, len); |
fcd15e0b |
356 | XSRETURN_YES; |
660b443c |
357 | |
358 | SV * |
359 | done(h) |
360 | ghash *h |
361 | CODE: |
362 | RETVAL = NEWSV(0, h->ops->c->hashsz); |
363 | h->ops->done(h, SvPVX(RETVAL)); |
364 | SvCUR_set(RETVAL, h->ops->c->hashsz); |
365 | SvPOK_on(RETVAL); |
366 | OUTPUT: |
367 | RETVAL |
368 | |
369 | ghash * |
370 | copy(h) |
371 | ghash *h |
372 | CODE: |
373 | RETVAL = h->ops->copy(h); |
374 | OUTPUT: |
375 | RETVAL |
376 | |
377 | gchash * |
378 | class(h) |
379 | ghash *h |
380 | CODE: |
381 | RETVAL = (gchash *)h->ops->c; |
382 | OUTPUT: |
383 | RETVAL |
384 | |
385 | MODULE = Catacomb PACKAGE = Catacomb::MACClass |
386 | |
387 | gcMAC * |
388 | find(me, name) |
389 | SV *me |
390 | char *name |
660b443c |
391 | CODE: |
a1a90aaf |
392 | RETVAL = (gcMAC *)gmac_byname(name); |
660b443c |
393 | OUTPUT: |
394 | RETVAL |
395 | |
396 | SV * |
397 | list(me) |
398 | SV *me |
399 | PREINIT: |
a1a90aaf |
400 | const gcMAC *const *mc; |
660b443c |
401 | PPCODE: |
a1a90aaf |
402 | for (mc = gmactab; *mc; mc++) |
403 | XPUSHs(RET((gcMAC *)*mc, "Catacomb::MACClass")); |
660b443c |
404 | |
405 | size_t |
406 | hashsz(mc) |
407 | gcMAC *mc |
408 | CODE: |
409 | RETVAL = mc->hashsz; |
410 | OUTPUT: |
411 | RETVAL |
412 | |
413 | keysize * |
414 | keysz(mc) |
415 | gcMAC *mc |
416 | CODE: |
417 | RETVAL = mc->keysz; |
418 | OUTPUT: |
419 | RETVAL |
420 | |
421 | char * |
422 | name(mc) |
423 | gcMAC *mc |
424 | CODE: |
425 | RETVAL = (char *)mc->name; |
426 | OUTPUT: |
427 | RETVAL |
428 | |
429 | gMAC * |
430 | key(mc, k) |
431 | gcMAC *mc |
432 | SV *k |
433 | PREINIT: |
434 | STRLEN len; |
435 | char *p; |
436 | CODE: |
437 | p = SvPV(k, len); |
438 | if (keysz(len, mc->keysz) != len) { |
439 | croak("bad key size %lu for mac `%s'", |
440 | (unsigned long)len, mc->name); |
441 | } |
442 | RETVAL = mc->key(p, len); |
443 | OUTPUT: |
444 | RETVAL |
445 | |
446 | MODULE = Catacomb PACKAGE = Catacomb::MAC |
447 | |
448 | SV * |
449 | DESTROY(m) |
450 | gMAC *m |
451 | CODE: |
452 | m->ops->destroy(m); |
fcd15e0b |
453 | XSRETURN_YES; |
660b443c |
454 | |
455 | ghash * |
456 | init(m) |
457 | gMAC *m |
458 | CODE: |
459 | RETVAL = m->ops->init(m); |
460 | OUTPUT: |
461 | RETVAL |
462 | |
463 | gcMAC * |
464 | class(m) |
465 | gMAC *m |
466 | CODE: |
467 | RETVAL = (gcMAC *)m->ops->c; |
468 | OUTPUT: |
469 | RETVAL |
470 | |
471 | MODULE = Catacomb PACKAGE = Catacomb::Rand |
472 | |
473 | SV * |
474 | seedint(r, seed) |
475 | grand *r |
476 | U32 seed |
477 | CODE: |
478 | if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDUINT32)) |
479 | croak("rng `%s' doesn't support `seedint'", r->ops->name); |
480 | r->ops->misc(r, GRAND_SEEDUINT32, seed); |
fcd15e0b |
481 | XSRETURN_YES; |
660b443c |
482 | |
483 | SV * |
484 | seedblock(r, seed) |
485 | grand *r |
486 | SV *seed |
487 | PREINIT: |
488 | STRLEN len; |
489 | char *p; |
490 | CODE: |
491 | if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDBLOCK)) |
492 | croak("rng `%s' doesn't support `seedblock'", r->ops->name); |
493 | p = SvPV(seed, len); |
494 | r->ops->misc(r, GRAND_SEEDBLOCK, p, len); |
fcd15e0b |
495 | XSRETURN_YES; |
660b443c |
496 | |
497 | SV * |
498 | seedmp(r, seed) |
499 | grand *r |
500 | mp *seed |
501 | CODE: |
502 | if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDMP)) |
503 | croak("rng `%s' doesn't support `seedmp'", r->ops->name); |
504 | r->ops->misc(r, GRAND_SEEDMP, seed); |
fcd15e0b |
505 | XSRETURN_YES; |
660b443c |
506 | |
507 | SV * |
508 | seedrand(r, seed) |
509 | grand *r |
510 | grand *seed |
511 | CODE: |
512 | if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDRAND)) |
513 | croak("rng `%s' doesn't support `seedrand'", r->ops->name); |
514 | r->ops->misc(r, GRAND_SEEDRAND, seed); |
fcd15e0b |
515 | XSRETURN_YES; |
660b443c |
516 | |
517 | U32 |
518 | raw(r) |
519 | grand *r |
520 | CODE: |
521 | RETVAL = r->ops->raw(r); |
522 | OUTPUT: |
523 | RETVAL |
524 | |
525 | U32 |
526 | word(r) |
527 | grand *r |
528 | CODE: |
529 | RETVAL = r->ops->word(r); |
530 | OUTPUT: |
531 | RETVAL |
532 | |
533 | U8 |
534 | byte(r) |
535 | grand *r |
536 | CODE: |
537 | RETVAL = r->ops->byte(r); |
538 | OUTPUT: |
539 | RETVAL |
540 | |
541 | char |
542 | char(r) |
543 | grand *r |
544 | CODE: |
545 | RETVAL = r->ops->byte(r); |
546 | OUTPUT: |
547 | RETVAL |
548 | |
549 | U32 |
550 | range(r, limit) |
551 | grand *r |
552 | U32 limit |
553 | CODE: |
554 | RETVAL = r->ops->range(r, limit); |
555 | OUTPUT: |
556 | RETVAL |
557 | |
558 | mp * |
559 | mp(r, bits, or = 0) |
560 | grand *r |
561 | unsigned or |
562 | unsigned bits |
563 | CODE: |
564 | RETVAL = mprand(MP_NEW, bits, r, or); |
565 | OUTPUT: |
566 | RETVAL |
567 | |
568 | mp * |
569 | mprange(r, limit) |
570 | grand *r |
571 | mp *limit |
572 | CODE: |
573 | RETVAL = mprand_range(MP_NEW, limit, r, 0); |
574 | OUTPUT: |
575 | RETVAL |
576 | |
577 | SV * |
578 | fill(r, n) |
579 | grand *r |
580 | size_t n |
581 | CODE: |
582 | RETVAL = NEWSV(0, n ? n : 1); |
583 | r->ops->fill(r, SvPVX(RETVAL), n); |
584 | SvCUR_set(RETVAL, n); |
585 | SvPOK_on(RETVAL); |
586 | OUTPUT: |
587 | RETVAL |
588 | |
589 | char * |
590 | name(r) |
591 | grand *r |
592 | CODE: |
593 | RETVAL = (char *)r->ops->name; |
594 | OUTPUT: |
595 | RETVAL |
596 | |
597 | U32 |
598 | flags(r) |
599 | grand *r |
600 | CODE: |
601 | RETVAL = r->ops->f; |
602 | OUTPUT: |
603 | RETVAL |
604 | |
605 | U32 |
606 | max(r) |
607 | grand *r |
608 | CODE: |
609 | RETVAL = r->ops->max; |
610 | OUTPUT: |
611 | RETVAL |
612 | |
613 | MODULE = Catacomb PACKAGE = Catacomb::Rand::True |
614 | |
615 | Rand_True * |
616 | _global(me) |
617 | SV *me |
618 | CODE: |
619 | RETVAL = &rand_global; |
620 | OUTPUT: |
621 | RETVAL |
622 | |
623 | Rand_True * |
624 | rand(me) |
625 | SV *me |
626 | CODE: |
627 | RETVAL = rand_create(); |
628 | OUTPUT: |
629 | RETVAL |
630 | |
631 | SV * |
632 | gate(r) |
633 | Rand_True *r |
634 | CODE: |
635 | r->ops->misc(r, RAND_GATE); |
fcd15e0b |
636 | XSRETURN_YES; |
660b443c |
637 | |
638 | SV * |
639 | stretch(r) |
640 | Rand_True *r |
641 | CODE: |
642 | r->ops->misc(r, RAND_STRETCH); |
fcd15e0b |
643 | XSRETURN_YES; |
660b443c |
644 | |
645 | SV * |
646 | key(r, k) |
647 | Rand_True *r |
648 | SV *k |
649 | PREINIT: |
650 | STRLEN len; |
651 | char *p; |
652 | CODE: |
653 | p = SvPV(k, len); |
654 | r->ops->misc(r, RAND_KEY, p, len); |
fcd15e0b |
655 | XSRETURN_YES; |
660b443c |
656 | |
657 | SV * |
658 | noisesrc(r) |
659 | Rand_True *r |
660 | CODE: |
661 | r->ops->misc(r, RAND_NOISESRC, &noise_source); |
fcd15e0b |
662 | XSRETURN_YES; |
660b443c |
663 | |
664 | SV * |
665 | seed(r, bits = 160) |
666 | Rand_True *r |
667 | int bits |
668 | CODE: |
669 | r->ops->misc(r, RAND_SEED, bits); |
fcd15e0b |
670 | XSRETURN_YES; |
660b443c |
671 | |
672 | MODULE = Catacomb PACKAGE = Catacomb::Rand::Fib |
673 | |
674 | SV * |
675 | new(me, seed) |
676 | SV *me |
677 | U32 seed |
678 | CODE: |
679 | RETVAL = MAKE(fibrand_create(seed), "Catacomb::Rand::Fib"); |
680 | OUTPUT: |
681 | RETVAL |
682 | |
683 | MODULE = Catacomb PACKAGE = Catacomb::Rand::LC |
684 | |
685 | SV * |
686 | new(me, seed) |
687 | SV *me |
688 | U32 seed |
689 | CODE: |
690 | RETVAL = MAKE(lcrand_create(seed), "Catacomb::Rand::LC"); |
691 | OUTPUT: |
692 | RETVAL |
693 | |
694 | MODULE = Catacomb PACKAGE = Catacomb::Rand::DSA |
695 | |
696 | Rand_DSA * |
697 | new(me, k) |
698 | SV *me |
699 | SV *k |
700 | PREINIT: |
701 | STRLEN len; |
702 | char *p; |
703 | CODE: |
704 | p = SvPV(k, len); |
705 | RETVAL = dsarand_create(p, len); |
706 | OUTPUT: |
707 | RETVAL |
708 | |
709 | SV * |
710 | passes(r, n) |
711 | Rand_DSA *r |
712 | unsigned n |
713 | CODE: |
714 | r->ops->misc(r, DSARAND_PASSES, n); |
fcd15e0b |
715 | XSRETURN_YES; |
660b443c |
716 | |
717 | SV * |
718 | seed(r) |
719 | Rand_DSA *r |
720 | PREINIT: |
721 | size_t sz; |
722 | CODE: |
723 | sz = r->ops->misc(r, DSARAND_SEEDSZ); |
724 | RETVAL = NEWSV(0, sz ? sz : 1); |
725 | r->ops->misc(r, DSARAND_GETSEED, SvPVX(RETVAL)); |
726 | SvCUR_set(RETVAL, sz); |
727 | SvPOK_on(RETVAL); |
728 | OUTPUT: |
729 | RETVAL |
730 | |
731 | MODULE = Catacomb PACKAGE = Catacomb::Rand::RC4 |
732 | |
733 | SV * |
734 | new(me, k) |
735 | SV *me |
736 | SV *k |
737 | PREINIT: |
738 | STRLEN len; |
739 | char *p; |
740 | CODE: |
741 | p = SvPV(k, len); |
742 | RETVAL = MAKE(rc4_rand(p, len), "Catacomb::Rand::RC4"); |
743 | OUTPUT: |
744 | RETVAL |
745 | |
746 | MODULE = Catacomb PACKAGE = Catacomb::Rand::SEAL |
747 | |
748 | SV * |
749 | new(me, k, n = 0) |
750 | SV *me |
751 | SV *k |
752 | U32 n |
753 | PREINIT: |
754 | STRLEN len; |
755 | char *p; |
756 | CODE: |
757 | p = SvPV(k, len); |
758 | RETVAL = MAKE(seal_rand(p, len, n), "Catacomb::Rand::SEAL"); |
759 | OUTPUT: |
760 | RETVAL |
761 | |
762 | MODULE = Catacomb PACKAGE = Catacomb::Rand::MGF |
763 | |
764 | SV * |
fcd15e0b |
765 | new(me, name, k) |
766 | SV *me |
660b443c |
767 | char *name |
768 | SV *k |
769 | CODE: |
770 | RETVAL = findrand(mgftab, "Catacomb::Rand::MGF", name, k); |
771 | OUTPUT: |
772 | RETVAL |
773 | |
660b443c |
774 | MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter |
775 | |
776 | SV * |
fcd15e0b |
777 | new(me, name, k) |
778 | SV *me |
660b443c |
779 | char *name |
780 | SV *k |
781 | CODE: |
782 | RETVAL = findrand(ctrtab, "Catacomb::Rand::Counter", name, k); |
783 | OUTPUT: |
784 | RETVAL |
785 | |
660b443c |
786 | MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB |
787 | |
788 | SV * |
fcd15e0b |
789 | new(me, name, k) |
790 | SV *me |
660b443c |
791 | char *name |
792 | SV *k |
793 | CODE: |
794 | RETVAL = findrand(ofbtab, "Catacomb::Rand::OFB", name, k); |
795 | OUTPUT: |
796 | RETVAL |
797 | |
660b443c |
798 | MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic |
799 | |
800 | SV * |
801 | DESTROY(r) |
802 | grand *r |
803 | CODE: |
fcd15e0b |
804 | XSRETURN_YES; |
660b443c |
805 | |
806 | #----- That's all, folks ---------------------------------------------------- |