if (PyObject_SetAttrString(me, "err", x)) goto end;
Py_DECREF(x); x = 0;
- x = PyString_FromString(key_strerror(err)); if (!x) goto end;
+ x = TEXT_FROMSTR(key_strerror(err)); if (!x) goto end;
if (PyObject_SetAttrString(me, "errstring", x)) goto end;
Py_DECREF(x); x = 0;
if (err >= 0 && err < N(tab)) errtag = tab[err];
else errtag = "<unknown>";
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 }
};
/*----- Data structures ---------------------------------------------------*/
typedef struct keydata_pyobj {
- PyObject_HEAD
+ GMAP_PYOBJ_HEAD
key_data *kd;
} keydata_pyobj;
#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;
#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;
#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)
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)
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)
return (rc);
}
-static PyObject *meth__KeyData_readflags(PyObject *me, PyObject *arg)
+static PyObject *kdmeth_readflags(PyObject *me, PyObject *arg)
{
const char *p;
char *end;
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);
+ 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);
}
return (getbool(KEY_MATCH(KEYDATA_KD(me), &f)));
}
-static PyObject *kdmeth_split(PyObject *me, PyObject *arg)
-{
- if (!PyArg_ParseTuple(arg, ":split"))
- return (0);
- key_split(&KEYDATA_KD(me));
- RETURN_ME;
-}
+static PyObject *kdmeth_split(PyObject *me)
+ { key_split(&KEYDATA_KD(me)); RETURN_ME; }
static PyObject *kdmeth_copy(PyObject *me, PyObject *arg, PyObject *kw)
{
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);
}
static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t 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;
- Py_ssize_t 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 (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 = <any>]) -> STRING")
- KWMETH(encode, "KD.encode([filter = <any>]) -> BYTES")
- KWMETH(copy, "KD.copy([filter = <any>]) -> KD")
- 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 = <any>]) -> STRING")
+ KWMETH(encode, "KD.encode([filter = <any>]) -> BYTES")
+ KWMETH(copy, "KD.copy([filter = <any>]) -> 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 */
+static const PyTypeObject keydata_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyData", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data base class.",
+ "Key data base class.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
static PyObject *keydatabin_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t n;
+ struct bin in;
unsigned f = 0;
keydata_pyobj *me = 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);
}
{ 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 */
+static const PyTypeObject keydatabin_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataBinary", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataBinary(KEY, [flags = 0]): key data for binary keys.",
+ "KeyDataBinary(KEY, [flags = 0]): key data for binary keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
static PyObject *keydataenc_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t n;
+ struct bin in;
unsigned f = 0;
keydata_pyobj *me = 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);
}
static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
{
- char *hunoz;
- Py_ssize_t 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);
static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t 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:
#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 */
+static const PyTypeObject keydataenc_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataEncrypted", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataEncrypted(KEY, [flags = 0]): key data for encrypted keys.",
+ "KeyDataEncrypted(KEY, [flags = 0]): key data for encrypted keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
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 */
+static const PyTypeObject keydatamp_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataMP", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataMP(KEY, [flags = 0]): key data for large-integer keys.",
+ "KeyDataMP(KEY, [flags = 0]): key data for large-integer keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
}
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 */
+static const PyTypeObject keydatastr_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataString", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataString(KEY, [flags = 0]): key data for string keys.",
+ "KeyDataString(KEY, [flags = 0]): key data for string keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
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 */
+static const PyTypeObject keydataec_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataECPt", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataECPt(KEY, [flags = 0]): key data for elliptic-curve keys.",
+ "KeyDataECPt(KEY, [flags = 0]): key data for elliptic-curve keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
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@ */
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_pynext(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 */
- "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_pynext, /* @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 const char *const kwlist[] = { "subkeys", 0 };
+ key_data *kd = KEYDATA_KD(me);
- Py_XINCREF(arg); Py_XINCREF(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;
- key_split(&KEYDATA_KD(me));
- 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 = {
- gmap_pysize, /* @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 */
+static const PyTypeObject keydatastruct_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyDataStructured", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyDataStructured([subkeys = []]): 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@ */
- gmap_pymethods, /* @tp_methods@ */
+ PYMETHODS(gmap), /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
/*----- Key attributes ----------------------------------------------------*/
-static PyObject *keyattriter_make(PyObject *kaobj)
-{
- 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);
-}
-
-static PyObject *keyattriter_pynext(PyObject *me)
+static void *keyattrs_gmlookup(PyObject *me, PyObject *k, unsigned *f)
{
- const char *name;
+ char *name = TEXT_STR(k);
+ key_attr *a = 0;
- 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 */
- "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,
-
- /* @tp_doc@ */
-"Iterator for key attributes.",
+static PyObject *keyattrs_gmentrykey(PyObject *me, void *e)
+ { return (TEXT_FROMSTR(SYM_NAME(e))); }
- 0, /* @tp_traverse@ */
- 0, /* @tp_clear@ */
- 0, /* @tp_richcompare@ */
- 0, /* @tp_weaklistoffset@ */
- PyObject_SelfIter, /* @tp_iter@ */
- keyattriter_pynext, /* @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_gmentryvalue(PyObject *me, void *e)
+ { return (TEXT_FROMSTR(((key_attr *)e)->p)); }
-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);
FREEOBJ(me);
}
-static PyMappingMethods keyattrs_pymapping = {
- gmap_pysize, /* @mp_length@ */
- keyattrs_pylookup, /* @mp_subscript@ */
- keyattrs_pystore /* @mp_ass_subscript@ */
+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 */
+static const PyTypeObject keyattrs_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyAttributes", /* @tp_name@ */
sizeof(keyattrs_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- &gmap_pysequence, /* @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@ */
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@ */
- gmap_pymethods, /* @tp_methods@ */
+ PYMETHODS(gmap), /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
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:
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 const char *const 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,
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 (getulong(KEY_K(me)->exp)); }
static PyObject *kget_deltime(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);
}
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)
{
char *tag;
if (!x || x == Py_None) tag = 0;
- else if ((tag = PyString_AsString(x)) == 0) goto end;
+ 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:
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)
{
char *c;
if (!x || x == Py_None) c = 0;
- else if ((c = PyString_AsString(x)) == 0) goto end;
+ 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 = <any>])")
+ KWMETH(extract
line, "KEY.extractline([filter = <any>])")
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")
{ 0 }
};
-static PyTypeObject key_pytype_skel = {
- PyObject_HEAD_INIT(0) 0, /* Header */
+static const PyTypeObject key_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"Key", /* @tp_name@ */
sizeof(key_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key(KF, ID, TYPE, [exptime = KEXP_FOREVER]): 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@ */
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_pynext(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 (getulong(k->id));
+ 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 */
- "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_pynext, /* @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;
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)
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 const char *const kwlist[] = { "file", "how", "report", 0 };
- Py_XINCREF(arg); Py_XINCREF(kw);
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) {
rc = 0;
}
done:
- Py_XDECREF(arg); Py_XDECREF(kw);
return ((PyObject *)rc);
}
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;
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 const char *const 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);
-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);
- }
+ 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 *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)
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 = <built-in-reporter>])")
- 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")
+ NAMETH(save, "KF.save()")
+ KWMETH(mergeline, "KF.mergeline(NAME, LNO, LINE, "
+ "[report = <built-in-reporter>])")
+ 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?")
{ 0 }
};
-static PyMappingMethods keyfile_pymapping = {
+static const PyMappingMethods keyfile_pymapping = {
gmap_pysize,
- keyfile_pylookup,
+ gmap_pylookup,
0
};
-static PyTypeObject keyfile_pytype_skel = {
- PyObject_HEAD_INIT(0) 0, /* Header */
+static const PyTypeObject keyfile_pytype_skel = {
+ PyVarObject_HEAD_INIT(0, 0) /* Header */
"KeyFile", /* @tp_name@ */
sizeof(keyfile_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- &gmap_pysequence, /* @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@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"KeyFile(FILE, [how = KOPEN_READ], [report = ?]): Keyring file.\n\
- calls REPORT(FILE, LINE, MSG) on problems",
+ "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@ */
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.decode(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);
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)
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);
INSERT("KeyDataECPt", keydataec_pytype);
INSERT("KeyDataString", keydatastr_pytype);
INSERT("KeyDataStructured", keydatastruct_pytype);
- INSERT("SubKeyIter", subkeyiter_pytype);
+ setconstants(mod, consts);
}
/*----- That's all, folks -------------------------------------------------*/
~mdw / catacomb-python / blobdiff