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

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