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