More fixing for modern Pythons. No longer works with 2.2. Sorry.

diff --git a/.gdbinit b/.gdbinit
index 440e5b57e416318b19887335eb57992c8dd5ff37..b48f913cda147f807d7b6f8daa3c9cd2a0ac35bd 100644 (file)
--- a/.gdbinit
+++ b/.gdbinit
@@ -3,4 +3,3 @@ dir py/python2.4-2.4+2.4.1rc2
 set env LD_LIBRARY_PATH=/home/mdw/src/catacomb/deb-build/.libs
 set env PYTHONPATH=/usr/lib/python2.4/lib-dynload
 cd build/lib.linux-i686-2.4
-set args pwsafe list

diff --git a/algorithms.c b/algorithms.c
index a740a714db0008db4cddaa2e14cfebf2bae1d43f..0a36f910740dcc0cd0ab83e2038479c5291b9f94 100644 (file)
--- a/algorithms.c
+++ b/algorithms.c
@@ -460,19 +460,18 @@ end:
 
 PyObject *gccipher_pywrap(gccipher *cc)
 {
-  gccipher_pyobj *g = newtype(gccipher_pytype, 0);
+  gccipher_pyobj *g = newtype(gccipher_pytype, 0, cc->name);
   g->cc = cc;
-  g->ty.tp_name = (/*unconst*/ char *)cc->name;
-  g->ty.tp_basicsize = sizeof(gcipher_pyobj);
-  g->ty.tp_base = gcipher_pytype;
+  g->ty.type.tp_basicsize = sizeof(gcipher_pyobj);
+  g->ty.type.tp_base = gcipher_pytype;
   Py_INCREF(gcipher_pytype);
-  g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                   Py_TPFLAGS_BASETYPE |
-                   Py_TPFLAGS_HEAPTYPE);
-  g->ty.tp_alloc = PyType_GenericAlloc;
-  g->ty.tp_free = 0;
-  g->ty.tp_new = gcipher_pynew;
-  PyType_Ready(&g->ty);
+  g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                        Py_TPFLAGS_BASETYPE |
+                        Py_TPFLAGS_HEAPTYPE);
+  g->ty.type.tp_alloc = PyType_GenericAlloc;
+  g->ty.type.tp_free = 0;
+  g->ty.type.tp_new = gcipher_pynew;
+  PyType_Ready(&g->ty.type);
   return ((PyObject *)g);
 }
 
@@ -705,19 +704,18 @@ end:
 
 PyObject *gchash_pywrap(gchash *ch)
 {
-  gchash_pyobj *g = newtype(gchash_pytype, 0);
+  gchash_pyobj *g = newtype(gchash_pytype, 0, ch->name);
   g->ch = ch;
-  g->ty.tp_name = (/*unconst*/ char *)ch->name;
-  g->ty.tp_basicsize = sizeof(ghash_pyobj);
-  g->ty.tp_base = ghash_pytype;
+  g->ty.type.tp_basicsize = sizeof(ghash_pyobj);
+  g->ty.type.tp_base = ghash_pytype;
   Py_INCREF(ghash_pytype);
-  g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                   Py_TPFLAGS_BASETYPE |
-                   Py_TPFLAGS_HEAPTYPE);
-  g->ty.tp_alloc = PyType_GenericAlloc;
-  g->ty.tp_free = 0;
-  g->ty.tp_new = ghash_pynew;
-  PyType_Ready(&g->ty);
+  g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                        Py_TPFLAGS_BASETYPE |
+                        Py_TPFLAGS_HEAPTYPE);
+  g->ty.type.tp_alloc = PyType_GenericAlloc;
+  g->ty.type.tp_free = 0;
+  g->ty.type.tp_new = ghash_pynew;
+  PyType_Ready(&g->ty.type);
   return ((PyObject *)g);
 }
 
