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