~mdw / catacomb-python / blob
? search:


499503504d47a49adbd1f5962a15f7d25c067c30
[catacomb-python] / 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 -------------------------------------------------*/
Catacomb cryptographic library -- Python bindings