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 bool
  31 key_chkident(me, p)
  32         SV *me
  33         char *p
  34         C_ARGS:
  35         p
  36
  37 bool
  38 key_chkcomment(me, p)
  39         SV *me
  40         char *p
  41         C_ARGS:
  42         p
  43
  44 time_t
  45 exp(k)
  46         Key *k
  47         CODE:
  48         RETVAL = k->k->exp;
  49         OUTPUT:
  50         RETVAL
  51
  52 time_t
  53 del(k)
  54         Key *k
  55         CODE:
  56         RETVAL = k->k->del;
  57         OUTPUT:
  58         RETVAL
  59
  60 Key_Data *
  61 data(k)
  62         Key *k
  63         CODE:
  64         RETVAL = &k->k->k;
  65         OUTPUT:
  66         RETVAL
  67
  68 char *
  69 comment(k)
  70         Key *k
  71         CODE:
  72         RETVAL = k->k->c;
  73         OUTPUT:
  74         RETVAL
  75
  76 U32
  77 id(k)
  78         Key *k
  79         CODE:
  80         RETVAL = k->k->id;
  81         OUTPUT:
  82         RETVAL
  83
  84 char *
  85 tag(k)
  86         Key *k
  87         CODE:
  88         RETVAL = k->k->tag;
  89         OUTPUT:
  90         RETVAL
  91
  92 char *
  93 type(k)
  94         Key *k
  95         CODE:
  96         RETVAL = k->k->type;
  97         OUTPUT:
  98         RETVAL
  99
 100 KeyErr
 101 key_setcomment(k, p)
 102         Key *k
 103         char *p
 104         C_ARGS:
 105         k->kf, k->k, p
 106
 107 KeyErr
 108 key_settag(k, p)
 109         Key *k
 110         char *p
 111         C_ARGS:
 112         k->kf, k->k, p
 113
 114 KeyErr
 115 key_delete(k)
 116         Key *k
 117         C_ARGS:
 118         k->kf, k->k
 119
 120 SV *
 121 fulltag(k)
 122         Key *k
 123         PREINIT:
 124         dstr d = DSTR_INIT;
 125         CODE:
 126         key_fulltag(k->k, &d);
 127         RETVAL = newSVpv(d.buf, d.len);
 128         dstr_destroy(&d);
 129         OUTPUT:
 130         RETVAL
 131
 132 const char *
 133 key_getattr(k, a)
 134         Key *k
 135         char *a
 136         C_ARGS:
 137         k->kf, k->k, a
 138
 139 KeyErr
 140 key_putattr(k, a, v)
 141         Key *k
 142         char *a
 143         char *v
 144         C_ARGS:
 145         k->kf, k->k, a, v
 146
 147 void
 148 attrlist(k)
 149         Key *k
 150         PREINIT:
 151         key_attriter i;
 152         const char *a, *v;
 153         PPCODE:
 154         for (key_mkattriter(&i, k->k); key_nextattr(&i, &a, &v); )
 155           XPUSHs(sv_2mortal(newSVpv((char *)a, strlen(a))));
 156
 157 bool
 158 expiredp(k)
 159         Key *k
 160         CODE:
 161         RETVAL = key_expired(k->k);
 162         OUTPUT:
 163         RETVAL
 164
 165 KeyErr
 166 key_expire(k)
 167         Key *k
 168         C_ARGS:
 169         k->kf, k->k
 170
 171 KeyErr
 172 key_used(k, t)
 173         Key *k
 174         time_t t
 175         C_ARGS:
 176         k->kf, k->k, t
 177
 178 bool
 179 fingerprint(k, h, kfiltstr)
 180         Key *k
 181         ghash *h
 182         char *kfiltstr
 183         PREINIT:
 184         key_filter kfilt;
 185         dstr d = DSTR_INIT;
 186         CODE:
 187         if (!kfiltstr)
 188           kfilt.f = kfilt.m = 0;
 189         else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
 190           croak("bad filter string `%s'", kfiltstr);
 191         RETVAL = key_fingerprint(k->k, h, &kfilt);
 192         OUTPUT:
 193         RETVAL
 194
 195 const char *
 196 key_strerror(me, err)
 197         SV *me
 198         int err
 199         C_ARGS:
 200         err
 201
 202 MODULE = Catacomb PACKAGE = Catacomb::Key::Data PREFIX = key_
 203
 204 Key_Data *
 205 _new(me)
 206         SV *me
 207         CODE:
 208         RETVAL = CREATE(key_data);
 209         RETVAL->e = 0;
 210         RETVAL->u.k.k = 0;
 211         RETVAL->u.k.sz = 0;
 212         OUTPUT:
 213         RETVAL
 214
 215 SV *
 216 destroy(kd)
 217         Key_Data *kd
 218         CODE:
 219         key_destroy(kd);
 220         XSRETURN_YES;
 221
 222 SV *
 223 setbinary(kd, sv)
 224         Key_Data *kd
 225         SV *sv
 226         PREINIT:
 227         char *p;
 228         STRLEN len;
 229         CODE:
 230         p = SvPV(sv, len);
 231         key_binary(kd, p, len);
 232         XSRETURN_YES;
 233
 234 SV *
 235 setencrypted(kd, sv)
 236         Key_Data *kd
 237         SV *sv
 238         PREINIT:
 239         char *p;
 240         STRLEN len;
 241         CODE:
 242         p = SvPV(sv, len);
 243         key_encrypted(kd, p, len);
 244         XSRETURN_YES;
 245
 246 SV *
 247 setmp(kd, x)
 248         Key_Data *kd
 249         mp *x
 250         CODE:
 251         key_mp(kd, x);
 252         XSRETURN_YES;
 253
 254 SV *
 255 setstring(kd, p)
 256         Key_Data *kd
 257         char *p
 258         CODE:
 259         key_string(kd, p);
 260         XSRETURN_YES;
 261
 262 SV *
 263 setec(kd, p)
 264         Key_Data *kd
 265         EC_Point *p
 266         CODE:
 267         key_ec(kd, p);
 268         XSRETURN_YES;
 269
 270 U32
 271 flags(kd)
 272         Key_Data *kd
 273         CODE:
 274         RETVAL = kd->e;
 275         OUTPUT:
 276         RETVAL
 277
 278 SV *
 279 getbinary(kd)
 280         Key_Data *kd
 281         CODE:
 282         if ((kd->e & KF_ENCMASK) != KENC_BINARY)
 283           croak("key is not binary");
 284         RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
 285         OUTPUT:
 286         RETVAL
 287
 288 SV *
 289 getencrypted(kd)
 290         Key_Data *kd
 291         CODE:
 292         if ((kd->e & KF_ENCMASK) != KENC_ENCRYPT)
 293           croak("key is not encrypted");
 294         RETVAL = newSVpv(kd->u.k.k, kd->u.k.sz);
 295         OUTPUT:
 296         RETVAL
 297
 298 mp *
 299 getmp(kd)
 300         Key_Data *kd
 301         CODE:
 302         if ((kd->e & KF_ENCMASK) != KENC_MP)
 303           croak("key is not bignum");
 304         RETVAL = kd->u.m;
 305         OUTPUT:
 306         RETVAL
 307
 308 EC_Point *
 309 getec(kd)
 310         Key_Data *kd
 311         CODE:
 312         if ((kd->e & KF_ENCMASK) != KENC_EC)
 313           croak("key is not a curve point");
 314         RETVAL = CREATE(ec);
 315         EC_CREATE(RETVAL);
 316         EC_COPY(RETVAL, &kd->u.e);
 317         OUTPUT:
 318         RETVAL
 319
 320 char *
 321 getstring(kd)
 322         Key_Data *kd
 323         CODE:
 324         if ((kd->e & KF_ENCMASK) != KENC_STRING)
 325           croak("key is not string");
 326         RETVAL = kd->u.p;
 327         OUTPUT:
 328         RETVAL
 329
 330 SV *
 331 setstruct(kd)
 332         Key_Data *kd
 333         CODE:
 334         key_structure(kd);
 335         XSRETURN_YES;
 336
 337 Key_Data *
 338 key_structfind(kd, tag)
 339         Key_Data *kd
 340         char *tag
 341
 342 Key_Data *
 343 key_structcreate(kd, tag)
 344         Key_Data *kd
 345         char *tag
 346
 347 void
 348 getstruct(kd)
 349         Key_Data *kd
 350         PREINIT:
 351         sym_iter i;
 352         key_struct *ks;
 353         PPCODE:
 354         if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
 355           croak("key is not structured");
 356         for (sym_mkiter(&i, &kd->u.s); ks = sym_next(&i); )
 357           XPUSHs(RET(&ks->k, "Catacomb::Key::Data"));
 358
 359 SV *
 360 structdel(kd, tag)
 361         Key_Data *kd
 362         char *tag
 363         PREINIT:
 364         key_struct *ks;
 365         CODE:
 366         if ((kd->e & KF_ENCMASK) != KENC_STRUCT)
 367           croak("key is not structured");
 368         if ((ks = sym_find(&kd->u.s, tag, -1, 0, 0)) == 0)
 369           XSRETURN_UNDEF;
 370         sym_remove(&kd->u.s, ks);
 371         XSRETURN_YES;
 372
 373 void
 374 readflags(me, p)
 375         SV *me
 376         char *p
 377         PREINIT:
 378         unsigned f, m;
 379         PPCODE:
 380         if (key_readflags(p, &p, &f, &m) || *p)
 381           croak("bad flags string");
 382         XPUSHs(sv_2mortal(newSVuv(m)));
 383         XPUSHs(sv_2mortal(newSVuv(f)));
 384
 385 SV *
 386 getflags(me, f)
 387         SV *me
 388         U32 f
 389         PREINIT:
 390         dstr d = DSTR_INIT;
 391         CODE:
 392         key_writeflags(f, &d);
 393         RETVAL = newSVpv(d.buf, d.len);
 394         dstr_destroy(&d);
 395         OUTPUT:
 396         RETVAL
 397
 398 Key_Data *
 399 copy(kd, kfiltstr = 0)
 400         Key_Data *kd
 401         char *kfiltstr
 402         PREINIT:
 403         key_filter kfilt;
 404         CODE:
 405         if (!kfiltstr)
 406           kfilt.f = kfilt.m = 0;
 407         else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
 408           croak("bad filter string `%s'", kfiltstr);
 409         RETVAL = CREATE(key_data);
 410         if (!key_copy(RETVAL, kd, &kfilt)) {
 411           DESTROY(RETVAL);
 412           RETVAL = 0;
 413         }
 414         OUTPUT:
 415         RETVAL
 416
 417 Key_Data *
 418 plock(kd, tag)
 419         Key_Data *kd
 420         char *tag
 421         CODE:
 422         RETVAL = CREATE(Key_Data);
 423         if (key_plock(tag, kd, RETVAL)) {
 424           DESTROY(RETVAL);
 425           RETVAL = 0;
 426         }
 427         OUTPUT:
 428         RETVAL
 429
 430 Key_Data *
 431 punlock(kd, tag)
 432         Key_Data *kd
 433         char *tag
 434         CODE:
 435         RETVAL = CREATE(Key_Data);
 436         if (key_punlock(tag, kd, RETVAL)) {
 437           DESTROY(RETVAL);
 438           RETVAL = 0;
 439         }
 440         OUTPUT:
 441         RETVAL
 442
 443 Key_Data *
 444 read(me, p)
 445         SV *me
 446         char *p
 447         CODE:
 448         RETVAL = CREATE(key_data);
 449         if (key_read(p, RETVAL, 0)) {
 450           DESTROY(RETVAL);
 451           RETVAL = 0;
 452         }
 453         OUTPUT:
 454         RETVAL
 455
 456 SV *
 457 write(kd, kfiltstr = 0)
 458         Key_Data *kd
 459         char *kfiltstr
 460         PREINIT:
 461         key_filter kfilt;
 462         dstr d = DSTR_INIT;
 463         CODE:
 464         if (!kfiltstr)
 465           kfilt.f = kfilt.m = 0;
 466         else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
 467           croak("bad filter string `%s'", kfiltstr);
 468         if (key_write(kd, &d, &kfilt))
 469           RETVAL = newSVpv(d.buf, d.len);
 470         else
 471           RETVAL = &PL_sv_undef;
 472         dstr_destroy(&d);
 473         OUTPUT:
 474         RETVAL
 475
 476 Key_Data *
 477 decode(me, sv)
 478         SV *me
 479         SV *sv
 480         PREINIT:
 481         char *p;
 482         STRLEN len;
 483         CODE:
 484         p = SvPV(sv, len);
 485         RETVAL = CREATE(key_data);
 486         if (key_decode(p, len, RETVAL)) {
 487           DESTROY(RETVAL);
 488           RETVAL = 0;
 489         }
 490         OUTPUT:
 491         RETVAL
 492
 493 SV *
 494 encode(kd, kfiltstr = 0)
 495         Key_Data *kd
 496         char *kfiltstr
 497         PREINIT:
 498         key_filter kfilt;
 499         dstr d = DSTR_INIT;
 500         CODE:
 501         if (!kfiltstr)
 502           kfilt.f = kfilt.m = 0;
 503         else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
 504           croak("bad filter string `%s'", kfiltstr);
 505         if (key_encode(kd, &d, &kfilt))
 506           RETVAL = newSVpv(d.buf, d.len);
 507         else
 508           RETVAL = &PL_sv_undef;
 509         dstr_destroy(&d);
 510         OUTPUT:
 511         RETVAL
 512
 513 MODULE = Catacomb PACKAGE = Catacomb::Key::File PREFIX = key_
 514
 515 Key_File *
 516 new(me, file, how)
 517         SV *me
 518         char *file
 519         unsigned how
 520         CODE:
 521         RETVAL = CREATE(key_file);
 522         if (key_open(RETVAL, file, how, warn_keyreporter, 0)) {
 523           DESTROY(RETVAL);
 524           RETVAL = 0;
 525         }
 526         OUTPUT:
 527         RETVAL
 528
 529 SV *
 530 DESTROY(kf)
 531         Key_File *kf
 532         CODE:
 533         key_close(kf);
 534         DESTROY(kf);
 535         XSRETURN_UNDEF;
 536
 537 KeyErr
 538 merge(kf, name, fp)
 539         Key_File *kf
 540         char *name
 541         FILE *fp
 542         CODE:
 543         RETVAL = key_merge(kf, name, fp, warn_keyreporter, 0);
 544         OUTPUT:
 545         RETVAL
 546
 547 bool
 548 extract(kf, k, fp, kfiltstr = 0)
 549         Key_File *kf
 550         Key *k
 551         FILE *fp
 552         char *kfiltstr
 553         PREINIT:
 554         key_filter kfilt;
 555         CODE:
 556         if (!kfiltstr)
 557           kfilt.f = kfilt.m = 0;
 558         else if (key_readflags(kfiltstr, 0, &kfilt.f, &kfilt.m))
 559           croak("bad filter string `%s'", kfiltstr);
 560         RETVAL = key_extract(kf, k->k, fp, &kfilt);
 561         OUTPUT:
 562         RETVAL
 563
 564 int
 565 key_save(kf)
 566         Key_File *kf
 567
 568 void
 569 qtag(kf, tag)
 570         Key_File *kf
 571         char *tag
 572         PREINIT:
 573         dstr d = DSTR_INIT;
 574         Key *k;
 575         key_data *kd;
 576         PPCODE:
 577         k = CREATE(Key);
 578         kd = CREATE(key_data);
 579         if (key_qtag(kf, tag, &d, &k->k, &kd)) {
 580           DESTROY(k);
 581           DESTROY(kd);
 582           XPUSHs(&PL_sv_undef);
 583           XPUSHs(&PL_sv_undef);
 584           XPUSHs(&PL_sv_undef);
 585         } else {
 586           k->kf = kf;
 587           XPUSHs(sv_2mortal(newSVpv(d.buf, d.len)));
 588           XPUSHs(RET(k, "Catacomb::Key"));
 589           XPUSHs(RET(k, "Catacomb::Key::Data"));
 590         }
 591         dstr_destroy(&d);
 592
 593 Key *
 594 bytype(kf, type)
 595         Key_File *kf
 596         char *type
 597         CODE:
 598         RETVAL = CREATE(Key);
 599         if ((RETVAL->k = key_bytype(kf, type)) != 0)
 600           RETVAL->kf = kf;
 601         else {
 602           DESTROY(RETVAL);
 603           RETVAL = 0;
 604         }
 605         OUTPUT:
 606         RETVAL
 607
 608 Key *
 609 byid(kf, id)
 610         Key_File *kf
 611         U32 id
 612         CODE:
 613         RETVAL = CREATE(Key);
 614         if ((RETVAL->k = key_byid(kf, id)) != 0)
 615           RETVAL->kf = kf;
 616         else {
 617           DESTROY(RETVAL);
 618           RETVAL = 0;
 619         }
 620         OUTPUT:
 621         RETVAL
 622
 623 Key *
 624 bytag(kf, tag)
 625         Key_File *kf
 626         char *tag
 627         CODE:
 628         RETVAL = CREATE(Key);
 629         if ((RETVAL->k = key_bytag(kf, tag)) != 0)
 630           RETVAL->kf = kf;
 631         else {
 632           DESTROY(RETVAL);
 633           RETVAL = 0;
 634         }
 635         OUTPUT:
 636         RETVAL
 637
 638 void
 639 list(kf)
 640         Key_File *kf
 641         PREINIT:
 642         key_iter i;
 643         key *k;
 644         Key *kk;
 645         PPCODE:
 646         for (key_mkiter(&i, kf); k = key_next(&i); ) {
 647           kk = CREATE(Key);
 648           kk->kf = kf;
 649           kk->k = k;
 650           XPUSHs(RET(kk, "Catacomb::Key"));
 651         }
 652
 653 #----- That's all, folks ----------------------------------------------------