python-ldap-dev

core dump / Objects/dictobject.c:471: bad argument to internal function

[\(::\) B. I. <bo...@re...>]

I'm having a problem using python-ldap (redhat linux).

ActivePython 2.1, build 210
OpenLDAP 2.0.11

This is with the latest CVS version of python-ldap.. 1.10alpha3 wouldn't 
compile with OpenLDAP 2.0.11, I haven't found the patch to try it.

Any ideas?  I've tried using different values for bind and search, and it 
worked fine if I issued a search that doesn't have any results.. but any search 
that has results gets that dictobject error, or just core dumps!

(from the interpreter)

>>> import _ldap
>>> l=_ldap.open("localhost")
>>> l.simple_bind_s("","")
>>> l.search_s("",0,"objectclass=*")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
SystemError: Objects/dictobject.c:471: bad argument to internal function
>>> l.search("",0,"objectclass=*")
3
>>> print l.result(3)
Segmentation fault (core dumped)

It's a weird install of redhat, and I haven't been using RPM's.. so I don't 
want to try one.  I just want to compile it myself and have it work.

(::) bob

Re: core dump / Objects/dictobject.c:471: bad argument to internal function

[\(::\) B. I. <bo...@re...>]

I got it to work.. what I had to do was turn off CIDict.. like this in setup.py

