/* -*-c-*-
*
- * $Id$
- *
* Key files and data
*
* (c) 2005 Straylight/Edgeware
*/
-/*----- Licensing notice --------------------------------------------------*
+/*----- Licensing notice --------------------------------------------------*
*
* This file is part of the Python interface to Catacomb.
*
* 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.
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 = PyString_FromString(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);
}
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;
rc = 1;
goto end;
tyerr:
- TYERR("expected flag string or flag/mask pair");
+ TYERR("expected flag string or integer bitfield");
end:
return (rc);
}
goto end;
if ((err = key_readflags(p, &end, &f, &m)) != 0)
KEYERR(err);
- rc = Py_BuildValue("(NNs)", getu32(f), getu32(m), end);
+ rc = Py_BuildValue("(NNs)", getulong(f), getulong(m), end);
end:
return (rc);
}
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)));
RETURN_ME;
}
+static PyObject *kdmeth_copy(PyObject *me, PyObject *arg, PyObject *kw)
+{
+ 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);
+ 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)
{
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);
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);
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)
static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
PyObject *rc = 0;
key_data *kd;
-
+
if (!PyArg_ParseTuple(arg, "s#:lock", &p, &n))
goto end;
key_lock(&kd, KEYDATA_KD(me), p, n);
static PyObject *meth__KeyData_decode(PyObject *me, PyObject *arg)
{
const char *p;
- int n;
+ Py_ssize_t n;
key_data *kd;
PyObject *rc = 0;
goto end;
if ((kd = key_decode(p, n)) == 0)
KEYERR(KERR_MALFORMED);
- rc = keydata_pywrap(kd);
+ 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[] = {
#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(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")
#undef METHNAME
static PyTypeObject keydata_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyData", /* @tp_name@ */
+ "KeyData", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
keydata_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
keydata_pygetset, /* @tp_getset@ */
PyObject *arg, PyObject *kw)
{
char *p;
- int n;
+ Py_ssize_t n;
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, &n, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
static PyTypeObject keydatabin_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataBinary", /* @tp_name@ */
+ "KeyDataBinary", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
keydatabin_pygetset, /* @tp_getset@ */
PyObject *arg, PyObject *kw)
{
char *p;
- int n;
+ Py_ssize_t n;
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, &n, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
{
char *hunoz;
- int hukairz;
+ Py_ssize_t hukairz;
if (!PyArg_ParseTuple(arg, "s#:lock", &hunoz, &hukairz)) goto end;
KEYERR(KERR_WRONGTYPE);
end:
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)
static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
{
char *p;
- int n;
+ Py_ssize_t n;
int err;
PyObject *rc = 0;
key_data *kd;
-
+
if (!PyArg_ParseTuple(arg, "s#:unlock", &p, &n))
goto end;
if ((err = key_unlock(&kd, KEYDATA_KD(me), p, n)) != 0)
static PyTypeObject keydataenc_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataEncrypted", /* @tp_name@ */
+ "KeyDataEncrypted", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
keydataenc_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
keydataenc_pygetset, /* @tp_getset@ */
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);
static PyTypeObject keydatamp_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataMP", /* @tp_name@ */
+ "KeyDataMP", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
keydatamp_pygetset, /* @tp_getset@ */
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);
static PyTypeObject keydatastr_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataString", /* @tp_name@ */
+ "KeyDataString", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
keydatastr_pygetset, /* @tp_getset@ */
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);
static PyTypeObject keydataec_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataECPt", /* @tp_name@ */
+ "KeyDataECPt", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
keydataec_pygetset, /* @tp_getset@ */
return ((PyObject *)me);
}
-static PyObject *subkeyiter_next(PyObject *me)
+static PyObject *subkeyiter_pynext(PyObject *me)
{
const char *tag;
if (!key_nextsubkey(SUBKEYITER_I(me), &tag, 0))
static PyTypeObject subkeyiter_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.SubKeyIter", /* @tp_name@ */
+ "SubKeyIter", /* @tp_name@ */
sizeof(subkeyiter_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
PyObject_SelfIter, /* @tp_iter@ */
- subkeyiter_next, /* @tp_iternexr@ */
+ subkeyiter_pynext, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
char *p;
keydata_pyobj *me = 0;
key_data *kd = 0;
- static char *kwlist[] = { "subkeys", 0 };
+ static const char *const kwlist[] = { "subkeys", 0 };
- Py_INCREF(arg); Py_INCREF(kw);
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", kwlist, &sub))
+ Py_XINCREF(arg); Py_XINCREF(kw);
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", KWLIST, &sub))
goto end;
kd = key_newstruct();
if (sub) {
if ((tag = PyString_AsString(key)) == 0)
goto end;
+ key_split(&KEYDATA_KD(me));
if (value) {
if (!KEYDATA_PYCHECK(value))
TYERR("expected KeyData value");
}
static PyMappingMethods keydatastruct_pymapping = {
- 0, /* @mp_length@ */
+ gmap_pysize, /* @mp_length@ */
keydatastruct_pylookup, /* @mp_subscript@ */
- keydatastruct_pystore, /* @mp_ass_subscript@ */
+ keydatastruct_pystore /* @mp_ass_subscript@ */
};
static PyTypeObject keydatastruct_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyDataStructured", /* @tp_name@ */
+ "KeyDataStructured", /* @tp_name@ */
sizeof(keydata_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
- 0, /* @tp_iternexr@ */
- 0, /* @tp_methods@ */
+ 0, /* @tp_iternext@ */
+ gmap_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
return ((PyObject *)me);
}
-static PyObject *keyattriter_next(PyObject *me)
+static PyObject *keyattriter_pynext(PyObject *me)
{
const char *name;
static PyTypeObject keyattriter_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyAttributeIter", /* @tp_name@ */
+ "KeyAttributeIter", /* @tp_name@ */
sizeof(keyattriter_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
PyObject_SelfIter, /* @tp_iter@ */
- keyattriter_next, /* @tp_iternexr@ */
+ keyattriter_pynext, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
}
static PyMappingMethods keyattrs_pymapping = {
- 0,
- keyattrs_pylookup,
- keyattrs_pystore
+ gmap_pysize, /* @mp_length@ */
+ keyattrs_pylookup, /* @mp_subscript@ */
+ keyattrs_pystore /* @mp_ass_subscript@ */
};
static PyTypeObject keyattrs_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyAttributes", /* @tp_name@ */
+ "KeyAttributes", /* @tp_name@ */
sizeof(keyattrs_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- 0, /* @tp_as_sequence@ */
+ &gmap_pysequence, /* @tp_as_sequence@ */
&keyattrs_pymapping, /* @tp_as_mapping@ */
0, /* @tp_hash@ */
0, /* @tp_call@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
keyattriter_make, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
- 0, /* @tp_methods@ */
+ 0, /* @tp_iternext@ */
+ gmap_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
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:
static PyObject *kmeth_delete(PyObject *me, PyObject *arg)
{
int err;
-
+
if (!PyArg_ParseTuple(arg, ":delete")) goto end;
if ((err = key_delete(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err);
RETURN_ME;
static PyObject *kmeth_expire(PyObject *me, PyObject *arg)
{
int err;
-
+
if (!PyArg_ParseTuple(arg, ":expire")) goto end;
if ((err = key_expire(KEY_KF(me), KEY_K(me))) != 0) KEYERR(err);
RETURN_ME;
{
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;
PyObject *nameobj;
char *name;
FILE *fp;
- static char *kwlist[] = { "file", "filter", 0 };
+ static const char *const kwlist[] = { "file", "filter", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", KWLIST,
&PyFile_Type, &file,
convfilter, &f) ||
(fp = PyFile_AsFile(file)) == 0 ||
{
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)); }
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;
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);
int err;
char *tag;
- if (x == Py_None) tag = 0;
+ if (!x || x == Py_None) tag = 0;
else if ((tag = PyString_AsString(x)) == 0) goto end;
if ((err = key_settag(KEY_KF(me), KEY_K(me), tag)) != 0) KEYERR(err);
return (0);
int err;
char *c;
- if (x == Py_None) c = 0;
+ if (!x || x == Py_None) c = 0;
else if ((c = PyString_AsString(x)) == 0) goto end;
if ((err = key_setcomment(KEY_KF(me), KEY_K(me), c)) != 0) KEYERR(err);
return (0);
METH (delete, "KEY.delete()")
METH (expire, "KEY.expire()")
METH (used, "KEY.used(TIME)")
- KWMETH(extract, "KEY.extract(FILE, filter = '')")
- KWMETH(fingerprint, "KEY.fingerprint(HASH, filtr = '-secret')")
+ KWMETH(extract, "KEY.extract(FILE, [filter = <any>])")
+ KWMETH(fingerprint, "KEY.fingerprint(HASH, [filter = '-secret'])")
#undef METHNAME
{ 0 }
};
static 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")
static PyTypeObject key_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.Key", /* @tp_name@ */
+ "Key", /* @tp_name@ */
sizeof(key_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
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@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
key_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
key_pygetset, /* @tp_getset@ */
return ((PyObject *)me);
}
-static PyObject *keyiter_next(PyObject *me)
+static PyObject *keyiter_pynext(PyObject *me)
{
key *k;
if ((k = key_next(KEYITER_I(me))) == 0)
return (0);
- return (key_pywrap(KEYITER_KFOBJ(me), k));
+ return (getulong(k->id));
}
static void keyiter_pydealloc(PyObject *me)
static PyTypeObject keyiter_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyFileIter", /* @tp_name@ */
+ "KeyFileIter", /* @tp_name@ */
sizeof(keyiter_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_richcompare@ */
0, /* @tp_weaklistoffset@ */
PyObject_SelfIter, /* @tp_iter@ */
- keyiter_next, /* @tp_iternexr@ */
+ keyiter_pynext, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
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))
PyObject *x = 0;
FILE *fp = 0;
int rc;
- static char *kwlist[] = { "file", "report", 0 };
+ static const char *const kwlist[] = { "file", "report", 0 };
Py_XINCREF(arg); Py_XINCREF(kw);
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", KWLIST,
&PyFile_Type, &x, &ri.func))
goto end;
if (ri.func && !PyCallable_Check(ri.func))
}
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:
static PyObject *kfmeth_qtag(PyObject *me, PyObject *arg, PyObject *kw)
{
key *k;
- key_data **kd;
+ key_data **kd, *okd;
PyObject *newkdobj = 0;
char *tag;
- PyObject *kdobj;
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))
KEYERR(KERR_NOTFOUND);
- key_incref(*kd);
- kdobj = keydata_pywrap(*kd);
+ okd = *kd;
if (newkdobj) {
if (!(KEYFILE_KF(me)->f & KF_WRITE))
KEYERR(KERR_READONLY);
- key_drop(*kd);
+ KEYFILE_KF(me)->f |= KF_MODIFIED;
*kd = KEYDATA_KD(newkdobj);
- key_incref(*kd);
}
- rc = Py_BuildValue("(s#NN)", d.buf, d.len, key_pywrap(me, k), kdobj);
+ key_incref(*kd);
+ rc = Py_BuildValue("(s#NN)",
+ d.buf, (Py_ssize_t)d.len,
+ key_pywrap(me, k),
+ keydata_pywrap(okd));
end:
return (rc);
}
static 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")
+ 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")
- KWMETH(qtag, "KF.qtag(TAG, new = KD) -> FULLTAG, KEY, OLDKD")
+ KWMETH(qtag, "KF.qtag(TAG, [new = KD]) -> FULLTAG, KEY, OLDKD")
+ GMAP_ROMETHODS
#undef METHNAME
{ 0 }
};
};
static PyMappingMethods keyfile_pymapping = {
- 0,
+ gmap_pysize,
keyfile_pylookup,
0
};
static PyTypeObject keyfile_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
- "catacomb.KeyFile", /* @tp_name@ */
+ "KeyFile", /* @tp_name@ */
sizeof(keyfile_pyobj), /* @tp_basicsize@ */
0, /* @tp_itemsize@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- 0, /* @tp_as_sequence@ */
+ &gmap_pysequence, /* @tp_as_sequence@ */
&keyfile_pymapping, /* @tp_as_mapping@ */
0, /* @tp_hash@ */
0, /* @tp_call@ */
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@ */
- 0, /* @tp_iternexr@ */
+ 0, /* @tp_iternext@ */
keyfile_pymethods, /* @tp_methods@ */
0, /* @tp_members@ */
keyfile_pygetset, /* @tp_getset@ */
"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 (_KeyData_decode, "KeyData.decode(BYTES) -> KD")
METH (barf, "barf(ERR)")
#undef METHNAME
{ 0 }
~mdw / catacomb-python / blobdiff