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