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