5 * (c) 2005 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the Python interface to Catacomb.
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.
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.
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.
27 /*----- Header files ------------------------------------------------------*/
29 #include "catacomb-python.h"
31 /*----- Exceptions --------------------------------------------------------*/
33 static PyObject
*keyexc
;
34 static PyObject
*keyioexc
;
35 static PyObject
*keyfilebrokenexc
;
37 static PyObject
*kxmeth___init__(PyObject
*me
, PyObject
*arg
)
43 n
= PyTuple_GET_SIZE(arg
);
44 if (n
< 2) TYERR("__init__() takes at least two arguments");
45 me
= PyTuple_GET_ITEM(arg
, 0);
46 err
= PyInt_AsLong(PyTuple_GET_ITEM(arg
, 1));
47 if (err
== -1 && PyErr_Occurred()) goto end
;
48 if (INT_MIN
> err
|| err
> INT_MAX
) OVFERR("error code out of range");
50 x
= PyInt_FromLong(err
); if (!x
) goto end
;
51 if (PyObject_SetAttrString(me
, "err", x
)) goto end
;
54 x
= PyString_FromString(key_strerror(err
)); if (!x
) goto end
;
55 if (PyObject_SetAttrString(me
, "errstring", x
)) goto end
;
58 x
= PyTuple_GetSlice(arg
, 1, n
); if (!x
) goto end
;
59 if (PyObject_SetAttrString(me
, "args", x
)) goto end
;
68 static PyObject
*kxmeth___str__(PyObject
*me
, PyObject
*arg
)
71 const char *errstr
, *errtag
;
75 static const char *const tab
[] = {
76 #define ENTRY(tag, num, str) "KERR_" #tag,
81 if (!PyArg_ParseTuple(arg
, "O:__str__", &me
) ||
82 (x
= PyObject_GetAttrString(me
, "err")) == 0 ||
83 (err
= PyInt_AsLong(x
), PyErr_Occurred()))
87 if (err
>= 0 && err
< N(tab
)) errtag
= tab
[err
];
88 else errtag
= "<unknown>";
89 if ((x
= PyObject_GetAttrString(me
, "errstring")) == 0 ||
90 (errstr
= PyString_AsString(x
)) == 0)
92 rc
= PyString_FromFormat("%s (%ld): %s", errtag
, -err
, errstr
);
99 static const PyMethodDef keyexc_pymethods
[] = {
100 #define METHNAME(func) kxmeth_##func
101 METH (__init__
, "KeyError(CODE)")
102 METH (__str__
, "E.__str__() -> STRING")
107 static void keyexc_raise(int err
)
109 PyObject
*arg
= Py_BuildValue("(i)", err
);
110 if (arg
) PyErr_SetObject(keyexc
, arg
);
113 #define KEYERR(err) do { keyexc_raise(err); goto end; } while (0)
114 #define KEYIOERR(name) do { \
115 PyErr_SetFromErrnoWithFilename(keyioexc, name); \
118 #define KEYFILEBROKEN(name) do { \
119 PyErr_SetFromErrnoWithFilename(keyfilebrokenexc, name); \
123 /*----- Data structures ---------------------------------------------------*/
125 typedef struct keydata_pyobj
{
130 static PyTypeObject
*keydata_pytype
;
131 static PyTypeObject
*keydatabin_pytype
;
132 static PyTypeObject
*keydataenc_pytype
;
133 static PyTypeObject
*keydatamp_pytype
;
134 static PyTypeObject
*keydatastruct_pytype
;
135 static PyTypeObject
*keydatastr_pytype
;
136 static PyTypeObject
*keydataec_pytype
;
137 #define KEYDATA_PYCHECK(o) PyObject_TypeCheck(o, keydata_pytype)
138 #define KEYDATA_KD(o) (((keydata_pyobj *)(o))->kd)
140 typedef struct subkeyiter_pyobj
{
146 static PyTypeObject
*subkeyiter_pytype
;
147 #define SUBKEYITER_PYCHECK(o) PyObject_TypeCheck(o, subkeyiter_pytype);
148 #define SUBKEYITER_I(o) (&((subkeyiter_pyobj *)(o))->i)
149 #define SUBKEYITER_KDOBJ(o) (((subkeyiter_pyobj *)(o))->kdobj)
151 typedef struct keyfile_pyobj
{
156 static PyTypeObject
*keyfile_pytype
;
157 #define KEYFILE_PYCHECK(o) PyObject_TypeCheck(o, keyfile_pytype)
158 #define KEYFILE_KF(o) (&((keyfile_pyobj *)(o))->kf)
160 typedef struct key_pyobj
{
166 static PyTypeObject
*key_pytype
;
167 #define KEY_PYCHECK(o) PyObject_TypeCheck(o, key_pytype)
168 #define KEY_K(o) (((key_pyobj *)(o))->k)
169 #define KEY_KFOBJ(o) (((key_pyobj *)(o))->kfobj)
170 #define KEY_KF(o) KEYFILE_KF(KEY_KFOBJ(o))
172 typedef struct keyiter_pyobj
{
178 static PyTypeObject
*keyiter_pytype
;
179 #define KEYITER_PYCHECK(o) PyObject_TypeCheck(o, keyiter_pytype)
180 #define KEYITER_I(o) (&((keyiter_pyobj *)(o))->i)
181 #define KEYITER_KFOBJ(o) (((keyiter_pyobj *)(o))->kfobj)
182 #define KEYITER_KF(o) KEYFILE_KF(KEYITER_KFOBJ(o))
184 typedef struct keyattrs_pyobj
{
189 static PyTypeObject
*keyattrs_pytype
;
190 #define KEYATTRS_PYCHECK(o) PyObject_TypeCheck(o, keyattrs_pytype)
191 #define KEYATTRS_KOBJ(o) (((keyattrs_pyobj *)(o))->kobj)
192 #define KEYATTRS_KF(o) KEY_KF(KEYATTRS_KOBJ(o))
193 #define KEYATTRS_K(o) KEY_K(KEYATTRS_KOBJ(o))
195 typedef struct keyattriter_pyobj
{
201 static PyTypeObject
*keyattriter_pytype
;
202 #define KEYATTRITER_PYCHECK(o) PyObject_TypeCheck(o, keyattriter_pytype)
203 #define KEYATTRITER_I(o) (&((keyattriter_pyobj *)(o))->i)
204 #define KEYATTRITER_KOBJ(o) (((keyattriter_pyobj *)(o))->kobj)
205 #define KEYATTRITER_K(o) KEY_K(KEYATTRITER_KOBJ(o))
206 #define KEYATTRITER_KFOBJ(o) KEY_KFOBJ(KEYATTRITER_KOBJ(o))
207 #define KEYATTRITER_KF(o) KEY_KF(KEYATTRITER_KOBJ(o))
209 /*----- Filters -----------------------------------------------------------*/
211 static int convfilter(PyObject
*x
, void *p
)
217 PyObject
*a
= 0, *b
= 0;
221 if ((fs
= PyString_AsString(x
)) != 0) {
222 if ((err
= key_readflags(fs
, &end
, &f
->f
, &f
->m
)) != 0)
225 KEYERR(KERR_BADFLAGS
);
228 if (!PySequence_Check(x
))
230 else if ((n
= PySequence_Size(x
)) < 0)
234 else if ((a
= PySequence_GetItem(x
, 0)) == 0 || !convuint(a
, &f
->f
) ||
235 (b
= PySequence_GetItem(x
, 1)) == 0 || !convuint(b
, &f
->m
))
241 TYERR("expected flag string or flag/mask pair");
248 static int convflags(PyObject
*x
, void *p
)
260 if ((fs
= PyString_AsString(x
)) != 0) {
261 if ((err
= key_readflags(fs
, &end
, f
, 0)) != 0)
264 KEYERR(KERR_BADFLAGS
);
273 TYERR("expected flag string or integer bitfield");
278 static PyObject
*kdmeth_readflags(PyObject
*me
, PyObject
*arg
)
286 if (!PyArg_ParseTuple(arg
, "s:readflags", &p
)) goto end
;
287 if ((err
= key_readflags(p
, &end
, &f
, &m
)) != 0) KEYERR(err
);
288 rc
= Py_BuildValue("(NNs)", getulong(f
), getulong(m
), end
);
293 static PyObject
*kdmeth_writeflags(PyObject
*me
, PyObject
*arg
)
299 if (!PyArg_ParseTuple(arg
, "O&:key_writeflags", convuint
, &f
)) return (0);
300 key_writeflags(f
, &d
);
301 rc
= PyString_FromStringAndSize(d
.buf
, d
.len
);
306 /*----- Key data ----------------------------------------------------------*/
308 static PyObject
*keydata_pywrap(key_data
*kd
)
311 keydata_pyobj
*kdobj
;
313 switch (kd
->e
& KF_ENCMASK
) {
314 case KENC_BINARY
: ty
= keydatabin_pytype
; break;
315 case KENC_ENCRYPT
: ty
= keydataenc_pytype
; break;
316 case KENC_MP
: ty
= keydatamp_pytype
; break;
317 case KENC_STRUCT
: ty
= keydatastruct_pytype
; break;
318 case KENC_STRING
: ty
= keydatastr_pytype
; break;
319 case KENC_EC
: ty
= keydataec_pytype
; break;
322 kdobj
= PyObject_NEW(keydata_pyobj
, ty
);
324 return ((PyObject
*)kdobj
);
327 static void keydata_pydealloc(PyObject
*me
)
329 key_drop(KEYDATA_KD(me
));
333 static PyObject
*kdmeth_matchp(PyObject
*me
, PyObject
*arg
)
337 if (!PyArg_ParseTuple(arg
, "O&:matchp", convfilter
, &f
))
339 return (getbool(KEY_MATCH(KEYDATA_KD(me
), &f
)));
342 static PyObject
*kdmeth_split(PyObject
*me
)
343 { key_split(&KEYDATA_KD(me
)); RETURN_ME
; }
345 static PyObject
*kdmeth_copy(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
347 key_filter f
= { 0, 0 };
348 static const char *const kwlist
[] = { "filter", 0 };
351 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "|O&:copy", KWLIST
,
354 if ((kd
= key_copydata(KEYDATA_KD(me
), &f
)) == 0)
357 return (keydata_pywrap(kd
));
360 static PyObject
*kdmeth_write(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
362 key_filter f
= { 0, 0 };
365 static const char *const kwlist
[] = { "filter", 0 };
367 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "|O&:write", KWLIST
,
370 key_write(KEYDATA_KD(me
), &d
, &f
);
371 rc
= PyString_FromStringAndSize(d
.buf
, d
.len
);
376 static PyObject
*kdmeth_encode(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
378 key_filter f
= { 0, 0 };
381 static const char *const kwlist
[] = { "filter", 0 };
383 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "|O&:encode", KWLIST
,
386 key_encode(KEYDATA_KD(me
), &d
, &f
);
387 rc
= bytestring_pywrap(d
.buf
, d
.len
);
392 static PyObject
*kdmeth_plock(PyObject
*me
, PyObject
*arg
)
399 if (!PyArg_ParseTuple(arg
, "s:plock", &tag
))
401 if ((err
= key_plock(&kd
, KEYDATA_KD(me
), tag
)) != 0)
403 rc
= keydata_pywrap(kd
);
408 static PyObject
*kdmeth_lock(PyObject
*me
, PyObject
*arg
)
415 if (!PyArg_ParseTuple(arg
, "s#:lock", &p
, &n
))
417 key_lock(&kd
, KEYDATA_KD(me
), p
, n
);
418 rc
= keydata_pywrap(kd
);
423 static PyObject
*kdmeth_read(PyObject
*me
, PyObject
*arg
)
430 if (!PyArg_ParseTuple(arg
, "s:read", &p
)) goto end
;
431 if ((kd
= key_read(p
, &end
)) == 0) KEYERR(KERR_MALFORMED
);
432 rc
= Py_BuildValue("(Ns)", keydata_pywrap(kd
), end
);
437 static PyObject
*kdmeth_decode(PyObject
*me
, PyObject
*arg
)
444 if (!PyArg_ParseTuple(arg
, "s#:decode", &p
, &n
)) goto end
;
445 if ((kd
= key_decode(p
, n
)) == 0) KEYERR(KERR_MALFORMED
);
446 rc
= keydata_pywrap(kd
);
451 static PyObject
*kdget_flags(PyObject
*me
, void *hunoz
)
452 { return (getulong(KEYDATA_KD(me
)->e
)); }
454 static const PyMethodDef keydata_pymethods
[] = {
455 #define METHNAME(func) kdmeth_##func
456 METH (matchp
, "KD.matchp(FILTER) -> BOOL")
457 NAMETH(split
, "KD.split()")
458 KWMETH(write
, "KD.write([filter = <any>]) -> STRING")
459 KWMETH(encode
, "KD.encode([filter = <any>]) -> BYTES")
460 KWMETH(copy
, "KD.copy([filter = <any>]) -> KD")
461 METH (plock
, "KD.plock(TAG) -> ENCRYPTED-KD")
462 METH (lock
, "KD.lock(KEY) -> ENCRYPTED-KD")
463 SMTH (readflags
, "readflags(STRING) -> (FLAGS, MASK, REST)")
464 SMTH (writeflags
, "writeflags(FLAGS) -> STRING")
465 SMTH (read
, "read(STRING) -> (KD, REST)")
466 SMTH (decode
, "decode(BYTES) -> KD")
471 static const PyGetSetDef keydata_pygetset
[] = {
472 #define GETSETNAME(op, name) kd##op##_##name
473 GET (flags
, "KD.flags -> FLAGS")
478 static const PyTypeObject keydata_pytype_skel
= {
479 PyObject_HEAD_INIT(0) 0, /* Header */
480 "KeyData", /* @tp_name@ */
481 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
482 0, /* @tp_itemsize@ */
484 keydata_pydealloc
, /* @tp_dealloc@ */
486 0, /* @tp_getattr@ */
487 0, /* @tp_setattr@ */
488 0, /* @tp_compare@ */
490 0, /* @tp_as_number@ */
491 0, /* @tp_as_sequence@ */
492 0, /* @tp_as_mapping@ */
496 0, /* @tp_getattro@ */
497 0, /* @tp_setattro@ */
498 0, /* @tp_as_buffer@ */
499 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
503 "Key data base class.",
505 0, /* @tp_traverse@ */
507 0, /* @tp_richcompare@ */
508 0, /* @tp_weaklistoffset@ */
510 0, /* @tp_iternext@ */
511 PYMETHODS(keydata
), /* @tp_methods@ */
512 0, /* @tp_members@ */
513 PYGETSET(keydata
), /* @tp_getset@ */
516 0, /* @tp_descr_get@ */
517 0, /* @tp_descr_set@ */
518 0, /* @tp_dictoffset@ */
520 PyType_GenericAlloc
, /* @tp_alloc@ */
521 abstract_pynew
, /* @tp_new@ */
526 static PyObject
*keydatabin_pynew(PyTypeObject
*ty
,
527 PyObject
*arg
, PyObject
*kw
)
532 keydata_pyobj
*me
= 0;
533 static const char *const kwlist
[] = { "key", "flags", 0 };
535 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#|O&:new", KWLIST
,
536 &p
, &n
, convflags
, &f
))
538 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
539 me
->kd
= key_newbinary(f
& ~KF_ENCMASK
, p
, n
);
541 return ((PyObject
*)me
);
544 static PyObject
*kdbget_bin(PyObject
*me
, void *hunoz
)
545 { return (bytestring_pywrap(KEYDATA_KD(me
)->u
.k
.k
,
546 KEYDATA_KD(me
)->u
.k
.sz
)); }
548 static const PyGetSetDef keydatabin_pygetset
[] = {
549 #define GETSETNAME(op, name) kdb##op##_##name
550 GET (bin
, "KD.bin -> BYTES")
555 static const PyTypeObject keydatabin_pytype_skel
= {
556 PyObject_HEAD_INIT(0) 0, /* Header */
557 "KeyDataBinary", /* @tp_name@ */
558 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
559 0, /* @tp_itemsize@ */
561 0, /* @tp_dealloc@ */
563 0, /* @tp_getattr@ */
564 0, /* @tp_setattr@ */
565 0, /* @tp_compare@ */
567 0, /* @tp_as_number@ */
568 0, /* @tp_as_sequence@ */
569 0, /* @tp_as_mapping@ */
573 0, /* @tp_getattro@ */
574 0, /* @tp_setattro@ */
575 0, /* @tp_as_buffer@ */
576 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
580 "KeyDataBinary(KEY, [flags = 0]): key data for binary keys.",
582 0, /* @tp_traverse@ */
584 0, /* @tp_richcompare@ */
585 0, /* @tp_weaklistoffset@ */
587 0, /* @tp_iternext@ */
588 0, /* @tp_methods@ */
589 0, /* @tp_members@ */
590 PYGETSET(keydatabin
), /* @tp_getset@ */
593 0, /* @tp_descr_get@ */
594 0, /* @tp_descr_set@ */
595 0, /* @tp_dictoffset@ */
597 PyType_GenericAlloc
, /* @tp_alloc@ */
598 keydatabin_pynew
, /* @tp_new@ */
603 static PyObject
*keydataenc_pynew(PyTypeObject
*ty
,
604 PyObject
*arg
, PyObject
*kw
)
609 keydata_pyobj
*me
= 0;
610 static const char *const kwlist
[] = { "key", "flags", 0 };
612 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#|O&:new", KWLIST
,
613 &p
, &n
, convflags
, &f
))
615 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
616 me
->kd
= key_newencrypted(f
& ~KF_ENCMASK
, p
, n
);
618 return ((PyObject
*)me
);
621 static PyObject
*kdemeth_plock(PyObject
*me
, PyObject
*arg
)
624 if (!PyArg_ParseTuple(arg
, "s:plock", &hunoz
)) goto end
;
625 KEYERR(KERR_WRONGTYPE
);
630 static PyObject
*kdemeth_lock(PyObject
*me
, PyObject
*arg
)
634 if (!PyArg_ParseTuple(arg
, "s#:lock", &hunoz
, &hukairz
)) goto end
;
635 KEYERR(KERR_WRONGTYPE
);
640 static PyObject
*kdemeth_punlock(PyObject
*me
, PyObject
*arg
)
647 if (!PyArg_ParseTuple(arg
, "s:punlock", &tag
))
649 if ((err
= key_punlock(&kd
, KEYDATA_KD(me
), tag
)) != 0)
651 rc
= keydata_pywrap(kd
);
656 static PyObject
*kdemeth_unlock(PyObject
*me
, PyObject
*arg
)
664 if (!PyArg_ParseTuple(arg
, "s#:unlock", &p
, &n
))
666 if ((err
= key_unlock(&kd
, KEYDATA_KD(me
), p
, n
)) != 0)
668 rc
= keydata_pywrap(kd
);
673 #define kdeget_ct kdbget_bin
675 static const PyMethodDef keydataenc_pymethods
[] = {
676 #define METHNAME(func) kdemeth_##func
677 METH (plock
, "KD.plock(TAG) -> ENCRYPTED-KD")
678 METH (lock
, "KD.lock(KEY) -> ENCRYPTED-KD")
679 METH (punlock
, "KD.punlock(TAG) -> KD")
680 METH (unlock
, "KD.unlock(KEY) -> KD")
685 static const PyGetSetDef keydataenc_pygetset
[] = {
686 #define GETSETNAME(op, name) kde##op##_##name
687 GET (ct
, "KD.ct -> BYTES")
692 static const PyTypeObject keydataenc_pytype_skel
= {
693 PyObject_HEAD_INIT(0) 0, /* Header */
694 "KeyDataEncrypted", /* @tp_name@ */
695 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
696 0, /* @tp_itemsize@ */
698 0, /* @tp_dealloc@ */
700 0, /* @tp_getattr@ */
701 0, /* @tp_setattr@ */
702 0, /* @tp_compare@ */
704 0, /* @tp_as_number@ */
705 0, /* @tp_as_sequence@ */
706 0, /* @tp_as_mapping@ */
710 0, /* @tp_getattro@ */
711 0, /* @tp_setattro@ */
712 0, /* @tp_as_buffer@ */
713 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
717 "KeyDataEncrypted(KEY, [flags = 0]): key data for encrypted keys.",
719 0, /* @tp_traverse@ */
721 0, /* @tp_richcompare@ */
722 0, /* @tp_weaklistoffset@ */
724 0, /* @tp_iternext@ */
725 PYMETHODS(keydataenc
), /* @tp_methods@ */
726 0, /* @tp_members@ */
727 PYGETSET(keydataenc
), /* @tp_getset@ */
730 0, /* @tp_descr_get@ */
731 0, /* @tp_descr_set@ */
732 0, /* @tp_dictoffset@ */
734 PyType_GenericAlloc
, /* @tp_alloc@ */
735 keydataenc_pynew
, /* @tp_new@ */
740 static PyObject
*keydatamp_pynew(PyTypeObject
*ty
,
741 PyObject
*arg
, PyObject
*kw
)
745 keydata_pyobj
*me
= 0;
746 static const char *const kwlist
[] = { "key", "flags", 0 };
748 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O&|O&:new", KWLIST
,
749 convmp
, &x
, convflags
, &f
))
751 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
752 me
->kd
= key_newmp(f
& ~KF_ENCMASK
, x
);
755 return ((PyObject
*)me
);
758 static PyObject
*kdmget_mp(PyObject
*me
, void *hunoz
)
759 { return (mp_pywrap(MP_COPY(KEYDATA_KD(me
)->u
.m
))); }
761 static const PyGetSetDef keydatamp_pygetset
[] = {
762 #define GETSETNAME(op, name) kdm##op##_##name
763 GET (mp
, "KD.mp -> X")
768 static const PyTypeObject keydatamp_pytype_skel
= {
769 PyObject_HEAD_INIT(0) 0, /* Header */
770 "KeyDataMP", /* @tp_name@ */
771 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
772 0, /* @tp_itemsize@ */
774 0, /* @tp_dealloc@ */
776 0, /* @tp_getattr@ */
777 0, /* @tp_setattr@ */
778 0, /* @tp_compare@ */
780 0, /* @tp_as_number@ */
781 0, /* @tp_as_sequence@ */
782 0, /* @tp_as_mapping@ */
786 0, /* @tp_getattro@ */
787 0, /* @tp_setattro@ */
788 0, /* @tp_as_buffer@ */
789 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
793 "KeyDataMP(KEY, [flags = 0]): key data for large-integer keys.",
795 0, /* @tp_traverse@ */
797 0, /* @tp_richcompare@ */
798 0, /* @tp_weaklistoffset@ */
800 0, /* @tp_iternext@ */
801 0, /* @tp_methods@ */
802 0, /* @tp_members@ */
803 PYGETSET(keydatamp
), /* @tp_getset@ */
806 0, /* @tp_descr_get@ */
807 0, /* @tp_descr_set@ */
808 0, /* @tp_dictoffset@ */
810 PyType_GenericAlloc
, /* @tp_alloc@ */
811 keydatamp_pynew
, /* @tp_new@ */
816 static PyObject
*keydatastr_pynew(PyTypeObject
*ty
,
817 PyObject
*arg
, PyObject
*kw
)
821 keydata_pyobj
*me
= 0;
822 static const char *const kwlist
[] = { "key", "flags", 0 };
824 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s|O&:new", KWLIST
,
827 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
828 me
->kd
= key_newstring(f
& ~KF_ENCMASK
, p
);
830 return ((PyObject
*)me
);
833 static PyObject
*kdsget_str(PyObject
*me
, void *hunoz
)
834 { return (PyString_FromString(KEYDATA_KD(me
)->u
.p
)); }
836 static const PyGetSetDef keydatastr_pygetset
[] = {
837 #define GETSETNAME(op, name) kds##op##_##name
838 GET (str
, "KD.str -> STRING")
843 static const PyTypeObject keydatastr_pytype_skel
= {
844 PyObject_HEAD_INIT(0) 0, /* Header */
845 "KeyDataString", /* @tp_name@ */
846 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
847 0, /* @tp_itemsize@ */
849 0, /* @tp_dealloc@ */
851 0, /* @tp_getattr@ */
852 0, /* @tp_setattr@ */
853 0, /* @tp_compare@ */
855 0, /* @tp_as_number@ */
856 0, /* @tp_as_sequence@ */
857 0, /* @tp_as_mapping@ */
861 0, /* @tp_getattro@ */
862 0, /* @tp_setattro@ */
863 0, /* @tp_as_buffer@ */
864 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
868 "KeyDataString(KEY, [flags = 0]): key data for string keys.",
870 0, /* @tp_traverse@ */
872 0, /* @tp_richcompare@ */
873 0, /* @tp_weaklistoffset@ */
875 0, /* @tp_iternext@ */
876 0, /* @tp_methods@ */
877 0, /* @tp_members@ */
878 PYGETSET(keydatastr
), /* @tp_getset@ */
881 0, /* @tp_descr_get@ */
882 0, /* @tp_descr_set@ */
883 0, /* @tp_dictoffset@ */
885 PyType_GenericAlloc
, /* @tp_alloc@ */
886 keydatastr_pynew
, /* @tp_new@ */
891 static PyObject
*keydataec_pynew(PyTypeObject
*ty
,
892 PyObject
*arg
, PyObject
*kw
)
896 keydata_pyobj
*me
= 0;
897 static const char *const kwlist
[] = { "key", "flags", 0 };
899 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O&|O&:new", KWLIST
,
900 convecpt
, &x
, convflags
, &f
))
902 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
903 me
->kd
= key_newec(f
& ~KF_ENCMASK
, &x
);
906 return ((PyObject
*)me
);
909 static PyObject
*kdeget_ecpt(PyObject
*me
, void *hunoz
)
912 EC_COPY(&pt
, &KEYDATA_KD(me
)->u
.e
);
913 return (ecpt_pywrapout(ecpt_pytype
, &pt
));
916 static const PyGetSetDef keydataec_pygetset
[] = {
917 #define GETSETNAME(op, name) kde##op##_##name
918 GET (ecpt
, "KD.ecpt -> ECPT")
923 static const PyTypeObject keydataec_pytype_skel
= {
924 PyObject_HEAD_INIT(0) 0, /* Header */
925 "KeyDataECPt", /* @tp_name@ */
926 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
927 0, /* @tp_itemsize@ */
929 0, /* @tp_dealloc@ */
931 0, /* @tp_getattr@ */
932 0, /* @tp_setattr@ */
933 0, /* @tp_compare@ */
935 0, /* @tp_as_number@ */
936 0, /* @tp_as_sequence@ */
937 0, /* @tp_as_mapping@ */
941 0, /* @tp_getattro@ */
942 0, /* @tp_setattro@ */
943 0, /* @tp_as_buffer@ */
944 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
948 "KeyDataECPt(KEY, [flags = 0]): key data for elliptic-curve keys.",
950 0, /* @tp_traverse@ */
952 0, /* @tp_richcompare@ */
953 0, /* @tp_weaklistoffset@ */
955 0, /* @tp_iternext@ */
956 0, /* @tp_methods@ */
957 0, /* @tp_members@ */
958 PYGETSET(keydataec
), /* @tp_getset@ */
961 0, /* @tp_descr_get@ */
962 0, /* @tp_descr_set@ */
963 0, /* @tp_dictoffset@ */
965 PyType_GenericAlloc
, /* @tp_alloc@ */
966 keydataec_pynew
, /* @tp_new@ */
971 static PyObject
*subkeyiter_make(PyObject
*kdobj
)
973 subkeyiter_pyobj
*me
= PyObject_NEW(subkeyiter_pyobj
, subkeyiter_pytype
);
976 key_mksubkeyiter(&me
->i
, KEYDATA_KD(kdobj
));
977 return ((PyObject
*)me
);
980 static PyObject
*subkeyiter_pynext(PyObject
*me
)
983 if (!key_nextsubkey(SUBKEYITER_I(me
), &tag
, 0))
985 return (PyString_FromString(tag
));
988 static void subkeyiter_pydealloc(PyObject
*me
)
990 Py_DECREF(SUBKEYITER_KDOBJ(me
));
994 static const PyTypeObject subkeyiter_pytype_skel
= {
995 PyObject_HEAD_INIT(0) 0, /* Header */
996 "SubKeyIter", /* @tp_name@ */
997 sizeof(subkeyiter_pyobj
), /* @tp_basicsize@ */
998 0, /* @tp_itemsize@ */
1000 subkeyiter_pydealloc
, /* @tp_dealloc@ */
1002 0, /* @tp_getattr@ */
1003 0, /* @tp_setattr@ */
1004 0, /* @tp_compare@ */
1006 0, /* @tp_as_number@ */
1007 0, /* @tp_as_sequence@ */
1008 0, /* @tp_as_mapping@ */
1012 0, /* @tp_getattro@ */
1013 0, /* @tp_setattro@ */
1014 0, /* @tp_as_buffer@ */
1015 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1016 Py_TPFLAGS_BASETYPE
,
1019 "Iterator for structured keys.",
1021 0, /* @tp_traverse@ */
1023 0, /* @tp_richcompare@ */
1024 0, /* @tp_weaklistoffset@ */
1025 PyObject_SelfIter
, /* @tp_iter@ */
1026 subkeyiter_pynext
, /* @tp_iternext@ */
1027 0, /* @tp_methods@ */
1028 0, /* @tp_members@ */
1029 0, /* @tp_getset@ */
1032 0, /* @tp_descr_get@ */
1033 0, /* @tp_descr_set@ */
1034 0, /* @tp_dictoffset@ */
1036 PyType_GenericAlloc
, /* @tp_alloc@ */
1037 abstract_pynew
, /* @tp_new@ */
1042 static PyObject
*keydatastruct_pynew(PyTypeObject
*ty
,
1043 PyObject
*arg
, PyObject
*kw
)
1046 PyObject
*it
= 0, *name
= 0, *val
= 0;
1048 keydata_pyobj
*me
= 0;
1050 static const char *const kwlist
[] = { "subkeys", 0 };
1052 Py_XINCREF(arg
); Py_XINCREF(kw
);
1053 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "|O:new", KWLIST
, &sub
))
1055 kd
= key_newstruct();
1057 if (!PyMapping_Check(sub
))
1058 TYERR("subkeys must be an iterable mapping");
1059 if ((it
= PyObject_GetIter(sub
)) == 0)
1061 while ((name
= PyIter_Next(it
)) != 0) {
1062 if ((p
= PyString_AsString(name
)) == 0 ||
1063 (val
= PyObject_GetItem(sub
, name
)) == 0)
1065 if (!KEYDATA_PYCHECK(val
))
1066 TYERR("subkey objects must be subclasses of KeyData");
1067 key_structset(kd
, p
, KEYDATA_KD(val
));
1068 Py_DECREF(name
); name
= 0;
1069 Py_DECREF(val
); val
= 0;
1071 if (PyErr_Occurred())
1073 Py_DECREF(it
); it
= 0;
1075 me
= (keydata_pyobj
*)ty
->tp_alloc(ty
, 0);
1078 if (kd
&& !me
) key_drop(kd
);
1079 Py_XDECREF(name
); Py_XDECREF(val
); Py_XDECREF(it
);
1080 Py_XDECREF(arg
); Py_XDECREF(kw
);
1081 return ((PyObject
*)me
);
1084 static PyObject
*keydatastruct_pylookup(PyObject
*me
, PyObject
*key
)
1090 if ((tag
= PyString_AsString(key
)) == 0)
1092 if ((kd
= key_structfind(KEYDATA_KD(me
), tag
)) == 0)
1095 rc
= keydata_pywrap(kd
);
1100 static int keydatastruct_pystore(PyObject
*me
,
1101 PyObject
*key
, PyObject
*value
)
1106 if ((tag
= PyString_AsString(key
)) == 0)
1108 key_split(&KEYDATA_KD(me
));
1110 if (!KEYDATA_PYCHECK(value
))
1111 TYERR("expected KeyData value");
1112 key_structset(KEYDATA_KD(me
), tag
, KEYDATA_KD(value
));
1114 if (!key_structfind(KEYDATA_KD(me
), tag
))
1116 key_structset(KEYDATA_KD(me
), tag
, 0);
1123 static const PyMappingMethods keydatastruct_pymapping
= {
1124 gmap_pysize
, /* @mp_length@ */
1125 keydatastruct_pylookup
, /* @mp_subscript@ */
1126 keydatastruct_pystore
/* @mp_ass_subscript@ */
1129 static const PyTypeObject keydatastruct_pytype_skel
= {
1130 PyObject_HEAD_INIT(0) 0, /* Header */
1131 "KeyDataStructured", /* @tp_name@ */
1132 sizeof(keydata_pyobj
), /* @tp_basicsize@ */
1133 0, /* @tp_itemsize@ */
1135 0, /* @tp_dealloc@ */
1137 0, /* @tp_getattr@ */
1138 0, /* @tp_setattr@ */
1139 0, /* @tp_compare@ */
1141 0, /* @tp_as_number@ */
1142 0, /* @tp_as_sequence@ */
1143 PYMAPPING(keydatastruct
), /* @tp_as_mapping@ */
1147 0, /* @tp_getattro@ */
1148 0, /* @tp_setattro@ */
1149 0, /* @tp_as_buffer@ */
1150 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1151 Py_TPFLAGS_BASETYPE
,
1154 "KeyDataStructured([subkeys = []]): key data for structured keys.",
1156 0, /* @tp_traverse@ */
1158 0, /* @tp_richcompare@ */
1159 0, /* @tp_weaklistoffset@ */
1160 subkeyiter_make
, /* @tp_iter@ */
1161 0, /* @tp_iternext@ */
1162 PYMETHODS(gmap
), /* @tp_methods@ */
1163 0, /* @tp_members@ */
1164 0, /* @tp_getset@ */
1167 0, /* @tp_descr_get@ */
1168 0, /* @tp_descr_set@ */
1169 0, /* @tp_dictoffset@ */
1171 PyType_GenericAlloc
, /* @tp_alloc@ */
1172 keydatastruct_pynew
, /* @tp_new@ */
1177 /*----- Key attributes ----------------------------------------------------*/
1179 static PyObject
*keyattriter_make(PyObject
*kaobj
)
1181 PyObject
*kobj
= KEYATTRS_KOBJ(kaobj
);
1182 keyattriter_pyobj
*me
= PyObject_NEW(keyattriter_pyobj
,
1183 keyattriter_pytype
);
1186 key_mkattriter(&me
->i
, KEY_K(kobj
));
1187 return ((PyObject
*)me
);
1190 static PyObject
*keyattriter_pynext(PyObject
*me
)
1194 if (!key_nextattr(KEYATTRITER_I(me
), &name
, 0))
1196 return (PyString_FromString(name
));
1199 static void keyattriter_pydealloc(PyObject
*me
)
1201 Py_DECREF(KEYATTRITER_KOBJ(me
));
1205 static const PyTypeObject keyattriter_pytype_skel
= {
1206 PyObject_HEAD_INIT(0) 0, /* Header */
1207 "KeyAttributeIter", /* @tp_name@ */
1208 sizeof(keyattriter_pyobj
), /* @tp_basicsize@ */
1209 0, /* @tp_itemsize@ */
1211 keyattriter_pydealloc
, /* @tp_dealloc@ */
1213 0, /* @tp_getattr@ */
1214 0, /* @tp_setattr@ */
1215 0, /* @tp_compare@ */
1217 0, /* @tp_as_number@ */
1218 0, /* @tp_as_sequence@ */
1219 0, /* @tp_as_mapping@ */
1223 0, /* @tp_getattro@ */
1224 0, /* @tp_setattro@ */
1225 0, /* @tp_as_buffer@ */
1226 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1227 Py_TPFLAGS_BASETYPE
,
1230 "Iterator for key attributes.",
1232 0, /* @tp_traverse@ */
1234 0, /* @tp_richcompare@ */
1235 0, /* @tp_weaklistoffset@ */
1236 PyObject_SelfIter
, /* @tp_iter@ */
1237 keyattriter_pynext
, /* @tp_iternext@ */
1238 0, /* @tp_methods@ */
1239 0, /* @tp_members@ */
1240 0, /* @tp_getset@ */
1243 0, /* @tp_descr_get@ */
1244 0, /* @tp_descr_set@ */
1245 0, /* @tp_dictoffset@ */
1247 PyType_GenericAlloc
, /* @tp_alloc@ */
1248 abstract_pynew
, /* @tp_new@ */
1253 static PyObject
*keyattrs_pylookup(PyObject
*me
, PyObject
*key
)
1259 if ((attr
= PyString_AsString(key
)) == 0)
1261 if ((value
= key_getattr(KEYATTRS_KF(me
), KEYATTRS_K(me
), attr
)) == 0)
1263 rc
= PyString_FromString(value
);
1268 static int keyattrs_pystore(PyObject
*me
,
1269 PyObject
*key
, PyObject
*value
)
1276 if ((attr
= PyString_AsString(key
)) == 0)
1279 if ((val
= PyString_AsString(value
)) == 0)
1281 if ((err
= key_putattr(KEYATTRS_KF(me
), KEYATTRS_K(me
),
1285 if (!key_getattr(KEYATTRS_KF(me
), KEYATTRS_K(me
), attr
))
1287 if ((err
= key_putattr(KEYATTRS_KF(me
), KEYATTRS_K(me
), attr
, 0)) != 0)
1295 static PyObject
*keyattrs_make(PyObject
*kobj
)
1297 keyattrs_pyobj
*me
= PyObject_NEW(keyattrs_pyobj
, keyattrs_pytype
);
1300 return ((PyObject
*)me
);
1303 static void keyattrs_pydealloc(PyObject
*me
)
1305 Py_DECREF(KEYATTRS_KOBJ(me
));
1309 static const PyMappingMethods keyattrs_pymapping
= {
1310 gmap_pysize
, /* @mp_length@ */
1311 keyattrs_pylookup
, /* @mp_subscript@ */
1312 keyattrs_pystore
/* @mp_ass_subscript@ */
1315 static const PyTypeObject keyattrs_pytype_skel
= {
1316 PyObject_HEAD_INIT(0) 0, /* Header */
1317 "KeyAttributes", /* @tp_name@ */
1318 sizeof(keyattrs_pyobj
), /* @tp_basicsize@ */
1319 0, /* @tp_itemsize@ */
1321 keyattrs_pydealloc
, /* @tp_dealloc@ */
1323 0, /* @tp_getattr@ */
1324 0, /* @tp_setattr@ */
1325 0, /* @tp_compare@ */
1327 0, /* @tp_as_number@ */
1328 PYSEQUENCE(gmap
), /* @tp_as_sequence@ */
1329 PYMAPPING(keyattrs
), /* @tp_as_mapping@ */
1333 0, /* @tp_getattro@ */
1334 0, /* @tp_setattro@ */
1335 0, /* @tp_as_buffer@ */
1336 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1337 Py_TPFLAGS_BASETYPE
,
1340 "Proxy thing for talking about key attributes.",
1342 0, /* @tp_traverse@ */
1344 0, /* @tp_richcompare@ */
1345 0, /* @tp_weaklistoffset@ */
1346 keyattriter_make
, /* @tp_iter@ */
1347 0, /* @tp_iternext@ */
1348 PYMETHODS(gmap
), /* @tp_methods@ */
1349 0, /* @tp_members@ */
1350 0, /* @tp_getset@ */
1353 0, /* @tp_descr_get@ */
1354 0, /* @tp_descr_set@ */
1355 0, /* @tp_dictoffset@ */
1357 PyType_GenericAlloc
, /* @tp_alloc@ */
1358 abstract_pynew
, /* @tp_new@ */
1363 /*----- Key objects -------------------------------------------------------*/
1365 static PyObject
*key_dowrap(PyTypeObject
*ty
, PyObject
*kfobj
, key
*k
)
1367 key_pyobj
*kobj
= (key_pyobj
*)ty
->tp_alloc(ty
, 0);
1368 kobj
->kfobj
= kfobj
;
1371 return ((PyObject
*)kobj
);
1374 static PyObject
*key_pywrap(PyObject
*kfobj
, key
*k
)
1375 { return (key_dowrap(key_pytype
, kfobj
, k
)); }
1377 static PyObject
*key_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
1382 unsigned long exptime
= KEXP_FOREVER
;
1383 static const char *const kwlist
[] =
1384 { "keyfile", "id", "type", "exptime", 0 };
1388 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O!O&s|O&:new", KWLIST
,
1389 keyfile_pytype
, &kfobj
, convu32
, &id
,
1390 &type
, convulong
, &exptime
))
1392 if ((err
= key_new(KEYFILE_KF(kfobj
), id
, type
, exptime
, &k
)) != 0)
1394 return (key_dowrap(ty
, kfobj
, k
));
1399 static void key_pydealloc(PyObject
*me
)
1401 Py_DECREF(KEY_KFOBJ(me
));
1405 static PyObject
*kmeth_delete(PyObject
*me
)
1409 if ((err
= key_delete(KEY_KF(me
), KEY_K(me
))) != 0) KEYERR(err
);
1415 static PyObject
*kmeth_expire(PyObject
*me
)
1419 if ((err
= key_expire(KEY_KF(me
), KEY_K(me
))) != 0) KEYERR(err
);
1425 static PyObject
*kmeth_used(PyObject
*me
, PyObject
*arg
)
1430 if (!PyArg_ParseTuple(arg
, "l:used", &t
)) goto end
;
1431 if ((err
= key_used(KEY_KF(me
), KEY_K(me
), t
)) != 0) KEYERR(err
);
1437 static PyObject
*kmeth_extract(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
1439 key_filter f
= { 0, 0 };
1444 static const char *const kwlist
[] = { "file", "filter", 0 };
1446 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O!|O&:extract", KWLIST
,
1447 &PyFile_Type
, &file
,
1449 (fp
= PyFile_AsFile(file
)) == 0 ||
1450 (nameobj
= PyFile_Name(file
)) == 0 ||
1451 (name
= PyString_AsString(nameobj
)) == 0)
1453 if (key_extract(KEY_KF(me
), KEY_K(me
), fp
, &f
))
1460 static PyObject
*kmeth_fingerprint(PyObject
*me
,
1461 PyObject
*arg
, PyObject
*kw
)
1464 key_filter f
= { KF_NONSECRET
, KF_NONSECRET
};
1465 static const char *const kwlist
[] = { "hash", "filter", 0 };
1467 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O&|O&:fingerprint", KWLIST
,
1468 convghash
, &h
, convfilter
, &f
))
1470 return (getbool(key_fingerprint(KEY_K(me
), h
, &f
)));
1473 static PyObject
*kget_id(PyObject
*me
, void *hunoz
)
1474 { return (getulong(KEY_K(me
)->id
)); }
1475 static PyObject
*kget_file(PyObject
*me
, void *hunoz
)
1476 { RETURN_OBJ(KEY_KFOBJ(me
)); }
1477 static PyObject
*kget_type(PyObject
*me
, void *hunoz
)
1478 { return (PyString_FromString(KEY_K(me
)->type
)); }
1479 static PyObject
*kget_exptime(PyObject
*me
, void *hunoz
)
1480 { return (getulong(KEY_K(me
)->exp
)); }
1481 static PyObject
*kget_deltime(PyObject
*me
, void *hunoz
)
1482 { return (getulong(KEY_K(me
)->del
)); }
1483 static PyObject
*kget_expiredp(PyObject
*me
, void *hunoz
)
1484 { return (getbool(key_expired(KEY_K(me
)))); }
1485 static PyObject
*kget_attr(PyObject
*me
, void *hunoz
)
1486 { return (keyattrs_make(me
)); }
1488 static int kset_exptime(PyObject
*me
, PyObject
*x
, void *hunoz
)
1493 if (!x
) NIERR("__del__");
1494 if (!convulong(x
, &et
))
1496 if (!(KEY_KF(me
)->f
& KF_WRITE
))
1497 KEYERR(KERR_READONLY
);
1499 KEY_KF(me
)->f
|= KF_MODIFIED
;
1505 static int kset_deltime(PyObject
*me
, PyObject
*x
, void *hunoz
)
1510 if (!x
) NIERR("__del__");
1511 if (!convulong(x
, &dt
))
1513 if (dt
== KEXP_FOREVER
&& k
->exp
!= KEXP_FOREVER
)
1514 VALERR("key will eventually expire");
1515 if (!(KEY_KF(me
)->f
& KF_WRITE
))
1516 KEYERR(KERR_READONLY
);
1518 KEY_KF(me
)->f
|= KF_MODIFIED
;
1524 static PyObject
*kget_data(PyObject
*me
, void *hunoz
)
1526 key_data
*kd
= KEY_K(me
)->k
;
1528 return (keydata_pywrap(kd
));
1530 static int kset_data(PyObject
*me
, PyObject
*x
, void *hunoz
)
1534 if (!x
) NIERR("__del__");
1535 if (!KEYDATA_PYCHECK(x
)) TYERR("expected KeyData object");
1536 if ((err
= key_setkeydata(KEY_KF(me
), KEY_K(me
), KEYDATA_KD(x
))) != 0)
1543 static PyObject
*kget_fulltag(PyObject
*me
, void *hunoz
)
1548 key_fulltag(KEY_K(me
), &d
);
1549 rc
= PyString_FromStringAndSize(d
.buf
, d
.len
);
1554 static PyObject
*kget_tag(PyObject
*me
, void *hunoz
)
1556 if (!KEY_K(me
)->tag
) RETURN_NONE
;
1557 return (PyString_FromString(KEY_K(me
)->tag
));
1559 static int kset_tag(PyObject
*me
, PyObject
*x
, void *hunoz
)
1564 if (!x
|| x
== Py_None
) tag
= 0;
1565 else if ((tag
= PyString_AsString(x
)) == 0) goto end
;
1566 if ((err
= key_settag(KEY_KF(me
), KEY_K(me
), tag
)) != 0) KEYERR(err
);
1572 static PyObject
*kget_comment(PyObject
*me
, void *hunoz
)
1574 if (!KEY_K(me
)->c
) RETURN_NONE
;
1575 return (PyString_FromString(KEY_K(me
)->c
));
1577 static int kset_comment(PyObject
*me
, PyObject
*x
, void *hunoz
)
1582 if (!x
|| x
== Py_None
) c
= 0;
1583 else if ((c
= PyString_AsString(x
)) == 0) goto end
;
1584 if ((err
= key_setcomment(KEY_KF(me
), KEY_K(me
), c
)) != 0) KEYERR(err
);
1590 static const PyMethodDef key_pymethods
[] = {
1591 #define METHNAME(func) kmeth_##func
1592 NAMETH(delete, "KEY.delete()")
1593 NAMETH(expire
, "KEY.expire()")
1594 METH (used
, "KEY.used(TIME)")
1595 KWMETH(extract
, "KEY.extract(FILE, [filter = <any>])")
1596 KWMETH(fingerprint
, "KEY.fingerprint(HASH, [filter = '-secret'])")
1601 static const PyGetSetDef key_pygetset
[] = {
1602 #define GETSETNAME(op, name) k##op##_##name
1603 GET (file
, "KEY.file -> KF")
1604 GET (id
, "KEY.id -> ID")
1605 GETSET(tag
, "KEY.tag -> TAG")
1606 GET (type
, "KEY.type -> TYPE")
1607 GETSET(exptime
, "KEY.exptime -> TIME")
1608 GETSET(deltime
, "KEY.deltime -> TIME")
1609 GET (expiredp
, "KEY.expiredp -> BOOL")
1610 GET (attr
, "KEY.attr -> ATTRIBUTES")
1611 GETSET(data
, "KEY.data -> KD")
1612 GETSET(comment
, "KEY.comment -> COMMENT")
1613 GET (fulltag
, "KEY.fulltag -> FULLTAG")
1618 static const PyTypeObject key_pytype_skel
= {
1619 PyObject_HEAD_INIT(0) 0, /* Header */
1620 "Key", /* @tp_name@ */
1621 sizeof(key_pyobj
), /* @tp_basicsize@ */
1622 0, /* @tp_itemsize@ */
1624 key_pydealloc
, /* @tp_dealloc@ */
1626 0, /* @tp_getattr@ */
1627 0, /* @tp_setattr@ */
1628 0, /* @tp_compare@ */
1630 0, /* @tp_as_number@ */
1631 0, /* @tp_as_sequence@ */
1632 0, /* @tp_as_mapping@ */
1636 0, /* @tp_getattro@ */
1637 0, /* @tp_setattro@ */
1638 0, /* @tp_as_buffer@ */
1639 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1640 Py_TPFLAGS_BASETYPE
,
1643 "Key(KF, ID, TYPE, [exptime = KEXP_FOREVER]): key object.",
1645 0, /* @tp_traverse@ */
1647 0, /* @tp_richcompare@ */
1648 0, /* @tp_weaklistoffset@ */
1650 0, /* @tp_iternext@ */
1651 PYMETHODS(key
), /* @tp_methods@ */
1652 0, /* @tp_members@ */
1653 PYGETSET(key
), /* @tp_getset@ */
1656 0, /* @tp_descr_get@ */
1657 0, /* @tp_descr_set@ */
1658 0, /* @tp_dictoffset@ */
1660 PyType_GenericAlloc
, /* @tp_alloc@ */
1661 key_pynew
, /* @tp_new@ */
1666 /*----- Key iteration -----------------------------------------------------*/
1668 static PyObject
*keyiter_new(PyObject
*kfobj
)
1670 keyiter_pyobj
*me
= PyObject_NEW(keyiter_pyobj
, keyiter_pytype
);
1671 key_mkiter(&me
->i
, KEYFILE_KF(kfobj
));
1674 return ((PyObject
*)me
);
1677 static PyObject
*keyiter_pynext(PyObject
*me
)
1681 if ((k
= key_next(KEYITER_I(me
))) == 0)
1683 return (getulong(k
->id
));
1686 static void keyiter_pydealloc(PyObject
*me
)
1688 Py_DECREF(KEYITER_KFOBJ(me
));
1692 static const PyTypeObject keyiter_pytype_skel
= {
1693 PyObject_HEAD_INIT(0) 0, /* Header */
1694 "KeyFileIter", /* @tp_name@ */
1695 sizeof(keyiter_pyobj
), /* @tp_basicsize@ */
1696 0, /* @tp_itemsize@ */
1698 keyiter_pydealloc
, /* @tp_dealloc@ */
1700 0, /* @tp_getattr@ */
1701 0, /* @tp_setattr@ */
1702 0, /* @tp_compare@ */
1704 0, /* @tp_as_number@ */
1705 0, /* @tp_as_sequence@ */
1706 0, /* @tp_as_mapping@ */
1710 0, /* @tp_getattro@ */
1711 0, /* @tp_setattro@ */
1712 0, /* @tp_as_buffer@ */
1713 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1714 Py_TPFLAGS_BASETYPE
,
1717 "Keyring iterator.",
1719 0, /* @tp_traverse@ */
1721 0, /* @tp_richcompare@ */
1722 0, /* @tp_weaklistoffset@ */
1723 PyObject_SelfIter
, /* @tp_iter@ */
1724 keyiter_pynext
, /* @tp_iternext@ */
1725 0, /* @tp_methods@ */
1726 0, /* @tp_members@ */
1727 0, /* @tp_getset@ */
1730 0, /* @tp_descr_get@ */
1731 0, /* @tp_descr_set@ */
1732 0, /* @tp_dictoffset@ */
1734 PyType_GenericAlloc
, /* @tp_alloc@ */
1735 abstract_pynew
, /* @tp_new@ */
1740 /*----- Key files ---------------------------------------------------------*/
1747 static void pythonreporter(const char *file
, int line
,
1748 const char *msg
, void *p
)
1750 struct reportinfo
*ri
= p
;
1756 key_moan(file
, line
, msg
, 0);
1757 else if ((res
= PyObject_CallFunction(ri
->func
, "sis",
1758 file
, line
, msg
)) == 0)
1764 static PyObject
*keyfile_pynew(PyTypeObject
*ty
,
1765 PyObject
*arg
, PyObject
*kw
)
1767 struct reportinfo ri
= { 0, 0 };
1769 unsigned how
= KOPEN_READ
;
1770 keyfile_pyobj
*rc
= 0;
1771 static const char *const kwlist
[] = { "file", "how", "report", 0 };
1773 Py_XINCREF(arg
); Py_XINCREF(kw
);
1774 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s|iO:new", KWLIST
,
1775 &file
, &how
, &ri
.func
))
1777 if (ri
.func
&& !PyCallable_Check(ri
.func
))
1778 TYERR("reporter function not callable");
1779 if ((rc
= (keyfile_pyobj
*)ty
->tp_alloc(ty
, 0)) == 0)
1781 if (key_open(&rc
->kf
, file
, how
, pythonreporter
, &ri
))
1784 key_discard(&rc
->kf
);
1795 Py_XDECREF(arg
); Py_XDECREF(kw
);
1796 return ((PyObject
*)rc
);
1799 static void keyfile_pydealloc(PyObject
*me
)
1801 key_discard(KEYFILE_KF(me
));
1805 static PyObject
*kfmeth_save(PyObject
*me
)
1807 switch (key_save(KEYFILE_KF(me
))) {
1811 KEYIOERR(KEYFILE_KF(me
)->name
);
1813 KEYFILEBROKEN(KEYFILE_KF(me
)->name
);
1821 static PyObject
*kfmeth_merge(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
1823 struct reportinfo ri
= { 0, 0 };
1828 static const char *const kwlist
[] = { "file", "report", 0 };
1830 Py_XINCREF(arg
); Py_XINCREF(kw
);
1831 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O!|O:merge", KWLIST
,
1832 &PyFile_Type
, &x
, &ri
.func
))
1834 if (ri
.func
&& !PyCallable_Check(ri
.func
))
1835 TYERR("reporter function not callable");
1836 if ((fp
= PyFile_AsFile(x
)) == 0)
1839 if ((name
= PyString_AsString(x
)) == 0)
1841 rc
= key_merge(KEYFILE_KF(me
), name
, fp
, pythonreporter
, &ri
);
1846 Py_XDECREF(arg
); Py_XDECREF(kw
);
1850 Py_XDECREF(arg
); Py_XDECREF(kw
);
1854 static PyObject
*kfmeth_byid(PyObject
*me
, PyObject
*arg
)
1860 if (!PyArg_ParseTuple(arg
, "O&:byid", convu32
, &id
)) goto end
;
1861 if ((k
= key_byid(KEYFILE_KF(me
), id
)) == 0) KEYERR(KERR_NOTFOUND
);
1862 rc
= key_pywrap(me
, k
);
1867 static PyObject
*kfmeth_bytype(PyObject
*me
, PyObject
*arg
)
1873 if (!PyArg_ParseTuple(arg
, "s:bytype", &type
)) goto end
;
1874 if ((k
= key_bytype(KEYFILE_KF(me
), type
)) == 0) RETURN_NONE
;
1875 rc
= key_pywrap(me
, k
);
1880 static PyObject
*bytag(PyObject
*me
, PyObject
*tagobj
)
1887 if (convu32(tagobj
, &id
))
1888 k
= key_byid(KEYFILE_KF(me
), id
);
1891 if ((tag
= PyString_AsString(tagobj
)) == 0)
1893 k
= key_bytag(KEYFILE_KF(me
), tag
);
1895 if (!k
) RETURN_NONE
;
1896 rc
= key_pywrap(me
, k
);
1901 static PyObject
*kfmeth_bytag(PyObject
*me
, PyObject
*arg
)
1905 if (!PyArg_ParseTuple(arg
, "O:bytag", &tagobj
)) return (0);
1906 return (bytag(me
, tagobj
));
1909 static PyObject
*keyfile_pylookup(PyObject
*me
, PyObject
*key
)
1911 PyObject
*rc
= bytag(me
, key
);
1913 if (rc
== Py_None
) {
1922 static PyObject
*kfmeth_newkey(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
1926 long exptime
= KEXP_FOREVER
;
1927 static const char *const kwlist
[] = { "id", "type", "exptime", 0 };
1931 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "O&s|l:newkey", KWLIST
,
1932 convu32
, &id
, &type
, &exptime
))
1934 if ((err
= key_new(KEYFILE_KF(me
), id
, type
, exptime
, &k
)) != 0)
1936 return (key_pywrap(me
, k
));
1941 static PyObject
*kfmeth_qtag(PyObject
*me
, PyObject
*arg
, PyObject
*kw
)
1944 key_data
**kd
, *okd
;
1945 PyObject
*newkdobj
= 0;
1949 static const char *const kwlist
[] = { "tag", "new", 0 };
1951 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s|O!:qtag", KWLIST
,
1952 &tag
, keydata_pytype
, &newkdobj
))
1954 if (key_qtag(KEYFILE_KF(me
), tag
, &d
, &k
, &kd
))
1955 KEYERR(KERR_NOTFOUND
);
1958 if (!(KEYFILE_KF(me
)->f
& KF_WRITE
))
1959 KEYERR(KERR_READONLY
);
1960 KEYFILE_KF(me
)->f
|= KF_MODIFIED
;
1961 *kd
= KEYDATA_KD(newkdobj
);
1964 rc
= Py_BuildValue("(s#NN)",
1965 d
.buf
, (Py_ssize_t
)d
.len
,
1967 keydata_pywrap(okd
));
1972 static PyObject
*kfget_name(PyObject
*me
, void *hunoz
)
1973 { return (PyString_FromString(KEYFILE_KF(me
)->name
)); }
1974 static PyObject
*kfget_modifiedp(PyObject
*me
, void *hunoz
)
1975 { return (getbool(KEYFILE_KF(me
)->f
& KF_MODIFIED
)); }
1976 static PyObject
*kfget_writep(PyObject
*me
, void *hunoz
)
1977 { return (getbool(KEYFILE_KF(me
)->f
& KF_WRITE
)); }
1978 static PyObject
*kfget_filep(PyObject
*me
, void *hunoz
)
1979 { return (getbool(!!KEYFILE_KF(me
)->fp
)); }
1981 static const PyMethodDef keyfile_pymethods
[] = {
1982 #define METHNAME(func) kfmeth_##func
1983 NAMETH(save
, "KF.save()")
1984 KWMETH(merge
, "KF.merge(FILE, [report = <built-in-reporter>])")
1985 KWMETH(newkey
, "KF.newkey(ID, TYPE, [exptime = KEXP_FOREVER]) "
1987 METH (byid
, "KF.byid(KEYID) -> KEY|None")
1988 METH (bytype
, "KF.bytype(TYPE) -> KEY|None")
1989 METH (bytag
, "KF.bytag(TAG) -> KEY|None")
1990 KWMETH(qtag
, "KF.qtag(TAG, [new = KD]) -> FULLTAG, KEY, OLDKD")
1996 static const PyGetSetDef keyfile_pygetset
[] = {
1997 #define GETSETNAME(op, name) kf##op##_##name
1998 GET (name
, "KF.name -> file name")
1999 GET (modifiedp
, "KF.modifiedp -> has keyring been modified?")
2000 GET (writep
, "KF.writep -> is keyring modifiable?")
2001 GET (filep
, "KF.filep -> does keyring have a backing file?")
2006 static const PyMappingMethods keyfile_pymapping
= {
2012 static const PyTypeObject keyfile_pytype_skel
= {
2013 PyObject_HEAD_INIT(0) 0, /* Header */
2014 "KeyFile", /* @tp_name@ */
2015 sizeof(keyfile_pyobj
), /* @tp_basicsize@ */
2016 0, /* @tp_itemsize@ */
2018 keyfile_pydealloc
, /* @tp_dealloc@ */
2020 0, /* @tp_getattr@ */
2021 0, /* @tp_setattr@ */
2022 0, /* @tp_compare@ */
2024 0, /* @tp_as_number@ */
2025 PYSEQUENCE(gmap
), /* @tp_as_sequence@ */
2026 PYMAPPING(keyfile
), /* @tp_as_mapping@ */
2030 0, /* @tp_getattro@ */
2031 0, /* @tp_setattro@ */
2032 0, /* @tp_as_buffer@ */
2033 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
2034 Py_TPFLAGS_BASETYPE
,
2037 "KeyFile(FILE, [how = KOPEN_READ], [report = ?]): Keyring file.\n"
2038 " calls REPORT(FILE, LINE, MSG) on problems",
2040 0, /* @tp_traverse@ */
2042 0, /* @tp_richcompare@ */
2043 0, /* @tp_weaklistoffset@ */
2044 keyiter_new
, /* @tp_iter@ */
2045 0, /* @tp_iternext@ */
2046 PYMETHODS(keyfile
), /* @tp_methods@ */
2047 0, /* @tp_members@ */
2048 PYGETSET(keyfile
), /* @tp_getset@ */
2051 0, /* @tp_descr_get@ */
2052 0, /* @tp_descr_set@ */
2053 0, /* @tp_dictoffset@ */
2055 PyType_GenericAlloc
, /* @tp_alloc@ */
2056 keyfile_pynew
, /* @tp_new@ */
2061 /*----- Initialization ----------------------------------------------------*/
2063 void key_pyinit(void)
2065 INITTYPE(keyfile
, root
);
2066 INITTYPE(key
, root
);
2067 INITTYPE(keyiter
, root
);
2068 INITTYPE(keydata
, root
);
2069 INITTYPE(keydatabin
, keydata
);
2070 INITTYPE(keydataenc
, keydata
);
2071 INITTYPE(keydatastr
, keydata
);
2072 INITTYPE(keydatamp
, keydata
);
2073 INITTYPE(keydataec
, keydata
);
2074 INITTYPE(keydatastruct
, keydata
);
2075 INITTYPE(subkeyiter
, root
);
2076 INITTYPE(keyattrs
, root
);
2077 INITTYPE(keyattriter
, root
);
2080 void key_pyinsert(PyObject
*mod
)
2082 INSEXC("KeyError", keyexc
, PyExc_Exception
, keyexc_pymethods
);
2083 INSEXC("KeyFileIOError", keyioexc
, PyExc_OSError
, 0);
2084 INSEXC("KeyFileBroken", keyfilebrokenexc
, keyioexc
, 0);
2085 INSERT("KeyFile", keyfile_pytype
);
2086 INSERT("KeyFileIter", keyiter_pytype
);
2087 INSERT("Key", key_pytype
);
2088 INSERT("KeyAttributes", keyattrs_pytype
);
2089 INSERT("KeyAttributeIter", keyattriter_pytype
);
2090 INSERT("KeyData", keydata_pytype
);
2091 INSERT("KeyDataBinary", keydatabin_pytype
);
2092 INSERT("KeyDataEncrypted", keydataenc_pytype
);
2093 INSERT("KeyDataMP", keydatamp_pytype
);
2094 INSERT("KeyDataECPt", keydataec_pytype
);
2095 INSERT("KeyDataString", keydatastr_pytype
);
2096 INSERT("KeyDataStructured", keydatastruct_pytype
);
2097 INSERT("SubKeyIter", subkeyiter_pytype
);
2100 /*----- That's all, folks -------------------------------------------------*/