chiark - git - mdw - catacomb-python/blob - key.c

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Key files and data
   6  *
   7  * (c) 2005 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of the Python interface to Catacomb.
  13  *
  14  * Catacomb/Python 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/Python 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/Python; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Header files ------------------------------------------------------*/
  30
  31 #include "catacomb-python.h"
  32
  33 /*----- Exceptions --------------------------------------------------------*/
  34
  35 static PyObject *keyexc;
  36 static PyObject *keyioexc;
  37 static PyObject *keyfilebrokenexc;
  38
  39 static PyObject *kxmeth___init__(PyObject *me, PyObject *arg)
  40 {
  41   int err;
  42   PyObject *x = 0;
  43
  44   if (!PyArg_ParseTuple(arg, "Oi:__init__", &me, &err) ||
  45       (x = PyInt_FromLong(err)) == 0 ||
  46       PyObject_SetAttrString(me, "err", x))
  47     goto fail;
  48   Py_DECREF(x); x = 0;
  49   if ((x = PyString_FromString(key_strerror(err))) == 0 ||
  50       PyObject_SetAttrString(me, "errstring", x))
  51     goto fail;
  52   Py_DECREF(x); x = 0;
  53   if ((x = PyString_FromString(key_strerror(err))) == 0 ||
  54       PyObject_SetAttrString(me, "errstring", x))
  55     goto fail;
  56   Py_DECREF(x); x = 0;
  57   if ((x = PySequence_GetSlice(arg, 1, PySequence_Size(arg))) == 0 ||
  58       PyObject_SetAttrString(me, "args", x))
  59     goto fail;
  60   Py_DECREF(x); x = 0;
  61   RETURN_NONE;
  62
  63 fail:
  64   Py_XDECREF(x);
  65   return (0);
  66 }
  67
  68 static PyObject *kxmeth___str__(PyObject *me, PyObject *arg)
  69 {
  70   long err;
  71   const char *errstr, *errtag;
  72   PyObject *x = 0;
  73   PyObject *rc = 0;
  74
  75   static const char *const tab[] = {
  76 #define ENTRY(tag, num, str) "KERR_" #tag,
  77     KEY_ERRORS(ENTRY)
  78 #undef ENTRY
  79   };
  80
  81   if (!PyArg_ParseTuple(arg, "O:__str__", &me) ||
  82       (x = PyObject_GetAttrString(me, "err")) == 0 ||
  83       (err = PyInt_AsLong(x), PyErr_Occurred()))
  84     goto done;
  85   Py_DECREF(x); x = 0;
  86   err = -err;
  87   if (err >= 0 && err < N(tab)) errtag = tab[err];
  88   else errtag = "<unknown>";
  89   if ((x = PyObject_GetAttrString(me, "errstring")) == 0 ||
  90       (errstr = PyString_AsString(x)) == 0)
  91     goto done;
  92   rc = PyString_FromFormat("%s (%ld): %s", errtag, -err, errstr);
  93
  94 done:
  95   Py_XDECREF(x);
  96   return (rc);
  97 }
  98
  99 static PyMethodDef keyexc_pymethods[] = {
 100 #define METHNAME(func) kxmeth_##func
 101   METH  (__init__,              "KeyError(CODE)")
 102   METH  (__str__,               "E.__str__() -> STRING")
 103 #undef METHNAME
 104   { 0 }
 105 };
 106
 107 static void keyexc_raise(int err)
 108 {
 109   PyObject *arg = Py_BuildValue("(i)", err);
 110   if (arg) PyErr_SetObject(keyexc, arg);
 111   Py_XDECREF(arg);
 112 }
 113 #define KEYERR(err) do { keyexc_raise(err); goto end; } while (0)
 114 #define KEYIOERR(name) do {                                             \
 115   PyErr_SetFromErrnoWithFilename(keyioexc, name);                       \
 116   goto end;                                                             \
 117 } while (0)
 118 #define KEYFILEBROKEN(name) do {                                        \
 119   PyErr_SetFromErrnoWithFilename(keyfilebrokenexc, name);               \
 120   goto end;                                                             \
 121 } while (0)
 122
 123 /*----- Data structures ---------------------------------------------------*/
 124
 125 typedef struct keydata_pyobj {
 126   PyObject_HEAD
 127   key_data *kd;
 128 } keydata_pyobj;
 129
 130 static PyTypeObject *keydata_pytype;
 131 static PyTypeObject *keydatabin_pytype;
 132 static PyTypeObject *keydataenc_pytype;
 133 static PyTypeObject *keydatamp_pytype;
 134 static PyTypeObject *keydatastruct_pytype;
 135 static PyTypeObject *keydatastr_pytype;
 136 static PyTypeObject *keydataec_pytype;
 137 #define KEYDATA_PYCHECK(o) PyObject_TypeCheck(o, keydata_pytype)
 138 #define KEYDATA_KD(o) (((keydata_pyobj *)(o))->kd)
 139
 140 typedef struct subkeyiter_pyobj {
 141   PyObject_HEAD
 142   key_subkeyiter i;
 143   PyObject *kdobj;
 144 } subkeyiter_pyobj;
 145
 146 static PyTypeObject *subkeyiter_pytype;
 147 #define SUBKEYITER_PYCHECK(o) PyObject_TypeCheck(o, subkeyiter_pytype);
 148 #define SUBKEYITER_I(o) (&((subkeyiter_pyobj *)(o))->i)
 149 #define SUBKEYITER_KDOBJ(o) (((subkeyiter_pyobj *)(o))->kdobj)
 150
 151 typedef struct keyfile_pyobj {
 152   PyObject_HEAD
 153   key_file kf;
 154 } keyfile_pyobj;
 155
 156 static PyTypeObject *keyfile_pytype;
 157 #define KEYFILE_PYCHECK(o) PyObject_TypeCheck(o, keyfile_pytype)
 158 #define KEYFILE_KF(o) (&((keyfile_pyobj *)(o))->kf)
 159
 160 typedef struct key_pyobj {
 161   PyObject_HEAD
 162   key *k;
 163   PyObject *kfobj;
 164 } key_pyobj;
 165
 166 static PyTypeObject *key_pytype;
 167 #define KEY_PYCHECK(o) PyObject_TypeCheck(o, key_pytype)
 168 #define KEY_K(o) (((key_pyobj *)(o))->k)
 169 #define KEY_KFOBJ(o) (((key_pyobj *)(o))->kfobj)
 170 #define KEY_KF(o) KEYFILE_KF(KEY_KFOBJ(o))
 171
 172 typedef struct keyiter_pyobj {
 173   PyObject_HEAD
 174   key_iter i;
 175   PyObject *kfobj;
 176 } keyiter_pyobj;
 177
 178 static PyTypeObject *keyiter_pytype;
 179 #define KEYITER_PYCHECK(o) PyObject_TypeCheck(o, keyiter_pytype)
 180 #define KEYITER_I(o) (&((keyiter_pyobj *)(o))->i)
 181 #define KEYITER_KFOBJ(o) (((keyiter_pyobj *)(o))->kfobj)
 182 #define KEYITER_KF(o) KEYFILE_KF(KEYITER_KFOBJ(o))
 183
 184 typedef struct keyattrs_pyobj {
 185   PyObject_HEAD
 186   PyObject *kobj;
 187 } keyattrs_pyobj;
 188
 189 static PyTypeObject *keyattrs_pytype;
 190 #define KEYATTRS_PYCHECK(o) PyObject_TypeCheck(o, keyattrs_pytype)
 191 #define KEYATTRS_KOBJ(o) (((keyattrs_pyobj *)(o))->kobj)
 192 #define KEYATTRS_KF(o) KEY_KF(KEYATTRS_KOBJ(o))
 193 #define KEYATTRS_K(o) KEY_K(KEYATTRS_KOBJ(o))
 194
 195 typedef struct keyattriter_pyobj {
 196   PyObject_HEAD
 197   key_attriter i;
 198   PyObject *kobj;
 199 } keyattriter_pyobj;
 200
 201 static PyTypeObject *keyattriter_pytype;
 202 #define KEYATTRITER_PYCHECK(o) PyObject_TypeCheck(o, keyattriter_pytype)
 203 #define KEYATTRITER_I(o) (&((keyattriter_pyobj *)(o))->i)
 204 #define KEYATTRITER_KOBJ(o) (((keyattriter_pyobj *)(o))->kobj)
 205 #define KEYATTRITER_K(o) KEY_K(KEYATTRITER_KOBJ(o))
 206 #define KEYATTRITER_KFOBJ(o) KEY_KFOBJ(KEYATTRITER_KOBJ(o))
 207 #define KEYATTRITER_KF(o) KEY_KF(KEYATTRITER_KOBJ(o))
 208
 209 /*----- Filters -----------------------------------------------------------*/
 210
 211 static int convfilter(PyObject *x, void *p)
 212 {
 213   key_filter *f = p;
 214   const char *fs;
 215   char *end;
 216   int n;
 217   PyObject *a = 0, *b = 0;
 218   int err;
 219   int rc = 0;
 220
 221   if ((fs = PyString_AsString(x)) != 0) {
 222     if ((err = key_readflags(fs, &end, &f->f, &f->m)) != 0)
 223       KEYERR(err);
 224     if (*end)
 225       KEYERR(KERR_BADFLAGS);
 226   } else {
 227     PyErr_Clear();
 228     if (!PySequence_Check(x))
 229       goto tyerr;
 230     else if ((n = PySequence_Size(x)) < 0)
 231       goto end;
 232     else if (n != 2)
 233       goto tyerr;
 234     else if ((a = PySequence_GetItem(x, 0)) == 0 || convuint(a, &f->f) ||
 235              (b = PySequence_GetItem(x, 1)) == 0 || convuint(b, &f->m))
 236       goto end;
 237   }
 238   rc = 1;
 239   goto end;
 240 tyerr:
 241   TYERR("expected flag string or flag/mask pair");
 242 end:
 243   Py_XDECREF(a);
 244   Py_XDECREF(b);
 245   return (rc);
 246 }
 247
 248 static int convflags(PyObject *x, void *p)
 249 {
 250   unsigned *f = p;
 251   const char *fs;
 252   char *end;
 253   int err;
 254   int rc = 0;
 255
 256   if (convuint(x, p))
 257     return (1);
 258   else {
 259     PyErr_Clear();
 260     if ((fs = PyString_AsString(x)) != 0) {
 261       if ((err = key_readflags(fs, &end, f, 0)) != 0)
 262         KEYERR(err);
 263       if (*end)
 264         KEYERR(KERR_BADFLAGS);
 265     } else {
 266       PyErr_Clear();
 267       goto tyerr;
 268     }
 269   }
 270   rc = 1;
 271   goto end;
 272 tyerr:
 273   TYERR("expected flag string or integer bitfield");
 274 end:
 275   return (rc);
 276 }
 277
 278 static PyObject *meth__KeyData_readflags(PyObject *me, PyObject *arg)
 279 {
 280   const char *p;
 281   char *end;
 282   unsigned f, m;
 283   PyObject *rc = 0;
 284   int err;
 285
 286   if (!PyArg_ParseTuple(arg, "Os:key_readflags", &me, &p))
 287     goto end;
 288   if ((err = key_readflags(p, &end, &f, &m)) != 0)
 289     KEYERR(err);
 290   rc = Py_BuildValue("(NNs)", getulong(f), getulong(m), end);
 291 end:
 292   return (rc);
 293 }
 294
 295 static PyObject *meth__KeyData_writeflags(PyObject *me, PyObject *arg)
 296 {
 297   dstr d = DSTR_INIT;
 298   PyObject *rc;
 299   unsigned f;
 300
 301   if (!PyArg_ParseTuple(arg, "OO&:key_writeflags", &me, convuint, &f))
 302     return (0);
 303   key_writeflags(f, &d);
 304   rc = PyString_FromStringAndSize(d.buf, d.len);
 305   dstr_destroy(&d);
 306   return (rc);
 307 }
 308
 309 /*----- Key data ----------------------------------------------------------*/
 310
 311 static PyObject *keydata_pywrap(key_data *kd)
 312 {
 313   PyTypeObject *ty;
 314   keydata_pyobj *kdobj;
 315
 316   switch (kd->e & KF_ENCMASK) {
 317     case KENC_BINARY: ty = keydatabin_pytype; break;
 318     case KENC_ENCRYPT: ty = keydataenc_pytype; break;
 319     case KENC_MP: ty = keydatamp_pytype; break;
 320     case KENC_STRUCT: ty = keydatastruct_pytype; break;
 321     case KENC_STRING: ty = keydatastr_pytype; break;
 322     case KENC_EC: ty = keydataec_pytype; break;
 323     default: abort();
 324   }
 325   kdobj = PyObject_NEW(keydata_pyobj, ty);
 326   kdobj->kd = kd;
 327   return ((PyObject *)kdobj);
 328 }
 329
 330 static void keydata_pydealloc(PyObject *me)
 331 {
 332   key_drop(KEYDATA_KD(me));
 333   FREEOBJ(me);
 334 }
 335
 336 static PyObject *kdmeth_matchp(PyObject *me, PyObject *arg)
 337 {
 338   key_filter f;
 339
 340   if (!PyArg_ParseTuple(arg, "O&:matchp", convfilter, &f))
 341     return (0);
 342   return (getbool(KEY_MATCH(KEYDATA_KD(me), &f)));
 343 }
 344
 345 static PyObject *kdmeth_split(PyObject *me, PyObject *arg)
 346 {
 347   if (!PyArg_ParseTuple(arg, ":split"))
 348     return (0);
 349   key_split(&KEYDATA_KD(me));
 350   RETURN_ME;
 351 }
 352
 353 static PyObject *kdmeth_copy(PyObject *me, PyObject *arg, PyObject *kw)
 354 {
 355   key_filter f = { 0, 0 };
 356   static char *kwlist[] = { "filter", 0 };
 357   key_data *kd;
 358
 359   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:copy", kwlist,
 360                                    convfilter, &f))
 361     return (0);
 362   if ((kd = key_copydata(KEYDATA_KD(me), &f)) == 0)
 363     RETURN_NONE;
 364   else
 365     return (keydata_pywrap(kd));
 366 }
 367
 368 static PyObject *kdmeth_write(PyObject *me, PyObject *arg, PyObject *kw)
 369 {
 370   key_filter f = { 0, 0 };
 371   dstr d = DSTR_INIT;
 372   PyObject *rc = 0;
 373   static char *kwlist[] = { "filter", 0 };
 374
 375   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:write", kwlist,
 376                                    convfilter, &f))
 377     return (0);
 378   key_write(KEYDATA_KD(me), &d, &f);
 379   rc = PyString_FromStringAndSize(d.buf, d.len);
 380   dstr_destroy(&d);
 381   return (rc);
 382 }
 383
 384 static PyObject *kdmeth_encode(PyObject *me, PyObject *arg, PyObject *kw)
 385 {
 386   key_filter f = { 0, 0 };
 387   dstr d = DSTR_INIT;
 388   PyObject *rc = 0;
 389   static char *kwlist[] = { "filter", 0 };
 390
 391   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:encode", kwlist,
 392                                    convfilter, &f))
 393     return (0);
 394   key_encode(KEYDATA_KD(me), &d, &f);
 395   rc = bytestring_pywrap(d.buf, d.len);
 396   dstr_destroy(&d);
 397   return (rc);
 398 }
 399
 400 static PyObject *kdmeth_plock(PyObject *me, PyObject *arg)
 401 {
 402   char *tag;
 403   int err;
 404   PyObject *rc = 0;
 405   key_data *kd;
 406
 407   if (!PyArg_ParseTuple(arg, "s:plock", &tag))
 408     goto end;
 409   if ((err = key_plock(&kd, KEYDATA_KD(me), tag)) != 0)
 410     KEYERR(err);
 411   rc = keydata_pywrap(kd);
 412 end:
 413   return (rc);
 414 }
 415
 416 static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
 417 {
 418   char *p;
 419   int n;
 420   PyObject *rc = 0;
 421   key_data *kd;
 422
 423   if (!PyArg_ParseTuple(arg, "s#:lock", &p, &n))
 424     goto end;
 425   key_lock(&kd, KEYDATA_KD(me), p, n);
 426   rc = keydata_pywrap(kd);
 427 end:
 428   return (rc);
 429 }
 430
 431 static PyObject *meth__KeyData_read(PyObject *me, PyObject *arg)
 432 {
 433   const char *p;
 434   char *end;
 435   key_data *kd;
 436   PyObject *rc = 0;
 437
 438   if (!PyArg_ParseTuple(arg, "Os:read", &me, &p))
 439     goto end;
 440   if ((kd = key_read(p, &end)) == 0)
 441     KEYERR(KERR_MALFORMED);
 442   rc = Py_BuildValue("(Ns)", keydata_pywrap(kd), end);
 443 end:
 444   return (rc);
 445 }
 446
 447 static PyObject *meth__KeyData_decode(PyObject *me, PyObject *arg)
 448 {
 449   const char *p;
 450   int n;
 451   key_data *kd;
 452   PyObject *rc = 0;
 453
 454   if (!PyArg_ParseTuple(arg, "Os#:decode", &me, &p, &n))
 455     goto end;
 456   if ((kd = key_decode(p, n)) == 0)
 457     KEYERR(KERR_MALFORMED);
 458   rc =  keydata_pywrap(kd);
 459 end:
 460   return (rc);
 461 }
 462
 463 static PyObject *kdget_flags(PyObject *me, void *hunoz)
 464   { return (getulong(KEYDATA_KD(me)->e)); }
 465
 466 static PyMethodDef keydata_pymethods[] = {
 467 #define METHNAME(func) kdmeth_##func
 468   METH  (matchp,                "KD.matchp(FILTER) -> BOOL")
 469   METH  (split,                 "KD.split()")
 470   KWMETH(write,                 "KD.write(filter = <any>) -> STRING")
 471   KWMETH(encode,                "KD.encode(filter = <any>) -> BYTES")
 472   KWMETH(copy,                  "KD.encode(filter = <any>) -> KD")
 473   METH  (plock,                 "KD.plock(TAG) -> ENCRYPTED-KD")
 474   METH  (lock,                  "KD.lock(KEY) -> ENCRYPTED-KD")
 475 #undef METHNAME
 476   { 0 }
 477 };
 478
 479 static PyGetSetDef keydata_pygetset[] = {
 480 #define GETSETNAME(op, name) kd##op##_##name
 481   GET   (flags,                 "KD.flags -> FLAGS")
 482 #undef GETSETNAME
 483   { 0 }
 484 };
 485
 486 static PyTypeObject keydata_pytype_skel = {
 487   PyObject_HEAD_INIT(0) 0,              /* Header */
 488   "catacomb.KeyData",                   /* @tp_name@ */
 489   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 490   0,                                    /* @tp_itemsize@ */
 491
 492   keydata_pydealloc,                    /* @tp_dealloc@ */
 493   0,                                    /* @tp_print@ */
 494   0,                                    /* @tp_getattr@ */
 495   0,                                    /* @tp_setattr@ */
 496   0,                                    /* @tp_compare@ */
 497   0,                                    /* @tp_repr@ */
 498   0,                                    /* @tp_as_number@ */
 499   0,                                    /* @tp_as_sequence@ */
 500   0,                                    /* @tp_as_mapping@ */
 501   0,                                    /* @tp_hash@ */
 502   0,                                    /* @tp_call@ */
 503   0,                                    /* @tp_str@ */
 504   0,                                    /* @tp_getattro@ */
 505   0,                                    /* @tp_setattro@ */
 506   0,                                    /* @tp_as_buffer@ */
 507   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 508     Py_TPFLAGS_BASETYPE,
 509
 510   /* @tp_doc@ */
 511 "Key data base class.",
 512
 513   0,                                    /* @tp_traverse@ */
 514   0,                                    /* @tp_clear@ */
 515   0,                                    /* @tp_richcompare@ */
 516   0,                                    /* @tp_weaklistoffset@ */
 517   0,                                    /* @tp_iter@ */
 518   0,                                    /* @tp_iternext@ */
 519   keydata_pymethods,                    /* @tp_methods@ */
 520   0,                                    /* @tp_members@ */
 521   keydata_pygetset,                     /* @tp_getset@ */
 522   0,                                    /* @tp_base@ */
 523   0,                                    /* @tp_dict@ */
 524   0,                                    /* @tp_descr_get@ */
 525   0,                                    /* @tp_descr_set@ */
 526   0,                                    /* @tp_dictoffset@ */
 527   0,                                    /* @tp_init@ */
 528   PyType_GenericAlloc,                  /* @tp_alloc@ */
 529   abstract_pynew,                       /* @tp_new@ */
 530   0,                                    /* @tp_free@ */
 531   0                                     /* @tp_is_gc@ */
 532 };
 533
 534 static PyObject *keydatabin_pynew(PyTypeObject *ty,
 535                                   PyObject *arg, PyObject *kw)
 536 {
 537   char *p;
 538   int n;
 539   unsigned f = 0;
 540   keydata_pyobj *me = 0;
 541   static char *kwlist[] = { "key", "flags", 0 };
 542
 543   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist,
 544                                    &p, &n, convflags, &f))
 545     goto end;
 546   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
 547   me->kd = key_newbinary(f & ~KF_ENCMASK, p, n);
 548 end:
 549   return ((PyObject *)me);
 550 }
 551
 552 static PyObject *kdbget_bin(PyObject *me, void *hunoz)
 553   { return (bytestring_pywrap(KEYDATA_KD(me)->u.k.k,
 554                               KEYDATA_KD(me)->u.k.sz)); }
 555
 556 static PyGetSetDef keydatabin_pygetset[] = {
 557 #define GETSETNAME(op, name) kdb##op##_##name
 558   GET   (bin,                   "KD.bin -> BYTES")
 559 #undef GETSETNAME
 560   { 0 }
 561 };
 562
 563 static PyTypeObject keydatabin_pytype_skel = {
 564   PyObject_HEAD_INIT(0) 0,              /* Header */
 565   "catacomb.KeyDataBinary",             /* @tp_name@ */
 566   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 567   0,                                    /* @tp_itemsize@ */
 568
 569   0,                                    /* @tp_dealloc@ */
 570   0,                                    /* @tp_print@ */
 571   0,                                    /* @tp_getattr@ */
 572   0,                                    /* @tp_setattr@ */
 573   0,                                    /* @tp_compare@ */
 574   0,                                    /* @tp_repr@ */
 575   0,                                    /* @tp_as_number@ */
 576   0,                                    /* @tp_as_sequence@ */
 577   0,                                    /* @tp_as_mapping@ */
 578   0,                                    /* @tp_hash@ */
 579   0,                                    /* @tp_call@ */
 580   0,                                    /* @tp_str@ */
 581   0,                                    /* @tp_getattro@ */
 582   0,                                    /* @tp_setattro@ */
 583   0,                                    /* @tp_as_buffer@ */
 584   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 585     Py_TPFLAGS_BASETYPE,
 586
 587   /* @tp_doc@ */
 588 "Key data for binary keys.",
 589
 590   0,                                    /* @tp_traverse@ */
 591   0,                                    /* @tp_clear@ */
 592   0,                                    /* @tp_richcompare@ */
 593   0,                                    /* @tp_weaklistoffset@ */
 594   0,                                    /* @tp_iter@ */
 595   0,                                    /* @tp_iternext@ */
 596   0,                                    /* @tp_methods@ */
 597   0,                                    /* @tp_members@ */
 598   keydatabin_pygetset,                  /* @tp_getset@ */
 599   0,                                    /* @tp_base@ */
 600   0,                                    /* @tp_dict@ */
 601   0,                                    /* @tp_descr_get@ */
 602   0,                                    /* @tp_descr_set@ */
 603   0,                                    /* @tp_dictoffset@ */
 604   0,                                    /* @tp_init@ */
 605   PyType_GenericAlloc,                  /* @tp_alloc@ */
 606   keydatabin_pynew,                     /* @tp_new@ */
 607   0,                                    /* @tp_free@ */
 608   0                                     /* @tp_is_gc@ */
 609 };
 610
 611 static PyObject *keydataenc_pynew(PyTypeObject *ty,
 612                                   PyObject *arg, PyObject *kw)
 613 {
 614   char *p;
 615   int n;
 616   unsigned f = 0;
 617   keydata_pyobj *me = 0;
 618   static char *kwlist[] = { "key", "flags", 0 };
 619
 620   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist,
 621                                    &p, &n, convflags, &f))
 622     goto end;
 623   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
 624   me->kd = key_newencrypted(f & ~KF_ENCMASK, p, n);
 625 end:
 626   return ((PyObject *)me);
 627 }
 628
 629 static PyObject *kdemeth_plock(PyObject *me, PyObject *arg)
 630 {
 631   char *hunoz;
 632   if (!PyArg_ParseTuple(arg, "s:plock", &hunoz)) goto end;
 633   KEYERR(KERR_WRONGTYPE);
 634 end:
 635   return (0);
 636 }
 637
 638 static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
 639 {
 640   char *hunoz;
 641   int hukairz;
 642   if (!PyArg_ParseTuple(arg, "s#:lock", &hunoz, &hukairz)) goto end;
 643   KEYERR(KERR_WRONGTYPE);
 644 end:
 645   return (0);
 646 }
 647
 648 static PyObject *kdemeth_punlock(PyObject *me, PyObject *arg)
 649 {
 650   char *tag;
 651   int err;
 652   PyObject *rc = 0;
 653   key_data *kd;
 654
 655   if (!PyArg_ParseTuple(arg, "s:punlock", &tag))
 656     goto end;
 657   if ((err = key_punlock(&kd, KEYDATA_KD(me), tag)) != 0)
 658     KEYERR(err);
 659   rc = keydata_pywrap(kd);
 660 end:
 661   return (rc);
 662 }
 663
 664 static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
 665 {
 666   char *p;
 667   int n;
 668   int err;
 669   PyObject *rc = 0;
 670   key_data *kd;
 671
 672   if (!PyArg_ParseTuple(arg, "s#:unlock", &p, &n))
 673     goto end;
 674   if ((err = key_unlock(&kd, KEYDATA_KD(me), p, n)) != 0)
 675     KEYERR(err);
 676   rc = keydata_pywrap(kd);
 677 end:
 678   return (rc);
 679 }
 680
 681 #define kdeget_ct kdbget_bin
 682
 683 static PyMethodDef keydataenc_pymethods[] = {
 684 #define METHNAME(func) kdemeth_##func
 685   METH  (plock,                 "KD.plock(TAG) -> ENCRYPTED-KD")
 686   METH  (lock,                  "KD.lock(KEY) -> ENCRYPTED-KD")
 687   METH  (punlock,               "KD.punlock(TAG) -> KD")
 688   METH  (unlock,                "KD.unlock(KEY) -> KD")
 689 #undef METHNAME
 690   { 0 }
 691 };
 692
 693 static PyGetSetDef keydataenc_pygetset[] = {
 694 #define GETSETNAME(op, name) kde##op##_##name
 695   GET   (ct,                    "KD.ct -> BYTES")
 696 #undef GETSETNAME
 697   { 0 }
 698 };
 699
 700 static PyTypeObject keydataenc_pytype_skel = {
 701   PyObject_HEAD_INIT(0) 0,              /* Header */
 702   "catacomb.KeyDataEncrypted",          /* @tp_name@ */
 703   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 704   0,                                    /* @tp_itemsize@ */
 705
 706   0,                                    /* @tp_dealloc@ */
 707   0,                                    /* @tp_print@ */
 708   0,                                    /* @tp_getattr@ */
 709   0,                                    /* @tp_setattr@ */
 710   0,                                    /* @tp_compare@ */
 711   0,                                    /* @tp_repr@ */
 712   0,                                    /* @tp_as_number@ */
 713   0,                                    /* @tp_as_sequence@ */
 714   0,                                    /* @tp_as_mapping@ */
 715   0,                                    /* @tp_hash@ */
 716   0,                                    /* @tp_call@ */
 717   0,                                    /* @tp_str@ */
 718   0,                                    /* @tp_getattro@ */
 719   0,                                    /* @tp_setattro@ */
 720   0,                                    /* @tp_as_buffer@ */
 721   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 722     Py_TPFLAGS_BASETYPE,
 723
 724   /* @tp_doc@ */
 725 "Key data for encrypted keys.",
 726
 727   0,                                    /* @tp_traverse@ */
 728   0,                                    /* @tp_clear@ */
 729   0,                                    /* @tp_richcompare@ */
 730   0,                                    /* @tp_weaklistoffset@ */
 731   0,                                    /* @tp_iter@ */
 732   0,                                    /* @tp_iternext@ */
 733   keydataenc_pymethods,                 /* @tp_methods@ */
 734   0,                                    /* @tp_members@ */
 735   keydataenc_pygetset,                  /* @tp_getset@ */
 736   0,                                    /* @tp_base@ */
 737   0,                                    /* @tp_dict@ */
 738   0,                                    /* @tp_descr_get@ */
 739   0,                                    /* @tp_descr_set@ */
 740   0,                                    /* @tp_dictoffset@ */
 741   0,                                    /* @tp_init@ */
 742   PyType_GenericAlloc,                  /* @tp_alloc@ */
 743   keydataenc_pynew,                     /* @tp_new@ */
 744   0,                                    /* @tp_free@ */
 745   0                                     /* @tp_is_gc@ */
 746 };
 747
 748 static PyObject *keydatamp_pynew(PyTypeObject *ty,
 749                                  PyObject *arg, PyObject *kw)
 750 {
 751   mp *x = 0;
 752   unsigned f = 0;
 753   keydata_pyobj *me = 0;
 754   static char *kwlist[] = { "key", "flags", 0 };
 755
 756   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist,
 757                                    convmp, &x, convflags, &f))
 758     goto end;
 759   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
 760   me->kd = key_newmp(f & ~KF_ENCMASK, x);
 761 end:
 762   mp_drop(x);
 763   return ((PyObject *)me);
 764 }
 765
 766 static PyObject *kdmget_mp(PyObject *me, void *hunoz)
 767   { return (mp_pywrap(MP_COPY(KEYDATA_KD(me)->u.m))); }
 768
 769 static PyGetSetDef keydatamp_pygetset[] = {
 770 #define GETSETNAME(op, name) kdm##op##_##name
 771   GET   (mp,                    "KD.mp -> X")
 772 #undef GETSETNAME
 773   { 0 }
 774 };
 775
 776 static PyTypeObject keydatamp_pytype_skel = {
 777   PyObject_HEAD_INIT(0) 0,              /* Header */
 778   "catacomb.KeyDataMP",                 /* @tp_name@ */
 779   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 780   0,                                    /* @tp_itemsize@ */
 781
 782   0,                                    /* @tp_dealloc@ */
 783   0,                                    /* @tp_print@ */
 784   0,                                    /* @tp_getattr@ */
 785   0,                                    /* @tp_setattr@ */
 786   0,                                    /* @tp_compare@ */
 787   0,                                    /* @tp_repr@ */
 788   0,                                    /* @tp_as_number@ */
 789   0,                                    /* @tp_as_sequence@ */
 790   0,                                    /* @tp_as_mapping@ */
 791   0,                                    /* @tp_hash@ */
 792   0,                                    /* @tp_call@ */
 793   0,                                    /* @tp_str@ */
 794   0,                                    /* @tp_getattro@ */
 795   0,                                    /* @tp_setattro@ */
 796   0,                                    /* @tp_as_buffer@ */
 797   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 798     Py_TPFLAGS_BASETYPE,
 799
 800   /* @tp_doc@ */
 801 "Key data for large-integer keys.",
 802
 803   0,                                    /* @tp_traverse@ */
 804   0,                                    /* @tp_clear@ */
 805   0,                                    /* @tp_richcompare@ */
 806   0,                                    /* @tp_weaklistoffset@ */
 807   0,                                    /* @tp_iter@ */
 808   0,                                    /* @tp_iternext@ */
 809   0,                                    /* @tp_methods@ */
 810   0,                                    /* @tp_members@ */
 811   keydatamp_pygetset,                   /* @tp_getset@ */
 812   0,                                    /* @tp_base@ */
 813   0,                                    /* @tp_dict@ */
 814   0,                                    /* @tp_descr_get@ */
 815   0,                                    /* @tp_descr_set@ */
 816   0,                                    /* @tp_dictoffset@ */
 817   0,                                    /* @tp_init@ */
 818   PyType_GenericAlloc,                  /* @tp_alloc@ */
 819   keydatamp_pynew,                      /* @tp_new@ */
 820   0,                                    /* @tp_free@ */
 821   0                                     /* @tp_is_gc@ */
 822 };
 823
 824 static PyObject *keydatastr_pynew(PyTypeObject *ty,
 825                                   PyObject *arg, PyObject *kw)
 826 {
 827   char *p;
 828   unsigned f = 0;
 829   keydata_pyobj *me = 0;
 830   static char *kwlist[] = { "key", "flags", 0 };
 831
 832   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:new", kwlist,
 833                                    &p, convflags, &f))
 834     goto end;
 835   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
 836   me->kd = key_newstring(f & ~KF_ENCMASK, p);
 837 end:
 838   return ((PyObject *)me);
 839 }
 840
 841 static PyObject *kdsget_str(PyObject *me, void *hunoz)
 842   { return (PyString_FromString(KEYDATA_KD(me)->u.p)); }
 843
 844 static PyGetSetDef keydatastr_pygetset[] = {
 845 #define GETSETNAME(op, name) kds##op##_##name
 846   GET   (str,                   "KD.str -> STRING")
 847 #undef GETSETNAME
 848   { 0 }
 849 };
 850
 851 static PyTypeObject keydatastr_pytype_skel = {
 852   PyObject_HEAD_INIT(0) 0,              /* Header */
 853   "catacomb.KeyDataString",             /* @tp_name@ */
 854   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 855   0,                                    /* @tp_itemsize@ */
 856
 857   0,                                    /* @tp_dealloc@ */
 858   0,                                    /* @tp_print@ */
 859   0,                                    /* @tp_getattr@ */
 860   0,                                    /* @tp_setattr@ */
 861   0,                                    /* @tp_compare@ */
 862   0,                                    /* @tp_repr@ */
 863   0,                                    /* @tp_as_number@ */
 864   0,                                    /* @tp_as_sequence@ */
 865   0,                                    /* @tp_as_mapping@ */
 866   0,                                    /* @tp_hash@ */
 867   0,                                    /* @tp_call@ */
 868   0,                                    /* @tp_str@ */
 869   0,                                    /* @tp_getattro@ */
 870   0,                                    /* @tp_setattro@ */
 871   0,                                    /* @tp_as_buffer@ */
 872   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 873     Py_TPFLAGS_BASETYPE,
 874
 875   /* @tp_doc@ */
 876 "Key data for string keys.",
 877
 878   0,                                    /* @tp_traverse@ */
 879   0,                                    /* @tp_clear@ */
 880   0,                                    /* @tp_richcompare@ */
 881   0,                                    /* @tp_weaklistoffset@ */
 882   0,                                    /* @tp_iter@ */
 883   0,                                    /* @tp_iternext@ */
 884   0,                                    /* @tp_methods@ */
 885   0,                                    /* @tp_members@ */
 886   keydatastr_pygetset,                  /* @tp_getset@ */
 887   0,                                    /* @tp_base@ */
 888   0,                                    /* @tp_dict@ */
 889   0,                                    /* @tp_descr_get@ */
 890   0,                                    /* @tp_descr_set@ */
 891   0,                                    /* @tp_dictoffset@ */
 892   0,                                    /* @tp_init@ */
 893   PyType_GenericAlloc,                  /* @tp_alloc@ */
 894   keydatastr_pynew,                     /* @tp_new@ */
 895   0,                                    /* @tp_free@ */
 896   0                                     /* @tp_is_gc@ */
 897 };
 898
 899 static PyObject *keydataec_pynew(PyTypeObject *ty,
 900                                  PyObject *arg, PyObject *kw)
 901 {
 902   ec x = EC_INIT;
 903   unsigned f = 0;
 904   keydata_pyobj *me = 0;
 905   static char *kwlist[] = { "key", "flags", 0 };
 906
 907   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist,
 908                                    convecpt, &x, convflags, &f))
 909     goto end;
 910   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
 911   me->kd = key_newec(f & ~KF_ENCMASK, &x);
 912 end:
 913   EC_DESTROY(&x);
 914   return ((PyObject *)me);
 915 }
 916
 917 static PyObject *kdeget_ecpt(PyObject *me, void *hunoz)
 918 {
 919   ec pt = EC_INIT;
 920   EC_COPY(&pt, &KEYDATA_KD(me)->u.e);
 921   return (ecpt_pywrapout(ecpt_pytype, &pt));
 922 }
 923
 924 static PyGetSetDef keydataec_pygetset[] = {
 925 #define GETSETNAME(op, name) kde##op##_##name
 926   GET   (ecpt,                  "KD.ecpt -> ECPT")
 927 #undef GETSETNAME
 928   { 0 }
 929 };
 930
 931 static PyTypeObject keydataec_pytype_skel = {
 932   PyObject_HEAD_INIT(0) 0,              /* Header */
 933   "catacomb.KeyDataECPt",               /* @tp_name@ */
 934   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
 935   0,                                    /* @tp_itemsize@ */
 936
 937   0,                                    /* @tp_dealloc@ */
 938   0,                                    /* @tp_print@ */
 939   0,                                    /* @tp_getattr@ */
 940   0,                                    /* @tp_setattr@ */
 941   0,                                    /* @tp_compare@ */
 942   0,                                    /* @tp_repr@ */
 943   0,                                    /* @tp_as_number@ */
 944   0,                                    /* @tp_as_sequence@ */
 945   0,                                    /* @tp_as_mapping@ */
 946   0,                                    /* @tp_hash@ */
 947   0,                                    /* @tp_call@ */
 948   0,                                    /* @tp_str@ */
 949   0,                                    /* @tp_getattro@ */
 950   0,                                    /* @tp_setattro@ */
 951   0,                                    /* @tp_as_buffer@ */
 952   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 953     Py_TPFLAGS_BASETYPE,
 954
 955   /* @tp_doc@ */
 956 "Key data for elliptic-curve keys.",
 957
 958   0,                                    /* @tp_traverse@ */
 959   0,                                    /* @tp_clear@ */
 960   0,                                    /* @tp_richcompare@ */
 961   0,                                    /* @tp_weaklistoffset@ */
 962   0,                                    /* @tp_iter@ */
 963   0,                                    /* @tp_iternext@ */
 964   0,                                    /* @tp_methods@ */
 965   0,                                    /* @tp_members@ */
 966   keydataec_pygetset,                   /* @tp_getset@ */
 967   0,                                    /* @tp_base@ */
 968   0,                                    /* @tp_dict@ */
 969   0,                                    /* @tp_descr_get@ */
 970   0,                                    /* @tp_descr_set@ */
 971   0,                                    /* @tp_dictoffset@ */
 972   0,                                    /* @tp_init@ */
 973   PyType_GenericAlloc,                  /* @tp_alloc@ */
 974   keydataec_pynew,                      /* @tp_new@ */
 975   0,                                    /* @tp_free@ */
 976   0                                     /* @tp_is_gc@ */
 977 };
 978
 979 static PyObject *subkeyiter_make(PyObject *kdobj)
 980 {
 981   subkeyiter_pyobj *me = PyObject_NEW(subkeyiter_pyobj, subkeyiter_pytype);
 982   me->kdobj = kdobj;
 983   Py_INCREF(kdobj);
 984   key_mksubkeyiter(&me->i, KEYDATA_KD(kdobj));
 985   return ((PyObject *)me);
 986 }
 987
 988 static PyObject *subkeyiter_pynext(PyObject *me)
 989 {
 990   const char *tag;
 991   if (!key_nextsubkey(SUBKEYITER_I(me), &tag, 0))
 992     return (0);
 993   return (PyString_FromString(tag));
 994 }
 995
 996 static void subkeyiter_pydealloc(PyObject *me)
 997 {
 998   Py_DECREF(SUBKEYITER_KDOBJ(me));
 999   FREEOBJ(me);
1000 }
1001
1002 static PyTypeObject subkeyiter_pytype_skel = {
1003   PyObject_HEAD_INIT(0) 0,              /* Header */
1004   "catacomb.SubKeyIter",                /* @tp_name@ */
1005   sizeof(subkeyiter_pyobj),             /* @tp_basicsize@ */
1006   0,                                    /* @tp_itemsize@ */
1007
1008   subkeyiter_pydealloc,                 /* @tp_dealloc@ */
1009   0,                                    /* @tp_print@ */
1010   0,                                    /* @tp_getattr@ */
1011   0,                                    /* @tp_setattr@ */
1012   0,                                    /* @tp_compare@ */
1013   0,                                    /* @tp_repr@ */
1014   0,                                    /* @tp_as_number@ */
1015   0,                                    /* @tp_as_sequence@ */
1016   0,                                    /* @tp_as_mapping@ */
1017   0,                                    /* @tp_hash@ */
1018   0,                                    /* @tp_call@ */
1019   0,                                    /* @tp_str@ */
1020   0,                                    /* @tp_getattro@ */
1021   0,                                    /* @tp_setattro@ */
1022   0,                                    /* @tp_as_buffer@ */
1023   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1024     Py_TPFLAGS_BASETYPE,
1025
1026   /* @tp_doc@ */
1027 "Iterator for structured keys.",
1028
1029   0,                                    /* @tp_traverse@ */
1030   0,                                    /* @tp_clear@ */
1031   0,                                    /* @tp_richcompare@ */
1032   0,                                    /* @tp_weaklistoffset@ */
1033   PyObject_SelfIter,                    /* @tp_iter@ */
1034   subkeyiter_pynext,                    /* @tp_iternext@ */
1035   0,                                    /* @tp_methods@ */
1036   0,                                    /* @tp_members@ */
1037   0,                                    /* @tp_getset@ */
1038   0,                                    /* @tp_base@ */
1039   0,                                    /* @tp_dict@ */
1040   0,                                    /* @tp_descr_get@ */
1041   0,                                    /* @tp_descr_set@ */
1042   0,                                    /* @tp_dictoffset@ */
1043   0,                                    /* @tp_init@ */
1044   PyType_GenericAlloc,                  /* @tp_alloc@ */
1045   abstract_pynew,                       /* @tp_new@ */
1046   0,                                    /* @tp_free@ */
1047   0                                     /* @tp_is_gc@ */
1048 };
1049
1050 static PyObject *keydatastruct_pynew(PyTypeObject *ty,
1051                                      PyObject *arg, PyObject *kw)
1052 {
1053   PyObject *sub = 0;
1054   PyObject *it = 0, *name = 0, *val = 0;
1055   char *p;
1056   keydata_pyobj *me = 0;
1057   key_data *kd = 0;
1058   static char *kwlist[] = { "subkeys", 0 };
1059
1060   Py_XINCREF(arg); Py_XINCREF(kw);
1061   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", kwlist, &sub))
1062     goto end;
1063   kd = key_newstruct();
1064   if (sub) {
1065     if (!PyMapping_Check(sub))
1066       TYERR("subkeys must be an iterable mapping");
1067     if ((it = PyObject_GetIter(sub)) == 0)
1068       goto end;
1069     while ((name = PyIter_Next(it)) != 0) {
1070       if ((p = PyString_AsString(name)) == 0 ||
1071           (val = PyObject_GetItem(sub, name)) == 0)
1072         goto end;
1073       if (!KEYDATA_PYCHECK(val))
1074         TYERR("subkey objects must be subclasses of KeyData");
1075       key_structset(kd, p, KEYDATA_KD(val));
1076       Py_DECREF(name); name = 0;
1077       Py_DECREF(val); val = 0;
1078     }
1079     if (PyErr_Occurred())
1080       goto end;
1081     Py_DECREF(it); it = 0;
1082   }
1083   me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
1084   me->kd = kd;
1085 end:
1086   if (kd && !me) key_drop(kd);
1087   Py_XDECREF(name); Py_XDECREF(val); Py_XDECREF(it);
1088   Py_XDECREF(arg); Py_XDECREF(kw);
1089   return ((PyObject *)me);
1090 }
1091
1092 static PyObject *keydatastruct_pylookup(PyObject *me, PyObject *key)
1093 {
1094   const char *tag;
1095   key_data *kd;
1096   PyObject *rc = 0;
1097
1098   if ((tag = PyString_AsString(key)) == 0)
1099     goto end;
1100   if ((kd = key_structfind(KEYDATA_KD(me), tag)) == 0)
1101     INDEXERR(key);
1102   key_incref(kd);
1103   rc = keydata_pywrap(kd);
1104 end:
1105   return (rc);
1106 }
1107
1108 static int keydatastruct_pystore(PyObject *me,
1109                                  PyObject *key, PyObject *value)
1110 {
1111   const char *tag;
1112   int rc = -1;
1113
1114   if ((tag = PyString_AsString(key)) == 0)
1115     goto end;
1116   key_split(&KEYDATA_KD(me));
1117   if (value) {
1118     if (!KEYDATA_PYCHECK(value))
1119       TYERR("expected KeyData value");
1120     key_structset(KEYDATA_KD(me), tag, KEYDATA_KD(value));
1121   } else {
1122     if (!key_structfind(KEYDATA_KD(me), tag))
1123       INDEXERR(key);
1124     key_structset(KEYDATA_KD(me), tag, 0);
1125   }
1126   rc = 0;
1127 end:
1128   return (rc);
1129 }
1130
1131 static PyMappingMethods keydatastruct_pymapping = {
1132   gmap_pysize,                          /* @mp_length@ */
1133   keydatastruct_pylookup,               /* @mp_subscript@ */
1134   keydatastruct_pystore                 /* @mp_ass_subscript@ */
1135 };
1136
1137 static PyTypeObject keydatastruct_pytype_skel = {
1138   PyObject_HEAD_INIT(0) 0,              /* Header */
1139   "catacomb.KeyDataStructured",         /* @tp_name@ */
1140   sizeof(keydata_pyobj),                /* @tp_basicsize@ */
1141   0,                                    /* @tp_itemsize@ */
1142
1143   0,                                    /* @tp_dealloc@ */
1144   0,                                    /* @tp_print@ */
1145   0,                                    /* @tp_getattr@ */
1146   0,                                    /* @tp_setattr@ */
1147   0,                                    /* @tp_compare@ */
1148   0,                                    /* @tp_repr@ */
1149   0,                                    /* @tp_as_number@ */
1150   0,                                    /* @tp_as_sequence@ */
1151   &keydatastruct_pymapping,             /* @tp_as_mapping@ */
1152   0,                                    /* @tp_hash@ */
1153   0,                                    /* @tp_call@ */
1154   0,                                    /* @tp_str@ */
1155   0,                                    /* @tp_getattro@ */
1156   0,                                    /* @tp_setattro@ */
1157   0,                                    /* @tp_as_buffer@ */
1158   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1159     Py_TPFLAGS_BASETYPE,
1160
1161   /* @tp_doc@ */
1162 "Key data for structured keys.",
1163
1164   0,                                    /* @tp_traverse@ */
1165   0,                                    /* @tp_clear@ */
1166   0,                                    /* @tp_richcompare@ */
1167   0,                                    /* @tp_weaklistoffset@ */
1168   subkeyiter_make,                      /* @tp_iter@ */
1169   0,                                    /* @tp_iternext@ */
1170   gmap_pymethods,                       /* @tp_methods@ */
1171   0,                                    /* @tp_members@ */
1172   0,                                    /* @tp_getset@ */
1173   0,                                    /* @tp_base@ */
1174   0,                                    /* @tp_dict@ */
1175   0,                                    /* @tp_descr_get@ */
1176   0,                                    /* @tp_descr_set@ */
1177   0,                                    /* @tp_dictoffset@ */
1178   0,                                    /* @tp_init@ */
1179   PyType_GenericAlloc,                  /* @tp_alloc@ */
1180   keydatastruct_pynew,                  /* @tp_new@ */
1181   0,                                    /* @tp_free@ */
1182   0                                     /* @tp_is_gc@ */
1183 };
1184
1185 /*----- Key attributes ----------------------------------------------------*/
1186
1187 static PyObject *keyattriter_make(PyObject *kaobj)
1188 {
1189   PyObject *kobj = KEYATTRS_KOBJ(kaobj);
1190   keyattriter_pyobj *me = PyObject_NEW(keyattriter_pyobj,
1191                                        keyattriter_pytype);
1192   me->kobj = kobj;
1193   Py_INCREF(kobj);
1194   key_mkattriter(&me->i, KEY_K(kobj));
1195   return ((PyObject *)me);
1196 }
1197
1198 static PyObject *keyattriter_pynext(PyObject *me)
1199 {
1200   const char *name;
1201
1202   if (!key_nextattr(KEYATTRITER_I(me), &name, 0))
1203     return (0);
1204   return (PyString_FromString(name));
1205 }
1206
1207 static void keyattriter_pydealloc(PyObject *me)
1208 {
1209   Py_DECREF(KEYATTRITER_KOBJ(me));
1210   FREEOBJ(me);
1211 }
1212
1213 static PyTypeObject keyattriter_pytype_skel = {
1214   PyObject_HEAD_INIT(0) 0,              /* Header */
1215   "catacomb.KeyAttributeIter",          /* @tp_name@ */
1216   sizeof(keyattriter_pyobj),            /* @tp_basicsize@ */
1217   0,                                    /* @tp_itemsize@ */
1218
1219   keyattriter_pydealloc,                /* @tp_dealloc@ */
1220   0,                                    /* @tp_print@ */
1221   0,                                    /* @tp_getattr@ */
1222   0,                                    /* @tp_setattr@ */
1223   0,                                    /* @tp_compare@ */
1224   0,                                    /* @tp_repr@ */
1225   0,                                    /* @tp_as_number@ */
1226   0,                                    /* @tp_as_sequence@ */
1227   0,                                    /* @tp_as_mapping@ */
1228   0,                                    /* @tp_hash@ */
1229   0,                                    /* @tp_call@ */
1230   0,                                    /* @tp_str@ */
1231   0,                                    /* @tp_getattro@ */
1232   0,                                    /* @tp_setattro@ */
1233   0,                                    /* @tp_as_buffer@ */
1234   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1235     Py_TPFLAGS_BASETYPE,
1236
1237   /* @tp_doc@ */
1238 "Iterator for key attributes.",
1239
1240   0,                                    /* @tp_traverse@ */
1241   0,                                    /* @tp_clear@ */
1242   0,                                    /* @tp_richcompare@ */
1243   0,                                    /* @tp_weaklistoffset@ */
1244   PyObject_SelfIter,                    /* @tp_iter@ */
1245   keyattriter_pynext,                   /* @tp_iternext@ */
1246   0,                                    /* @tp_methods@ */
1247   0,                                    /* @tp_members@ */
1248   0,                                    /* @tp_getset@ */
1249   0,                                    /* @tp_base@ */
1250   0,                                    /* @tp_dict@ */
1251   0,                                    /* @tp_descr_get@ */
1252   0,                                    /* @tp_descr_set@ */
1253   0,                                    /* @tp_dictoffset@ */
1254   0,                                    /* @tp_init@ */
1255   PyType_GenericAlloc,                  /* @tp_alloc@ */
1256   abstract_pynew,                       /* @tp_new@ */
1257   0,                                    /* @tp_free@ */
1258   0                                     /* @tp_is_gc@ */
1259 };
1260
1261 static PyObject *keyattrs_pylookup(PyObject *me, PyObject *key)
1262 {
1263   const char *attr;
1264   const char *value;
1265   PyObject *rc = 0;
1266
1267   if ((attr = PyString_AsString(key)) == 0)
1268     goto end;
1269   if ((value = key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr)) == 0)
1270     INDEXERR(key);
1271   rc = PyString_FromString(value);
1272 end:
1273   return (rc);
1274 }
1275
1276 static int keyattrs_pystore(PyObject *me,
1277                             PyObject *key, PyObject *value)
1278 {
1279   const char *attr;
1280   const char *val;
1281   int err;
1282   int rc = -1;
1283
1284   if ((attr = PyString_AsString(key)) == 0)
1285     goto end;
1286   if (value) {
1287     if ((val = PyString_AsString(value)) == 0)
1288       goto end;
1289     if ((err = key_putattr(KEYATTRS_KF(me), KEYATTRS_K(me),
1290                            attr, val)) != 0)
1291       KEYERR(err);
1292   } else {
1293     if (!key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr))
1294       INDEXERR(key);
1295     if ((err = key_putattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr, 0)) != 0)
1296       KEYERR(err);
1297   }
1298   rc = 0;
1299 end:
1300   return (rc);
1301 }
1302
1303 static PyObject *keyattrs_make(PyObject *kobj)
1304 {
1305   keyattrs_pyobj *me = PyObject_NEW(keyattrs_pyobj, keyattrs_pytype);
1306   me->kobj = kobj;
1307   Py_INCREF(kobj);
1308   return ((PyObject *)me);
1309 }
1310
1311 static void keyattrs_pydealloc(PyObject *me)
1312 {
1313   Py_DECREF(KEYATTRS_KOBJ(me));
1314   FREEOBJ(me);
1315 }
1316
1317 static PyMappingMethods keyattrs_pymapping = {
1318   gmap_pysize,                          /* @mp_length@ */
1319   keyattrs_pylookup,                    /* @mp_subscript@ */
1320   keyattrs_pystore                      /* @mp_ass_subscript@ */
1321 };
1322
1323 static PyTypeObject keyattrs_pytype_skel = {
1324   PyObject_HEAD_INIT(0) 0,              /* Header */
1325   "catacomb.KeyAttributes",             /* @tp_name@ */
1326   sizeof(keyattrs_pyobj),               /* @tp_basicsize@ */
1327   0,                                    /* @tp_itemsize@ */
1328
1329   keyattrs_pydealloc,                   /* @tp_dealloc@ */
1330   0,                                    /* @tp_print@ */
1331   0,                                    /* @tp_getattr@ */
1332   0,                                    /* @tp_setattr@ */
1333   0,                                    /* @tp_compare@ */
1334   0,                                    /* @tp_repr@ */
1335   0,                                    /* @tp_as_number@ */
1336   &gmap_pysequence,                     /* @tp_as_sequence@ */
1337   &keyattrs_pymapping,                  /* @tp_as_mapping@ */
1338   0,                                    /* @tp_hash@ */
1339   0,                                    /* @tp_call@ */
1340   0,                                    /* @tp_str@ */
1341   0,                                    /* @tp_getattro@ */
1342   0,                                    /* @tp_setattro@ */
1343   0,                                    /* @tp_as_buffer@ */
1344   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1345     Py_TPFLAGS_BASETYPE,
1346
1347   /* @tp_doc@ */
1348 "Proxy thing for talking about key attributes.",
1349
1350   0,                                    /* @tp_traverse@ */
1351   0,                                    /* @tp_clear@ */
1352   0,                                    /* @tp_richcompare@ */
1353   0,                                    /* @tp_weaklistoffset@ */
1354   keyattriter_make,                     /* @tp_iter@ */
1355   0,                                    /* @tp_iternext@ */
1356   gmap_pymethods,                       /* @tp_methods@ */
1357   0,                                    /* @tp_members@ */
1358   0,                                    /* @tp_getset@ */
1359   0,                                    /* @tp_base@ */
1360   0,                                    /* @tp_dict@ */
1361   0,                                    /* @tp_descr_get@ */
1362   0,                                    /* @tp_descr_set@ */
1363   0,                                    /* @tp_dictoffset@ */
1364   0,                                    /* @tp_init@ */
1365   PyType_GenericAlloc,                  /* @tp_alloc@ */
1366   abstract_pynew,                       /* @tp_new@ */
1367   0,                                    /* @tp_free@ */
1368   0                                     /* @tp_is_gc@ */
1369 };
1370
1371 /*----- Key objects -------------------------------------------------------*/
1372
1373 static PyObject *key_dowrap(PyTypeObject *ty, PyObject *kfobj, key *k)
1374 {
1375   key_pyobj *kobj = (key_pyobj *)ty->tp_alloc(ty, 0);
1376   kobj->kfobj = kfobj;
1377   Py_INCREF(kfobj);
1378   kobj->k = k;
1379   return ((PyObject *)kobj);
1380 }
1381
1382 static PyObject *key_pywrap(PyObject *kfobj, key *k)
1383   { return (key_dowrap(key_pytype, kfobj, k)); }
1384
1385 static PyObject *key_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
1386 {
1387   PyObject *kfobj;
1388   uint32 id;
1389   char *type;
1390   long exptime = KEXP_FOREVER;
1391   static char *kwlist[] = { "keyfile", "id", "type", "exptime", 0 };
1392   key *k;
1393   int err;
1394
1395   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&sl:new", kwlist,
1396                                    keyfile_pytype, &kfobj, convu32, &id,
1397                                    &type, &exptime))
1398     goto end;
1399   if ((err = key_new(KEYFILE_KF(kfobj), id, type, exptime, &k)) == 0)
1400     KEYERR(err);
1401   return (key_dowrap(ty, kfobj, k));
1402 end:
1403   return (0);
1404 }
1405
1406 static void key_pydealloc(PyObject *me)
1407 {
1408   Py_DECREF(KEY_KFOBJ(me));
1409   FREEOBJ(me);
1410 }
1411
1412 static PyObject *kmeth_delete(PyObject *me, PyObject *arg)
1413 {
1414   int err;
1415
1416   if (!PyArg_ParseTuple(arg, ":delete")) goto end;
1417   if ((err = key_delete(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err);
1418   RETURN_ME;
1419 end:
1420   return (0);
1421 }
1422
1423 static PyObject *kmeth_expire(PyObject *me, PyObject *arg)
1424 {
1425   int err;
1426
1427   if (!PyArg_ParseTuple(arg, ":expire")) goto end;
1428   if ((err = key_expire(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err);
1429   RETURN_ME;
1430 end:
1431   return (0);
1432 }
1433
1434 static PyObject *kmeth_used(PyObject *me, PyObject *arg)
1435 {
1436   long t;
1437   int err;
1438
1439   if (!PyArg_ParseTuple(arg, "l:used", &t)) goto end;
1440   if ((err = key_used(KEY_KF(me), KEY_K(me), t)) != 0) KEYERR(err);
1441   RETURN_ME;
1442 end:
1443   return (0);
1444 }
1445
1446 static PyObject *kmeth_extract(PyObject *me, PyObject *arg, PyObject *kw)
1447 {
1448   key_filter f = { 0, 0 };
1449   PyObject *file;
1450   PyObject *nameobj;
1451   char *name;
1452   FILE *fp;
1453   static char *kwlist[] = { "file", "filter", 0 };
1454
1455   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", kwlist,
1456                                    &PyFile_Type, &file,
1457                                    convfilter, &f) ||
1458       (fp = PyFile_AsFile(file)) == 0 ||
1459       (nameobj = PyFile_Name(file)) == 0 ||
1460       (name = PyString_AsString(nameobj)) == 0)
1461     goto end;
1462   if (key_extract(KEY_KF(me), KEY_K(me), fp, &f))
1463     OSERR(name);
1464   RETURN_ME;
1465 end:
1466   return (0);
1467 }
1468
1469 static PyObject *kmeth_fingerprint(PyObject *me,
1470                                    PyObject *arg, PyObject *kw)
1471 {
1472   ghash *h;
1473   key_filter f = { KF_NONSECRET, KF_NONSECRET };
1474   static char *kwlist[] = { "hash", "filter", 0 };
1475
1476   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:fingerprint", kwlist,
1477                                    convghash, &h, convfilter, &f))
1478     return (0);
1479   return (getbool(key_fingerprint(KEY_K(me), h, &f)));
1480 }
1481
1482 static PyObject *kget_id(PyObject *me, void *hunoz)
1483   { return (getulong(KEY_K(me)->id)); }
1484 static PyObject *kget_file(PyObject *me, void *hunoz)
1485   { RETURN_OBJ(KEY_KFOBJ(me)); }
1486 static PyObject *kget_type(PyObject *me, void *hunoz)
1487   { return (PyString_FromString(KEY_K(me)->type)); }
1488 static PyObject *kget_exptime(PyObject *me, void *hunoz)
1489   { return (getulong(KEY_K(me)->exp)); }
1490 static PyObject *kget_deltime(PyObject *me, void *hunoz)
1491   { return (getulong(KEY_K(me)->del)); }
1492 static PyObject *kget_expiredp(PyObject *me, void *hunoz)
1493   { return (getbool(key_expired(KEY_K(me)))); }
1494 static PyObject *kget_attr(PyObject *me, void *hunoz)
1495   { return (keyattrs_make(me)); }
1496
1497 static int kset_exptime(PyObject *me, PyObject *x, void *hunoz)
1498 {
1499   key *k = KEY_K(me);
1500   unsigned long et;
1501
1502   if (!convulong(x, &et))
1503     goto end;
1504   if (!(KEY_KF(me)->f & KF_WRITE))
1505     KEYERR(KERR_READONLY);
1506   k->exp = et;
1507   KEY_KF(me)->f |= KF_MODIFIED;
1508   return (0);
1509 end:
1510   return (-1);
1511 }
1512
1513 static int kset_deltime(PyObject *me, PyObject *x, void *hunoz)
1514 {
1515   key *k = KEY_K(me);
1516   unsigned long dt;
1517
1518   if (!convulong(x, &dt))
1519     goto end;
1520   if (dt == KEXP_FOREVER && k->exp != KEXP_FOREVER)
1521     VALERR("key will eventually expire");
1522   if (!(KEY_KF(me)->f & KF_WRITE))
1523     KEYERR(KERR_READONLY);
1524   k->del = dt;
1525   KEY_KF(me)->f |= KF_MODIFIED;
1526   return (0);
1527 end:
1528   return (-1);
1529 }
1530
1531 static PyObject *kget_data(PyObject *me, void *hunoz)
1532 {
1533   key_data *kd = KEY_K(me)->k;
1534   key_incref(kd);
1535   return (keydata_pywrap(kd));
1536 }
1537 static int kset_data(PyObject *me, PyObject *x, void *hunoz)
1538 {
1539   int err;
1540
1541   if (!x) NIERR("__del__");
1542   if (!KEYDATA_PYCHECK(x)) TYERR("expected KeyData object");
1543   if ((err = key_setkeydata(KEY_KF(me), KEY_K(me), KEYDATA_KD(x))) != 0)
1544     KEYERR(err);
1545   return (0);
1546 end:
1547   return (-1);
1548 }
1549
1550 static PyObject *kget_fulltag(PyObject *me, void *hunoz)
1551 {
1552   dstr d = DSTR_INIT;
1553   PyObject *rc;
1554
1555   key_fulltag(KEY_K(me), &d);
1556   rc = PyString_FromStringAndSize(d.buf, d.len);
1557   dstr_destroy(&d);
1558   return (rc);
1559 }
1560
1561 static PyObject *kget_tag(PyObject *me, void *hunoz)
1562 {
1563   if (!KEY_K(me)->tag) RETURN_NONE;
1564   return (PyString_FromString(KEY_K(me)->tag));
1565 }
1566 static int kset_tag(PyObject *me, PyObject *x, void *hunoz)
1567 {
1568   int err;
1569   char *tag;
1570
1571   if (!x || x == Py_None) tag = 0;
1572   else if ((tag = PyString_AsString(x)) == 0) goto end;
1573   if ((err = key_settag(KEY_KF(me), KEY_K(me), tag)) != 0) KEYERR(err);
1574   return (0);
1575 end:
1576   return (-1);
1577 }
1578
1579 static PyObject *kget_comment(PyObject *me, void *hunoz)
1580 {
1581   if (!KEY_K(me)->c) RETURN_NONE;
1582   return (PyString_FromString(KEY_K(me)->c));
1583 }
1584 static int kset_comment(PyObject *me, PyObject *x, void *hunoz)
1585 {
1586   int err;
1587   char *c;
1588
1589   if (!x || x == Py_None) c = 0;
1590   else if ((c = PyString_AsString(x)) == 0) goto end;
1591   if ((err = key_setcomment(KEY_KF(me), KEY_K(me), c)) != 0) KEYERR(err);
1592   return (0);
1593 end:
1594   return (-1);
1595 }
1596
1597 static PyMethodDef key_pymethods[] = {
1598 #define METHNAME(func) kmeth_##func
1599   METH  (delete,        "KEY.delete()")
1600   METH  (expire,        "KEY.expire()")
1601   METH  (used,          "KEY.used(TIME)")
1602   KWMETH(extract,       "KEY.extract(FILE, filter = '')")
1603   KWMETH(fingerprint,   "KEY.fingerprint(HASH, filtr = '-secret')")
1604 #undef METHNAME
1605   { 0 }
1606 };
1607
1608 static PyGetSetDef key_pygetset[] = {
1609 #define GETSETNAME(op, name) k##op##_##name
1610   GET   (file,          "KEY.file -> KF")
1611   GET   (id,            "KEY.id -> ID")
1612   GETSET(tag,           "KEY.tag -> TAG")
1613   GET   (type,          "KEY.type -> TYPE")
1614   GETSET(exptime,       "KEY.exptime -> TIME")
1615   GETSET(deltime,       "KEY.deltime -> TIME")
1616   GET   (expiredp,      "KEY.expiredp -> BOOL")
1617   GET   (attr,          "KEY.attr -> ATTRIBUTES")
1618   GETSET(data,          "KEY.data -> KD")
1619   GETSET(comment,       "KEY.comment -> COMMENT")
1620   GET   (fulltag,       "KEY.fulltag -> FULLTAG")
1621 #undef GETSETNAME
1622   { 0 }
1623 };
1624
1625 static PyTypeObject key_pytype_skel = {
1626   PyObject_HEAD_INIT(0) 0,              /* Header */
1627   "catacomb.Key",                       /* @tp_name@ */
1628   sizeof(key_pyobj),                    /* @tp_basicsize@ */
1629   0,                                    /* @tp_itemsize@ */
1630
1631   key_pydealloc,                        /* @tp_dealloc@ */
1632   0,                                    /* @tp_print@ */
1633   0,                                    /* @tp_getattr@ */
1634   0,                                    /* @tp_setattr@ */
1635   0,                                    /* @tp_compare@ */
1636   0,                                    /* @tp_repr@ */
1637   0,                                    /* @tp_as_number@ */
1638   0,                                    /* @tp_as_sequence@ */
1639   0,                                    /* @tp_as_mapping@ */
1640   0,                                    /* @tp_hash@ */
1641   0,                                    /* @tp_call@ */
1642   0,                                    /* @tp_str@ */
1643   0,                                    /* @tp_getattro@ */
1644   0,                                    /* @tp_setattro@ */
1645   0,                                    /* @tp_as_buffer@ */
1646   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1647     Py_TPFLAGS_BASETYPE,
1648
1649   /* @tp_doc@ */
1650 "Key object.",
1651
1652   0,                                    /* @tp_traverse@ */
1653   0,                                    /* @tp_clear@ */
1654   0,                                    /* @tp_richcompare@ */
1655   0,                                    /* @tp_weaklistoffset@ */
1656   0,                                    /* @tp_iter@ */
1657   0,                                    /* @tp_iternext@ */
1658   key_pymethods,                        /* @tp_methods@ */
1659   0,                                    /* @tp_members@ */
1660   key_pygetset,                         /* @tp_getset@ */
1661   0,                                    /* @tp_base@ */
1662   0,                                    /* @tp_dict@ */
1663   0,                                    /* @tp_descr_get@ */
1664   0,                                    /* @tp_descr_set@ */
1665   0,                                    /* @tp_dictoffset@ */
1666   0,                                    /* @tp_init@ */
1667   PyType_GenericAlloc,                  /* @tp_alloc@ */
1668   key_pynew,                            /* @tp_new@ */
1669   0,                                    /* @tp_free@ */
1670   0                                     /* @tp_is_gc@ */
1671 };
1672
1673 /*----- Key iteration -----------------------------------------------------*/
1674
1675 static PyObject *keyiter_new(PyObject *kfobj)
1676 {
1677   keyiter_pyobj *me = PyObject_NEW(keyiter_pyobj, keyiter_pytype);
1678   key_mkiter(&me->i, KEYFILE_KF(kfobj));
1679   me->kfobj = kfobj;
1680   Py_INCREF(kfobj);
1681   return ((PyObject *)me);
1682 }
1683
1684 static PyObject *keyiter_pynext(PyObject *me)
1685 {
1686   key *k;
1687
1688   if ((k = key_next(KEYITER_I(me))) == 0)
1689     return (0);
1690   return (getulong(k->id));
1691 }
1692
1693 static void keyiter_pydealloc(PyObject *me)
1694 {
1695   Py_DECREF(KEYITER_KFOBJ(me));
1696   FREEOBJ(me);
1697 }
1698
1699 static PyTypeObject keyiter_pytype_skel = {
1700   PyObject_HEAD_INIT(0) 0,              /* Header */
1701   "catacomb.KeyFileIter",               /* @tp_name@ */
1702   sizeof(keyiter_pyobj),                /* @tp_basicsize@ */
1703   0,                                    /* @tp_itemsize@ */
1704
1705   keyiter_pydealloc,                    /* @tp_dealloc@ */
1706   0,                                    /* @tp_print@ */
1707   0,                                    /* @tp_getattr@ */
1708   0,                                    /* @tp_setattr@ */
1709   0,                                    /* @tp_compare@ */
1710   0,                                    /* @tp_repr@ */
1711   0,                                    /* @tp_as_number@ */
1712   0,                                    /* @tp_as_sequence@ */
1713   0,                                    /* @tp_as_mapping@ */
1714   0,                                    /* @tp_hash@ */
1715   0,                                    /* @tp_call@ */
1716   0,                                    /* @tp_str@ */
1717   0,                                    /* @tp_getattro@ */
1718   0,                                    /* @tp_setattro@ */
1719   0,                                    /* @tp_as_buffer@ */
1720   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1721     Py_TPFLAGS_BASETYPE,
1722
1723   /* @tp_doc@ */
1724 "Keyring iterator.",
1725
1726   0,                                    /* @tp_traverse@ */
1727   0,                                    /* @tp_clear@ */
1728   0,                                    /* @tp_richcompare@ */
1729   0,                                    /* @tp_weaklistoffset@ */
1730   PyObject_SelfIter,                    /* @tp_iter@ */
1731   keyiter_pynext,                       /* @tp_iternext@ */
1732   0,                                    /* @tp_methods@ */
1733   0,                                    /* @tp_members@ */
1734   0,                                    /* @tp_getset@ */
1735   0,                                    /* @tp_base@ */
1736   0,                                    /* @tp_dict@ */
1737   0,                                    /* @tp_descr_get@ */
1738   0,                                    /* @tp_descr_set@ */
1739   0,                                    /* @tp_dictoffset@ */
1740   0,                                    /* @tp_init@ */
1741   PyType_GenericAlloc,                  /* @tp_alloc@ */
1742   abstract_pynew,                       /* @tp_new@ */
1743   0,                                    /* @tp_free@ */
1744   0                                     /* @tp_is_gc@ */
1745 };
1746
1747 /*----- Key files ---------------------------------------------------------*/
1748
1749 struct reportinfo {
1750   PyObject *func;
1751   int stop;
1752 };
1753
1754 static void pythonreporter(const char *file, int line,
1755                            const char *msg, void *p)
1756 {
1757   struct reportinfo *ri = p;
1758   PyObject *res = 0;
1759
1760   if (ri->stop)
1761     return;
1762   if (!ri->func)
1763     key_moan(file, line, msg, 0);
1764   else if ((res = PyObject_CallFunction(ri->func, "sis",
1765                                         file, line, msg)) == 0)
1766     ri->stop = 1;
1767   else
1768     Py_DECREF(res);
1769 }
1770
1771 static PyObject *keyfile_pynew(PyTypeObject *ty,
1772                                PyObject *arg, PyObject *kw)
1773 {
1774   struct reportinfo ri = { 0, 0 };
1775   char *file = 0;
1776   unsigned how = KOPEN_READ;
1777   keyfile_pyobj *rc = 0;
1778   static char *kwlist[] = { "file", "how", "report", 0 };
1779
1780   Py_XINCREF(arg); Py_XINCREF(kw);
1781   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|iO:new", kwlist,
1782                                    &file, &how, &ri.func))
1783     goto end;
1784   if (ri.func && !PyCallable_Check(ri.func))
1785     TYERR("reporter function not callable");
1786   if ((rc = (keyfile_pyobj *)ty->tp_alloc(ty, 0)) == 0)
1787     goto end;
1788   if (key_open(&rc->kf, file, how, pythonreporter, &ri))
1789     OSERR(file);
1790   if (ri.stop) {
1791     key_discard(&rc->kf);
1792     goto end;
1793   }
1794   goto done;
1795
1796 end:
1797   if (rc) {
1798     FREEOBJ(rc);
1799     rc = 0;
1800   }
1801 done:
1802   Py_XDECREF(arg); Py_XDECREF(kw);
1803   return ((PyObject *)rc);
1804 }
1805
1806 static void keyfile_pydealloc(PyObject *me)
1807 {
1808   key_discard(KEYFILE_KF(me));
1809   FREEOBJ(me);
1810 }
1811
1812 static PyObject *kfmeth_save(PyObject *me, PyObject *arg)
1813 {
1814   if (!PyArg_ParseTuple(arg, ":save"))
1815     goto end;
1816   switch (key_save(KEYFILE_KF(me))) {
1817     case KWRITE_OK:
1818       RETURN_ME;
1819     case KWRITE_FAIL:
1820       KEYIOERR(KEYFILE_KF(me)->name);
1821     case KWRITE_BROKEN:
1822       KEYFILEBROKEN(KEYFILE_KF(me)->name);
1823     default:
1824       abort();
1825   }
1826 end:
1827   return (0);
1828 }
1829
1830 static PyObject *kfmeth_merge(PyObject *me, PyObject *arg, PyObject *kw)
1831 {
1832   struct reportinfo ri = { 0, 0 };
1833   char *name;
1834   PyObject *x = 0;
1835   FILE *fp = 0;
1836   int rc;
1837   static char *kwlist[] = { "file", "report", 0 };
1838
1839   Py_XINCREF(arg); Py_XINCREF(kw);
1840   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", kwlist,
1841                                    &PyFile_Type, &x, &ri.func))
1842     goto end;
1843   if (ri.func && !PyCallable_Check(ri.func))
1844     TYERR("reporter function not callable");
1845   if ((fp = PyFile_AsFile(x)) == 0)
1846     goto end;
1847   x = PyFile_Name(x);
1848   if ((name = PyString_AsString(x)) == 0)
1849     goto end;
1850   rc = key_merge(KEYFILE_KF(me), name, fp, pythonreporter, &ri);
1851   if (ri.stop)
1852     goto end;
1853   if (rc != 0)
1854     KEYERR(rc);
1855   Py_XDECREF(arg); Py_XDECREF(kw);
1856   RETURN_ME;
1857
1858 end:
1859   Py_XDECREF(arg); Py_XDECREF(kw);
1860   return (0);
1861 }
1862
1863 static PyObject *kfmeth_byid(PyObject *me, PyObject *arg)
1864 {
1865   uint32 id;
1866   key *k;
1867   PyObject *rc = 0;
1868
1869   if (!PyArg_ParseTuple(arg, "O&:byid", convu32, &id)) goto end;
1870   if ((k = key_byid(KEYFILE_KF(me), id)) == 0) KEYERR(KERR_NOTFOUND);
1871   rc = key_pywrap(me, k);
1872 end:
1873   return (rc);
1874 }
1875
1876 static PyObject *kfmeth_bytype(PyObject *me, PyObject *arg)
1877 {
1878   char *type;
1879   key *k;
1880   PyObject *rc = 0;
1881
1882   if (!PyArg_ParseTuple(arg, "s:bytype", &type)) goto end;
1883   if ((k = key_bytype(KEYFILE_KF(me), type)) == 0) RETURN_NONE;
1884   rc = key_pywrap(me, k);
1885 end:
1886   return (rc);
1887 }
1888
1889 static PyObject *bytag(PyObject *me, PyObject *tagobj)
1890 {
1891   uint32 id;
1892   char *tag;
1893   key *k;
1894   PyObject *rc = 0;
1895
1896   if (convu32(tagobj, &id))
1897     k = key_byid(KEYFILE_KF(me), id);
1898   else {
1899     PyErr_Clear();
1900     if ((tag = PyString_AsString(tagobj)) == 0)
1901       goto end;
1902     k = key_bytag(KEYFILE_KF(me), tag);
1903   }
1904   if (!k) RETURN_NONE;
1905   rc = key_pywrap(me, k);
1906 end:
1907   return (rc);
1908 }
1909
1910 static PyObject *kfmeth_bytag(PyObject *me, PyObject *arg)
1911 {
1912   PyObject *tagobj;
1913
1914   if (!PyArg_ParseTuple(arg, "O:bytag", &tagobj)) return (0);
1915   return (bytag(me, tagobj));
1916 }
1917
1918 static PyObject *keyfile_pylookup(PyObject *me, PyObject *key)
1919 {
1920   PyObject *rc = bytag(me, key);
1921   if (!rc) goto end;
1922   if (rc == Py_None) {
1923     Py_DECREF(rc);
1924     rc = 0;
1925     INDEXERR(key);
1926   }
1927 end:
1928   return (rc);
1929 }
1930
1931 static PyObject *kfmeth_newkey(PyObject *me, PyObject *arg, PyObject *kw)
1932 {
1933   uint32 id;
1934   char *type;
1935   long exptime = KEXP_FOREVER;
1936   static char *kwlist[] = { "id", "type", "exptime", 0 };
1937   key *k;
1938   int err;
1939
1940   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s|l:newkey", kwlist,
1941                                    convu32, &id, &type, &exptime))
1942     goto end;
1943   if ((err = key_new(KEYFILE_KF(me), id, type, exptime, &k)) != 0)
1944     KEYERR(err);
1945   return (key_pywrap(me, k));
1946 end:
1947   return (0);
1948 }
1949
1950 static PyObject *kfmeth_qtag(PyObject *me, PyObject *arg, PyObject *kw)
1951 {
1952   key *k;
1953   key_data **kd, *okd;
1954   PyObject *newkdobj = 0;
1955   char *tag;
1956   dstr d = DSTR_INIT;
1957   PyObject *rc = 0;
1958   static char *kwlist[] = { "tag", "new", 0 };
1959
1960   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O!:qtag", kwlist,
1961                                    &tag, keydata_pytype, &newkdobj))
1962     goto end;
1963   if (key_qtag(KEYFILE_KF(me), tag, &d, &k, &kd))
1964     KEYERR(KERR_NOTFOUND);
1965   okd = *kd;
1966   if (newkdobj) {
1967     if (!(KEYFILE_KF(me)->f & KF_WRITE))
1968       KEYERR(KERR_READONLY);
1969     KEYFILE_KF(me)->f |= KF_MODIFIED;
1970     *kd = KEYDATA_KD(newkdobj);
1971   }
1972   key_incref(*kd);
1973   rc = Py_BuildValue("(s#NN)",
1974                      d.buf, d.len,
1975                      key_pywrap(me, k),
1976                      keydata_pywrap(okd));
1977 end:
1978   return (rc);
1979 }
1980
1981 static PyObject *kfget_name(PyObject *me, void *hunoz)
1982   { return (PyString_FromString(KEYFILE_KF(me)->name)); }
1983 static PyObject *kfget_modifiedp(PyObject *me, void *hunoz)
1984   { return (getbool(KEYFILE_KF(me)->f & KF_MODIFIED)); }
1985 static PyObject *kfget_writep(PyObject *me, void *hunoz)
1986   { return (getbool(KEYFILE_KF(me)->f & KF_WRITE)); }
1987 static PyObject *kfget_filep(PyObject *me, void *hunoz)
1988   { return (getbool(!!KEYFILE_KF(me)->fp)); }
1989
1990 static PyMethodDef keyfile_pymethods[] = {
1991 #define METHNAME(func) kfmeth_##func
1992   METH  (save,          "KF.save()")
1993   KWMETH(merge,         "KF.merge(FILE, report = <built-in-reporter>)")
1994   KWMETH(newkey,        "KF.newkey(ID, TYPE, exptime = KEXP_FOREVER) -> KEY")
1995   METH  (byid,          "KF.byid(KEYID) -> KEY|None")
1996   METH  (bytype,        "KF.bytype(TYPE) -> KEY|None")
1997   METH  (bytag,         "KF.bytag(TAG) -> KEY|None")
1998   KWMETH(qtag,          "KF.qtag(TAG, new = KD) -> FULLTAG, KEY, OLDKD")
1999   GMAP_ROMETHODS
2000 #undef METHNAME
2001   { 0 }
2002 };
2003
2004 static PyGetSetDef keyfile_pygetset[] = {
2005 #define GETSETNAME(op, name) kf##op##_##name
2006   GET   (name,          "KF.name -> file name")
2007   GET   (modifiedp,     "KF.modifiedp -> has keyring been modified?")
2008   GET   (writep,        "KF.writep -> is keyring modifiable?")
2009   GET   (filep,         "KF.filep -> does keyring have a backing file?")
2010 #undef GETSETNAME
2011   { 0 }
2012 };
2013
2014 static PyMappingMethods keyfile_pymapping = {
2015   gmap_pysize,
2016   keyfile_pylookup,
2017   0
2018 };
2019
2020 static PyTypeObject keyfile_pytype_skel = {
2021   PyObject_HEAD_INIT(0) 0,              /* Header */
2022   "catacomb.KeyFile",                   /* @tp_name@ */
2023   sizeof(keyfile_pyobj),                /* @tp_basicsize@ */
2024   0,                                    /* @tp_itemsize@ */
2025
2026   keyfile_pydealloc,                    /* @tp_dealloc@ */
2027   0,                                    /* @tp_print@ */
2028   0,                                    /* @tp_getattr@ */
2029   0,                                    /* @tp_setattr@ */
2030   0,                                    /* @tp_compare@ */
2031   0,                                    /* @tp_repr@ */
2032   0,                                    /* @tp_as_number@ */
2033   &gmap_pysequence,                     /* @tp_as_sequence@ */
2034   &keyfile_pymapping,                   /* @tp_as_mapping@ */
2035   0,                                    /* @tp_hash@ */
2036   0,                                    /* @tp_call@ */
2037   0,                                    /* @tp_str@ */
2038   0,                                    /* @tp_getattro@ */
2039   0,                                    /* @tp_setattro@ */
2040   0,                                    /* @tp_as_buffer@ */
2041   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
2042     Py_TPFLAGS_BASETYPE,
2043
2044   /* @tp_doc@ */
2045 "Keyring file.",
2046
2047   0,                                    /* @tp_traverse@ */
2048   0,                                    /* @tp_clear@ */
2049   0,                                    /* @tp_richcompare@ */
2050   0,                                    /* @tp_weaklistoffset@ */
2051   keyiter_new,                          /* @tp_iter@ */
2052   0,                                    /* @tp_iternext@ */
2053   keyfile_pymethods,                    /* @tp_methods@ */
2054   0,                                    /* @tp_members@ */
2055   keyfile_pygetset,                     /* @tp_getset@ */
2056   0,                                    /* @tp_base@ */
2057   0,                                    /* @tp_dict@ */
2058   0,                                    /* @tp_descr_get@ */
2059   0,                                    /* @tp_descr_set@ */
2060   0,                                    /* @tp_dictoffset@ */
2061   0,                                    /* @tp_init@ */
2062   PyType_GenericAlloc,                  /* @tp_alloc@ */
2063   keyfile_pynew,                        /* @tp_new@ */
2064   0,                                    /* @tp_free@ */
2065   0                                     /* @tp_is_gc@ */
2066 };
2067
2068 /*----- Global stuff ------------------------------------------------------*/
2069
2070 static PyObject *meth_barf(PyObject *me, PyObject *arg)
2071 {
2072   int err;
2073
2074   if (PyArg_ParseTuple(arg, "i:barf", &err))
2075     KEYERR(err);
2076 end:
2077   return (0);
2078 }
2079
2080 static PyMethodDef methods[] = {
2081 #define METHNAME(func) meth_##func
2082   METH  (_KeyData_readflags,
2083            "KeyData.readflags(STRING) -> (FLAGS, MASK, REST)")
2084   METH  (_KeyData_writeflags,   "KeyData.writeflags(FLAGS) -> STRING")
2085   METH  (_KeyData_read,         "KeyData.read(STRING) -> (KD, REST)")
2086   METH  (_KeyData_decode,       "KeyData.read(BYTES) -> KD")
2087   METH  (barf,                  "barf(ERR)")
2088 #undef METHNAME
2089   { 0 }
2090 };
2091
2092 /*----- Initialization ----------------------------------------------------*/
2093
2094 void key_pyinit(void)
2095 {
2096   INITTYPE(keyfile, root);
2097   INITTYPE(key, root);
2098   INITTYPE(keyiter, root);
2099   INITTYPE(keydata, root);
2100   INITTYPE(keydatabin, keydata);
2101   INITTYPE(keydataenc, keydata);
2102   INITTYPE(keydatastr, keydata);
2103   INITTYPE(keydatamp, keydata);
2104   INITTYPE(keydataec, keydata);
2105   INITTYPE(keydatastruct, keydata);
2106   INITTYPE(subkeyiter, root);
2107   INITTYPE(keyattrs, root);
2108   INITTYPE(keyattriter, root);
2109   addmethods(methods);
2110 }
2111
2112 void key_pyinsert(PyObject *mod)
2113 {
2114   INSEXC("KeyError", keyexc, PyExc_Exception, keyexc_pymethods);
2115   INSEXC("KeyFileIOError", keyioexc, PyExc_OSError, 0);
2116   INSEXC("KeyFileBroken", keyfilebrokenexc, keyioexc, 0);
2117   INSERT("KeyFile", keyfile_pytype);
2118   INSERT("KeyFileIter", keyiter_pytype);
2119   INSERT("Key", key_pytype);
2120   INSERT("KeyAttributes", keyattrs_pytype);
2121   INSERT("KeyAttributeIter", keyattriter_pytype);
2122   INSERT("KeyData", keydata_pytype);
2123   INSERT("KeyDataBinary", keydatabin_pytype);
2124   INSERT("KeyDataEncrypted", keydataenc_pytype);
2125   INSERT("KeyDataMP", keydatamp_pytype);
2126   INSERT("KeyDataECPt", keydataec_pytype);
2127   INSERT("KeyDataString", keydatastr_pytype);
2128   INSERT("KeyDataStructured", keydatastruct_pytype);
2129   INSERT("SubKeyIter", subkeyiter_pytype);
2130 }
2131
2132 /*----- That's all, folks -------------------------------------------------*/