chiark - git - mdw - catacomb-perl/blob - key.xs

   1 # ---?---
   2 #
   3 # $Id$
   4 #
   5 # Key-management interface
   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
  28 MODULE = Catacomb PACKAGE = Catacomb::Key PREFIX = key_
  29
  30 SV *
  31 DESTROY(k)
  32         Key *k
  33         CODE:
  34         keyfile_dec(k->kf);
  35         DESTROY(k);
  36         XSRETURN_YES;
  37
  38 bool
  39 key_chkident(me, p)
  40         SV *me
  41         char *p
  42         C_ARGS:
  43         p
  44
  45 bool
  46 key_chkcomment(me, p)
  47         SV *me
  48         char *p
  49         C_ARGS:
  50         p
  51
  52 time_t
  53 exp(k)
  54         Key *k
  55         CODE:
  56         RETVAL = k->k->exp;
  57         OUTPUT:
  58         RETVAL
  59
  60 time_t
  61 del(k)
  62         Key *k
  63         CODE:
  64         RETVAL = k->k->del;
  65         OUTPUT:
  66         RETVAL
  67
  68 Key_Data *
  69 data(k)
  70         Key *k
  71         CODE:
  72         RETVAL = k->k->k;
  73         key_incref(RETVAL);
  74         OUTPUT:
  75         RETVAL
  76
  77 KeyErr
  78 setdata(k, kd)
  79         Key *k
  80         Key_Data *kd
  81         CODE:
  82         RETVAL = key_setkeydata(&k->kf->kf, k->k, kd);
  83         OUTPUT:
  84         RETVAL
  85
  86 char *
  87 comment(k)
  88         Key *k
  89         CODE:
  90         RETVAL = k->k->c;
  91         OUTPUT:
  92         RETVAL
  93
  94 U32
  95 id(k)
  96         Key *k
  97         CODE:
  98         RETVAL = k->k->id;
  99         OUTPUT:
 100         RETVAL
 101
 102 char *
 103 tag(k)
 104         Key *k
 105         CODE:
 106         RETVAL = k->k->tag;
 107         OUTPUT:
 108         RETVAL
 109
 110 char *
 111 type(k)
 112         Key *k
 113         CODE:
 114         RETVAL = k->k->type;
 115         OUTPUT:
 116         RETVAL
 117
 118 KeyErr
 119 key_setcomment(k, p)
 120         Key *k
 121         char *p
 122         C_ARGS:
 123         &k->kf->kf, k->k, p
 124
 125 KeyErr
 126 key_settag(k, p)
 127         Key *k
 128         char *p
 129         C_ARGS:
 130         &k->kf->kf, k->k, p
 131
 132 KeyErr
 133 key_delete(k)
 134         Key *k
 135         C_ARGS:
 136         &k->kf->kf, k->k
 137
 138 SV *
 139 fulltag(k)
 140         Key *k
 141         PREINIT:
 142         dstr d = DSTR_INIT;
 143         CODE:
 144         key_fulltag(k->k, &d);
 145         RETVAL = newSVpvn(d.buf, d.len);
 146         dstr_destroy(&d);
 147         OUTPUT:
 148         RETVAL
 149
 150 const char *
 151 key_getattr(k, a)
 152         Key *k
 153         char *a
 154         C_ARGS:
 155         &k->kf->kf, k->k, a
 156
 157 KeyErr
 158 putattr(k, a, v = &PL_sv_undef)
 159         Key *k
 160         char *a
 161         SV *v
 162         PREINIT:
 163         char *vv;
 164         STRLEN len;
 165         CODE:
 166         if (!SvOK(v))
 167           vv = 0;
 168         else
 169           vv = SvPV(v, len);
 170         RETVAL = key_putattr(&k->kf->kf, k->k, a, vv);
 171         OUTPUT:
 172         RETVAL
 173
 174 Key_AttrIter *
 175 attriter(k)
 176         Key *k
 177         CODE:
 178         RETVAL = CREATE(Key_AttrIter);
 179         key_mkattriter(&RETVAL->i, k->k);
 180         RETVAL->kf = k->kf;
 181         k->kf->ref++;
 182         OUTPUT:
 183         RETVAL
 184
 185 bool
 186 expiredp(k)
 187         Key *k
 188         CODE:
 189         RETVAL = key_expired(k->k);
 190         OUTPUT:
 191         RETVAL
 192
 193 KeyErr
 194 key_expire(k)
 195         Key *k
 196         C_ARGS:
 197         &k->kf->kf, k->k
 198
 199 KeyErr
 200 key_used(k, t)
 201         Key *k
 202         time_t t
 203         C_ARGS:
 204         &k->kf->kf, k->k, t
 205
 206 bool
 207 key_fingerprint(k, h, kf = 0)
 208         Key *k
 209         ghash *h
 210         Key_Filter *kf
 211         C_ARGS:
 212         k->k, h, kf
 213
 214 const char *
 215 key_strerror(me, err)
 216         SV *me
 217         int err
 218         C_ARGS:
 219         err
 220
 221 MODULE = Catacomb PACKAGE = Catacomb::Key::AttrIter
 222
 223 void
 224 next(i)
 225         Key_AttrIter *i
 226         PREINIT:
 227         const char *a, *v;
 228         PPCODE:
 229         if (key_nextattr(&i->i, &a, &v)) {
 230           XPUSHs(sv_2mortal(newSVpv(a, 0)));
 231           if (GIMME_V == G_ARRAY)
 232             XPUSHs(sv_2mortal(newSVpv(v, 0)));
 233         }
 234
 235 SV *
 236 DESTROY(i)
 237         Key_AttrIter *i
 238         CODE:
 239         keyfile_dec(i->kf);
 240         DESTROY(i);
 241         XSRETURN_YES;
 242
 243 MODULE = Catacomb PACKAGE = Catacomb::Key::Filter
 244
 245 Key_Filter *
 246 new(me, f = 0, m = 0)
 247         SV *me
 248         SV *f
 249         SV *m
 250         PREINIT:
 251         char *p;
 252         STRLEN len;
 253         CODE:
 254         RETVAL = CREATE(Key_Filter);
 255         if (!f || !SvOK(f))
 256           RETVAL->f = RETVAL->m = 0;
 257         else if (m) {
 258           RETVAL->f = SvUV(f);
 259           RETVAL->m = SvUV(m);
 260         } else {
 261           p = SvPV(f, len);
 262           if (key_readflags(p, 0, &RETVAL->f, &RETVAL->m)) {
 263             DESTROY(RETVAL);
 264             RETVAL = 0;
 265           }
 266         }
 267         OUTPUT:
 268         RETVAL
 269
 270 SV *
 271 DESTROY(kf)
 272         Key_Filter *kf
 273         CODE:
 274         if (!kf)
 275           XSRETURN_UNDEF;
 276         DESTROY(kf);
 277         XSRETURN_YES;
 278
 279 SV *
 280 tostring(kf)
 281         Key_Filter *kf
 282         PREINIT:
 283         dstr d = DSTR_INIT;
 284         CODE:
 285         if (!kf)
 286           XSRETURN_UNDEF;
 287         key_writeflags(kf->f, &d);
 288         RETVAL = newSVpvn(d.buf, d.len);
 289         dstr_destroy(&d);
 290         OUTPUT:
 291         RETVAL
 292
 293 UV
 294 f(kf)
 295         Key_Filter *kf
 296         CODE:
 297         RETVAL = kf ? kf->f : 0;
 298         OUTPUT:
 299         RETVAL
 300
 301 UV
 302 m(kf)
 303         Key_Filter *kf
 304         CODE:
 305         RETVAL = kf ? kf->m : 0;
 306         OUTPUT:
 307         RETVAL
 308
 309 MODULE = Catacomb PACKAGE = Catacomb::Key::Data PREFIX = key_
 310
 311 SV *
 312 DESTROY(kd)
 313         Key_Data *kd
 314         CODE:
 315         key_drop(kd);
 316         XSRETURN_YES;
 317
 318 U32
 319 flags(kd)
 320         Key_Data *kd
 321         CODE:
 322         RETVAL = kd->e;
 323         OUTPUT:
 324         RETVAL
 325
 326 void
 327 readflags(me, p)
 328         SV *me
 329         char *p
 330         PREINIT:
 331         unsigned f, m;
 332         PPCODE:
 333         if (key_readflags(p, &p, &f, &m) || *p)
 334           croak("bad flags string");
 335         XPUSHs(sv_2mortal(newSVuv(m)));
 336         XPUSHs(sv_2mortal(newSVuv(f)));
 337
 338 SV *
 339 getflags(me, f)
 340         SV *me
 341         U32 f
 342         PREINIT:
 343         dstr d = DSTR_INIT;
 344         CODE:
 345         key_writeflags(f, &d);
 346         RETVAL = newSVpvn(d.buf, d.len);
 347         dstr_destroy(&d);
 348         OUTPUT:
 349         RETVAL
 350
 351 SV *
 352 setflags(kd, f)
 353         Key_Data *kd
 354         U32 f
 355         CODE:
 356         kd->e = (kd->e & KF_ENCMASK) | (f & ~KF_ENCMASK);
 357         XSRETURN_YES;
 358
 359 void
 360 read(me, p)
 361         SV *me
 362         char *p
 363         PREINIT:
 364         key_data *kd;
 365         char *pp;
 366         PPCODE:
 367         if ((kd = key_read(p, &pp)) != 0) {
 368           XPUSHs(RET(kd, keydata_type(kd)));
 369           if (GIMME_V == G_ARRAY)
 370             XPUSHs(sv_2mortal(newSVpvn(pp, strlen(pp))));
 371         }
 372
 373 SV *
 374 write(kd, kf = 0)
 375         Key_Data *kd
 376         Key_Filter *kf
 377         PREINIT:
 378         dstr d = DSTR_INIT;
 379         CODE:
 380         if (key_write(kd, &d, kf))
 381           RETVAL = newSVpvn(d.buf, d.len);
 382         else
 383           RETVAL = &PL_sv_undef;
 384         dstr_destroy(&d);
 385         OUTPUT:
 386         RETVAL
 387
 388 Key_Data *
 389 decode(me, sv)
 390         SV *me
 391         SV *sv
 392         PREINIT:
 393         char *p;
 394         STRLEN len;
 395         CODE:
 396         p = SvPV(sv, len);
 397         RETVAL = key_decode(p, len);
 398         OUTPUT:
 399         RETVAL
 400
 401 SV *
 402 encode(kd, kf = 0)
 403         Key_Data *kd
 404         Key_Filter *kf
 405         PREINIT:
 406         dstr d = DSTR_INIT;
 407         CODE:
 408         if (key_encode(kd, &d, kf))
 409           RETVAL = newSVpvn(d.buf, d.len);
 410         else
 411           RETVAL = &PL_sv_undef;
 412         dstr_destroy(&d);
 413         OUTPUT:
 414         RETVAL
 415
 416 Key_Data *
 417 lock(kd, key)
 418         Key_Data *kd
 419         SV *key
 420         PREINIT:
 421         STRLEN len;
 422         char *p;
 423         CODE:
 424         p = SvPV(key, len);
 425         key_lock(&RETVAL, kd, p, len);
 426         OUTPUT:
 427         RETVAL
 428
 429 Key_Data *
 430 plock(kd, tag)
 431         Key_Data *kd
 432         char *tag
 433         PREINIT:
 434         int rc;
 435         CODE:
 436         if ((rc = key_plock(&RETVAL, kd, tag)) != 0) {
 437           keyerr(rc);
 438           RETVAL = 0;
 439         }
 440         OUTPUT:
 441         RETVAL
 442
 443 bool
 444 key_match(kd, kf)
 445         Key_Data *kd
 446         Key_Filter *kf
 447
 448 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Binary PREFIX = key_
 449
 450 Key_Data *
 451 new(me, sv, f = 0)
 452         SV *me
 453         SV *sv
 454         unsigned f
 455         PREINIT:
 456         char *p;
 457         STRLEN len;
 458         CODE:
 459         p = SvPV(sv, len);
 460         RETVAL = key_newbinary(f, p, len);
 461         OUTPUT:
 462         RETVAL
 463
 464 SV *
 465 bin(kd)
 466         Key_Data *kd
 467         CODE:
 468         RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
 469         OUTPUT:
 470         RETVAL
 471
 472 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Encrypted PREFIX = key_
 473
 474 Key_Data *
 475 new(me, sv, f = 0)
 476         SV *me
 477         SV *sv
 478         unsigned f
 479         PREINIT:
 480         char *p;
 481         STRLEN len;
 482         CODE:
 483         p = SvPV(sv, len);
 484         RETVAL = key_newencrypted(f, p, len);
 485         OUTPUT:
 486         RETVAL
 487
 488 SV *
 489 ct(kd)
 490         Key_Data *kd
 491         CODE:
 492         RETVAL = newSVpvn((char *)kd->u.k.k, kd->u.k.sz);
 493         OUTPUT:
 494         RETVAL
 495
 496 SV *
 497 lock(kd, key)
 498         Key_Data *kd
 499         SV *key
 500         CODE:
 501         croak("already encrypted");
 502
 503 SV *
 504 plock(kd, tag)
 505         Key_Data *kd
 506         char *tag
 507         CODE:
 508         croak("already encrypted");
 509
 510 Key_Data *
 511 unlock(kd, key)
 512         Key_Data *kd
 513         SV *key
 514         PREINIT:
 515         STRLEN len;
 516         char *p;
 517         int rc;
 518         CODE:
 519         p = SvPV(key, len);
 520         if ((rc = key_unlock(&RETVAL, kd, p, len)) != 0) {
 521           keyerr(rc);
 522           RETVAL = 0;
 523         }
 524         OUTPUT:
 525         RETVAL
 526
 527 Key_Data *
 528 punlock(kd, tag)
 529         Key_Data *kd
 530         char *tag
 531         PREINIT:
 532         int rc;
 533         CODE:
 534         if ((rc = key_punlock(&RETVAL, kd, tag)) != 0) {
 535           keyerr(rc);
 536           RETVAL = 0;
 537         }
 538         OUTPUT:
 539         RETVAL
 540
 541 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::MP PREFIX = key_
 542
 543 Key_Data *
 544 new(me, x, f = 0)
 545         SV *me
 546         mp *x
 547         unsigned f
 548         CODE:
 549         RETVAL = key_newmp(f, x);
 550         OUTPUT:
 551         RETVAL
 552
 553 mp *
 554 mp(kd)
 555         Key_Data *kd
 556         CODE:
 557         RETVAL = MP_COPY(kd->u.m);
 558         OUTPUT:
 559         RETVAL
 560
 561 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::EC PREFIX = key_
 562
 563 Key_Data *
 564 new(me, p, f = 0)
 565         SV *me
 566         ec *p
 567         unsigned f
 568         CODE:
 569         RETVAL = key_newec(f, p);
 570         OUTPUT:
 571         RETVAL
 572
 573 ec *
 574 ec(kd)
 575         Key_Data *kd
 576         CODE:
 577         RETVAL = CREATE(ec);
 578         EC_CREATE(RETVAL);
 579         EC_COPY(RETVAL, &kd->u.e);
 580         OUTPUT:
 581         RETVAL
 582
 583 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::String PREFIX = key_
 584
 585 Key_Data *
 586 new(me, p, f = 0)
 587         SV *me
 588         char *p
 589         unsigned f
 590         CODE:
 591         RETVAL = key_newstring(f, p);
 592         OUTPUT:
 593         RETVAL
 594
 595 char *
 596 str(kd)
 597         Key_Data *kd
 598         CODE:
 599         RETVAL = kd->u.p;
 600         OUTPUT:
 601         RETVAL
 602
 603 MODULE = Catacomb PACKAGE = Catacomb::Key::Data::Structured PREFIX = key_
 604
 605 Key_Data *
 606 new()
 607         CODE:
 608         RETVAL = key_newstruct();
 609         OUTPUT:
 610         RETVAL
 611
 612 Key_StructIter *
 613 iterate(kd)
 614         Key_Data *kd
 615         CODE:
 616         RETVAL = CREATE(Key_StructIter);
 617         sym_mkiter(RETVAL, &kd->u.s);
 618         OUTPUT:
 619         RETVAL
 620
 621 Key_Data *
 622 find(kd, tag)
 623         Key_Data *kd
 624         char *tag
 625         CODE:
 626         RETVAL = key_structfind(kd, tag);
 627         if (RETVAL) key_incref(RETVAL);
 628         OUTPUT:
 629         RETVAL
 630
 631 SV *
 632 del(kd, tag)
 633         Key_Data *kd
 634         char *tag
 635         CODE:
 636         key_structset(kd, tag, 0);
 637         XSRETURN_YES;
 638
 639 SV *
 640 set(kd, tag, kdnew = 0)
 641         Key_Data *kd
 642         char *tag
 643         Key_Data *kdnew
 644         CODE:
 645         key_structset(kd, tag, kdnew);
 646         XSRETURN_YES;
 647
 648 MODULE = Catacomb PACKAGE = Catacomb::Key::StructIter
 649
 650 SV *
 651 next(i)
 652         Key_StructIter *i
 653         PREINIT:
 654         key_struct *s;
 655         CODE:
 656         if ((s = sym_next(i)) == 0)
 657           XSRETURN_UNDEF;
 658         RETVAL = newSVpvn(SYM_NAME(s), SYM_LEN(s));
 659         OUTPUT:
 660         RETVAL
 661
 662 SV *
 663 DESTROY(i)
 664         Key_StructIter *i
 665         CODE:
 666         DESTROY(i);
 667         XSRETURN_YES;
 668
 669 MODULE = Catacomb PACKAGE = Catacomb::Key::Data
 670
 671 MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_
 672
 673 Key_File *
 674 new(me, file, how = KOPEN_READ, report = &PL_sv_undef)
 675         SV *me
 676         char *file
 677         unsigned how
 678         SV *report
 679         CODE:
 680         RETVAL = CREATE(key_file);
 681         if (key_open(&RETVAL->kf, file, how, keyreport, report)) {
 682           DESTROY(RETVAL);
 683           RETVAL = 0;
 684         }
 685         OUTPUT:
 686         RETVAL
 687
 688 SV *
 689 DESTROY(kf)
 690         Key_File *kf
 691         CODE:
 692         keyfile_dec(kf);
 693         XSRETURN_UNDEF;
 694
 695 KeyErr
 696 merge(kf, name, fp, report = &PL_sv_undef)
 697         Key_File *kf
 698         char *name
 699         FILE *fp
 700         SV *report
 701         CODE:
 702         RETVAL = key_merge(&kf->kf, name, fp, keyreport, report);
 703         OUTPUT:
 704         RETVAL
 705
 706 bool
 707 key_extract(kf, k, fp, kfilt = 0)
 708         Key_File *kf
 709         Key *k
 710         FILE *fp
 711         Key_Filter *kfilt
 712         C_ARGS:
 713         &kf->kf, k->k, fp, kfilt
 714
 715 void
 716 qtag(kf, tag, kdnew = 0)
 717         Key_File *kf
 718         char *tag
 719         Key_Data *kdnew
 720         PREINIT:
 721         dstr d = DSTR_INIT;
 722         key_data **kd;
 723         key_data *okd;
 724         key *k;
 725         Key *kk;
 726         PPCODE:
 727         if (key_qtag(&kf->kf, tag, &d, &k, &kd)) {
 728           keyerr(KERR_NOTFOUND);
 729           XSRETURN_UNDEF;
 730         }
 731         okd = *kd;
 732         if (kdnew) {
 733           if (!(kf->kf.f & KF_WRITE)) {
 734             keyerr(KERR_READONLY);
 735             XSRETURN_UNDEF;
 736           }
 737           kf->kf.f |= KF_MODIFIED;
 738           *kd = kdnew;
 739         }
 740         key_incref(*kd);
 741         kk = CREATE(Key);
 742         kk->k = k;
 743         kk->kf = kf;
 744         kf->ref++;
 745         XPUSHs(sv_2mortal(newSVpvn(d.buf, d.len)));
 746         XPUSHs(RET(kk, "Catacomb::Key"));
 747         XPUSHs(RET(okd, keydata_type(okd)));
 748         dstr_destroy(&d);
 749
 750 int
 751 key_save(kf)
 752         Key_File *kf
 753         C_ARGS:
 754         &kf->kf
 755
 756 Key *
 757 bytype(kf, type)
 758         Key_File *kf
 759         char *type
 760         CODE:
 761         RETVAL = CREATE(Key);
 762         if ((RETVAL->k = key_bytype(&kf->kf, type)) != 0) {
 763           kf->ref++;
 764           RETVAL->kf = kf;
 765         } else {
 766           DESTROY(RETVAL);
 767           RETVAL = 0;
 768         }
 769         OUTPUT:
 770         RETVAL
 771
 772 Key *
 773 byid(kf, id)
 774         Key_File *kf
 775         U32 id
 776         CODE:
 777         RETVAL = CREATE(Key);
 778         if ((RETVAL->k = key_byid(&kf->kf, id)) != 0) {
 779           kf->ref++;
 780           RETVAL->kf = kf;
 781         } else {
 782           DESTROY(RETVAL);
 783           RETVAL = 0;
 784         }
 785         OUTPUT:
 786         RETVAL
 787
 788 Key *
 789 bytag(kf, tag)
 790         Key_File *kf
 791         char *tag
 792         CODE:
 793         RETVAL = CREATE(Key);
 794         if ((RETVAL->k = key_bytag(&kf->kf, tag)) != 0) {
 795           kf->ref++;
 796           RETVAL->kf = kf;
 797         } else {
 798           DESTROY(RETVAL);
 799           RETVAL = 0;
 800         }
 801         OUTPUT:
 802         RETVAL
 803
 804 Key *
 805 newkey(kf, id, type, exp = KEXP_FOREVER)
 806         Key_File *kf
 807         U32 id
 808         const char *type
 809         time_t exp
 810         PREINIT:
 811         int err;
 812         CODE:
 813         RETVAL = CREATE(Key);
 814         if ((err = key_new(&kf->kf, id, type, exp, &RETVAL->k)) == 0) {
 815           DESTROY(RETVAL);
 816           keyerr(err);
 817           RETVAL = 0;
 818         } else {
 819           kf->ref++;
 820           RETVAL->kf = kf;
 821         }
 822         OUTPUT:
 823         RETVAL
 824
 825 Key_FileIter *
 826 iterate(kf)
 827         Key_File *kf
 828         CODE:
 829         RETVAL = CREATE(Key_FileIter);
 830         key_mkiter(&RETVAL->i, &kf->kf);
 831         RETVAL->kf = kf;
 832         kf->ref++;
 833         OUTPUT:
 834         RETVAL
 835
 836 MODULE = Catacomb PACKAGE = Catacomb::Key::FileIter
 837
 838 Key *
 839 next(ki)
 840         Key_FileIter *ki
 841         CODE:
 842         RETVAL = CREATE(Key);
 843         if ((RETVAL->k = key_next(&ki->i)) == 0) {
 844           DESTROY(RETVAL);
 845           RETVAL = 0;
 846         } else {
 847           RETVAL->kf = ki->kf;
 848           ki->kf->ref++;
 849         }
 850         OUTPUT:
 851         RETVAL
 852
 853 SV *
 854 DESTROY(ki)
 855         Key_FileIter *ki
 856         CODE:
 857         keyfile_dec(ki->kf);
 858         DESTROY(ki);
 859         XSRETURN_YES;
 860
 861 #----- That's all, folks ----------------------------------------------------