@@ -922,19 +920,18 @@ static PyObject *gmhash_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 
 PyObject *gcmac_pywrap(gcmac *cm)
 {
-  gcmac_pyobj *g = newtype(gcmac_pytype, 0);
+  gcmac_pyobj *g = newtype(gcmac_pytype, 0, cm->name);
   g->cm = cm;
-  g->ty.tp_name = (/*unconst*/ char *)cm->name;
-  g->ty.tp_basicsize = sizeof(gmac_pyobj);
-  g->ty.tp_base = gmac_pytype;
+  g->ty.type.tp_basicsize = sizeof(gmac_pyobj);
+  g->ty.type.tp_base = gmac_pytype;
   Py_INCREF(gmac_pytype);
-  g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
+  g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
                    Py_TPFLAGS_BASETYPE |
                    Py_TPFLAGS_HEAPTYPE);
-  g->ty.tp_alloc = PyType_GenericAlloc;
-  g->ty.tp_free = 0;
-  g->ty.tp_new = gmac_pynew;
-  PyType_Ready(&g->ty);
+  g->ty.type.tp_alloc = PyType_GenericAlloc;
+  g->ty.type.tp_free = 0;
+  g->ty.type.tp_new = gmac_pynew;
+  PyType_Ready(&g->ty.type);
   return ((PyObject *)g);
 }
 
@@ -943,18 +940,18 @@ PyObject *gmac_pywrap(PyObject *cobj, gmac *m, unsigned f)
   gmac_pyobj *g;
   if (!cobj) cobj = gcmac_pywrap((/*unconst*/ gcmac *)GM_CLASS(m));
   else Py_INCREF(cobj);
-  g = newtype((PyTypeObject *)cobj, 0);
-  g->nameobj = PyString_FromFormat("%s(keyed)", m->ops->c->name);
-  g->ty.tp_name = PyString_AS_STRING(g->nameobj);
-  g->ty.tp_base = gmhash_pytype;
+  g = newtype((PyTypeObject *)cobj, 0, 0);
+  g->ty.name = PyString_FromFormat("%s(keyed)", m->ops->c->name);
+  g->ty.type.tp_name = PyString_AS_STRING(g->ty.name);
+  g->ty.type.tp_base = gmhash_pytype;
   Py_INCREF(gmac_pytype);
-  g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                   Py_TPFLAGS_BASETYPE |
-                   Py_TPFLAGS_HEAPTYPE);
-  g->ty.tp_alloc = PyType_GenericAlloc;
-  g->ty.tp_free = 0;
-  g->ty.tp_new = gmhash_pynew;
-  PyType_Ready(&g->ty);
+  g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                        Py_TPFLAGS_BASETYPE |
+                        Py_TPFLAGS_HEAPTYPE);
+  g->ty.type.tp_alloc = PyType_GenericAlloc;
+  g->ty.type.tp_free = 0;
+  g->ty.type.tp_new = gmhash_pynew;
+  PyType_Ready(&g->ty.type);
   g->m = m;
   g->f = f;
   return ((PyObject *)g);  
@@ -965,7 +962,6 @@ static void gmac_pydealloc(PyObject *me)
   if (GMAC_F(me) & f_freeme)
     GM_DESTROY(GMAC_M(me));
   Py_DECREF(me->ob_type);
-  Py_DECREF(GMAC_NAMEOBJ(me));
   PyType_Type.tp_dealloc(me);
 }
 

diff --git a/catacomb-python.h b/catacomb-python.h
index 368c7bbcd599811b07c76ac36f212dfb624c0f0b..ff99a785d700945e1bb89d44c07b1dd28f7017b5 100644 (file)
--- a/catacomb-python.h
+++ b/catacomb-python.h
@@ -221,7 +221,7 @@ extern int mp_tolong_checked(mp *, long *);
 /*----- Abstract fields ---------------------------------------------------*/
 
 typedef struct field_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   field *f;
 } field_pyobj;
 
@@ -274,7 +274,7 @@ extern void getecptout(ec *, PyObject *);
 extern int convec(PyObject *, void *);
 
 typedef struct eccurve_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   ec_curve *c;
   PyObject *fobj;
 } eccurve_pyobj;
