X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/963a61481edc7a83698b18b518bf20cd93d268a6..refs/heads/mdw/python3:/key.c diff --git a/key.c b/key.c index 2b21e92..82bbb19 100644 --- a/key.c +++ b/key.c @@ -1,13 +1,11 @@ /* -*-c-*- * - * $Id$ - * * Key files and data * * (c) 2005 Straylight/Edgeware */ -/*----- Licensing notice --------------------------------------------------* +/*----- Licensing notice --------------------------------------------------* * * This file is part of the Python interface to Catacomb. * @@ -15,12 +13,12 @@ * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * Catacomb/Python is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with Catacomb/Python; if not, write to the Free Software Foundation, * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. @@ -38,29 +36,31 @@ static PyObject *keyfilebrokenexc; static PyObject *kxmeth___init__(PyObject *me, PyObject *arg) { - int err; + long err; PyObject *x = 0; + Py_ssize_t n; - if (!PyArg_ParseTuple(arg, "Oi:__init__", &me, &err) || - (x = PyInt_FromLong(err)) == 0 || - PyObject_SetAttrString(me, "err", x)) - goto fail; - Py_DECREF(x); x = 0; - if ((x = PyString_FromString(key_strerror(err))) == 0 || - PyObject_SetAttrString(me, "errstring", x)) - goto fail; + n = PyTuple_GET_SIZE(arg); + if (n < 2) TYERR("__init__() takes at least two arguments"); + me = PyTuple_GET_ITEM(arg, 0); + err = PyInt_AsLong(PyTuple_GET_ITEM(arg, 1)); + if (err == -1 && PyErr_Occurred()) goto end; + if (INT_MIN > err || err > INT_MAX) OVFERR("error code out of range"); + + x = PyInt_FromLong(err); if (!x) goto end; + if (PyObject_SetAttrString(me, "err", x)) goto end; Py_DECREF(x); x = 0; - if ((x = PyString_FromString(key_strerror(err))) == 0 || - PyObject_SetAttrString(me, "errstring", x)) - goto fail; + + x = TEXT_FROMSTR(key_strerror(err)); if (!x) goto end; + if (PyObject_SetAttrString(me, "errstring", x)) goto end; Py_DECREF(x); x = 0; - if ((x = PySequence_GetSlice(arg, 1, PySequence_Size(arg))) == 0 || - PyObject_SetAttrString(me, "args", x)) - goto fail; + + x = PyTuple_GetSlice(arg, 1, n); if (!x) goto end; + if (PyObject_SetAttrString(me, "args", x)) goto end; Py_DECREF(x); x = 0; RETURN_NONE; -fail: +end: Py_XDECREF(x); return (0); } @@ -87,19 +87,19 @@ static PyObject *kxmeth___str__(PyObject *me, PyObject *arg) if (err >= 0 && err < N(tab)) errtag = tab[err]; else errtag = ""; if ((x = PyObject_GetAttrString(me, "errstring")) == 0 || - (errstr = PyString_AsString(x)) == 0) + (errstr = TEXT_STR(x)) == 0) goto done; - rc = PyString_FromFormat("%s (%ld): %s", errtag, -err, errstr); + rc = TEXT_FORMAT("%s (%ld): %s", errtag, -err, errstr); done: Py_XDECREF(x); return (rc); } -static PyMethodDef keyexc_pymethods[] = { +static const PyMethodDef keyexc_pymethods[] = { #define METHNAME(func) kxmeth_##func - METH (__init__, "KeyError(CODE)") - METH (__str__, "E.__str__() -> STRING") + METH (__init__, "KeyError(CODE)") + METH (__str__, "E.__str__() -> STRING") #undef METHNAME { 0 } }; @@ -123,7 +123,7 @@ static void keyexc_raise(int err) /*----- Data structures ---------------------------------------------------*/ typedef struct keydata_pyobj { - PyObject_HEAD + GMAP_PYOBJ_HEAD key_data *kd; } keydata_pyobj; @@ -137,19 +137,8 @@ static PyTypeObject *keydataec_pytype; #define KEYDATA_PYCHECK(o) PyObject_TypeCheck(o, keydata_pytype) #define KEYDATA_KD(o) (((keydata_pyobj *)(o))->kd) -typedef struct subkeyiter_pyobj { - PyObject_HEAD - key_subkeyiter i; - PyObject *kdobj; -} subkeyiter_pyobj; - -static PyTypeObject *subkeyiter_pytype; -#define SUBKEYITER_PYCHECK(o) PyObject_TypeCheck(o, subkeyiter_pytype); -#define SUBKEYITER_I(o) (&((subkeyiter_pyobj *)(o))->i) -#define SUBKEYITER_KDOBJ(o) (((subkeyiter_pyobj *)(o))->kdobj) - typedef struct keyfile_pyobj { - PyObject_HEAD + GMAP_PYOBJ_HEAD key_file kf; } keyfile_pyobj; @@ -169,20 +158,8 @@ static PyTypeObject *key_pytype; #define KEY_KFOBJ(o) (((key_pyobj *)(o))->kfobj) #define KEY_KF(o) KEYFILE_KF(KEY_KFOBJ(o)) -typedef struct keyiter_pyobj { - PyObject_HEAD - key_iter i; - PyObject *kfobj; -} keyiter_pyobj; - -static PyTypeObject *keyiter_pytype; -#define KEYITER_PYCHECK(o) PyObject_TypeCheck(o, keyiter_pytype) -#define KEYITER_I(o) (&((keyiter_pyobj *)(o))->i) -#define KEYITER_KFOBJ(o) (((keyiter_pyobj *)(o))->kfobj) -#define KEYITER_KF(o) KEYFILE_KF(KEYITER_KFOBJ(o)) - typedef struct keyattrs_pyobj { - PyObject_HEAD + GMAP_PYOBJ_HEAD PyObject *kobj; } keyattrs_pyobj; @@ -192,20 +169,6 @@ static PyTypeObject *keyattrs_pytype; #define KEYATTRS_KF(o) KEY_KF(KEYATTRS_KOBJ(o)) #define KEYATTRS_K(o) KEY_K(KEYATTRS_KOBJ(o)) -typedef struct keyattriter_pyobj { - PyObject_HEAD - key_attriter i; - PyObject *kobj; -} keyattriter_pyobj; - -static PyTypeObject *keyattriter_pytype; -#define KEYATTRITER_PYCHECK(o) PyObject_TypeCheck(o, keyattriter_pytype) -#define KEYATTRITER_I(o) (&((keyattriter_pyobj *)(o))->i) -#define KEYATTRITER_KOBJ(o) (((keyattriter_pyobj *)(o))->kobj) -#define KEYATTRITER_K(o) KEY_K(KEYATTRITER_KOBJ(o)) -#define KEYATTRITER_KFOBJ(o) KEY_KFOBJ(KEYATTRITER_KOBJ(o)) -#define KEYATTRITER_KF(o) KEY_KF(KEYATTRITER_KOBJ(o)) - /*----- Filters -----------------------------------------------------------*/ static int convfilter(PyObject *x, void *p) @@ -218,7 +181,7 @@ static int convfilter(PyObject *x, void *p) int err; int rc = 0; - if ((fs = PyString_AsString(x)) != 0) { + if ((fs = TEXT_STR(x)) != 0) { if ((err = key_readflags(fs, &end, &f->f, &f->m)) != 0) KEYERR(err); if (*end) @@ -231,8 +194,8 @@ static int convfilter(PyObject *x, void *p) goto end; else if (n != 2) goto tyerr; - else if ((a = PySequence_GetItem(x, 0)) == 0 || convuint(a, &f->f) || - (b = PySequence_GetItem(x, 1)) == 0 || convuint(b, &f->m)) + else if ((a = PySequence_GetItem(x, 0)) == 0 || !convuint(a, &f->f) || + (b = PySequence_GetItem(x, 1)) == 0 || !convuint(b, &f->m)) goto end; } rc = 1; @@ -257,7 +220,7 @@ static int convflags(PyObject *x, void *p) return (1); else { PyErr_Clear(); - if ((fs = PyString_AsString(x)) != 0) { + if ((fs = TEXT_STR(x)) != 0) { if ((err = key_readflags(fs, &end, f, 0)) != 0) KEYERR(err); if (*end) @@ -270,12 +233,12 @@ static int convflags(PyObject *x, void *p) rc = 1; goto end; tyerr: - TYERR("expected flag string or flag/mask pair"); + TYERR("expected flag string or integer bitfield"); end: return (rc); } -static PyObject *meth__KeyData_readflags(PyObject *me, PyObject *arg) +static PyObject *kdmeth_readflags(PyObject *me, PyObject *arg) { const char *p; char *end; @@ -283,46 +246,50 @@ static PyObject *meth__KeyData_readflags(PyObject *me, PyObject *arg) PyObject *rc = 0; int err; - if (!PyArg_ParseTuple(arg, "Os:key_readflags", &me, &p)) - goto end; - if ((err = key_readflags(p, &end, &f, &m)) != 0) - KEYERR(err); - rc = Py_BuildValue("(NNs)", getu32(f), getu32(m), end); + if (!PyArg_ParseTuple(arg, "s:readflags", &p)) goto end; + if ((err = key_readflags(p, &end, &f, &m)) != 0) KEYERR(err); + rc = Py_BuildValue("(NNs)", getulong(f), getulong(m), end); end: return (rc); } -static PyObject *meth__KeyData_writeflags(PyObject *me, PyObject *arg) +static PyObject *kdmeth_writeflags(PyObject *me, PyObject *arg) { dstr d = DSTR_INIT; PyObject *rc; unsigned f; - if (!PyArg_ParseTuple(arg, "OO&:key_writeflags", &me, convuint, &f)) - return (0); + if (!PyArg_ParseTuple(arg, "O&:key_writeflags", convuint, &f)) return (0); key_writeflags(f, &d); - rc = PyString_FromStringAndSize(d.buf, d.len); + rc = TEXT_FROMSTRLEN(d.buf, d.len); dstr_destroy(&d); return (rc); } /*----- Key data ----------------------------------------------------------*/ +static const gmap_ops keydatastruct_gmops; + static PyObject *keydata_pywrap(key_data *kd) { PyTypeObject *ty; keydata_pyobj *kdobj; + const gmap_ops *gmops = 0; switch (kd->e & KF_ENCMASK) { case KENC_BINARY: ty = keydatabin_pytype; break; case KENC_ENCRYPT: ty = keydataenc_pytype; break; case KENC_MP: ty = keydatamp_pytype; break; - case KENC_STRUCT: ty = keydatastruct_pytype; break; + case KENC_STRUCT: + ty = keydatastruct_pytype; + gmops = &keydatastruct_gmops; + break; case KENC_STRING: ty = keydatastr_pytype; break; case KENC_EC: ty = keydataec_pytype; break; default: abort(); } kdobj = PyObject_NEW(keydata_pyobj, ty); + kdobj->gmops = gmops; kdobj->kd = kd; return ((PyObject *)kdobj); } @@ -336,18 +303,28 @@ static void keydata_pydealloc(PyObject *me) static PyObject *kdmeth_matchp(PyObject *me, PyObject *arg) { key_filter f; - + if (!PyArg_ParseTuple(arg, "O&:matchp", convfilter, &f)) return (0); return (getbool(KEY_MATCH(KEYDATA_KD(me), &f))); } -static PyObject *kdmeth_split(PyObject *me, PyObject *arg) +static PyObject *kdmeth_split(PyObject *me) + { key_split(&KEYDATA_KD(me)); RETURN_ME; } + +static PyObject *kdmeth_copy(PyObject *me, PyObject *arg, PyObject *kw) { - if (!PyArg_ParseTuple(arg, ":split")) + key_filter f = { 0, 0 }; + static const char *const kwlist[] = { "filter", 0 }; + key_data *kd; + + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:copy", KWLIST, + convfilter, &f)) return (0); - key_split(&KEYDATA_KD(me)); - RETURN_ME; + if ((kd = key_copydata(KEYDATA_KD(me), &f)) == 0) + RETURN_NONE; + else + return (keydata_pywrap(kd)); } static PyObject *kdmeth_write(PyObject *me, PyObject *arg, PyObject *kw) @@ -355,13 +332,13 @@ static PyObject *kdmeth_write(PyObject *me, PyObject *arg, PyObject *kw) key_filter f = { 0, 0 }; dstr d = DSTR_INIT; PyObject *rc = 0; - static char *kwlist[] = { "filter", 0 }; + static const char *const kwlist[] = { "filter", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:write", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:write", KWLIST, convfilter, &f)) return (0); key_write(KEYDATA_KD(me), &d, &f); - rc = PyString_FromStringAndSize(d.buf, d.len); + rc = TEXT_FROMSTRLEN(d.buf, d.len); dstr_destroy(&d); return (rc); } @@ -371,9 +348,9 @@ static PyObject *kdmeth_encode(PyObject *me, PyObject *arg, PyObject *kw) key_filter f = { 0, 0 }; dstr d = DSTR_INIT; PyObject *rc = 0; - static char *kwlist[] = { "filter", 0 }; + static const char *const kwlist[] = { "filter", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:encode", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:encode", KWLIST, convfilter, &f)) return (0); key_encode(KEYDATA_KD(me), &d, &f); @@ -388,7 +365,7 @@ static PyObject *kdmeth_plock(PyObject *me, PyObject *arg) int err; PyObject *rc = 0; key_data *kd; - + if (!PyArg_ParseTuple(arg, "s:plock", &tag)) goto end; if ((err = key_plock(&kd, KEYDATA_KD(me), tag)) != 0) @@ -400,76 +377,75 @@ end: static PyObject *kdmeth_lock(PyObject *me, PyObject *arg) { - char *p; - int n; + struct bin pp; PyObject *rc = 0; key_data *kd; - - if (!PyArg_ParseTuple(arg, "s#:lock", &p, &n)) + + if (!PyArg_ParseTuple(arg, "O&:lock", convbin, &pp)) goto end; - key_lock(&kd, KEYDATA_KD(me), p, n); + key_lock(&kd, KEYDATA_KD(me), pp.p, pp.sz); rc = keydata_pywrap(kd); end: return (rc); } -static PyObject *meth__KeyData_read(PyObject *me, PyObject *arg) +static PyObject *kdmeth_read(PyObject *me, PyObject *arg) { const char *p; char *end; key_data *kd; PyObject *rc = 0; - if (!PyArg_ParseTuple(arg, "Os:read", &me, &p)) - goto end; - if ((kd = key_read(p, &end)) == 0) - KEYERR(KERR_MALFORMED); + if (!PyArg_ParseTuple(arg, "s:read", &p)) goto end; + if ((kd = key_read(p, &end)) == 0) KEYERR(KERR_MALFORMED); rc = Py_BuildValue("(Ns)", keydata_pywrap(kd), end); end: return (rc); } -static PyObject *meth__KeyData_decode(PyObject *me, PyObject *arg) +static PyObject *kdmeth_decode(PyObject *me, PyObject *arg) { - const char *p; - int n; + struct bin in; key_data *kd; PyObject *rc = 0; - if (!PyArg_ParseTuple(arg, "Os#:decode", &me, &p, &n)) - goto end; - if ((kd = key_decode(p, n)) == 0) - KEYERR(KERR_MALFORMED); - rc = keydata_pywrap(kd); + if (!PyArg_ParseTuple(arg, "O&:decode", convbin, &in)) goto end; + if ((kd = key_decode(in.p, in.sz)) == 0) KEYERR(KERR_MALFORMED); + rc = keydata_pywrap(kd); end: return (rc); } static PyObject *kdget_flags(PyObject *me, void *hunoz) - { return (getu32(KEYDATA_KD(me)->e)); } + { return (getulong(KEYDATA_KD(me)->e)); } -static PyMethodDef keydata_pymethods[] = { +static const PyMethodDef keydata_pymethods[] = { #define METHNAME(func) kdmeth_##func - METH (matchp, "KD.matchp(FILTER) -> BOOL") - METH (split, "KD.split()") - KWMETH(write, "KD.write(filter = ) -> STRING") - KWMETH(encode, "KD.encode(filter = ) -> BYTES") - METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD") - METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD") + METH (matchp, "KD.matchp(FILTER) -> BOOL") + NAMETH(split, "KD.split()") + KWMETH(write, "KD.write([filter = ]) -> STRING") + KWMETH(encode, "KD.encode([filter = ]) -> BYTES") + KWMETH(copy, "KD.copy([filter = ]) -> KD") + METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD") + METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD") + SMTH (readflags, "readflags(STRING) -> (FLAGS, MASK, REST)") + SMTH (writeflags, "writeflags(FLAGS) -> STRING") + SMTH (read, "read(STRING) -> (KD, REST)") + SMTH (decode, "decode(BYTES) -> KD") #undef METHNAME { 0 } }; -static PyGetSetDef keydata_pygetset[] = { +static const PyGetSetDef keydata_pygetset[] = { #define GETSETNAME(op, name) kd##op##_##name - GET (flags, "KD.flags -> FLAGS") + GET (flags, "KD.flags -> FLAGS") #undef GETSETNAME { 0 } }; -static PyTypeObject keydata_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyData", /* @tp_name@ */ +static const PyTypeObject keydata_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyData", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -492,7 +468,7 @@ static PyTypeObject keydata_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data base class.", + "Key data base class.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -500,9 +476,9 @@ static PyTypeObject keydata_pytype_skel = { 0, /* @tp_weaklistoffset@ */ 0, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - keydata_pymethods, /* @tp_methods@ */ + PYMETHODS(keydata), /* @tp_methods@ */ 0, /* @tp_members@ */ - keydata_pygetset, /* @tp_getset@ */ + PYGETSET(keydata), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -518,17 +494,16 @@ static PyTypeObject keydata_pytype_skel = { static PyObject *keydatabin_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) { - char *p; - int n; + struct bin in; unsigned f = 0; keydata_pyobj *me = 0; - static char *kwlist[] = { "key", "flags", 0 }; + static const char *const kwlist[] = { "key", "flags", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist, - &p, &n, convflags, &f)) + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST, + convbin, &in, convflags, &f)) goto end; me = (keydata_pyobj *)ty->tp_alloc(ty, 0); - me->kd = key_newbinary(f & ~KF_ENCMASK, p, n); + me->kd = key_newbinary(f & ~KF_ENCMASK, in.p, in.sz); end: return ((PyObject *)me); } @@ -537,16 +512,16 @@ static PyObject *kdbget_bin(PyObject *me, void *hunoz) { return (bytestring_pywrap(KEYDATA_KD(me)->u.k.k, KEYDATA_KD(me)->u.k.sz)); } -static PyGetSetDef keydatabin_pygetset[] = { +static const PyGetSetDef keydatabin_pygetset[] = { #define GETSETNAME(op, name) kdb##op##_##name - GET (bin, "KD.bin -> BYTES") + GET (bin, "KD.bin -> BYTES") #undef GETSETNAME { 0 } }; -static PyTypeObject keydatabin_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataBinary", /* @tp_name@ */ +static const PyTypeObject keydatabin_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataBinary", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -569,7 +544,7 @@ static PyTypeObject keydatabin_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for binary keys.", + "KeyDataBinary(KEY, [flags = 0]): key data for binary keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -579,7 +554,7 @@ static PyTypeObject keydatabin_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - keydatabin_pygetset, /* @tp_getset@ */ + PYGETSET(keydatabin), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -595,17 +570,16 @@ static PyTypeObject keydatabin_pytype_skel = { static PyObject *keydataenc_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) { - char *p; - int n; + struct bin in; unsigned f = 0; keydata_pyobj *me = 0; - static char *kwlist[] = { "key", "flags", 0 }; + static const char *const kwlist[] = { "key", "flags", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist, - &p, &n, convflags, &f)) + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST, + convbin, &in, convflags, &f)) goto end; me = (keydata_pyobj *)ty->tp_alloc(ty, 0); - me->kd = key_newencrypted(f & ~KF_ENCMASK, p, n); + me->kd = key_newencrypted(f & ~KF_ENCMASK, in.p, in.sz); end: return ((PyObject *)me); } @@ -621,9 +595,8 @@ end: static PyObject *kdemeth_lock(PyObject *me, PyObject *arg) { - char *hunoz; - int hukairz; - if (!PyArg_ParseTuple(arg, "s#:lock", &hunoz, &hukairz)) goto end; + struct bin hunoz; + if (!PyArg_ParseTuple(arg, "O&:lock", convbin, &hunoz)) goto end; KEYERR(KERR_WRONGTYPE); end: return (0); @@ -635,7 +608,7 @@ static PyObject *kdemeth_punlock(PyObject *me, PyObject *arg) int err; PyObject *rc = 0; key_data *kd; - + if (!PyArg_ParseTuple(arg, "s:punlock", &tag)) goto end; if ((err = key_punlock(&kd, KEYDATA_KD(me), tag)) != 0) @@ -647,15 +620,14 @@ end: static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg) { - char *p; - int n; + struct bin pp; int err; PyObject *rc = 0; key_data *kd; - - if (!PyArg_ParseTuple(arg, "s#:unlock", &p, &n)) + + if (!PyArg_ParseTuple(arg, "O&:unlock", convbin, &pp)) goto end; - if ((err = key_unlock(&kd, KEYDATA_KD(me), p, n)) != 0) + if ((err = key_unlock(&kd, KEYDATA_KD(me), pp.p, pp.sz)) != 0) KEYERR(err); rc = keydata_pywrap(kd); end: @@ -664,26 +636,26 @@ end: #define kdeget_ct kdbget_bin -static PyMethodDef keydataenc_pymethods[] = { +static const PyMethodDef keydataenc_pymethods[] = { #define METHNAME(func) kdemeth_##func - METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD") - METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD") - METH (punlock, "KD.punlock(TAG) -> KD") - METH (unlock, "KD.unlock(KEY) -> KD") + METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD") + METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD") + METH (punlock, "KD.punlock(TAG) -> KD") + METH (unlock, "KD.unlock(KEY) -> KD") #undef METHNAME { 0 } }; -static PyGetSetDef keydataenc_pygetset[] = { +static const PyGetSetDef keydataenc_pygetset[] = { #define GETSETNAME(op, name) kde##op##_##name - GET (ct, "KD.ct -> BYTES") + GET (ct, "KD.ct -> BYTES") #undef GETSETNAME { 0 } }; -static PyTypeObject keydataenc_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataEncrypted", /* @tp_name@ */ +static const PyTypeObject keydataenc_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataEncrypted", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -706,7 +678,7 @@ static PyTypeObject keydataenc_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for encrypted keys.", + "KeyDataEncrypted(KEY, [flags = 0]): key data for encrypted keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -714,9 +686,9 @@ static PyTypeObject keydataenc_pytype_skel = { 0, /* @tp_weaklistoffset@ */ 0, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - keydataenc_pymethods, /* @tp_methods@ */ + PYMETHODS(keydataenc), /* @tp_methods@ */ 0, /* @tp_members@ */ - keydataenc_pygetset, /* @tp_getset@ */ + PYGETSET(keydataenc), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -735,9 +707,9 @@ static PyObject *keydatamp_pynew(PyTypeObject *ty, mp *x = 0; unsigned f = 0; keydata_pyobj *me = 0; - static char *kwlist[] = { "key", "flags", 0 }; + static const char *const kwlist[] = { "key", "flags", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST, convmp, &x, convflags, &f)) goto end; me = (keydata_pyobj *)ty->tp_alloc(ty, 0); @@ -750,16 +722,16 @@ end: static PyObject *kdmget_mp(PyObject *me, void *hunoz) { return (mp_pywrap(MP_COPY(KEYDATA_KD(me)->u.m))); } -static PyGetSetDef keydatamp_pygetset[] = { +static const PyGetSetDef keydatamp_pygetset[] = { #define GETSETNAME(op, name) kdm##op##_##name - GET (mp, "KD.mp -> X") + GET (mp, "KD.mp -> X") #undef GETSETNAME { 0 } }; -static PyTypeObject keydatamp_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataMP", /* @tp_name@ */ +static const PyTypeObject keydatamp_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataMP", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -782,7 +754,7 @@ static PyTypeObject keydatamp_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for large-integer keys.", + "KeyDataMP(KEY, [flags = 0]): key data for large-integer keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -792,7 +764,7 @@ static PyTypeObject keydatamp_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - keydatamp_pygetset, /* @tp_getset@ */ + PYGETSET(keydatamp), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -811,9 +783,9 @@ static PyObject *keydatastr_pynew(PyTypeObject *ty, char *p; unsigned f = 0; keydata_pyobj *me = 0; - static char *kwlist[] = { "key", "flags", 0 }; + static const char *const kwlist[] = { "key", "flags", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:new", KWLIST, &p, convflags, &f)) goto end; me = (keydata_pyobj *)ty->tp_alloc(ty, 0); @@ -823,18 +795,18 @@ end: } static PyObject *kdsget_str(PyObject *me, void *hunoz) - { return (PyString_FromString(KEYDATA_KD(me)->u.p)); } + { return (TEXT_FROMSTR(KEYDATA_KD(me)->u.p)); } -static PyGetSetDef keydatastr_pygetset[] = { +static const PyGetSetDef keydatastr_pygetset[] = { #define GETSETNAME(op, name) kds##op##_##name - GET (str, "KD.str -> STRING") + GET (str, "KD.str -> STRING") #undef GETSETNAME { 0 } }; -static PyTypeObject keydatastr_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataString", /* @tp_name@ */ +static const PyTypeObject keydatastr_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataString", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -857,7 +829,7 @@ static PyTypeObject keydatastr_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for string keys.", + "KeyDataString(KEY, [flags = 0]): key data for string keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -867,7 +839,7 @@ static PyTypeObject keydatastr_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - keydatastr_pygetset, /* @tp_getset@ */ + PYGETSET(keydatastr), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -886,9 +858,9 @@ static PyObject *keydataec_pynew(PyTypeObject *ty, ec x = EC_INIT; unsigned f = 0; keydata_pyobj *me = 0; - static char *kwlist[] = { "key", "flags", 0 }; + static const char *const kwlist[] = { "key", "flags", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST, convecpt, &x, convflags, &f)) goto end; me = (keydata_pyobj *)ty->tp_alloc(ty, 0); @@ -905,16 +877,16 @@ static PyObject *kdeget_ecpt(PyObject *me, void *hunoz) return (ecpt_pywrapout(ecpt_pytype, &pt)); } -static PyGetSetDef keydataec_pygetset[] = { +static const PyGetSetDef keydataec_pygetset[] = { #define GETSETNAME(op, name) kde##op##_##name - GET (ecpt, "KD.ecpt -> ECPT") + GET (ecpt, "KD.ecpt -> ECPT") #undef GETSETNAME { 0 } }; -static PyTypeObject keydataec_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataECPt", /* @tp_name@ */ +static const PyTypeObject keydataec_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataECPt", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -937,7 +909,7 @@ static PyTypeObject keydataec_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for elliptic-curve keys.", + "KeyDataECPt(KEY, [flags = 0]): key data for elliptic-curve keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -947,7 +919,7 @@ static PyTypeObject keydataec_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - keydataec_pygetset, /* @tp_getset@ */ + PYGETSET(keydataec), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -960,166 +932,146 @@ static PyTypeObject keydataec_pytype_skel = { 0 /* @tp_is_gc@ */ }; -static PyObject *subkeyiter_make(PyObject *kdobj) -{ - subkeyiter_pyobj *me = PyObject_NEW(subkeyiter_pyobj, subkeyiter_pytype); - me->kdobj = kdobj; - Py_INCREF(kdobj); - key_mksubkeyiter(&me->i, KEYDATA_KD(kdobj)); - return ((PyObject *)me); -} - -static PyObject *subkeyiter_next(PyObject *me) +static void *keydatastruct_gmlookup(PyObject *me, PyObject *k, unsigned *f) { + key_data *kd = KEYDATA_KD(me); const char *tag; - if (!key_nextsubkey(SUBKEYITER_I(me), &tag, 0)) - return (0); - return (PyString_FromString(tag)); + key_struct *ks; + + assert((kd->e&KF_ENCMASK) == KENC_STRUCT); + if ((tag = TEXT_STR(k)) == 0) return (0); + if (f) { key_split(&kd); KEYDATA_KD(me) = kd; } + ks = sym_find(&kd->u.s, tag, -1, f ? sizeof(key_struct) : 0, f); + if (ks && f && !*f) ks->k = 0; + return (ks); } -static void subkeyiter_pydealloc(PyObject *me) +static void keydatastruct_gmiterinit(PyObject *me, void *i) { - Py_DECREF(SUBKEYITER_KDOBJ(me)); - FREEOBJ(me); + key_data *kd = KEYDATA_KD(me); + + assert((kd->e&KF_ENCMASK) == KENC_STRUCT); + sym_mkiter(i, &kd->u.s); } -static PyTypeObject subkeyiter_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.SubKeyIter", /* @tp_name@ */ - sizeof(subkeyiter_pyobj), /* @tp_basicsize@ */ - 0, /* @tp_itemsize@ */ +static void *keydatastruct_gmiternext(PyObject *me, void *i) + { return (sym_next(i)); } - subkeyiter_pydealloc, /* @tp_dealloc@ */ - 0, /* @tp_print@ */ - 0, /* @tp_getattr@ */ - 0, /* @tp_setattr@ */ - 0, /* @tp_compare@ */ - 0, /* @tp_repr@ */ - 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - 0, /* @tp_as_mapping@ */ - 0, /* @tp_hash@ */ - 0, /* @tp_call@ */ - 0, /* @tp_str@ */ - 0, /* @tp_getattro@ */ - 0, /* @tp_setattro@ */ - 0, /* @tp_as_buffer@ */ - Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ - Py_TPFLAGS_BASETYPE, +static PyObject *keydatastruct_gmentrykey(PyObject *me, void *e) + { key_struct *ks = e; return (TEXT_FROMSTR(SYM_NAME(ks))); } - /* @tp_doc@ */ -"Iterator for structured keys.", +static PyObject *keydatastruct_gmentryvalue(PyObject *me, void *e) +{ + key_struct *ks = e; + key_data *kd = ks->k; - 0, /* @tp_traverse@ */ - 0, /* @tp_clear@ */ - 0, /* @tp_richcompare@ */ - 0, /* @tp_weaklistoffset@ */ - PyObject_SelfIter, /* @tp_iter@ */ - subkeyiter_next, /* @tp_iternext@ */ - 0, /* @tp_methods@ */ - 0, /* @tp_members@ */ - 0, /* @tp_getset@ */ - 0, /* @tp_base@ */ - 0, /* @tp_dict@ */ - 0, /* @tp_descr_get@ */ - 0, /* @tp_descr_set@ */ - 0, /* @tp_dictoffset@ */ - 0, /* @tp_init@ */ - PyType_GenericAlloc, /* @tp_alloc@ */ - abstract_pynew, /* @tp_new@ */ - 0, /* @tp_free@ */ - 0 /* @tp_is_gc@ */ -}; + key_incref(kd); + return (keydata_pywrap(kd)); +} -static PyObject *keydatastruct_pynew(PyTypeObject *ty, - PyObject *arg, PyObject *kw) +static key_struct *maybe_split_and_reprobe(PyObject *me, key_struct *ks) { - PyObject *sub = 0; - PyObject *it = 0, *name = 0, *val = 0; - char *p; - keydata_pyobj *me = 0; - key_data *kd = 0; - static char *kwlist[] = { "subkeys", 0 }; + key_data *kd = KEYDATA_KD(me); - Py_INCREF(arg); Py_INCREF(kw); - if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", kwlist, &sub)) - goto end; - kd = key_newstruct(); - if (sub) { - if (!PyMapping_Check(sub)) - TYERR("subkeys must be an iterable mapping"); - if ((it = PyObject_GetIter(sub)) == 0) - goto end; - while ((name = PyIter_Next(it)) != 0) { - if ((p = PyString_AsString(name)) == 0 || - (val = PyObject_GetItem(sub, name)) == 0) - goto end; - if (!KEYDATA_PYCHECK(val)) - TYERR("subkey objects must be subclasses of KeyData"); - key_structset(kd, p, KEYDATA_KD(val)); - Py_DECREF(name); name = 0; - Py_DECREF(val); val = 0; - } - if (PyErr_Occurred()) - goto end; - Py_DECREF(it); it = 0; - } - me = (keydata_pyobj *)ty->tp_alloc(ty, 0); - me->kd = kd; -end: - if (kd && !me) key_drop(kd); - Py_XDECREF(name); Py_XDECREF(val); Py_XDECREF(it); - Py_XDECREF(arg); Py_XDECREF(kw); - return ((PyObject *)me); + if (kd->ref == 1) return (ks); + key_split(&kd); KEYDATA_KD(me) = kd; + ks = sym_find(&kd->u.s, SYM_NAME(ks), SYM_LEN(ks), 0, 0); assert(ks); + return (ks); } -static PyObject *keydatastruct_pylookup(PyObject *me, PyObject *key) +static int keydatastruct_gmsetentry(PyObject *me, void *e, PyObject *val) { - const char *tag; + key_struct *ks; key_data *kd; - PyObject *rc = 0; + int rc = -1; - if ((tag = PyString_AsString(key)) == 0) - goto end; - if ((kd = key_structfind(KEYDATA_KD(me), tag)) == 0) - INDEXERR(key); - key_incref(kd); - rc = keydata_pywrap(kd); + if (!KEYDATA_PYCHECK(val)) TYERR("expected KeyData value"); + ks = maybe_split_and_reprobe(me, e); + if (ks->k) key_drop(ks->k); + ks->k = kd = KEYDATA_KD(val); key_incref(kd); + rc = 0; end: return (rc); } -static int keydatastruct_pystore(PyObject *me, - PyObject *key, PyObject *value) +static int keydatastruct_gmdelentry(PyObject *me, void *e) { - const char *tag; + key_struct *ks; + + ks = maybe_split_and_reprobe(me, e); + if (ks->k) key_drop(ks->k); + sym_remove(&KEYDATA_KD(me)->u.s, ks); + return (0); +} + +static const gmap_ops keydatastruct_gmops = { + sizeof(sym_iter), + keydatastruct_gmlookup, + keydatastruct_gmiterinit, + keydatastruct_gmiternext, + keydatastruct_gmentrykey, + keydatastruct_gmentryvalue, + keydatastruct_gmsetentry, + keydatastruct_gmdelentry +}; + +static int populate_struct(key_data *kd, PyObject *map) +{ + PyObject *it = 0, *name = 0, *val = 0; + const char *p; int rc = -1; - if ((tag = PyString_AsString(key)) == 0) - goto end; - if (value) { - if (!KEYDATA_PYCHECK(value)) - TYERR("expected KeyData value"); - key_structset(KEYDATA_KD(me), tag, KEYDATA_KD(value)); - } else { - if (!key_structfind(KEYDATA_KD(me), tag)) - INDEXERR(key); - key_structset(KEYDATA_KD(me), tag, 0); + if (!PyMapping_Check(map)) TYERR("subkeys must be an iterable mapping"); + if ((it = PyObject_GetIter(map)) == 0) goto end; + while ((name = PyIter_Next(it)) != 0) { + if ((p = TEXT_STR(name)) == 0 || + (val = PyObject_GetItem(map, name)) == 0) + goto end; + if (!KEYDATA_PYCHECK(val)) + TYERR("subkey objects must be instances of KeyData"); + if (key_structfind(kd, p)) VALERR("duplicate tag"); + key_structset(kd, p, KEYDATA_KD(val)); + Py_DECREF(name); name = 0; + Py_DECREF(val); val = 0; } + if (PyErr_Occurred()) goto end; rc = 0; end: + Py_XDECREF(it); Py_XDECREF(name); Py_XDECREF(val); return (rc); } -static PyMappingMethods keydatastruct_pymapping = { - 0, /* @mp_length@ */ - keydatastruct_pylookup, /* @mp_subscript@ */ - keydatastruct_pystore, /* @mp_ass_subscript@ */ +static PyObject *keydatastruct_pynew(PyTypeObject *ty, + PyObject *arg, PyObject *kw) +{ + PyObject *sub = 0; + keydata_pyobj *me = 0; + key_data *kd = 0; + + if (!PyArg_ParseTuple(arg, "|O:new", &sub)) goto end; + kd = key_newstruct(); + if (sub && populate_struct(kd, sub)) goto end; + if (kw && populate_struct(kd, kw)) goto end; + me = (keydata_pyobj *)ty->tp_alloc(ty, 0); + me->gmops = &keydatastruct_gmops; + me->kd = kd; kd = 0; +end: + if (kd) key_drop(kd); + return ((PyObject *)me); +} + +static Py_ssize_t keydatastruct_pysize(PyObject *me) + { return gmap_pysize_from_sym(&KEYDATA_KD(me)->u.s); } + +static const PyMappingMethods keydatastruct_pymapping = { + keydatastruct_pysize, + gmap_pylookup, + gmap_pystore }; -static PyTypeObject keydatastruct_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyDataStructured", /* @tp_name@ */ +static const PyTypeObject keydatastruct_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyDataStructured", /* @tp_name@ */ sizeof(keydata_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -1130,8 +1082,8 @@ static PyTypeObject keydatastruct_pytype_skel = { 0, /* @tp_compare@ */ 0, /* @tp_repr@ */ 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - &keydatastruct_pymapping, /* @tp_as_mapping@ */ + PYSEQUENCE(gmap), /* @tp_as_sequence@ */ + PYMAPPING(keydatastruct), /* @tp_as_mapping@ */ 0, /* @tp_hash@ */ 0, /* @tp_call@ */ 0, /* @tp_str@ */ @@ -1142,15 +1094,15 @@ static PyTypeObject keydatastruct_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key data for structured keys.", + "KeyDataStructured([subkeys = []]): key data for structured keys.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ 0, /* @tp_richcompare@ */ 0, /* @tp_weaklistoffset@ */ - subkeyiter_make, /* @tp_iter@ */ + gmap_pyiter, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - 0, /* @tp_methods@ */ + PYMETHODS(gmap), /* @tp_methods@ */ 0, /* @tp_members@ */ 0, /* @tp_getset@ */ 0, /* @tp_base@ */ @@ -1167,125 +1119,78 @@ static PyTypeObject keydatastruct_pytype_skel = { /*----- Key attributes ----------------------------------------------------*/ -static PyObject *keyattriter_make(PyObject *kaobj) +static void *keyattrs_gmlookup(PyObject *me, PyObject *k, unsigned *f) { - PyObject *kobj = KEYATTRS_KOBJ(kaobj); - keyattriter_pyobj *me = PyObject_NEW(keyattriter_pyobj, - keyattriter_pytype); - me->kobj = kobj; - Py_INCREF(kobj); - key_mkattriter(&me->i, KEY_K(kobj)); - return ((PyObject *)me); -} + char *name = TEXT_STR(k); + key_attr *a = 0; -static PyObject *keyattriter_next(PyObject *me) -{ - const char *name; - - if (!key_nextattr(KEYATTRITER_I(me), &name, 0)) - return (0); - return (PyString_FromString(name)); + if (!name) goto end; + if (f && !(KEYATTRS_KF(me)->f&KF_WRITE)) KEYERR(KERR_READONLY); + a = sym_find(&KEYATTRS_K(me)->a, name, -1, f ? sizeof(key_attr) : 0, f); + if (f && !*f) a->p = 0; +end: + return (a); } -static void keyattriter_pydealloc(PyObject *me) -{ - Py_DECREF(KEYATTRITER_KOBJ(me)); - FREEOBJ(me); -} +static void keyattrs_gmiterinit(PyObject *me, void *i) + { sym_mkiter(i, &KEYATTRS_K(me)->a); } -static PyTypeObject keyattriter_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyAttributeIter", /* @tp_name@ */ - sizeof(keyattriter_pyobj), /* @tp_basicsize@ */ - 0, /* @tp_itemsize@ */ +static void *keyattrs_gmiternext(PyObject *me, void *i) + { return (sym_next(i)); } - keyattriter_pydealloc, /* @tp_dealloc@ */ - 0, /* @tp_print@ */ - 0, /* @tp_getattr@ */ - 0, /* @tp_setattr@ */ - 0, /* @tp_compare@ */ - 0, /* @tp_repr@ */ - 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - 0, /* @tp_as_mapping@ */ - 0, /* @tp_hash@ */ - 0, /* @tp_call@ */ - 0, /* @tp_str@ */ - 0, /* @tp_getattro@ */ - 0, /* @tp_setattro@ */ - 0, /* @tp_as_buffer@ */ - Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ - Py_TPFLAGS_BASETYPE, +static PyObject *keyattrs_gmentrykey(PyObject *me, void *e) + { return (TEXT_FROMSTR(SYM_NAME(e))); } - /* @tp_doc@ */ -"Iterator for key attributes.", +static PyObject *keyattrs_gmentryvalue(PyObject *me, void *e) + { return (TEXT_FROMSTR(((key_attr *)e)->p)); } - 0, /* @tp_traverse@ */ - 0, /* @tp_clear@ */ - 0, /* @tp_richcompare@ */ - 0, /* @tp_weaklistoffset@ */ - PyObject_SelfIter, /* @tp_iter@ */ - keyattriter_next, /* @tp_iternext@ */ - 0, /* @tp_methods@ */ - 0, /* @tp_members@ */ - 0, /* @tp_getset@ */ - 0, /* @tp_base@ */ - 0, /* @tp_dict@ */ - 0, /* @tp_descr_get@ */ - 0, /* @tp_descr_set@ */ - 0, /* @tp_dictoffset@ */ - 0, /* @tp_init@ */ - PyType_GenericAlloc, /* @tp_alloc@ */ - abstract_pynew, /* @tp_new@ */ - 0, /* @tp_free@ */ - 0 /* @tp_is_gc@ */ -}; - -static PyObject *keyattrs_pylookup(PyObject *me, PyObject *key) +static int keyattrs_gmsetentry(PyObject *me, void *e, PyObject *val) { - const char *attr; - const char *value; - PyObject *rc = 0; + key_attr *a = e; + const char *p; + Py_ssize_t n; + int rc = -1; - if ((attr = PyString_AsString(key)) == 0) - goto end; - if ((value = key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr)) == 0) - INDEXERR(key); - rc = PyString_FromString(value); + if (!TEXT_CHECK(val)) TYERR("expected string"); + TEXT_PTRLEN(val, p, n); + if (n > 255) VALERR("attribute too long"); + if (memchr(p, 0, n)) VALERR("attribute must not contain nul"); + if (a->p) xfree(a->p); + a->p = xmalloc(n + 1); memcpy(a->p, p, n + 1); + KEYATTRS_KF(me)->f |= KF_MODIFIED; + rc = 0; end: return (rc); } -static int keyattrs_pystore(PyObject *me, - PyObject *key, PyObject *value) +static int keyattrs_gmdelentry(PyObject *me, void *e) { - const char *attr; - const char *val; - int err; + key_attr *a = e; int rc = -1; - if ((attr = PyString_AsString(key)) == 0) - goto end; - if (value) { - if ((val = PyString_AsString(value)) == 0) - goto end; - if ((err = key_putattr(KEYATTRS_KF(me), KEYATTRS_K(me), - attr, val)) != 0) - KEYERR(err); - } else { - if (!key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr)) - INDEXERR(key); - if ((err = key_putattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr, 0)) != 0) - KEYERR(err); - } + if (!(KEYATTRS_KF(me)->f&KF_WRITE)) KEYERR(KERR_READONLY); + if (a->p) { KEYATTRS_KF(me)->f |= KF_MODIFIED; xfree(a->p); } + sym_remove(&KEYATTRS_K(me)->a, a); rc = 0; end: return (rc); } +static const gmap_ops keyattrs_gmops = { + sizeof(sym_iter), + keyattrs_gmlookup, + keyattrs_gmiterinit, + keyattrs_gmiternext, + keyattrs_gmentrykey, + keyattrs_gmentryvalue, + keyattrs_gmsetentry, + keyattrs_gmdelentry +}; + static PyObject *keyattrs_make(PyObject *kobj) { keyattrs_pyobj *me = PyObject_NEW(keyattrs_pyobj, keyattrs_pytype); + me->gmops = &keyattrs_gmops; me->kobj = kobj; Py_INCREF(kobj); return ((PyObject *)me); @@ -1297,15 +1202,18 @@ static void keyattrs_pydealloc(PyObject *me) FREEOBJ(me); } -static PyMappingMethods keyattrs_pymapping = { - 0, - keyattrs_pylookup, - keyattrs_pystore +static Py_ssize_t keyattrs_pysize(PyObject *me) + { return gmap_pysize_from_sym(&KEYATTRS_K(me)->a); } + +static const PyMappingMethods keyattrs_pymapping = { + keyattrs_pysize, + gmap_pylookup, + gmap_pystore }; -static PyTypeObject keyattrs_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyAttributes", /* @tp_name@ */ +static const PyTypeObject keyattrs_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyAttributes", /* @tp_name@ */ sizeof(keyattrs_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -1316,8 +1224,8 @@ static PyTypeObject keyattrs_pytype_skel = { 0, /* @tp_compare@ */ 0, /* @tp_repr@ */ 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - &keyattrs_pymapping, /* @tp_as_mapping@ */ + PYSEQUENCE(gmap), /* @tp_as_sequence@ */ + PYMAPPING(keyattrs), /* @tp_as_mapping@ */ 0, /* @tp_hash@ */ 0, /* @tp_call@ */ 0, /* @tp_str@ */ @@ -1328,15 +1236,15 @@ static PyTypeObject keyattrs_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Proxy thing for talking about key attributes.", + "Proxy thing for talking about key attributes.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ 0, /* @tp_richcompare@ */ 0, /* @tp_weaklistoffset@ */ - keyattriter_make, /* @tp_iter@ */ + gmap_pyiter, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - 0, /* @tp_methods@ */ + PYMETHODS(gmap), /* @tp_methods@ */ 0, /* @tp_members@ */ 0, /* @tp_getset@ */ 0, /* @tp_base@ */ @@ -1370,16 +1278,17 @@ static PyObject *key_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) PyObject *kfobj; uint32 id; char *type; - long exptime = KEXP_FOREVER; - static char *kwlist[] = { "keyfile", "id", "type", "exptime", 0 }; + unsigned long exptime = KEXP_FOREVER; + static const char *const kwlist[] = + { "keyfile", "id", "type", "exptime", 0 }; key *k; int err; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&sl:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&s|O&:new", KWLIST, keyfile_pytype, &kfobj, convu32, &id, - &type, &exptime)) + &type, convulong, &exptime)) goto end; - if ((err = key_new(KEYFILE_KF(kfobj), id, type, exptime, &k)) == 0) + if ((err = key_new(KEYFILE_KF(kfobj), id, type, exptime, &k)) != 0) KEYERR(err); return (key_dowrap(ty, kfobj, k)); end: @@ -1392,22 +1301,35 @@ static void key_pydealloc(PyObject *me) FREEOBJ(me); } -static PyObject *kmeth_delete(PyObject *me, PyObject *arg) +static Py_hash_t key_pyhash(PyObject *me) + { return ((Py_hash_t)KEY_K(me)); } + +static PyObject *key_pyrichcompare(PyObject *me, PyObject *you, int op) +{ + if (!KEY_PYCHECK(you)) RETURN_NOTIMPL; + switch (op) { + case Py_EQ: return (getbool(KEY_K(me) == KEY_K(you))); + case Py_NE: return (getbool(KEY_K(me) == KEY_K(you))); + default: TYERR("ordering makes no sense"); + } +end: + return (0); +} + +static PyObject *kmeth_delete(PyObject *me) { int err; - - if (!PyArg_ParseTuple(arg, ":delete")) goto end; + if ((err = key_delete(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err); RETURN_ME; end: return (0); } -static PyObject *kmeth_expire(PyObject *me, PyObject *arg) +static PyObject *kmeth_expire(PyObject *me) { int err; - - if (!PyArg_ParseTuple(arg, ":expire")) goto end; + if ((err = key_expire(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err); RETURN_ME; end: @@ -1418,7 +1340,7 @@ static PyObject *kmeth_used(PyObject *me, PyObject *arg) { long t; int err; - + if (!PyArg_ParseTuple(arg, "l:used", &t)) goto end; if ((err = key_used(KEY_KF(me), KEY_K(me), t)) != 0) KEYERR(err); RETURN_ME; @@ -1426,27 +1348,21 @@ end: return (0); } -static PyObject *kmeth_extract(PyObject *me, PyObject *arg, PyObject *kw) +static PyObject *kmeth_extractline(PyObject *me, PyObject *arg, PyObject *kw) { key_filter f = { 0, 0 }; - PyObject *file; - PyObject *nameobj; - char *name; - FILE *fp; - static char *kwlist[] = { "file", "filter", 0 }; - - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", kwlist, - &PyFile_Type, &file, - convfilter, &f) || - (fp = PyFile_AsFile(file)) == 0 || - (nameobj = PyFile_Name(file)) == 0 || - (name = PyString_AsString(nameobj)) == 0) + dstr d = DSTR_INIT; + PyObject *rc = 0; + static const char *const kwlist[] = { "filter", 0 }; + + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:extract", KWLIST, + convfilter, &f)) goto end; - if (key_extract(KEY_KF(me), KEY_K(me), fp, &f)) - OSERR(name); - RETURN_ME; + key_extractline(KEY_KF(me), KEY_K(me), &d, &f); + rc = TEXT_FROMSTRLEN(d.buf, d.len); end: - return (0); + dstr_destroy(&d); + return (rc); } static PyObject *kmeth_fingerprint(PyObject *me, @@ -1454,27 +1370,65 @@ static PyObject *kmeth_fingerprint(PyObject *me, { ghash *h; key_filter f = { KF_NONSECRET, KF_NONSECRET }; - static char *kwlist[] = { "hash", "filter", 0 }; + static const char *const kwlist[] = { "hash", "filter", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:fingerprint", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:fingerprint", KWLIST, convghash, &h, convfilter, &f)) return (0); return (getbool(key_fingerprint(KEY_K(me), h, &f))); } static PyObject *kget_id(PyObject *me, void *hunoz) - { return (getu32(KEY_K(me)->id)); } + { return (getulong(KEY_K(me)->id)); } +static PyObject *kget_file(PyObject *me, void *hunoz) + { RETURN_OBJ(KEY_KFOBJ(me)); } static PyObject *kget_type(PyObject *me, void *hunoz) - { return (PyString_FromString(KEY_K(me)->type)); } + { return (TEXT_FROMSTR(KEY_K(me)->type)); } static PyObject *kget_exptime(PyObject *me, void *hunoz) - { return (PyInt_FromLong(KEY_K(me)->exp)); } + { return (getulong(KEY_K(me)->exp)); } static PyObject *kget_deltime(PyObject *me, void *hunoz) - { return (PyInt_FromLong(KEY_K(me)->del)); } + { return (getulong(KEY_K(me)->del)); } static PyObject *kget_expiredp(PyObject *me, void *hunoz) { return (getbool(key_expired(KEY_K(me)))); } static PyObject *kget_attr(PyObject *me, void *hunoz) { return (keyattrs_make(me)); } +static int kset_exptime(PyObject *me, PyObject *x, void *hunoz) +{ + key *k = KEY_K(me); + unsigned long et; + + if (!x) NIERR("__del__"); + if (!convulong(x, &et)) + goto end; + if (!(KEY_KF(me)->f & KF_WRITE)) + KEYERR(KERR_READONLY); + k->exp = et; + KEY_KF(me)->f |= KF_MODIFIED; + return (0); +end: + return (-1); +} + +static int kset_deltime(PyObject *me, PyObject *x, void *hunoz) +{ + key *k = KEY_K(me); + unsigned long dt; + + if (!x) NIERR("__del__"); + if (!convulong(x, &dt)) + goto end; + if (dt == KEXP_FOREVER && k->exp != KEXP_FOREVER) + VALERR("key will eventually expire"); + if (!(KEY_KF(me)->f & KF_WRITE)) + KEYERR(KERR_READONLY); + k->del = dt; + KEY_KF(me)->f |= KF_MODIFIED; + return (0); +end: + return (-1); +} + static PyObject *kget_data(PyObject *me, void *hunoz) { key_data *kd = KEY_K(me)->k; @@ -1484,6 +1438,8 @@ static PyObject *kget_data(PyObject *me, void *hunoz) static int kset_data(PyObject *me, PyObject *x, void *hunoz) { int err; + + if (!x) NIERR("__del__"); if (!KEYDATA_PYCHECK(x)) TYERR("expected KeyData object"); if ((err = key_setkeydata(KEY_KF(me), KEY_K(me), KEYDATA_KD(x))) != 0) KEYERR(err); @@ -1498,7 +1454,7 @@ static PyObject *kget_fulltag(PyObject *me, void *hunoz) PyObject *rc; key_fulltag(KEY_K(me), &d); - rc = PyString_FromStringAndSize(d.buf, d.len); + rc = TEXT_FROMSTRLEN(d.buf, d.len); dstr_destroy(&d); return (rc); } @@ -1506,15 +1462,15 @@ static PyObject *kget_fulltag(PyObject *me, void *hunoz) static PyObject *kget_tag(PyObject *me, void *hunoz) { if (!KEY_K(me)->tag) RETURN_NONE; - return (PyString_FromString(KEY_K(me)->tag)); + return (TEXT_FROMSTR(KEY_K(me)->tag)); } static int kset_tag(PyObject *me, PyObject *x, void *hunoz) { int err; char *tag; - if (x == Py_None) tag = 0; - else if ((tag = PyString_AsString(x)) == 0) goto end; + if (!x || x == Py_None) tag = 0; + else if ((tag = TEXT_STR(x)) == 0) goto end; if ((err = key_settag(KEY_KF(me), KEY_K(me), tag)) != 0) KEYERR(err); return (0); end: @@ -1524,39 +1480,40 @@ end: static PyObject *kget_comment(PyObject *me, void *hunoz) { if (!KEY_K(me)->c) RETURN_NONE; - return (PyString_FromString(KEY_K(me)->c)); + return (TEXT_FROMSTR(KEY_K(me)->c)); } static int kset_comment(PyObject *me, PyObject *x, void *hunoz) { int err; char *c; - if (x == Py_None) c = 0; - else if ((c = PyString_AsString(x)) == 0) goto end; + if (!x || x == Py_None) c = 0; + else if ((c = TEXT_STR(x)) == 0) goto end; if ((err = key_setcomment(KEY_KF(me), KEY_K(me), c)) != 0) KEYERR(err); return (0); end: return (-1); } -static PyMethodDef key_pymethods[] = { +static const PyMethodDef key_pymethods[] = { #define METHNAME(func) kmeth_##func - METH (delete, "KEY.delete()") - METH (expire, "KEY.expire()") + NAMETH(delete, "KEY.delete()") + NAMETH(expire, "KEY.expire()") METH (used, "KEY.used(TIME)") - KWMETH(extract, "KEY.extract(FILE, filter = '')") - KWMETH(fingerprint, "KEY.fingerprint(HASH, filtr = '-secret')") + KWMETH(extractline, "KEY.extractline([filter = ])") + KWMETH(fingerprint, "KEY.fingerprint(HASH, [filter = '-secret'])") #undef METHNAME { 0 } }; -static PyGetSetDef key_pygetset[] = { +static const PyGetSetDef key_pygetset[] = { #define GETSETNAME(op, name) k##op##_##name + GET (file, "KEY.file -> KF") GET (id, "KEY.id -> ID") GETSET(tag, "KEY.tag -> TAG") GET (type, "KEY.type -> TYPE") - GET (exptime, "KEY.exptime -> TIME") - GET (deltime, "KEY.deltime -> TIME") + GETSET(exptime, "KEY.exptime -> TIME") + GETSET(deltime, "KEY.deltime -> TIME") GET (expiredp, "KEY.expiredp -> BOOL") GET (attr, "KEY.attr -> ATTRIBUTES") GETSET(data, "KEY.data -> KD") @@ -1566,9 +1523,9 @@ static PyGetSetDef key_pygetset[] = { { 0 } }; -static PyTypeObject key_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.Key", /* @tp_name@ */ +static const PyTypeObject key_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "Key", /* @tp_name@ */ sizeof(key_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -1581,7 +1538,7 @@ static PyTypeObject key_pytype_skel = { 0, /* @tp_as_number@ */ 0, /* @tp_as_sequence@ */ 0, /* @tp_as_mapping@ */ - 0, /* @tp_hash@ */ + key_pyhash, /* @tp_hash@ */ 0, /* @tp_call@ */ 0, /* @tp_str@ */ 0, /* @tp_getattro@ */ @@ -1591,17 +1548,17 @@ static PyTypeObject key_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Key object.", + "Key(KF, ID, TYPE, [exptime = KEXP_FOREVER]): key object.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ - 0, /* @tp_richcompare@ */ + key_pyrichcompare, /* @tp_richcompare@ */ 0, /* @tp_weaklistoffset@ */ 0, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - key_pymethods, /* @tp_methods@ */ + PYMETHODS(key), /* @tp_methods@ */ 0, /* @tp_members@ */ - key_pygetset, /* @tp_getset@ */ + PYGETSET(key), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -1614,81 +1571,51 @@ static PyTypeObject key_pytype_skel = { 0 /* @tp_is_gc@ */ }; -/*----- Key iteration -----------------------------------------------------*/ - -static PyObject *keyiter_new(PyObject *kfobj) -{ - keyiter_pyobj *me = PyObject_NEW(keyiter_pyobj, keyiter_pytype); - key_mkiter(&me->i, KEYFILE_KF(kfobj)); - me->kfobj = kfobj; - Py_INCREF(kfobj); - return ((PyObject *)me); -} +/*----- Key files ---------------------------------------------------------*/ -static PyObject *keyiter_next(PyObject *me) +static key *bytag(PyObject *me, PyObject *tagobj) { - key *k; + uint32 id; + char *tag; + key *k = 0; - if ((k = key_next(KEYITER_I(me))) == 0) - return (0); - return (key_pywrap(KEYITER_KFOBJ(me), k)); + if (convu32(tagobj, &id)) + k = key_byid(KEYFILE_KF(me), id); + else { + PyErr_Clear(); + if ((tag = TEXT_STR(tagobj)) == 0) + goto end; + k = key_bytag(KEYFILE_KF(me), tag); + } +end: + return (k); } -static void keyiter_pydealloc(PyObject *me) -{ - Py_DECREF(KEYITER_KFOBJ(me)); - FREEOBJ(me); -} +static void *keyfile_gmlookup(PyObject *me, PyObject *k, unsigned *f) + { key *kk = bytag(me, k); if (f) *f = !!kk; return (kk); } -static PyTypeObject keyiter_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyFileIter", /* @tp_name@ */ - sizeof(keyiter_pyobj), /* @tp_basicsize@ */ - 0, /* @tp_itemsize@ */ +static void keyfile_gmiterinit(PyObject *me, void *i) + { key_mkiter(i, KEYFILE_KF(me)); } - keyiter_pydealloc, /* @tp_dealloc@ */ - 0, /* @tp_print@ */ - 0, /* @tp_getattr@ */ - 0, /* @tp_setattr@ */ - 0, /* @tp_compare@ */ - 0, /* @tp_repr@ */ - 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - 0, /* @tp_as_mapping@ */ - 0, /* @tp_hash@ */ - 0, /* @tp_call@ */ - 0, /* @tp_str@ */ - 0, /* @tp_getattro@ */ - 0, /* @tp_setattro@ */ - 0, /* @tp_as_buffer@ */ - Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ - Py_TPFLAGS_BASETYPE, +static void *keyfile_gmiternext(PyObject *me, void *i) + { return (key_next(i)); } - /* @tp_doc@ */ -"Keyring iterator.", +static PyObject *keyfile_gmentrykey(PyObject *me, void *e) + { key *k = e; return (getulong(k->id)); } - 0, /* @tp_traverse@ */ - 0, /* @tp_clear@ */ - 0, /* @tp_richcompare@ */ - 0, /* @tp_weaklistoffset@ */ - PyObject_SelfIter, /* @tp_iter@ */ - keyiter_next, /* @tp_iternext@ */ - 0, /* @tp_methods@ */ - 0, /* @tp_members@ */ - 0, /* @tp_getset@ */ - 0, /* @tp_base@ */ - 0, /* @tp_dict@ */ - 0, /* @tp_descr_get@ */ - 0, /* @tp_descr_set@ */ - 0, /* @tp_dictoffset@ */ - 0, /* @tp_init@ */ - PyType_GenericAlloc, /* @tp_alloc@ */ - abstract_pynew, /* @tp_new@ */ - 0, /* @tp_free@ */ - 0 /* @tp_is_gc@ */ -}; +static PyObject *keyfile_gmentryvalue(PyObject *me, void *e) + { return (key_pywrap(me, e)); } -/*----- Key files ---------------------------------------------------------*/ +static const gmap_ops keyfile_gmops = { + sizeof(key_iter), + keyfile_gmlookup, + keyfile_gmiterinit, + keyfile_gmiternext, + keyfile_gmentrykey, + keyfile_gmentryvalue, + 0, + 0 +}; struct reportinfo { PyObject *func; @@ -1703,7 +1630,7 @@ static void pythonreporter(const char *file, int line, if (ri->stop) return; - if (!ri->func) + if (ri->func == Py_None) key_moan(file, line, msg, 0); else if ((res = PyObject_CallFunction(ri->func, "sis", file, line, msg)) == 0) @@ -1715,20 +1642,20 @@ static void pythonreporter(const char *file, int line, static PyObject *keyfile_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) { - struct reportinfo ri = { 0, 0 }; + struct reportinfo ri = { Py_None, 0 }; char *file = 0; unsigned how = KOPEN_READ; keyfile_pyobj *rc = 0; - static char *kwlist[] = { "file", "how", "report", 0 }; + static const char *const kwlist[] = { "file", "how", "report", 0 }; - Py_XINCREF(arg); Py_XINCREF(kw); - if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|iO:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|iO:new", KWLIST, &file, &how, &ri.func)) goto end; - if (ri.func && !PyCallable_Check(ri.func)) + if (ri.func != Py_None && !PyCallable_Check(ri.func)) TYERR("reporter function not callable"); if ((rc = (keyfile_pyobj *)ty->tp_alloc(ty, 0)) == 0) goto end; + rc->gmops = &keyfile_gmops; if (key_open(&rc->kf, file, how, pythonreporter, &ri)) OSERR(file); if (ri.stop) { @@ -1743,7 +1670,6 @@ end: rc = 0; } done: - Py_XDECREF(arg); Py_XDECREF(kw); return ((PyObject *)rc); } @@ -1753,10 +1679,8 @@ static void keyfile_pydealloc(PyObject *me) FREEOBJ(me); } -static PyObject *kfmeth_save(PyObject *me, PyObject *arg) +static PyObject *kfmeth_save(PyObject *me) { - if (!PyArg_ParseTuple(arg, ":save")) - goto end; switch (key_save(KEYFILE_KF(me))) { case KWRITE_OK: RETURN_ME; @@ -1771,120 +1695,96 @@ end: return (0); } -static PyObject *kfmeth_merge(PyObject *me, PyObject *arg, PyObject *kw) +static PyObject *kfmeth_mergeline(PyObject *me, PyObject *arg, PyObject *kw) { - struct reportinfo ri = { 0, 0 }; - char *name; - PyObject *x = 0; - FILE *fp = 0; - int rc; - static char *kwlist[] = { "file", "report", 0 }; + struct reportinfo ri = { Py_None, 0 }; + const char *file, *line; + int lno, rc; + static const char *const kwlist[] = { "name", "lno", "line", "report", 0 }; - Py_XINCREF(arg); Py_XINCREF(kw); - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", kwlist, - &PyFile_Type, &x, &ri.func)) + if (!PyArg_ParseTupleAndKeywords(arg, kw, "sis|O:merge", KWLIST, + &file, &lno, &line, &ri.func)) goto end; - if (ri.func && !PyCallable_Check(ri.func)) + if (ri.func != Py_None && !PyCallable_Check(ri.func)) TYERR("reporter function not callable"); - if ((fp = PyFile_AsFile(x)) == 0) - goto end; - x = PyFile_Name(x); - if ((name = PyString_AsString(x)) == 0) - goto end; - rc = key_merge(KEYFILE_KF(me), name, fp, pythonreporter, &ri); + rc = key_mergeline(KEYFILE_KF(me), file, lno, line, pythonreporter, &ri); if (ri.stop) goto end; if (rc != 0) KEYERR(rc); - Py_XDECREF(arg); Py_XDECREF(kw); RETURN_ME; end: - Py_XDECREF(arg); Py_XDECREF(kw); return (0); } -static PyObject *kfmeth_byid(PyObject *me, PyObject *arg) +static PyObject *kfmeth_byid(PyObject *me, PyObject *arg, PyObject *kw) { uint32 id; key *k; + PyObject *failp = Py_True; PyObject *rc = 0; + static const char *const kwlist[] = { "id", "fail", 0 }; - if (!PyArg_ParseTuple(arg, "O&:byid", convu32, &id)) goto end; - if ((k = key_byid(KEYFILE_KF(me), id)) == 0) KEYERR(KERR_NOTFOUND); - rc = key_pywrap(me, k); + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O:byid", KWLIST, + convu32, &id, &failp)) + goto end; + if ((k = key_byid(KEYFILE_KF(me), id)) != 0) rc = key_pywrap(me, k); + else if (PyObject_IsTrue(failp)) KEYERR(KERR_NOTFOUND); + else RETURN_NONE; end: return (rc); } -static PyObject *kfmeth_bytype(PyObject *me, PyObject *arg) +static PyObject *kfmeth_bytype(PyObject *me, PyObject *arg, PyObject *kw) { char *type; key *k; + PyObject *failp = Py_True; PyObject *rc = 0; + static const char *const kwlist[] = { "type", "fail", 0 }; - if (!PyArg_ParseTuple(arg, "s:bytype", &type)) goto end; - if ((k = key_bytype(KEYFILE_KF(me), type)) == 0) RETURN_NONE; - rc = key_pywrap(me, k); + if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O:bytype", KWLIST, + &type, &failp)) + goto end; + if ((k = key_bytype(KEYFILE_KF(me), type)) != 0) rc = key_pywrap(me, k); + else if (PyObject_IsTrue(failp)) KEYERR(KERR_NOTFOUND); + else RETURN_NONE; end: return (rc); } -static PyObject *bytag(PyObject *me, PyObject *tagobj) +static PyObject *kfmeth_bytag(PyObject *me, PyObject *arg, PyObject *kw) { - uint32 id; - char *tag; + PyObject *tagobj; key *k; + PyObject *failp = Py_True; PyObject *rc = 0; + static const char *const kwlist[] = { "type", "fail", 0 }; - if (convu32(tagobj, &id)) - k = key_byid(KEYFILE_KF(me), id); - else { - PyErr_Clear(); - if ((tag = PyString_AsString(tagobj)) == 0) - goto end; - k = key_bytag(KEYFILE_KF(me), tag); - } - if (!k) RETURN_NONE; - rc = key_pywrap(me, k); + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O|O:bytag", KWLIST, + &tagobj, &failp)) + goto end; + if ((k = bytag(me, tagobj)) != 0) rc = key_pywrap(me, k); + else if (PyObject_IsTrue(failp)) KEYERR(KERR_NOTFOUND); + else RETURN_NONE; end: return (rc); } -static PyObject *kfmeth_bytag(PyObject *me, PyObject *arg) -{ - PyObject *tagobj; - - if (!PyArg_ParseTuple(arg, "O:bytag", &tagobj)) return (0); - return (bytag(me, tagobj)); -} - -static PyObject *keyfile_pylookup(PyObject *me, PyObject *key) -{ - PyObject *rc = bytag(me, key); - if (!rc) goto end; - if (rc == Py_None) { - Py_DECREF(rc); - rc = 0; - INDEXERR(key); - } -end: - return (rc); -} - static PyObject *kfmeth_newkey(PyObject *me, PyObject *arg, PyObject *kw) { uint32 id; char *type; long exptime = KEXP_FOREVER; - static char *kwlist[] = { "id", "type", "exptime", 0 }; + static const char *const kwlist[] = { "id", "type", "exptime", 0 }; key *k; int err; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&sl:new", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s|l:newkey", KWLIST, convu32, &id, &type, &exptime)) goto end; - if ((err = key_new(KEYFILE_KF(me), id, type, exptime, &k)) == 0) + if ((err = key_new(KEYFILE_KF(me), id, type, exptime, &k)) != 0) KEYERR(err); return (key_pywrap(me, k)); end: @@ -1899,9 +1799,9 @@ static PyObject *kfmeth_qtag(PyObject *me, PyObject *arg, PyObject *kw) char *tag; dstr d = DSTR_INIT; PyObject *rc = 0; - static char *kwlist[] = { "tag", "new", 0 }; + static const char *const kwlist[] = { "tag", "new", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O!:qtag", kwlist, + if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O!:qtag", KWLIST, &tag, keydata_pytype, &newkdobj)) goto end; if (key_qtag(KEYFILE_KF(me), tag, &d, &k, &kd)) @@ -1915,7 +1815,7 @@ static PyObject *kfmeth_qtag(PyObject *me, PyObject *arg, PyObject *kw) } key_incref(*kd); rc = Py_BuildValue("(s#NN)", - d.buf, d.len, + d.buf, (Py_ssize_t)d.len, key_pywrap(me, k), keydata_pywrap(okd)); end: @@ -1923,7 +1823,7 @@ end: } static PyObject *kfget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(KEYFILE_KF(me)->name)); } + { return (TEXT_FROMSTR(KEYFILE_KF(me)->name)); } static PyObject *kfget_modifiedp(PyObject *me, void *hunoz) { return (getbool(KEYFILE_KF(me)->f & KF_MODIFIED)); } static PyObject *kfget_writep(PyObject *me, void *hunoz) @@ -1931,20 +1831,23 @@ static PyObject *kfget_writep(PyObject *me, void *hunoz) static PyObject *kfget_filep(PyObject *me, void *hunoz) { return (getbool(!!KEYFILE_KF(me)->fp)); } -static PyMethodDef keyfile_pymethods[] = { +static const PyMethodDef keyfile_pymethods[] = { #define METHNAME(func) kfmeth_##func - METH (save, "KF.save()") - KWMETH(merge, "KF.merge(FILE, report = )") - KWMETH(newkey, "KF.newkey(ID, TYPE, exptime = KEXP_FOREVER) -> KEY") - METH (byid, "KF.byid(KEYID) -> KEY|None") - METH (bytype, "KF.bytype(TYPE) -> KEY|None") - METH (bytag, "KF.bytag(TAG) -> KEY|None") - KWMETH(qtag, "KF.qtag(TAG, new = KD) -> FULLTAG, KEY, OLDKD") + NAMETH(save, "KF.save()") + KWMETH(mergeline, "KF.mergeline(NAME, LNO, LINE, " + "[report = ])") + KWMETH(newkey, "KF.newkey(ID, TYPE, [exptime = KEXP_FOREVER]) " + "-> KEY") + KWMETH(byid, "KF.byid(KEYID, [fail = True]) -> KEY|None") + KWMETH(bytype, "KF.bytype(TYPE, [fail = True]) -> KEY|None") + KWMETH(bytag, "KF.bytag(TAG, [fail = True]) -> KEY|None") + KWMETH(qtag, "KF.qtag(TAG, [new = KD]) -> FULLTAG, KEY, OLDKD") + GMAP_ROMETHODS #undef METHNAME { 0 } }; -static PyGetSetDef keyfile_pygetset[] = { +static const PyGetSetDef keyfile_pygetset[] = { #define GETSETNAME(op, name) kf##op##_##name GET (name, "KF.name -> file name") GET (modifiedp, "KF.modifiedp -> has keyring been modified?") @@ -1954,15 +1857,15 @@ static PyGetSetDef keyfile_pygetset[] = { { 0 } }; -static PyMappingMethods keyfile_pymapping = { - 0, - keyfile_pylookup, +static const PyMappingMethods keyfile_pymapping = { + gmap_pysize, + gmap_pylookup, 0 }; -static PyTypeObject keyfile_pytype_skel = { - PyObject_HEAD_INIT(0) 0, /* Header */ - "catacomb.KeyFile", /* @tp_name@ */ +static const PyTypeObject keyfile_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KeyFile", /* @tp_name@ */ sizeof(keyfile_pyobj), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -1973,8 +1876,8 @@ static PyTypeObject keyfile_pytype_skel = { 0, /* @tp_compare@ */ 0, /* @tp_repr@ */ 0, /* @tp_as_number@ */ - 0, /* @tp_as_sequence@ */ - &keyfile_pymapping, /* @tp_as_mapping@ */ + PYSEQUENCE(gmap), /* @tp_as_sequence@ */ + PYMAPPING(keyfile), /* @tp_as_mapping@ */ 0, /* @tp_hash@ */ 0, /* @tp_call@ */ 0, /* @tp_str@ */ @@ -1985,17 +1888,18 @@ static PyTypeObject keyfile_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ -"Keyring file.", + "KeyFile(FILE, [how = KOPEN_READ], [report = ?]): Keyring file.\n" + " calls REPORT(FILE, LINE, MSG) on problems", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ 0, /* @tp_richcompare@ */ 0, /* @tp_weaklistoffset@ */ - keyiter_new, /* @tp_iter@ */ + gmap_pyiter, /* @tp_iter@ */ 0, /* @tp_iternext@ */ - keyfile_pymethods, /* @tp_methods@ */ + PYMETHODS(keyfile), /* @tp_methods@ */ 0, /* @tp_members@ */ - keyfile_pygetset, /* @tp_getset@ */ + PYGETSET(keyfile), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -2008,37 +1912,27 @@ static PyTypeObject keyfile_pytype_skel = { 0 /* @tp_is_gc@ */ }; -/*----- Global stuff ------------------------------------------------------*/ - -static PyObject *meth_barf(PyObject *me, PyObject *arg) -{ - int err; - - if (PyArg_ParseTuple(arg, "i:barf", &err)) - KEYERR(err); -end: - return (0); -} +/*----- Initialization ----------------------------------------------------*/ -static PyMethodDef methods[] = { -#define METHNAME(func) meth_##func - METH (_KeyData_readflags, - "KeyData.readflags(STRING) -> (FLAGS, MASK, REST)") - METH (_KeyData_writeflags, "KeyData.writeflags(FLAGS) -> STRING") - METH (_KeyData_read, "KeyData.read(STRING) -> (KD, REST)") - METH (_KeyData_decode, "KeyData.read(BYTES) -> KD") - METH (barf, "barf(ERR)") -#undef METHNAME +static const struct nameval consts[] = { + CONST(KOPEN_READ), CONST(KOPEN_WRITE), CONST(KOPEN_NOFILE), + CONSTFLAG(0, KEXP_FOREVER), CONSTFLAG(0, KEXP_EXPIRE), + CONST(KF_ENCMASK), CONST(KENC_BINARY), CONST(KENC_MP), CONST(KENC_STRUCT), + CONST(KENC_ENCRYPT), CONST(KENC_STRING), CONST(KENC_EC), + CONST(KF_CATMASK), CONST(KCAT_SYMM), CONST(KCAT_PRIV), CONST(KCAT_PUB), + CONST(KCAT_SHARE), + CONST(KF_NONSECRET), + CONST(KF_BURN), CONST(KF_OPT), +#define ENTRY(tag, val, str) CONST(KERR_##tag), + KEY_ERRORS(ENTRY) +#undef ENTRY { 0 } }; -/*----- Initialization ----------------------------------------------------*/ - void key_pyinit(void) { INITTYPE(keyfile, root); INITTYPE(key, root); - INITTYPE(keyiter, root); INITTYPE(keydata, root); INITTYPE(keydatabin, keydata); INITTYPE(keydataenc, keydata); @@ -2046,10 +1940,7 @@ void key_pyinit(void) INITTYPE(keydatamp, keydata); INITTYPE(keydataec, keydata); INITTYPE(keydatastruct, keydata); - INITTYPE(subkeyiter, root); INITTYPE(keyattrs, root); - INITTYPE(keyattriter, root); - addmethods(methods); } void key_pyinsert(PyObject *mod) @@ -2058,10 +1949,8 @@ void key_pyinsert(PyObject *mod) INSEXC("KeyFileIOError", keyioexc, PyExc_OSError, 0); INSEXC("KeyFileBroken", keyfilebrokenexc, keyioexc, 0); INSERT("KeyFile", keyfile_pytype); - INSERT("KeyFileIter", keyiter_pytype); INSERT("Key", key_pytype); INSERT("KeyAttributes", keyattrs_pytype); - INSERT("KeyAttributeIter", keyattriter_pytype); INSERT("KeyData", keydata_pytype); INSERT("KeyDataBinary", keydatabin_pytype); INSERT("KeyDataEncrypted", keydataenc_pytype); @@ -2069,7 +1958,7 @@ void key_pyinsert(PyObject *mod) INSERT("KeyDataECPt", keydataec_pytype); INSERT("KeyDataString", keydatastr_pytype); INSERT("KeyDataStructured", keydatastruct_pytype); - INSERT("SubKeyIter", subkeyiter_pytype); + setconstants(mod, consts); } /*----- That's all, folks -------------------------------------------------*/