line 16: defines =       [#-- ('USE_CIDICT', None),

it fixed both modes (I guess they're called synchronous and asynchronous?).. no 
more SystemError or core dump.


Quoting "(::) Bob Ippolito" <bo...@re...>:

> I'm having a problem using python-ldap (redhat linux).
> 
> ActivePython 2.1, build 210
> OpenLDAP 2.0.11
> 
> This is with the latest CVS version of python-ldap.. 1.10alpha3 wouldn't
> 
> compile with OpenLDAP 2.0.11, I haven't found the patch to try it.
> 
> Any ideas?  I've tried using different values for bind and search, and
> it 
> worked fine if I issued a search that doesn't have any results.. but any
> search 
> that has results gets that dictobject error, or just core dumps!
> 
> (from the interpreter)
> 
> >>> import _ldap
> >>> l=_ldap.open("localhost")
> >>> l.simple_bind_s("","")
> >>> l.search_s("",0,"objectclass=*")
> Traceback (most recent call last):
>   File "<stdin>", line 1, in ?
> SystemError: Objects/dictobject.c:471: bad argument to internal
> function
> >>> l.search("",0,"objectclass=*")
> 3
> >>> print l.result(3)
> Segmentation fault (core dumped)
> 
> It's a weird install of redhat, and I haven't been using RPM's.. so I
> don't 
> want to try one.  I just want to compile it myself and have it work.
> 
> (::) bob
> 
> _______________________________________________
> Python-LDAP-dev mailing list
> Pyt...@li...
> http://lists.sourceforge.net/lists/listinfo/python-ldap-dev
> 



(::) bob

Re: core dump / Objects/dictobject.c:471: bad argument to internal function

[David L. <dav...@cs...>]

On Sat, 16 Jun 2001, (::) Bob Ippolito typed thusly:
> I got it to work.. what I had to do was turn off CIDict.. like this in setup.py
>
> > ActivePython 2.1, build 210
> > SystemError: Objects/dictobject.c:471: bad argument to internal
> > function
> > Segmentation fault (core dumped)

my lazily written CIDict module worked by copying the python dict type
and then 'patching' it so that it lowercased its keys. Python (2.0?)
seems to check that the objects being passed back are really dicts, and
so thats why you get an internal error.. which leads later to a core dump.

i've rewritten cidict to get rid of that ugly hack... the patch below
indicates what i've done .. i haven't committed (or compiled) it yet
because i am re-installing python2.1 on this machine at the moment.
i just wanted to let you know that i'll try and get it tested and fixed
today because its so awful.

and if anyone wants to run their eye over it for memory leaks, please do :)

d

Index: functions.c
===================================================================
RCS file: /cvsroot/python-ldap/python-ldap/Modules/functions.c,v
retrieving revision 1.4
diff -u -r1.4 functions.c
--- functions.c	2000/08/17 23:50:28	1.4
+++ functions.c	2001/06/17 04:39:31
@@ -10,6 +10,7 @@
 #include "LDAPObject.h"
 #include "errors.h"
 #include "template.h"
+#include "CIDict.h"

 /* ldap_open */

@@ -131,6 +132,16 @@
 "\tThis function returns true if url `looks like' an LDAP URL\n"
 "\t(as opposed to some other kind of URL).";

+#if defined(USE_CIDICT)
+static PyObject *
+cidict(PyObject *unused, PyObject *args)
+{
+	if (!PyArg_NoArgs(args))
+		return NULL;
+	return CIDict_New();
+}
+#endif
+
 /* methods */

 static PyMethodDef methods[] = {
@@ -146,6 +157,11 @@
     { "init_templates", (PyCFunction)l_init_templates,		METH_VARARGS,
     	l_init_templates_doc },
 #endif
+#if defined(USE_CIDICT)
+    { "cidict",		(PyCFunction)cidict,			METH_VARARGS,
+    	NULL },
+#endif
+
     { NULL, NULL }
 };

Index: CIDict.c
===================================================================
RCS file: /cvsroot/python-ldap/python-ldap/Modules/CIDict.c,v
retrieving revision 1.4
diff -u -r1.4 CIDict.c
--- CIDict.c	2001/05/12 08:08:39	1.4
+++ CIDict.c	2001/06/17 04:39:33
@@ -23,13 +23,18 @@
  * XXX I forget whose idea this originally was, but its a good one. - d
  */

+typedef struct {
+	PyObject_HEAD
+	PyObject *dict;
+} CIDictObject;
+
 /*
  * Return a new object representing a lowercased version of the argument.
  * Typically this is a string -> string conversion.
  * Returns: New Reference
  */
 static PyObject *
-case_insensitive(PyObject *o)
+lowercase(PyObject *o)
 {
 	char *str, *cp;
 	int len, i;
@@ -55,74 +60,146 @@
 	return s;
 }

-/* read-access the dictionary after lowercasing the subscript */
-
 static PyObject *
-cid_subscript(PyObject *d, PyObject *k)
+subscript(CIDictObject *self, PyObject *k)
 {
 	PyObject *ret;
 	PyObject *cik;

-	cik = case_insensitive(k);
-	ret = (*PyDict_Type.tp_as_mapping->mp_subscript)(d, cik);
-	Py_XDECREF(cik);
+	cik = lowercase(k);
+	if (cik == NULL)
+		return NULL;
+	ret = PyObject_GetItem(self->dict, cik);
+	Py_DECREF(cik);
 	return ret;
 }
+
+static int
+length(CIDictObject *self)
+{
+	return PyMapping_Length(self->dict);
+}

-/* write-access the dictionary after lowecasing the subscript */

 static int
-cid_ass_subscript(PyObject *d, PyObject *k, PyObject *v)
+ass_subscript(CIDictObject *self, PyObject *k, PyObject *v)
 {
 	int ret;
 	PyObject *cik;

-	cik = case_insensitive(k);
-	ret = (*PyDict_Type.tp_as_mapping->mp_ass_subscript)(d, cik, v);
-	Py_XDECREF(cik);
+	cik = lowercase(k);
+	if (cik == NULL)
+		return -1;
+	ret = PyObject_SetItem(self->dict, cik, v);
+	Py_DECREF(cik);
 	return ret;
 }

-/* This type and mapping structure gets filled in from the PyDict structs */
-
-static PyMappingMethods CIDict_mapping;
-PyTypeObject CIDict_Type;
+static void
+dealloc(CIDictObject *self)
+{
+	Py_DECREF(self->dict);
+	PyMem_DEL(self);
+}

-/* Initialise the case-insensitive dictionary type */
+static int
+print(CIDictObject *self, FILE *fp, int flags)
+{
+	return PyObject_Print(self->dict, fp, flags);
+}

-static void
-CIDict_init()
+PyObject *
+getattr(CIDictObject *self, char *attr_name)
+{
+	return PyObject_GetAttr(self->dict, attr_name);
+}
+
+static int
+compare(CIDictObject *self, PyObject *o)
+{
+	PyObject *lo = NULL;
+	PyObject *oitems = NULL;
+	PyObject *key = NULL;
+	PyObject *item = NULL;
+	int len, i, ret = -1;
+
+	if (!PyMapping_Check(o))
+		return PyObject_Compare(self->dict, o);
+
+	/* Create equivalent dictionary with lowercased keys */
+	if ((lo = PyDict_New()) == NULL)
+		goto done;
+	if ((oitems = PyMapping_Items(o)) == NULL)
+		goto done;
+	len = PyObject_Length(oitems);
+	for (i = 0; i < len; i++) {
+		Py_XDECREF(item);
+		if ((item = PySequence_GetItem(oitems, i)) == NULL)
+			goto done;
+		Py_XDECREF(key);
+		if ((key = lowercase(PyTuple_GET_ITEM(item, 0))) == NULL)
+			goto done;
+		PyMapping_SetItem(key, PyTuple_GET_ITEM(item, 1));
+	}
+	ret = PyObject_Compare(self->dict, lo);
+    done:
+	Py_XDECREF(key);
+	Py_XDECREF(item);
+	Py_XDECREF(oitems);
+	Py_XDECREF(lo);
+	return ret;
+}
+
+static PyObject *
+repr(CIDictObject *self)
 {
-	/*
-	 * Duplicate the standard python dictionary type,
-	 * but override the subscript accessor methods
-	 */
-	memcpy(&CIDict_Type, &PyDict_Type, sizeof CIDict_Type);
-	CIDict_Type.tp_name = "cidictionary";
-	CIDict_Type.tp_as_mapping = &CIDict_mapping;
-
-	memcpy(&CIDict_mapping, PyDict_Type.tp_as_mapping,
-		sizeof CIDict_mapping);
-	CIDict_mapping.mp_subscript = cid_subscript;
-	CIDict_mapping.mp_ass_subscript = cid_ass_subscript;
+	return PyObject_Repr(self->dict);
 }

+static PyMappingMethods as_mapping = {
+	length, 			/* mp_length */
+	subscript, 			/* mp_subscript */
+	ass_subscript			/* mp_ass_subscript */
+};
+
+PyTypeObject CIDict_Type = {
+#if defined(WIN32) || defined(__CYGWIN__)
+	/* see http://www.python.org/doc/FAQ.html#3.24 */
+	PyObject_HEAD_INIT(NULL)
+#else /* ! WIN32 */
+	PyObject_HEAD_INIT(&PyType_Type)
+#endif /* ! WIN32 */
+	"cidictionary",			/* tp_name */
+	sizeof (CIDictObject),		/* tp_basicsize */
+	0,				/* tp_itemsize */
+	(destructor)dealloc,		/* tp_dealloc */
+	(printfunc)print,		/* tp_print */
+	(getattrfunc)getattr,		/* tp_getattr */
+	NULL,				/* tp_setattr */
+	(cmpfunc)compare,		/* tp_compare */
+	(reprfunc)repr,			/* tp_repr */
+	NULL,				/* tp_as_number */
+	NULL,				/* tp_as_sequence */
+	&as_mapping,			/* tp_as_mapping */
+};
+
 /* Create a new case-insensitive dictionary, based on PyDict */

 PyObject *
 CIDict_New()
 {
-	PyObject *mp;
-	static int initialised = 0;
+	CIDictObject *o;
+	PyObject *dict;

-	if (!initialised) {
-		CIDict_init();
-		initialised = 1;
-	}
-
-	mp = PyDict_New();
-	mp->ob_type = &CIDict_Type;
-	return (mp);
+	dict = PyDict_New();
+	if (dict == NULL)
+		return NULL;
+	o = PyObject_NEW(CIDictObject, &CIDict_Type);
+	if (o == NULL)
+		Py_DECREF(dict);
+	else
+		o->dict = dict;
+	return o;
 }

 #endif /* USE_CIDICT */
-- 
David Leonard                           Dav...@ds...
DSTC                                    Room:78-632  Ph:+61 7 336 58358
The University of Queensland            http://www.dstc.edu.au/
QLD 4072  AUSTRALIA                     B73CD65FBEF4C089B79A8EBADF1A932F13EA0FC8

.signature: Invalid argument