@@ -328,7 +328,7 @@ extern PyTypeObject *ge_pytype;
 extern PyObject *ge_pywrap(PyObject *, ge *);
 
 typedef struct group_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   group *g;
 } group_pyobj;
 
@@ -383,7 +383,7 @@ extern PyObject *keysz_pywrap(const octet *);
 /*----- Symmetric cryptography --------------------------------------------*/
 
 typedef struct gccipher_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   gccipher *cc;
 } gccipher_pyobj;
 
@@ -409,7 +409,7 @@ extern PyObject *gcipher_pywrap(PyObject *, gcipher *, unsigned);
 extern int convgcipher(PyObject *, void *);
 
 typedef struct gchash_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   gchash *ch;
 } gchash_pyobj;
 
@@ -436,7 +436,7 @@ extern int convghash(PyObject *, void *);
 extern int convgmhash(PyObject *, void *);
 
 typedef struct gcmac_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   gcmac *cm;
 } gcmac_pyobj;
 
@@ -448,16 +448,14 @@ extern PyObject *gcmac_pywrap(gcmac *);
 extern int convgcmac(PyObject *, void *);
 
 typedef struct gmac_pyobj {
-  PyTypeObject ty;
+  PyHeapTypeObject ty;
   unsigned f;
   gmac *m;
-  PyObject *nameobj;
 } gmac_pyobj;
 
 extern PyTypeObject *gmac_pytype;
 #define GMAC_PYCHECK(o) PyObject_TypeCheck((o), gmac_pytype)
 #define GMAC_M(o) (((gmac_pyobj *)(o))->m)
-#define GMAC_NAMEOBJ(o) (((gmac_pyobj *)(o))->nameobj)
 #define GMAC_F(o) (((gmac_pyobj *)(o))->f)
 extern PyObject *gmac_pywrap(PyObject *, gmac *, unsigned);
 extern int convgmac(PyObject *, void *);
@@ -510,7 +508,7 @@ extern int convbool(PyObject *, void *);
 extern PyObject *abstract_pynew(PyTypeObject *, PyObject *, PyObject *);
 extern PyObject *getbool(int);
 extern PyObject *getu32(uint32);
-extern void *newtype(PyTypeObject *, const PyTypeObject *);
+extern void *newtype(PyTypeObject *, const PyTypeObject *, const char *);
 extern PyTypeObject *inittype(PyTypeObject *);
 extern void addmethods(const PyMethodDef *);
 

diff --git a/catacomb.c b/catacomb.c
index acc0e35e382e1e15ec5cfa414890ed02f3b448cf..0e1c7119c6f4ee28a0cc31c0577584f01798a34c 100644 (file)
--- a/catacomb.c
+++ b/catacomb.c
@@ -236,18 +236,35 @@ void addmethods(const PyMethodDef *m)
 
 static const PyTypeObject emptytype = { 0 };
 
-void *newtype(PyTypeObject *metaty, const PyTypeObject *skel)
+void *newtype(PyTypeObject *metaty,
+             const PyTypeObject *skel,
+             const char *name)
 {
-  PyTypeObject *ty =
-#if PY_VERSION_HEX < 0x02030000
-    (PyTypeObject *)_PyObject_GC_Malloc(metaty, 0);
-#else
-    (PyTypeObject *)_PyObject_GC_Malloc(_PyObject_VAR_SIZE(metaty, 0));
-#endif
+  PyHeapTypeObject *ty =
+    (PyHeapTypeObject *)_PyObject_GC_Malloc(_PyObject_VAR_SIZE(metaty, 0));
   if (!skel) skel = &emptytype;
   memcpy(ty, skel, sizeof(*skel));
-  if (ty->tp_base) Py_INCREF(ty->tp_base);
-  PyObject_INIT(ty, metaty);
+  if (ty->type.tp_base) Py_INCREF(ty->type.tp_base);
+#define COPY(blah) do {                                                        \
+    if (ty->type.tp_as_##blah) {                                       \
+      memcpy(&ty->as_##blah,                                           \
+            ty->type.tp_as_##blah,                                     \
+            sizeof(ty->as_##blah));                                    \
+      ty->type.tp_as_##blah = &ty->as_##blah;                          \
+    }                                                                  \
+  } while (0)
+  COPY(number);
+  COPY(sequence);
+  COPY(mapping);
+  COPY(buffer);
+#undef COPY
+  if (name)
+    ty->name = PyString_FromString(name);
+  else if (ty->type.tp_name)
+    ty->name = PyString_FromString(ty->type.tp_name);
+  if (ty->name)
+    ty->type.tp_name = PyString_AS_STRING(ty->name);
+  PyObject_INIT(&ty->type, metaty);
   Py_INCREF(metaty);
   return (ty);
 }
@@ -264,7 +281,7 @@ static PyObject *smallprimes(void)
 
 PyTypeObject *inittype(PyTypeObject *tyskel)
 {
-  PyTypeObject *ty = newtype(&PyType_Type, tyskel);
+  PyTypeObject *ty = newtype(&PyType_Type, tyskel, 0);
   ty->tp_flags |= Py_TPFLAGS_HEAPTYPE;
   PyType_Ready(ty);
   return (ty);

diff --git a/catacomb/__init__.py b/catacomb/__init__.py
index b7f40fa60360bbf53e4a676fc95a862ea2b2000f..65c3fbac0bf006ed24b6174c63a9a7a463f99abd 100644 (file)
--- a/catacomb/__init__.py
+++ b/catacomb/__init__.py
@@ -135,6 +135,10 @@ class _groupmap (object):
     raise TypeError, "immutable object"
   def __iter__(me):
     return iter(me.map)
+  def keys(me):
+    return [k for k in me]
+  def values(me):
+    return [me[k] for k in me]
 eccurves = _groupmap(_base._eccurves, ECInfo._curven)
 primegroups = _groupmap(_base._pgroups, DHInfo._groupn)
 bingroups = _groupmap(_base._bingroups, BinDHInfo._groupn)

diff --git a/ec.c b/ec.c
index 59384bcff5e020405537581d799e014ee4d0d225..c38c6c472eb3d33d99f01dc9602aa432adecd4c7 100644 (file)
--- a/ec.c
+++ b/ec.c
@@ -900,21 +900,20 @@ static PyObject *ecmeth_rand(PyObject *me, PyObject *arg, PyObject *kw)
 static PyObject *eccurve_dopywrap(PyTypeObject *ty,
                                  PyObject *fobj, ec_curve *c)
 {
-  eccurve_pyobj *cobj = newtype(ty, 0);
+  eccurve_pyobj *cobj = newtype(ty, 0, c->ops->name);
   cobj->c = c;
   cobj->fobj = fobj;
-  cobj->ty.tp_name = (/*unconst*/ char *)c->ops->name;
-  cobj->ty.tp_basicsize = sizeof(ecpt_pyobj);
-  cobj->ty.tp_base = ecptcurve_pytype;
+  cobj->ty.type.tp_basicsize = sizeof(ecpt_pyobj);
+  cobj->ty.type.tp_base = ecptcurve_pytype;
   Py_INCREF(ecptcurve_pytype);
-  cobj->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                      Py_TPFLAGS_BASETYPE |
-                      Py_TPFLAGS_CHECKTYPES |
-                      Py_TPFLAGS_HEAPTYPE);
-  cobj->ty.tp_alloc = PyType_GenericAlloc;
-  cobj->ty.tp_free = 0;
-  cobj->ty.tp_new = ecpt_pynew;
-  PyType_Ready(&cobj->ty);
+  cobj->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                           Py_TPFLAGS_BASETYPE |
+                           Py_TPFLAGS_CHECKTYPES |
+                           Py_TPFLAGS_HEAPTYPE);
+  cobj->ty.type.tp_alloc = PyType_GenericAlloc;
+  cobj->ty.type.tp_free = 0;
+  cobj->ty.type.tp_new = ecpt_pynew;
+  PyType_Ready(&cobj->ty.type);
   return ((PyObject *)cobj);
 }
 

diff --git a/field.c b/field.c
index aa071b27ae257673068713ffbb83080b123a8532..89fe8fbf2e26e01951542553f3f66bb955bb4571 100644 (file)
--- a/field.c
+++ b/field.c
@@ -56,20 +56,19 @@ static PyObject *fe_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 
 static PyObject *field_dopywrap(PyTypeObject *ty, field *f)
 {
-  field_pyobj *fobj = newtype(ty, 0);
+  field_pyobj *fobj = newtype(ty, 0, f->ops->name);
   fobj->f = f;
-  fobj->ty.tp_name = (/*unconst*/ char *)f->ops->name;
-  fobj->ty.tp_basicsize = sizeof(fe_pyobj);
-  fobj->ty.tp_base = fe_pytype;
+  fobj->ty.type.tp_basicsize = sizeof(fe_pyobj);
+  fobj->ty.type.tp_base = fe_pytype;
   Py_INCREF(fe_pytype);
-  fobj->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                      Py_TPFLAGS_BASETYPE |
-                      Py_TPFLAGS_CHECKTYPES |
-                      Py_TPFLAGS_HEAPTYPE);
-  fobj->ty.tp_alloc = PyType_GenericAlloc;
-  fobj->ty.tp_free = 0;
-  fobj->ty.tp_new = fe_pynew;
-  PyType_Ready(&fobj->ty);
+  fobj->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                           Py_TPFLAGS_BASETYPE |
+                           Py_TPFLAGS_CHECKTYPES |
+                           Py_TPFLAGS_HEAPTYPE);
+  fobj->ty.type.tp_alloc = PyType_GenericAlloc;
+  fobj->ty.type.tp_free = 0;
+  fobj->ty.type.tp_new = fe_pynew;
+  PyType_Ready(&fobj->ty.type);
   return ((PyObject *)fobj);
 }
 

diff --git a/group.c b/group.c
index 7ae387a22d7cc08fcc86017439d2aee69af51355..bb9e9e61db21283ea1969ecfaf22ae88b8b20972 100644 (file)
--- a/group.c
+++ b/group.c
@@ -505,20 +505,19 @@ end:
 
 static PyObject *group_dopywrap(PyTypeObject *ty, group *g)
 {
-  group_pyobj *gobj = newtype(ty, 0);
+  group_pyobj *gobj = newtype(ty, 0, g->ops->name);
   gobj->g = g;
-  gobj->ty.tp_name = (/*unconst*/ char *)g->ops->name;
-  gobj->ty.tp_basicsize = sizeof(ge_pyobj);
-  gobj->ty.tp_base = ge_pytype;
+  gobj->ty.type.tp_basicsize = sizeof(ge_pyobj);
+  gobj->ty.type.tp_base = ge_pytype;
   Py_INCREF(group_pytype);
-  gobj->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
-                      Py_TPFLAGS_BASETYPE |
-                      Py_TPFLAGS_CHECKTYPES |
-                      Py_TPFLAGS_HEAPTYPE);
-  gobj->ty.tp_alloc = PyType_GenericAlloc;
-  gobj->ty.tp_free = 0;
-  gobj->ty.tp_new = ge_pynew;
-  PyType_Ready(&gobj->ty);
+  gobj->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
+                           Py_TPFLAGS_BASETYPE |
+                           Py_TPFLAGS_CHECKTYPES |
+                           Py_TPFLAGS_HEAPTYPE);
+  gobj->ty.type.tp_alloc = PyType_GenericAlloc;
+  gobj->ty.type.tp_free = 0;
+  gobj->ty.type.tp_new = ge_pynew;
+  PyType_Ready(&gobj->ty.type);
   return ((PyObject *)gobj);
 }