r26570: - Trim size of the swig-generated Python bindings by removing a bunch of {}'s.

- Start working on Python equivalents for various EJS tests.
- Fix regression in argument order for reg_diff_apply() in EJS bindings.
(This used to be commit c550c03372cb260b78f6a6c132e70571bc4cb852)

13 files changed, 1851 insertions, 663 deletions

diff --git a/source4/lib/events/events.i b/source4/lib/events/events.i
index 925a74c252..e2f3b788cb 100644
--- a/source4/lib/events/events.i
+++ b/source4/lib/events/events.i
@@ -26,7 +26,7 @@
 
 struct event_context *event_context_init(TALLOC_CTX *mem_ctx);
 
-%typemap(default) struct event_context * {
+%typemap(default,noblock=1) struct event_context * {
     $1 = event_context_init(NULL);
 }
 
diff --git a/source4/lib/events/events_wrap.c b/source4/lib/events/events_wrap.c
index 08158cdc63..c3eef44882 100644
--- a/source4/lib/events/events_wrap.c
+++ b/source4/lib/events/events_wrap.c
@@ -2579,9 +2579,7 @@ SWIGINTERN PyObject *_wrap_event_context_init(PyObject *SWIGUNUSEDPARM(self), Py
   TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
   struct event_context *result = 0 ;
   
-  {
-    arg1 = NULL;
-  }
+  arg1 = NULL;
   if (!SWIG_Python_UnpackTuple(args,"event_context_init",0,0,0)) SWIG_fail;
   result = (struct event_context *)event_context_init(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_event_context, 0 |  0 );
@@ -2604,9 +2602,7 @@ SWIGINTERN PyObject *_wrap_event_context_init_byname(PyObject *SWIGUNUSEDPARM(se
     (char *) "name", NULL 
   };
   
-  {
-    arg1 = NULL;
-  }
+  arg1 = NULL;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:event_context_init_byname",kwnames,&obj0)) SWIG_fail;
   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
@@ -2628,9 +2624,7 @@ SWIGINTERN PyObject *_wrap_event_backend_list(PyObject *SWIGUNUSEDPARM(self), Py
   TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
   char **result = 0 ;
   
-  {
-    arg1 = NULL;
-  }
+  arg1 = NULL;
   if (!SWIG_Python_UnpackTuple(args,"event_backend_list",0,0,0)) SWIG_fail;
   result = (char **)event_backend_list(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
diff --git a/source4/lib/ldb/ldb.i b/source4/lib/ldb/ldb.i
index 1ed1b45eaf..7c8241ba54 100644
--- a/source4/lib/ldb/ldb.i
+++ b/source4/lib/ldb/ldb.i
@@ -67,13 +67,13 @@ typedef int ldb_error;
 /* The ldb functions will crash if a NULL ldb context is passed so
    catch this before it happens. */
 
-%typemap(check) struct ldb_context* {
+%typemap(check,noblock=1) struct ldb_context* {
 	if ($1 == NULL)
 		SWIG_exception(SWIG_ValueError, 
 			"ldb context must be non-NULL");
 }
 
-%typemap(check) ldb_msg * {
+%typemap(check,noblock=1) ldb_msg * {
 	if ($1 == NULL)
 		SWIG_exception(SWIG_ValueError, 
 			"Message can not be None");
@@ -83,7 +83,7 @@ typedef int ldb_error;
  * Wrap struct ldb_val
  */
 
-%typemap(in) struct ldb_val *INPUT (struct ldb_val temp) {
+%typemap(in,noblock=1) struct ldb_val *INPUT (struct ldb_val temp) {
 	$1 = &temp;
 	if (!PyString_Check($input)) {
 		PyErr_SetString(PyExc_TypeError, "string arg expected");
@@ -93,7 +93,7 @@ typedef int ldb_error;
 	$1->data = PyString_AsString($input);
 }
 
-%typemap(out) struct ldb_val {
+%typemap(out,noblock=1) struct ldb_val {
 	$result = PyString_FromStringAndSize((const char *)$1.data, $1.length);
 }
 
@@ -101,7 +101,7 @@ typedef int ldb_error;
  * Wrap struct ldb_result
  */
 
-%typemap(in, numinputs=0) struct ldb_result **OUT (struct ldb_result *temp_ldb_result) {
+%typemap(in,noblock=1,numinputs=0) struct ldb_result **OUT (struct ldb_result *temp_ldb_result) {
 	$1 = &temp_ldb_result;
 }
 
@@ -115,7 +115,7 @@ typedef int ldb_error;
     }
 }
 
-%typemap(in, numinputs=1) const char * const *attrs {
+%typemap(in,noblock=1,numinputs=1) const char * const *attrs {
     if ($input == Py_None) {
         $1 = NULL;
     } else if (PySequence_Check($input)) {
@@ -196,12 +196,16 @@ fail:
 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object, 
                          struct ldb_context *ldb, ldb_dn **dn)
 {
+    int ret;
+    struct ldb_dn *odn;
     if (ldb != NULL && PyString_Check(object)) {
         *dn = ldb_dn_new(mem_ctx, ldb, PyString_AsString(object));
         return 0;
     }
-    return SWIG_ConvertPtr(object, (void **)dn, SWIGTYPE_p_ldb_dn, 
+    ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn, 
                            SWIG_POINTER_EXCEPTION);
+    *dn = ldb_dn_copy(mem_ctx, odn);
+    return ret;
 }
 
 ldb_msg_element *ldb_msg_element_from_pyobject(PyObject *set_obj, int flags,
@@ -277,6 +281,15 @@ typedef struct ldb_message_element {
         ~ldb_msg_element() { talloc_free($self); }
         int compare(ldb_msg_element *);
     }
+    %pythoncode {
+        def __eq__(self, other):
+            if (isinstance(other, str) and 
+                len(set(self)) == 1 and 
+                set(self).pop() == other):
+                return True
+            return self.__cmp__(other) == 0
+                
+    }
 } ldb_msg_element;
 
 /* ldb_message */
@@ -427,7 +440,7 @@ PyObject *PyExc_LdbError;
  */
 
 
-%typemap(out) ldb_error {
+%typemap(out,noblock=1) ldb_error {
     if ($1 != LDB_SUCCESS) {
         PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", $1, ldb_strerror($1)));
         SWIG_fail;
@@ -436,6 +449,17 @@ PyObject *PyExc_LdbError;
 };
 
 %rename(Ldb) ldb_context;
+
+%typemap(in,noblock=1) struct ldb_dn * {
+    if (ldb_dn_from_pyobject(NULL, $input, arg1, &$1) != 0) {
+        SWIG_fail;
+    }
+};
+
+%typemap(freearg,noblock=1) struct ldb_dn * {
+    talloc_free($1);
+};
+
 /* Top-level ldb operations */
 typedef struct ldb_context {
     %extend {
@@ -554,6 +578,9 @@ fail:
     }
 } ldb;
 
+%typemap(in,noblock=1) struct ldb_dn *;
+%typemap(freearg,noblock=1) struct ldb_dn *;
+
 %nodefault ldb_message;
 %nodefault ldb_context;
 %nodefault Dn;
diff --git a/source4/lib/ldb/ldb.py b/source4/lib/ldb/ldb.py
index 63c6555c28..160fa88dff 100644
--- a/source4/lib/ldb/ldb.py
+++ b/source4/lib/ldb/ldb.py
@@ -94,6 +94,14 @@ class ldb_msg_element(object):
     def __init__(self): raise AttributeError, "No constructor defined"
     __repr__ = _swig_repr
     __swig_destroy__ = _ldb.delete_ldb_msg_element
+    def __eq__(self, other):
+        if (isinstance(other, str) and 
+            len(set(self)) == 1 and 
+            set(self).pop() == other):
+            return True
+        return self.__cmp__(other) == 0
+            
+
 ldb_msg_element.__iter__ = new_instancemethod(_ldb.ldb_msg_element___iter__,None,ldb_msg_element)
 ldb_msg_element.__set__ = new_instancemethod(_ldb.ldb_msg_element___set__,None,ldb_msg_element)
 ldb_msg_element.__cmp__ = new_instancemethod(_ldb.ldb_msg_element___cmp__,None,ldb_msg_element)
diff --git a/source4/lib/ldb/ldb_wrap.c b/source4/lib/ldb/ldb_wrap.c
index 827fad09e1..1823fc192c 100644
--- a/source4/lib/ldb/ldb_wrap.c
+++ b/source4/lib/ldb/ldb_wrap.c
@@ -2675,12 +2675,16 @@ SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object, 
                          struct ldb_context *ldb, ldb_dn **dn)
 {
+    int ret;
+    struct ldb_dn *odn;
     if (ldb != NULL && PyString_Check(object)) {
         *dn = ldb_dn_new(mem_ctx, ldb, PyString_AsString(object));
         return 0;
     }
-    return SWIG_ConvertPtr(object, (void **)dn, SWIGTYPE_p_ldb_dn, 
+    ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn, 
                            SWIG_POINTER_EXCEPTION);
+    *dn = ldb_dn_copy(mem_ctx, odn);
+    return ret;
 }
 
 ldb_msg_element *ldb_msg_element_from_pyobject(PyObject *set_obj, int flags,
@@ -3137,11 +3141,9 @@ SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -3760,11 +3762,9 @@ SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self),
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (PyObject *)ldb_msg_list_elements(arg1);
   resultobj = result;
   return resultobj;
@@ -3794,11 +3794,9 @@ SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObje
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'"); 
   }
   arg2 = (ldb_dn *)(argp2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   if (arg1) (arg1)->dn = arg2;
   
   resultobj = SWIG_Py_Void();
@@ -3823,11 +3821,9 @@ SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObje
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (ldb_dn *) ((arg1)->dn);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
   return resultobj;
@@ -3877,11 +3873,9 @@ SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObje
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   delete_ldb_msg(arg1);
   
   resultobj = SWIG_Py_Void();
@@ -3918,11 +3912,9 @@ SWIGINTERN PyObject *_wrap_Message___getitem__(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___getitem__" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (ldb_msg_element *)ldb_msg_find_element(arg1,(char const *)arg2);
   {
     if (result == NULL)
@@ -3967,11 +3959,9 @@ SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(
     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_msg_element *""'"); 
   }
   arg3 = (ldb_msg_element *)(argp3);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -4005,11 +3995,9 @@ SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(
   }
   arg2 = (char *)(buf2);
   arg3 = swig_obj[2];
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -4063,11 +4051,9 @@ SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObj
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (unsigned int)ldb_msg___len__(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
@@ -4091,11 +4077,9 @@ SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (PyObject *)ldb_msg_keys(arg1);
   resultobj = result;
   return resultobj;
@@ -4119,11 +4103,9 @@ SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyOb
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'"); 
   }
   arg1 = (ldb_msg *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = (PyObject *)ldb_msg___iter__(arg1);
   resultobj = result;
   return resultobj;
@@ -4158,11 +4140,9 @@ SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   ldb_msg_remove_attr(arg1,(char const *)arg2);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -4310,19 +4290,15 @@ SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject
     } 
     arg4 = (char **)(argp4);
   }
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -4345,11 +4321,9 @@ SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   delete_ldb(arg1);
   
   resultobj = SWIG_Py_Void();
@@ -4370,8 +4344,6 @@ SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *
   ldb_error result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   int val3 ;
   int ecode3 = 0 ;
   int res4 ;
@@ -4388,9 +4360,7 @@ SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *
     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs", NULL 
   };
   
-  {
-    arg6 = &temp_ldb_result6;
-  }
+  arg6 = &temp_ldb_result6;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Ldb_search",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
@@ -4398,11 +4368,9 @@ SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *
   }
   arg1 = (ldb *)(argp1);
   if (obj1) {
-    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_search" "', argument " "2"" of type '" "ldb_dn *""'"); 
+    if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
+      SWIG_fail;
     }
-    arg2 = (ldb_dn *)(argp2);
   }
   if (obj2) {
     ecode3 = SWIG_AsVal_int(obj2, &val3);
@@ -4419,33 +4387,27 @@ SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *
     arg4 = (char *)(buf4);
   }
   if (obj4) {
-    {
-      if (obj4 == Py_None) {
-        arg5 = NULL;
-      } else if (PySequence_Check(obj4)) {
-        int i;
-        arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
-        for(i = 0; i < PySequence_Size(obj4); i++)
-        arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i));
-        arg5[i] = NULL;
-      } else {
-        SWIG_exception(SWIG_TypeError, "expected sequence");
-      }
+    if (obj4 == Py_None) {
+      arg5 = NULL;
+    } else if (PySequence_Check(obj4)) {
+      int i;
+      arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
+      for(i = 0; i < PySequence_Size(obj4); i++)
+      arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i));
+      arg5[i] = NULL;
+    } else {
+      SWIG_exception(SWIG_TypeError, "expected sequence");
     }
   }
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_search(arg1,arg2,arg3,(char const *)arg4,(char const *const *)arg5,arg6);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   {
     resultobj = PyList_New((*arg6)->count);
     for (i6 = 0; i6 < (*arg6)->count; i6++) {
@@ -4454,12 +4416,14 @@ SWIGINTERN PyObject *_wrap_Ldb_search(PyObject *SWIGUNUSEDPARM(self), PyObject *
         );
     }
   }
+  talloc_free(arg2);
   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   {
     talloc_free(arg5);
   }
   return resultobj;
 fail:
+  talloc_free(arg2);
   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
   {
     talloc_free(arg5);
@@ -4475,8 +4439,6 @@ SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *
   ldb_error result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   char *  kwnames[] = {
@@ -4489,26 +4451,22 @@ SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_delete" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
+  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
+    SWIG_fail;
   }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_delete(arg1,arg2);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
+  talloc_free(arg2);
   return resultobj;
 fail:
+  talloc_free(arg2);
   return NULL;
 }
 
@@ -4521,10 +4479,6 @@ SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *
   ldb_error result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
@@ -4538,31 +4492,27 @@ SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_rename" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_rename" "', argument " "3"" of type '" "ldb_dn *""'"); 
+  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
+    SWIG_fail;
   }
-  arg3 = (ldb_dn *)(argp3);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
+  if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
+    SWIG_fail;
   }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_rename(arg1,arg2,arg3);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
+  talloc_free(arg2);
+  talloc_free(arg3);
   return resultobj;
 fail:
+  talloc_free(arg2);
+  talloc_free(arg3);
   return NULL;
 }
 
@@ -4588,24 +4538,18 @@ SWIGINTERN PyObject *_wrap_Ldb_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int n
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_add" "', argument " "2"" of type '" "ldb_msg *""'"); 
   }
   arg2 = (ldb_msg *)(argp2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
-  {
-    if (arg2 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
+  if (arg2 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = ldb_add(arg1,arg2);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -4627,19 +4571,15 @@ SWIGINTERN PyObject *_wrap_Ldb_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int n
   }
   arg1 = (ldb *)(argp1);
   arg2 = swig_obj[1];
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_add__SWIG_1(arg1,arg2);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -4700,24 +4640,18 @@ SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'"); 
   }
   arg2 = (ldb_msg *)(argp2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
-  {
-    if (arg2 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "Message can not be None");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
+  if (arg2 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "Message can not be None");
   result = ldb_modify(arg1,arg2);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -4739,11 +4673,9 @@ SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self),
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (ldb_dn *)ldb_get_config_basedn(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
   return resultobj;
@@ -4767,11 +4699,9 @@ SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (ldb_dn *)ldb_get_root_basedn(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
   return resultobj;
@@ -4795,11 +4725,9 @@ SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self),
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
   return resultobj;
@@ -4823,11 +4751,9 @@ SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self)
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (ldb_dn *)ldb_get_default_basedn(arg1);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
   return resultobj;
@@ -4851,11 +4777,9 @@ SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObjec
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (char *)ldb_errstring(arg1);
   resultobj = SWIG_FromCharPtr((const char *)result);
   return resultobj;
@@ -4889,11 +4813,9 @@ SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self),
     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
   } 
   arg2 = (unsigned int)(val2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   ldb_set_create_perms(arg1,arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -4928,11 +4850,9 @@ SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   ldb_set_modules_dir(arg1,(char const *)arg2);
   resultobj = SWIG_Py_Void();
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -4970,19 +4890,15 @@ SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObjec
     Py_INCREF(obj1);
     arg3 = obj1;
   }
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_set_debug(arg1,arg2,arg3);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -5023,19 +4939,15 @@ SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObje
   if (!SWIG_IsOK(res3)) {
     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'"); 
   }
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -5071,11 +4983,9 @@ SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObje
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -5101,19 +5011,15 @@ SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self),
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_transaction_start(arg1);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -5135,19 +5041,15 @@ SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self)
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_transaction_commit(arg1);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -5169,19 +5071,15 @@ SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self)
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb_transaction_cancel(arg1);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
@@ -5196,8 +5094,6 @@ SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyOb
   ldb_error result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   struct ldb_result *tmp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
@@ -5214,32 +5110,28 @@ SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyOb
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'"); 
   }
   arg1 = (ldb *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb___contains__" "', argument " "2"" of type '" "ldb_dn *""'"); 
-  }
-  arg2 = (ldb_dn *)(argp2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
+  if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
+    SWIG_fail;
   }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = ldb___contains__(arg1,arg2,arg3);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   {
     resultobj = ((*arg3)->count > 0)?Py_True:Py_False; 
   }
+  talloc_free(arg2);
   {
     talloc_free(*arg3); 
   }
   return resultobj;
 fail:
+  talloc_free(arg2);
   {
     talloc_free(*arg3); 
   }
@@ -5274,11 +5166,9 @@ SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObje
     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
   }
   arg2 = (char *)(buf2);
-  {
-    if (arg1 == NULL)
-    SWIG_exception(SWIG_ValueError, 
-      "ldb context must be non-NULL");
-  }
+  if (arg1 == NULL)
+  SWIG_exception(SWIG_ValueError, 
+    "ldb context must be non-NULL");
   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
   resultobj = result;
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -5397,13 +5287,11 @@ SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObj
     arg1->name = PyObject_GetAttrString(obj0, "name");
   }
   result = ldb_register_module((struct ldb_module_ops const *)arg1);
-  {
-    if (result != 0) {
-      PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
-      SWIG_fail;
-    }
-    resultobj = Py_None;
+  if (result != 0) {
+    PyErr_SetObject(PyExc_LdbError, Py_BuildValue("(i,s)", result, ldb_strerror(result)));
+    SWIG_fail;
   }
+  resultobj = Py_None;
   return resultobj;
 fail:
   return NULL;
diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py
index c280a3f3c4..d9dfce8718 100755
--- a/source4/lib/ldb/tests/python/api.py
+++ b/source4/lib/ldb/tests/python/api.py
@@ -52,6 +52,10 @@ class SimpleLdb(unittest.TestCase):
         l = ldb.Ldb("foo.tdb")
         self.assertEquals(len(l.search(ldb.Dn(l, ""), ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
 
+    def test_search_string_dn(self):
+        l = ldb.Ldb("foo.tdb")
+        self.assertEquals(len(l.search("", ldb.SCOPE_SUBTREE, "(dc=*)", ["dc"])), 0)
+
     def test_opaque(self):
         l = ldb.Ldb("foo.tdb")
         l.set_opaque("my_opaque", l)
@@ -142,6 +146,19 @@ class SimpleLdb(unittest.TestCase):
         finally:
             l.delete(ldb.Dn(l, "dc=bar"))
 
+    def test_rename_string_dns(self):
+        l = ldb.Ldb("foo.tdb")
+        m = ldb.Message()
+        m.dn = ldb.Dn(l, "dc=foo")
+        m["bla"] = "bla"
+        self.assertEquals(len(l.search()), 1)
+        l.add(m)
+        try:
+            l.rename("dc=foo", "dc=bar")
+            self.assertEquals(len(l.search()), 2)
+        finally:
+            l.delete(ldb.Dn(l, "dc=bar"))
+
     def test_modify_delete(self):
         l = ldb.Ldb("foo.tdb")
         m = ldb.Message()
diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py
new file mode 100755
index 0000000000..519e228fca
--- /dev/null
+++ b/source4/lib/ldb/tests/python/ldap.py
@@ -0,0 +1,1355 @@
+#!/usr/bin/python
+# This is a port of the original in testprogs/ejs/ldap.js
+
+import sys
+
+if len(sys.argv) < 2:
+    print "Usage: %s <HOST>" % sys.argv[0]
+    sys.exit(1)
+
+host = sys.argv[1]
+
+def assertEquals(a1, a2):
+    assert a1 == a2
+
+def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn):
+	print "Running basic tests"
+
+	ldb.delete("cn=ldaptestuser,cn=users," + base_dn)
+	ldb.delete("cn=ldaptestgroup,cn=users," + base_dn)
+
+	print "Testing group add with invalid member"
+	ok = ldb.add({
+        "dn": "cn=ldaptestgroup,cn=uSers," + base_dn,
+        "objectclass": "group",
+        "member": "cn=ldaptestuser,cn=useRs," + base_dn})
+
+	if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT
+		print ok.errstr
+		assertEquals(ok.error, 32)
+	}
+
+	print "Testing user add"
+	ok = ldb.add({
+        "dn": "cn=ldaptestuser,cn=uSers," + base_dn,
+        "objectclass": ["user", "person"],
+        "cN": "LDAPtestUSER",
+        "givenname": "ldap",
+        "sn": "testy"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestuser,cn=users," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+		ok = ldb.add({
+            "dn": "cn=ldaptestuser,cn=uSers," + base_dn,
+            "objectclass": ["user", "person"],
+            "cN": "LDAPtestUSER",
+            "givenname": "ldap",
+            "sn": "testy"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	ok = ldb.add({
+        "dn": "cn=ldaptestgroup,cn=uSers," + base_dn,
+        "objectclass": "group",
+        "member": "cn=ldaptestuser,cn=useRs," + base_dn})
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.add({
+        "dn": "cn=ldaptestcomputer,cn=computers," + base_dn,
+        "objectclass": "computer",
+        "cN": "LDAPtestCOMPUTER"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestcomputer,cn=computers," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+		ok = ldb.add({
+            "dn": "cn=ldaptestcomputer,cn=computers," + base_dn,
+            "objectClass": "computer",
+            "cn": "LDAPtestCOMPUTER"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.add({"dn": "cn=ldaptest2computer,cn=computers," + base_dn,
+        "objectClass": "computer",
+        "cn": "LDAPtest2COMPUTER",
+        "userAccountControl": "4096",
+        "displayname": "ldap testy"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptest2computer,cn=computers," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+		ok = ldb.add({
+            "dn": "cn=ldaptest2computer,cn=computers," + base_dn,
+            "objectClass": "computer",
+            "cn": "LDAPtest2COMPUTER",
+            "userAccountControl": "4096",
+            "displayname": "ldap testy"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	    print "Testing attribute or value exists behaviour"
+	    ok = ldb.modify("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+changetype: modify
+replace: servicePrincipalName
+servicePrincipalName: host/ldaptest2computer
+servicePrincipalName: host/ldaptest2computer
+servicePrincipalName: cifs/ldaptest2computer
+")
+
+#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
+		if (ok.error != 20) {
+			print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr
+			assertEquals(ok.error, 20)
+		}
+
+	    ok = ldb.modify("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+changetype: modify
+replace: servicePrincipalName
+servicePrincipalName: host/ldaptest2computer
+servicePrincipalName: cifs/ldaptest2computer
+")
+
+	    if (ok.error != 0) {
+		    print "Failed to replace servicePrincpalName:" + ok.errstr
+		    assertEquals(ok.error, 20)
+	    }
+
+	    ok = ldb.modify("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+changetype: modify
+add: servicePrincipalName
+servicePrincipalName: host/ldaptest2computer
+")
+
+#LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
+	    if (ok.error != 20) {
+		    print "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + ok.errstr
+			assertEquals(ok.error, 20)
+	    }
+	    
+	    print "Testing ranged results"
+	    ok = ldb.modify("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+changetype: modify
+replace: servicePrincipalName
+")
+	    if (ok.error != 0) {
+		    print "Failed to replace servicePrincpalName:" + ok.errstr
+		    assertEquals(ok.error, 0)
+	    }
+	    
+	    ok = ldb.modify("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+changetype: modify
+add: servicePrincipalName
+servicePrincipalName: host/ldaptest2computer0
+servicePrincipalName: host/ldaptest2computer1
+servicePrincipalName: host/ldaptest2computer2
+servicePrincipalName: host/ldaptest2computer3
+servicePrincipalName: host/ldaptest2computer4
+servicePrincipalName: host/ldaptest2computer5
+servicePrincipalName: host/ldaptest2computer6
+servicePrincipalName: host/ldaptest2computer7
+servicePrincipalName: host/ldaptest2computer8
+servicePrincipalName: host/ldaptest2computer9
+servicePrincipalName: host/ldaptest2computer10
+servicePrincipalName: host/ldaptest2computer11
+servicePrincipalName: host/ldaptest2computer12
+servicePrincipalName: host/ldaptest2computer13
+servicePrincipalName: host/ldaptest2computer14
+servicePrincipalName: host/ldaptest2computer15
+servicePrincipalName: host/ldaptest2computer16
+servicePrincipalName: host/ldaptest2computer17
+servicePrincipalName: host/ldaptest2computer18
+servicePrincipalName: host/ldaptest2computer19
+servicePrincipalName: host/ldaptest2computer20
+servicePrincipalName: host/ldaptest2computer21
+servicePrincipalName: host/ldaptest2computer22
+servicePrincipalName: host/ldaptest2computer23
+servicePrincipalName: host/ldaptest2computer24
+servicePrincipalName: host/ldaptest2computer25
+servicePrincipalName: host/ldaptest2computer26
+servicePrincipalName: host/ldaptest2computer27
+servicePrincipalName: host/ldaptest2computer28
+servicePrincipalName: host/ldaptest2computer29
+")
+
+	    if (ok.error != 0) {
+		    print "Failed to replace servicePrincpalName:" + ok.errstr
+		    assertEquals(ok.error, 0)
+	    }
+	    
+	    res = ldb.search(base_dn, expression="(cn=ldaptest2computer))", scope=ldb.SCOPE_SUBTREE, 
+                         attrs=["servicePrincipalName;range=0-*"])
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+#	    print res[0]["servicePrincipalName;range=0-*"].length
+	    assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
+
+	    attrs = ["servicePrincipalName;range=0-19"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+#	    print res[0]["servicePrincipalName;range=0-19"].length
+	    assertEquals(res[0]["servicePrincipalName;range=0-19"].length, 20)
+
+	    attrs = ["servicePrincipalName;range=0-30"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
+
+	    attrs = ["servicePrincipalName;range=0-40"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=0-*"].length, 30)
+
+	    attrs = ["servicePrincipalName;range=30-40"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=30-*"].length, 0)
+
+	    attrs = ["servicePrincipalName;range=10-40"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=10-*"].length, 20)
+#	    pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
+
+	    attrs = ["servicePrincipalName;range=11-40"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=11-*"].length, 19)
+#	    print res[0]["servicePrincipalName;range=11-*"][18]
+#	    print pos_11
+#	    assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
+
+	    attrs = ["servicePrincipalName;range=11-15"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+	    assertEquals(res[0]["servicePrincipalName;range=11-15"].length, 5)
+#	    assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
+
+	    attrs = ["servicePrincipalName"]
+	    res = ldb.search("(cn=ldaptest2computer))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	    if (res.error != 0 || len(res) != 1) {
+		    print "Could not find (cn=ldaptest2computer)"
+		    assertEquals(res.error, 0)
+		    assertEquals(len(res), 1)
+	    }
+#	    print res[0]["servicePrincipalName"][18]
+#	    print pos_11
+	    assertEquals(res[0]["servicePrincipalName"].length, 30)
+#	    assertEquals(res[0]["servicePrincipalName"][18], pos_11)
+
+	    ok = ldb.add({
+        "dn": "cn=ldaptestuser2,cn=useRs," + base_dn,
+        "objectClass": ["person", "user"],
+        "cn": "LDAPtestUSER2",
+        "givenname": "testy",
+        "sn": "ldap user2"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestuser2,cn=users," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	        ok = ldb.add({
+                "dn": "cn=ldaptestuser2,cn=useRs," + base_dn,
+                "objectClass": ["person", "user"],
+                "cn": "LDAPtestUSER2",
+                "givenname": "testy",
+                "sn": "ldap user2"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+
+	print "Testing Ambigious Name Resolution"
+#   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
+	res = ldb.search("(&(anr=ldap testy)(objectClass=user))")
+	if (res.error != 0 || len(res) != 3) {
+		print "Could not find (&(anr=ldap testy)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 3)
+	}
+
+#   Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
+	res = ldb.search("(&(anr=testy ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 2) {
+		print "Found only " + len(res) + " for (&(anr=testy ldap)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 2)
+	}
+
+#   Testing ldb.search for (&(anr=ldap)(objectClass=user))
+	res = ldb.search("(&(anr=ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 4) {
+		print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 4)
+	} 
+
+#   Testing ldb.search for (&(anr==ldap)(objectClass=user))
+	res = ldb.search("(&(anr==ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Found only " + len(res) + " for (&(anr=ldap)(objectClass=user))"
+		print "Could not find (&(anr==ldap)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser")
+	assertEquals(res[0].name, "ldaptestuser")
+
+#   Testing ldb.search for (&(anr=testy)(objectClass=user))
+	res = ldb.search("(&(anr=testy)(objectClass=user))")
+	if (res.error != 0 || len(res) != 2) {
+		print "Found only " + len(res) + " for (&(anr=testy)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 2)
+	}
+
+#   Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
+	res = ldb.search("(&(anr=testy ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 2) {
+		print "Found only " + len(res) + " for (&(anr=ldap testy)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 2)
+	}
+
+#   Testing ldb.search for (&(anr==ldap testy)(objectClass=user))
+	res = ldb.search("(&(anr==testy ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Found only " + len(res) + " for (&(anr==ldap testy)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser")
+	assertEquals(res[0].name, "ldaptestuser")
+
+# Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
+	res = ldb.search("(&(anr==testy ldap)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(anr==testy ldap)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser")
+	assertEquals(res[0].name, "ldaptestuser")
+
+	# Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
+	res = ldb.search("(&(anr=testy ldap user)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(anr=testy ldap user)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser2")
+	assertEquals(res[0].name, "ldaptestuser2")
+
+	# Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
+	res = ldb.search("(&(anr==testy ldap user2)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(anr==testy ldap user2)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser2")
+	assertEquals(res[0].name, "ldaptestuser2")
+
+	# Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
+	res = ldb.search("(&(anr==ldap user2)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(anr==ldap user2)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser2")
+	assertEquals(res[0].name, "ldaptestuser2")
+
+	# Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
+	res = ldb.search("(&(anr==not ldap user2)(objectClass=user))")
+	if (res.error != 0 || len(res) != 0) {
+		print "Must not find (&(anr==not ldap user2)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 0)
+	}
+
+	# Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
+	res = ldb.search("(&(anr=not ldap user2)(objectClass=user))")
+	if (res.error != 0 || len(res) != 0) {
+		print "Must not find (&(anr=not ldap user2)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 0)
+	}
+
+	print "Testing Group Modifies"
+	ok = ldb.modify("
+dn: cn=ldaptestgroup,cn=users," + base_dn + "
+changetype: modify
+add: member
+member: cn=ldaptestuser2,cn=users," + base_dn + "
+member: cn=ldaptestcomputer,cn=computers," + base_dn + "
+")
+
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.delete("cn=ldaptestuser3,cn=users," + base_dn)
+
+	print "Testing adding non-existent user to a group"
+	ok = ldb.modify("
+dn: cn=ldaptestgroup,cn=users," + base_dn + "
+changetype: modify
+add: member
+member: cn=ldaptestuser3,cn=users," + base_dn + "
+")
+	if (ok.error != 32) { # LDAP_NO_SUCH_OBJECT
+		print ok.errstr
+		assertEquals(ok.error, 32)
+	}
+
+	print "Testing Renames"
+
+	ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print "Could not rename cn=ldaptestuser2,cn=users," + base_dn + " into cn=ldaptestuser3,cn=users," + base_dn + ": " + ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " onto itself: " + ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestUSER3,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print "Could not rename cn=ldaptestuser3,cn=users," + base_dn + " into cn=ldaptestUSER3,cn=users," + base_dn + ": " + ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestuser3)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestuser3)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestUSER3")
+	assertEquals(res[0].name, "ldaptestUSER3")
+
+# This is a Samba special, and does not exist in real AD
+#	print "Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
+#	res = ldb.search("(dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
+#	if (res.error != 0 || len(res) != 1) {
+#		print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
+#		assertEquals(res.error, 0)
+#		assertEquals(len(res), 1)
+#	}
+#	assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
+#	assertEquals(res[0].cn, "ldaptestUSER3")
+#	assertEquals(res[0].name, "ldaptestUSER3")
+
+	print "Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
+	res = ldb.search("(distinguishedName=CN=ldaptestUSER3,CN=Users," + base_dn + ")")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (dn=CN=ldaptestUSER3,CN=Users," + base_dn + ")"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+	assertEquals(res[0].dn, ("CN=ldaptestUSER3,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestUSER3")
+	assertEquals(res[0].name, "ldaptestUSER3")
+
+	# ensure we cannot add it again
+	ok = ldb.add({"dn": "cn=ldaptestuser3,cn=userS," + base_dn,
+                  "objectClass": ["person", "user"],
+                  "cn": "LDAPtestUSER3"})
+#LDB_ERR_ENTRY_ALREADY_EXISTS
+	if (ok.error != 68) {
+		print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr
+		assertEquals(ok.error, 68)
+	}
+
+	# rename back
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	# ensure we cannnot rename it twice
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn)
+#LDB_ERR_NO_SUCH_OBJECT
+	assertEquals(ok.error, 32)
+
+	# ensure can now use that name
+	ok = ldb.add({"dn": "cn=ldaptestuser3,cn=users," + base_dn,
+                  "objectClass": ["person", "user"],
+                  "cn": "LDAPtestUSER3"})
+	
+	# ensure we now cannnot rename
+	ok = ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
+#LDB_ERR_ENTRY_ALREADY_EXISTS
+	if (ok.error != 68) {
+		print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS, got: " + ok.errstr
+		assertEquals(ok.error, 68)
+	}
+	assertEquals(ok.error, 68)
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser3,cn=configuration," + base_dn)
+	if (ok.error != 71 && ok.error != 64) {
+		print "expected error LDB_ERR_ENTRY_ALREADY_EXISTS or LDAP_NAMING_VIOLATION, got: " + ok.errstr
+		assertEquals(ok.error == 71 || ok.error, 64)
+	}
+	assertEquals(ok.error == 71 || ok.error, 64)
+
+	ok = ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser5,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.delete("cn=ldaptestuser5,cn=users," + base_dn)
+
+	ok = ldb.delete("cn=ldaptestgroup2,cn=users," + base_dn)
+
+	ok = ldb.rename("cn=ldaptestgroup,cn=users," + base_dn, "cn=ldaptestgroup2,cn=users," + base_dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing subtree Renames"
+
+	ok = ldb.add({"dn": "cn=ldaptestcontainer," + base_dn, "objectClass": "container"})
+	
+	ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn, 
+                  "objectClass": ["person", "user"],
+                  "cn": "LDAPtestUSER4"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+		ok = ldb.add({"dn": "CN=ldaptestuser4,CN=ldaptestcontainer," + base_dn,
+                      "objectClass": ["person", "user"],
+                      "cn": "LDAPtestUSER4"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+add: member
+member: cn=ldaptestuser4,cn=ldaptestcontainer," + base_dn + "
+")
+	if (ok.error != 0) {
+		print "Failure adding ldaptestuser4 to a group"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	print "Testing ldb.rename of cn=ldaptestcontainer," + base_dn + " to cn=ldaptestcontainer2," + base_dn
+	ok = ldb.rename("CN=ldaptestcontainer," + base_dn, "CN=ldaptestcontainer2," + base_dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestuser4)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	print "Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_SUBTREE)
+	if (res.error != 32) {
+		print res.errstr
+		assertEquals(res.error, 32)
+	}
+
+	print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + base_dn
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer," + base_dn, ldb.SCOPE_ONELEVEL)
+	if (res.error != 32) {
+		print res.errstr
+		assertEquals(res.error, 32)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_SUBTREE)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + base_dn
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn))
+	assertEquals(strupper(res[0].memberOf[0]), strupper(("CN=ldaptestgroup2,CN=Users," + base_dn)))
+
+	print "Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
+	res = ldb.search("(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group))", base_dn, ldb.SCOPE_SUBTREE)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn + ")(objectclass=group)), perhaps linked attributes are not conistant with subtree renames?"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	print "Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn
+	ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn)
+	if (ok.error != 53) { # LDAP_UNWILLING_TO_PERFORM
+		print ok.errstr
+		assertEquals(ok.error, 53)
+	}
+
+	print "Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn
+	ok = ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer3," + base_dn)
+	if (ok.error != 53 && ok.error != 80) { # LDAP_UNWILLING_TO_PERFORM or LDAP_OTHER
+		print ok.errstr
+		assertEquals(ok.error == 53 || ok.error, 80)
+	}
+
+	print "Testing delete (should fail, not a leaf node) of renamed cn=ldaptestcontainer2," + base_dn
+	ok = ldb.delete("cn=ldaptestcontainer2," + base_dn)
+	if (ok.error != 66) { # LDB_ERR_NOT_ALLOWED_ON_NON_LEAF
+		print ok.errstr
+		assertEquals(ok.error, 66)
+	}
+
+	print "Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn
+	res = ldb.search("(objectclass=*)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE)
+	if (res.error == 0 && res.count == 1) {
+		assertEquals(res.error == 0 && res.count, 1)
+	}
+	res = ldb.search("(cn=ldaptestuser40)", ("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn), ldb.SCOPE_BASE)
+	if (res.error == 0 && res.count == 0) {
+		assertEquals(res.error == 0 && res.count, 0)
+	}
+
+	print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_ONELEVEL)
+	if (res.error == 0 && res.count == 0) {
+		assertEquals(res.error == 0 && res.count, 0)
+	}
+
+	print "Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + base_dn
+	res = ldb.search("(&(cn=ldaptestuser4)(objectClass=user))", "cn=ldaptestcontainer2," + base_dn, ldb.SCOPE_SUBTREE)
+	if (res.error == 0 && res.count == 0) {
+		assertEquals(res.error == 0 && res.count, 0)
+	}
+
+	print "Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn)
+	ok = ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + base_dn))
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	print "Testing delete of renamed cn=ldaptestcontainer2," + base_dn
+	ok = ldb.delete("cn=ldaptestcontainer2," + base_dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+    ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	ok = ldb.add({"dn": "cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	ok = ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn, "objectClass": "user"})
+	if (ok.error != 0) {
+		ok = ldb.delete("cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn)
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+    ok = ldb.add({"dn": "cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn,
+                  "objectClass": "user"})
+		if (ok.error != 0) {
+			print ok.errstr
+			assertEquals(ok.error, 0)
+		}
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestuser)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestuser)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser")
+	assertEquals(res[0].name, "ldaptestuser")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "person")
+	assertEquals(res[0].objectClass[2], "organizationalPerson")
+	assertEquals(res[0].objectClass[3], "user")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+	assertEquals(res[0].objectCategory, ("CN=Person,CN=Schema,CN=Configuration," + base_dn))
+	assertEquals(res[0].sAMAccountType, 805306368)
+#	assertEquals(res[0].userAccountControl, 546)
+	assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn))
+	assertEquals(res[0].memberOf.length, 1)
+ 
+	print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))"
+	res2 = ldb.search("(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))")
+	if (res2.error != 0 || res2.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))"
+		assertEquals(res2.error, 0)
+		assertEquals(res2.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res2.msgs[0].dn)
+
+	print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
+	res3 = ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))")
+	if (res3.error != 0) {
+		print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): " + res3.errstr
+		assertEquals(res3.error, 0)
+	} else if (res3.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched " + res3.msgs.length
+		assertEquals(res3.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res3.msgs[0].dn)
+
+	if (gc_ldb != undefined) {
+		print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
+		res3gc = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))")
+		if (res3gc.error != 0) {
+			print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: " + res3gc.errstr
+			assertEquals(res3gc.error, 0)
+		} else if (res3gc.msgs.length != 1) {
+			print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog: matched " + res3gc.msgs.length
+			assertEquals(res3gc.msgs.length, 1)
+		}
+	
+		assertEquals(res[0].dn, res3gc.msgs[0].dn)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
+	attrs = ["cn"]
+	controls = ["search_options:1:2"]
+	res3control = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
+	if (res3control.error != 0 || res3control.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
+		assertEquals(res3control.error, 0)
+		assertEquals(res3control.msgs.length, 1)
+	}
+	
+	assertEquals(res[0].dn, res3control.msgs[0].dn)
+
+	ok = ldb.delete(res[0].dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestcomputer)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestuser)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestcomputer,CN=Computers," + base_dn))
+	assertEquals(res[0].cn, "ldaptestcomputer")
+	assertEquals(res[0].name, "ldaptestcomputer")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "person")
+	assertEquals(res[0].objectClass[2], "organizationalPerson")
+	assertEquals(res[0].objectClass[3], "user")
+	assertEquals(res[0].objectClass[4], "computer")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+	assertEquals(res[0].objectCategory, ("CN=Computer,CN=Schema,CN=Configuration," + base_dn))
+	assertEquals(res[0].primaryGroupID, 513)
+#	assertEquals(res[0].sAMAccountType, 805306368)
+#	assertEquals(res[0].userAccountControl, 546)
+	assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn))
+	assertEquals(res[0].memberOf.length, 1)
+
+	print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))"
+	res2 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))")
+	if (res2.error != 0 || res2.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))"
+		assertEquals(res2.error, 0)
+		assertEquals(res2.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res2.msgs[0].dn)
+
+	if (gc_ldb != undefined) {
+		print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog"
+		res2gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))")
+		if (res2gc.error != 0 || res2gc.msgs.length != 1) {
+			print "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog"
+			assertEquals(res2gc.error, 0)
+			assertEquals(res2gc.msgs.length, 1)
+		}
+
+		assertEquals(res[0].dn, res2gc.msgs[0].dn)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
+	res3 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
+	if (res3.error != 0 || res3.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
+		assertEquals(res3.error, 0)
+		assertEquals(res3.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res3.msgs[0].dn)
+
+	if (gc_ldb != undefined) {
+		print "Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
+		res3gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
+		if (res3gc.error != 0 || res3gc.msgs.length != 1) {
+			print "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
+			assertEquals(res3gc.error, 0)
+			assertEquals(res3gc.msgs.length, 1)
+		}
+
+		assertEquals(res[0].dn, res3gc.msgs[0].dn)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
+	res4 = ldb.search("(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
+	if (res4.error != 0 || res4.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
+		assertEquals(res4.error, 0)
+		assertEquals(res4.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res4.msgs[0].dn)
+
+	print "Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
+	res5 = ldb.search("(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
+	if (res5.error != 0 || res5.msgs.length != 1) {
+		print "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
+		assertEquals(res5.error, 0)
+		assertEquals(res5.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res5.msgs[0].dn)
+
+	print "Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
+	res6 = ldb.search("(&(cn=*daptestcomputer)(objectCategory=compuTER))")
+	if (res6.error != 0 || res6.msgs.length != 1) {
+		print "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))"
+		assertEquals(res6.error, 0)
+		assertEquals(res6.msgs.length, 1)
+	}
+
+	assertEquals(res[0].dn, res6.msgs[0].dn)
+
+	ok = ldb.delete(res[0].dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptest2computer)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptest2computer)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptest2computer,CN=Computers," + base_dn))
+	assertEquals(res[0].cn, "ldaptest2computer")
+	assertEquals(res[0].name, "ldaptest2computer")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "person")
+	assertEquals(res[0].objectClass[2], "organizationalPerson")
+	assertEquals(res[0].objectClass[3], "user")
+	assertEquals(res[0].objectClass[4], "computer")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+	assertEquals(res[0].objectCategory, "cn=Computer,cn=Schema,cn=Configuration," + base_dn)
+	assertEquals(res[0].sAMAccountType, 805306369)
+#	assertEquals(res[0].userAccountControl, 4098)
+
+   	ok = ldb.delete(res[0].dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+    attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "memberOf"]
+	print "Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
+	res = ldb.search(base_dn, "(&(cn=ldaptestUSer2)(objectClass=user))", ldb.SCOPE_SUBTREE, attrs)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestUSer2)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestuser2")
+	assertEquals(res[0].name, "ldaptestuser2")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "person")
+	assertEquals(res[0].objectClass[2], "organizationalPerson")
+	assertEquals(res[0].objectClass[3], "user")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+	assert(res[0].nTSecurityDescriptor != undefined)
+	assertEquals(res[0].memberOf[0], ("CN=ldaptestgroup2,CN=Users," + base_dn))
+
+        attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
+	print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
+	res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestgroup2")
+	assertEquals(res[0].name, "ldaptestgroup2")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "group")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+	assert(res[0].nTSecurityDescriptor != undefined)
+	assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].member.length, 1)
+
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+replace: member
+member: CN=ldaptestuser2,CN=Users," + base_dn + "
+member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + "
+")
+	if (ok.error != 0) {
+		print "Failure testing replace of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	print "Testing Linked attribute behaviours"
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+delete: member
+")
+	if (ok.error != 0) {
+		print "Failure testing delete of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+add: member
+member: CN=ldaptestuser2,CN=Users," + base_dn + "
+member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + "
+")
+	if (ok.error != 0) {
+		print "Failure testing add of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+replace: member
+")
+	if (ok.error != 0) {
+		print "Failure testing replace of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+add: member
+member: CN=ldaptestuser2,CN=Users," + base_dn + "
+member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + "
+")
+	if (ok.error != 0) {
+		print "Failure testing add of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	ok = ldb.modify("
+dn: cn=ldaptestgroup2,cn=users," + base_dn + "
+changetype: modify
+delete: member
+member: CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn + "
+")
+	if (ok.error != 0) {
+		print "Failure testing replace of linked attributes"
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+	
+	res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestgroup2)(objectClass=group))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
+	assertEquals(res[0].member[0], ("CN=ldaptestuser2,CN=Users," + base_dn))
+	assertEquals(res[0].member.length, 1)
+
+	ok = ldb.delete(("CN=ldaptestuser2,CN=Users," + base_dn))
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+        attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
+	print "Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
+	res = ldb.search("(&(cn=ldaptestgroup2)(objectClass=group))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestgroup2,CN=Users," + base_dn))
+	assertEquals(res[0].member, undefined)
+
+	print "Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	assertEquals(res[0].dn, ("CN=ldaptestutf8user èùéìòà,CN=Users," + base_dn))
+	assertEquals(res[0].cn, "ldaptestutf8user èùéìòà")
+	assertEquals(res[0].name, "ldaptestutf8user èùéìòà")
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "person")
+	assertEquals(res[0].objectClass[2], "organizationalPerson")
+	assertEquals(res[0].objectClass[3], "user")
+	assert(res[0].objectGUID != undefined)
+	assert(res[0].whenCreated != undefined)
+
+	ok = ldb.delete(res[0].dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestutf8user2*)(objectClass=user))")
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))"
+		assertEquals(res.error, 0)
+		assertEquals(len(res), 1)
+	}
+
+	ok = ldb.delete(res[0].dn)
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	ok = ldb.delete(("CN=ldaptestgroup2,CN=Users," + base_dn))
+	if (ok.error != 0) {
+		print ok.errstr
+		assertEquals(ok.error, 0)
+	}
+
+	print "Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
+	res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+
+	if (res.error != 0 || len(res) != 1) {
+		print "Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
+	} else {
+		assertEquals(res[0].dn, ("cn=ldaptestutf8user2 èùéìòà,cn=users," + base_dn))
+		assertEquals(res[0].cn, "ldaptestutf8user2 èùéìòà")
+	}
+
+	print "Testing that we can't get at the configuration DN from the main search base"
+	attrs = ["cn"]
+	res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	if (len(res) != 0) {
+		print "Got configuration DN " + res[0].dn + " which should not be able to be seen from main search base"
+	}
+	assertEquals(len(res), 0)
+
+	print "Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
+	attrs = ["cn"]
+	controls = ["search_options:1:2"]
+	res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+
+	if (gc_ldb != undefined) {
+		print "Testing that we can get at the configuration DN from the main search base on the GC port with the search_options control == 0"
+		attrs = ["cn"]
+		controls = ["search_options:1:0"]
+		res = gc_ldb.search("objectClass=crossRef", base_dn, gc_ldb.SCOPE_SUBTREE, attrs, controls)
+		assertEquals(res.error, 0)
+		assert(len(res) > 0)
+
+		print "Testing that we do find configuration elements in the global catlog"
+		attrs = ["cn"]
+		res = gc_ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs)
+		assertEquals(res.error, 0)
+		assert (len(res) > 0)
+	
+		print "Testing that we do find configuration elements and user elements at the same time"
+		attrs = ["cn"]
+		res = gc_ldb.search("(|(objectClass=crossRef)(objectClass=person))", base_dn, ldb.SCOPE_SUBTREE, attrs)
+		assertEquals(res.error, 0)
+		assert (len(res) > 0)
+
+		print "Testing that we do find configuration elements in the global catlog, with the configuration basedn"
+		attrs = ["cn"]
+		res = gc_ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
+		assertEquals(res.error, 0)
+		assert (len(res) > 0)
+	}
+
+	print "Testing that we can get at the configuration DN on the main LDAP port"
+	attrs = ["cn"]
+	res = ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	assert (len(res) > 0)
+
+	print "Testing objectCategory canonacolisation"
+	attrs = ["cn"]
+	res = ldb.search("objectCategory=ntDsDSA", configuration_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	if (len(res) == 0) {
+		print "Didn't find any records with objectCategory=ntDsDSA"
+	}
+	assert(len(res) != 0)
+	
+	attrs = ["cn"]
+	res = ldb.search("objectCategory=CN=ntDs-DSA," + schema_dn, configuration_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	if (len(res) == 0) {
+		print "Didn't find any records with objectCategory=CN=ntDs-DSA," + schema_dn
+	}
+	assert(len(res) != 0)
+	
+	print "Testing objectClass attribute order on "+ base_dn
+	attrs = ["objectClass"]
+	res = ldb.search("objectClass=domain", base_dn, ldb.SCOPE_BASE, attrs)
+	assertEquals(res.error, 0)
+	assertEquals(len(res), 1)
+
+	assertEquals(res[0].objectClass[0], "top")
+	assertEquals(res[0].objectClass[1], "domain")
+	assertEquals(res[0].objectClass[2], "domainDNS")
+
+#  check enumeration
+
+ 	attrs = ["cn"]
+	print "Testing ldb.search for objectCategory=person"
+	res = ldb.search("objectCategory=person", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+
+ 	attrs = ["cn"]
+	controls = ["domain_scope:1"]
+	print "Testing ldb.search for objectCategory=person with domain scope control"
+	res = ldb.search("objectCategory=person", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+ 
+	attrs = ["cn"]
+	print "Testing ldb.search for objectCategory=user"
+	res = ldb.search("objectCategory=user", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+
+ 	attrs = ["cn"]
+	controls = ["domain_scope:1"]
+	print "Testing ldb.search for objectCategory=user with domain scope control"
+	res = ldb.search("objectCategory=user", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+	
+ 	attrs = ["cn"]
+	print "Testing ldb.search for objectCategory=group"
+	res = ldb.search("objectCategory=group", base_dn, ldb.SCOPE_SUBTREE, attrs)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+
+ 	attrs = ["cn"]
+	controls = ["domain_scope:1"]
+	print "Testing ldb.search for objectCategory=group with domain scope control"
+	res = ldb.search("objectCategory=group", base_dn, ldb.SCOPE_SUBTREE, attrs, controls)
+	assertEquals(res.error, 0)
+	assert(len(res) > 0)
+	
+}
+
+def basedn_tests(ldb, gc_ldb):
+	print "Testing for all rootDSE attributes"
+	attrs = []
+	res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+	assertEquals(res.error, 0)
+	assertEquals(len(res), 1)
+
+	print "Testing for highestCommittedUSN"
+	attrs = ["highestCommittedUSN"]
+	res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+	assertEquals(res.error, 0)
+	assertEquals(len(res), 1)
+	assert(res[0].highestCommittedUSN != undefined)
+	assert(res[0].highestCommittedUSN != 0)
+
+	print "Testing for netlogon via LDAP"
+	attrs = ["netlogon"]
+	res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+	assertEquals(res.error, 0)
+	assertEquals(len(res), 0)
+
+	print "Testing for netlogon and highestCommittedUSN via LDAP"
+	attrs = ["netlogon", "highestCommittedUSN"]
+	res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+	assertEquals(res.error, 0)
+	assertEquals(len(res), 0)
+
+def find_basedn(ldb):
+    attrs = ["defaultNamingContext"]
+    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+    assertEquals(res.error, 0)
+    assertEquals(len(res), 1)
+    return res[0].defaultNamingContext
+
+def find_configurationdn(ldb):
+    attrs = ["configurationNamingContext"]
+    res = ldb.search("", "", ldb.SCOPE_BASE, attrs)
+    assertEquals(res.error, 0)
+    assertEquals(len(res), 1)
+    return res[0].configurationNamingContext
+
+def find_schemadn(ldb):
+    res = ldb.search("", "", ldb.SCOPE_BASE, attrs=["schemaNamingContext"])
+    assertEquals(res.error, 0)
+    assertEquals(len(res), 1)
+    return res[0].schemaNamingContext
+
+# use command line creds if available
+ldb.credentials = options.get_credentials()
+gc_ldb.credentials = options.get_credentials()
+
+ok = ldb.connect("ldap://" + host)
+base_dn = find_basedn(ldb)
+
+configuration_dn = find_configurationdn(ldb)
+schema_dn = find_schemadn(ldb)
+
+print "baseDN: %s\n" % base_dn
+
+ok = gc_ldb.connect("ldap://" + host + ":3268")
+if (!ok) {
+	gc_ldb = undefined
+}
+
+basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn)
+basedn_tests(ldb, gc_ldb)
diff --git a/source4/lib/registry/registry.i b/source4/lib/registry/registry.i
index 3fabba9a66..6f46e081c2 100644
--- a/source4/lib/registry/registry.i
+++ b/source4/lib/registry/registry.i
@@ -32,7 +32,7 @@ typedef struct hive_key hive_key;
 %}
 
 /* FIXME: This should be in another file */
-%typemap(default) struct auth_session_info * {
+%typemap(default,noblock=1) struct auth_session_info * {
     $1 = NULL; 
 }
 
@@ -48,11 +48,11 @@ const char *reg_get_predef_name(uint32_t hkey);
 const char *str_regtype(int type);
 
 /* Registry contexts */
-%typemap(in,numinputs=0) struct registry_context ** (struct registry_context *tmp) {
+%typemap(in,noblock=1,numinputs=0) struct registry_context ** (struct registry_context *tmp) {
     $1 = &tmp; 
 }
 
-%typemap(argout) struct registry_context ** {
+%typemap(argout,noblock=1) struct registry_context ** {
     $result = SWIG_NewPointerObj(*$1, SWIGTYPE_p_registry_context, 0);
 }
 
@@ -61,7 +61,7 @@ WERROR reg_open_local(TALLOC_CTX *parent_ctx, struct registry_context **ctx,
                       struct auth_session_info *session_info,
                       struct cli_credentials *credentials);
 
-%typemap(in) const char ** {
+%typemap(in,noblock=1) const char ** {
   /* Check if is a list */
   if (PyList_Check($input)) {
     int size = PyList_Size($input);
@@ -84,7 +84,7 @@ WERROR reg_open_local(TALLOC_CTX *parent_ctx, struct registry_context **ctx,
   }
 }
 
-%typemap(freearg) const char ** {
+%typemap(freearg,noblock=1) const char ** {
   free((char **) $1);
 }
 
@@ -121,11 +121,11 @@ typedef struct registry_context {
 } reg;
 
 /* Hives */
-%typemap(in,numinputs=0) struct hive_key ** (struct hive_key *tmp) {
+%typemap(in,noblock=1,numinputs=0) struct hive_key ** (struct hive_key *tmp) {
     $1 = &tmp; 
 }
 
-%typemap(argout) struct hive_key ** {
+%typemap(argout,noblock=1) struct hive_key ** {
     Py_XDECREF($result);
     $result = SWIG_NewPointerObj(*$1, SWIGTYPE_p_hive_key, 0);
 }
diff --git a/source4/lib/registry/registry_wrap.c b/source4/lib/registry/registry_wrap.c
index c02f9cacc6..cabdfad887 100644
--- a/source4/lib/registry/registry_wrap.c
+++ b/source4/lib/registry/registry_wrap.c
@@ -2928,18 +2928,12 @@ SWIGINTERN PyObject *_wrap_Registry(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     (char *) "session_info",(char *) "credentials", NULL 
   };
   
-  {
-    arg3 = NULL; 
-  }
+  arg3 = NULL;
   {
     arg4 = NULL;
   }
-  {
-    arg1 = NULL;
-  }
-  {
-    arg2 = &tmp2; 
-  }
+  arg1 = NULL;
+  arg2 = &tmp2;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:Registry",kwnames,&obj0,&obj1)) SWIG_fail;
   if (obj0) {
     res3 = SWIG_ConvertPtr(obj0, &argp3,SWIGTYPE_p_auth_session_info, 0 |  0 );
@@ -2956,17 +2950,14 @@ SWIGINTERN PyObject *_wrap_Registry(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     arg4 = (struct cli_credentials *)(argp4);
   }
   result = reg_open_local(arg1,arg2,arg3,arg4);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    resultobj = SWIG_NewPointerObj(*arg2, SWIGTYPE_p_registry_context, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  resultobj = SWIG_NewPointerObj(*arg2, SWIGTYPE_p_registry_context, 0);
   return resultobj;
 fail:
   return NULL;
@@ -3010,13 +3001,12 @@ SWIGINTERN PyObject *_wrap_reg_get_predefined_key_by_name(PyObject *SWIGUNUSEDPA
   }
   arg3 = (struct registry_key **)(argp3);
   result = reg_get_predefined_key_by_name(arg1,(char const *)arg2,arg3);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -3054,13 +3044,12 @@ SWIGINTERN PyObject *_wrap_reg_key_del_abs(PyObject *SWIGUNUSEDPARM(self), PyObj
   }
   arg2 = (char *)(buf2);
   result = reg_key_del_abs(arg1,(char const *)arg2);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -3106,13 +3095,12 @@ SWIGINTERN PyObject *_wrap_reg_get_predefined_key(PyObject *SWIGUNUSEDPARM(self)
   }
   arg3 = (struct registry_key **)(argp3);
   result = reg_get_predefined_key(arg1,arg2,arg3);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   return resultobj;
 fail:
@@ -3148,13 +3136,12 @@ SWIGINTERN PyObject *_wrap_reg_diff_apply(PyObject *SWIGUNUSEDPARM(self), PyObje
   }
   arg2 = (char *)(buf2);
   result = reg_diff_apply(arg1,(char const *)arg2);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
@@ -3207,13 +3194,12 @@ SWIGINTERN PyObject *_wrap_reg_generate_diff(PyObject *SWIGUNUSEDPARM(self), PyO
     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "reg_generate_diff" "', argument " "4"" of type '" "void *""'"); 
   }
   result = reg_generate_diff(arg1,arg2,(struct reg_diff_callbacks const *)arg3,arg4);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   return resultobj;
 fail:
@@ -3252,46 +3238,39 @@ SWIGINTERN PyObject *_wrap_reg_mount_hive__SWIG_0(PyObject *SWIGUNUSEDPARM(self)
   } 
   arg3 = (uint32_t)(val3);
   if (swig_obj[3]) {
-    {
-      /* Check if is a list */
-      if (PyList_Check(swig_obj[3])) {
-        int size = PyList_Size(swig_obj[3]);
-        int i = 0;
-        arg4 = (char **) malloc((size+1)*sizeof(const char *));
-        for (i = 0; i < size; i++) {
-          PyObject *o = PyList_GetItem(swig_obj[3],i);
-          if (PyString_Check(o))
-          arg4[i] = PyString_AsString(PyList_GetItem(swig_obj[3],i));
-          else {
-            PyErr_SetString(PyExc_TypeError,"list must contain strings");
-            free(arg4);
-            return NULL;
-          }
+    /* Check if is a list */
+    if (PyList_Check(swig_obj[3])) {
+      int size = PyList_Size(swig_obj[3]);
+      int i = 0;
+      arg4 = (char **) malloc((size+1)*sizeof(const char *));
+      for (i = 0; i < size; i++) {
+        PyObject *o = PyList_GetItem(swig_obj[3],i);
+        if (PyString_Check(o))
+        arg4[i] = PyString_AsString(PyList_GetItem(swig_obj[3],i));
+        else {
+          PyErr_SetString(PyExc_TypeError,"list must contain strings");
+          free(arg4);
+          return NULL;
         }
-        arg4[i] = 0;
-      } else {
-        PyErr_SetString(PyExc_TypeError,"not a list");
-        return NULL;
       }
+      arg4[i] = 0;
+    } else {
+      PyErr_SetString(PyExc_TypeError,"not a list");
+      return NULL;
     }
   }
   result = reg_mount_hive(arg1,arg2,arg3,(char const **)arg4);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    free((char **) arg4);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  free((char **) arg4);
   return resultobj;
 fail:
-  {
-    free((char **) arg4);
-  }
+  free((char **) arg4);
   return NULL;
 }
 
@@ -3333,38 +3312,32 @@ SWIGINTERN PyObject *_wrap_reg_import_hive_key(PyObject *SWIGUNUSEDPARM(self), P
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "reg_import_hive_key" "', argument " "3"" of type '" "uint32_t""'");
   } 
   arg3 = (uint32_t)(val3);
-  {
-    /* Check if is a list */
-    if (PyList_Check(obj3)) {
-      int size = PyList_Size(obj3);
-      int i = 0;
-      arg4 = (char **) malloc((size+1)*sizeof(const char *));
-      for (i = 0; i < size; i++) {
-        PyObject *o = PyList_GetItem(obj3,i);
-        if (PyString_Check(o))
-        arg4[i] = PyString_AsString(PyList_GetItem(obj3,i));
-        else {
-          PyErr_SetString(PyExc_TypeError,"list must contain strings");
-          free(arg4);
-          return NULL;
-        }
+  /* Check if is a list */
+  if (PyList_Check(obj3)) {
+    int size = PyList_Size(obj3);
+    int i = 0;
+    arg4 = (char **) malloc((size+1)*sizeof(const char *));
+    for (i = 0; i < size; i++) {
+      PyObject *o = PyList_GetItem(obj3,i);
+      if (PyString_Check(o))
+      arg4[i] = PyString_AsString(PyList_GetItem(obj3,i));
+      else {
+        PyErr_SetString(PyExc_TypeError,"list must contain strings");
+        free(arg4);
+        return NULL;
       }
-      arg4[i] = 0;
-    } else {
-      PyErr_SetString(PyExc_TypeError,"not a list");
-      return NULL;
     }
+    arg4[i] = 0;
+  } else {
+    PyErr_SetString(PyExc_TypeError,"not a list");
+    return NULL;
   }
   result = (struct registry_key *)reg_import_hive_key(arg1,arg2,arg3,(char const **)arg4);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_registry_key, 0 |  0 );
-  {
-    free((char **) arg4);
-  }
+  free((char **) arg4);
   return resultobj;
 fail:
-  {
-    free((char **) arg4);
-  }
+  free((char **) arg4);
   return NULL;
 }
 
@@ -3400,13 +3373,12 @@ SWIGINTERN PyObject *_wrap_reg_mount_hive__SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   }
   arg3 = (char *)(buf3);
   result = reg_mount_hive__SWIG_1(arg1,arg2,(char const *)arg3);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
   }
   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
   return resultobj;
@@ -3519,21 +3491,15 @@ SWIGINTERN PyObject *_wrap_hive_key(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     (char *) "location",(char *) "session_info",(char *) "credentials",(char *) "lp_ctx", NULL 
   };
   
-  {
-    arg3 = NULL; 
-  }
+  arg3 = NULL;
   {
     arg4 = NULL;
   }
   {
     arg5 = loadparm_init(NULL);
   }
-  {
-    arg1 = NULL;
-  }
-  {
-    arg6 = &tmp6; 
-  }
+  arg1 = NULL;
+  arg6 = &tmp6;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:hive_key",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
@@ -3562,18 +3528,15 @@ SWIGINTERN PyObject *_wrap_hive_key(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     arg5 = (struct loadparm_context *)(argp5);
   }
   result = reg_open_hive(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    Py_XDECREF(resultobj);
-    resultobj = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_hive_key, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  Py_XDECREF(resultobj);
+  resultobj = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_hive_key, 0);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -3609,21 +3572,15 @@ SWIGINTERN PyObject *_wrap_open_ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     (char *) "location",(char *) "session_info",(char *) "credentials",(char *) "lp_ctx", NULL 
   };
   
-  {
-    arg3 = NULL; 
-  }
+  arg3 = NULL;
   {
     arg4 = NULL;
   }
   {
     arg5 = loadparm_init(NULL);
   }
-  {
-    arg1 = NULL;
-  }
-  {
-    arg6 = &tmp6; 
-  }
+  arg1 = NULL;
+  arg6 = &tmp6;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:open_ldb",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
@@ -3652,18 +3609,15 @@ SWIGINTERN PyObject *_wrap_open_ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     arg5 = (struct loadparm_context *)(argp5);
   }
   result = reg_open_ldb_file(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    Py_XDECREF(resultobj);
-    resultobj = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_hive_key, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  Py_XDECREF(resultobj);
+  resultobj = SWIG_NewPointerObj(*arg6, SWIGTYPE_p_hive_key, 0);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -3687,12 +3641,8 @@ SWIGINTERN PyObject *_wrap_create_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *
     (char *) "location", NULL 
   };
   
-  {
-    arg1 = NULL;
-  }
-  {
-    arg3 = &tmp3; 
-  }
+  arg1 = NULL;
+  arg3 = &tmp3;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:create_dir",kwnames,&obj0)) SWIG_fail;
   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
@@ -3700,18 +3650,15 @@ SWIGINTERN PyObject *_wrap_create_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *
   }
   arg2 = (char *)(buf2);
   result = reg_create_directory(arg1,(char const *)arg2,arg3);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    Py_XDECREF(resultobj);
-    resultobj = SWIG_NewPointerObj(*arg3, SWIGTYPE_p_hive_key, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  Py_XDECREF(resultobj);
+  resultobj = SWIG_NewPointerObj(*arg3, SWIGTYPE_p_hive_key, 0);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -3735,12 +3682,8 @@ SWIGINTERN PyObject *_wrap_open_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
     (char *) "location", NULL 
   };
   
-  {
-    arg1 = NULL;
-  }
-  {
-    arg3 = &tmp3; 
-  }
+  arg1 = NULL;
+  arg3 = &tmp3;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:open_dir",kwnames,&obj0)) SWIG_fail;
   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
@@ -3748,18 +3691,15 @@ SWIGINTERN PyObject *_wrap_open_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
   }
   arg2 = (char *)(buf2);
   result = reg_open_directory(arg1,(char const *)arg2,arg3);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    Py_XDECREF(resultobj);
-    resultobj = SWIG_NewPointerObj(*arg3, SWIGTYPE_p_hive_key, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  Py_XDECREF(resultobj);
+  resultobj = SWIG_NewPointerObj(*arg3, SWIGTYPE_p_hive_key, 0);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
@@ -3793,18 +3733,12 @@ SWIGINTERN PyObject *_wrap_open_samba(PyObject *SWIGUNUSEDPARM(self), PyObject *
   {
     arg3 = loadparm_init(NULL);
   }
-  {
-    arg4 = NULL; 
-  }
+  arg4 = NULL;
   {
     arg5 = NULL;
   }
-  {
-    arg1 = NULL;
-  }
-  {
-    arg2 = &tmp2; 
-  }
+  arg1 = NULL;
+  arg2 = &tmp2;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:open_samba",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
   if (obj0) {
     res3 = SWIG_ConvertPtr(obj0, &argp3,SWIGTYPE_p_loadparm_context, 0 |  0 );
@@ -3828,17 +3762,14 @@ SWIGINTERN PyObject *_wrap_open_samba(PyObject *SWIGUNUSEDPARM(self), PyObject *
     arg5 = (struct cli_credentials *)(argp5);
   }
   result = reg_open_samba(arg1,arg2,arg3,arg4,arg5);
-  {
-    if (!W_ERROR_IS_OK(result)) {
-      PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
-      PyErr_SetObject(PyExc_RuntimeError, obj);
-    } else if (resultobj == NULL) {
-      resultobj = Py_None;
-    }
-  }
-  {
-    resultobj = SWIG_NewPointerObj(*arg2, SWIGTYPE_p_registry_context, 0);
-  }
+  if (!W_ERROR_IS_OK(result)) {
+    PyObject *obj = Py_BuildValue("(i,s)", (&result)->v, win_errstr(result));
+    PyErr_SetObject(PyExc_RuntimeError, obj);
+    SWIG_fail;
+  } else if (resultobj == NULL) {
+    resultobj = Py_None;
+  }
+  resultobj = SWIG_NewPointerObj(*arg2, SWIGTYPE_p_registry_context, 0);
   return resultobj;
 fail:
   return NULL;
diff --git a/source4/lib/registry/tests/bindings.py b/source4/lib/registry/tests/bindings.py
index 9f93ee9382..906deed7e9 100644
--- a/source4/lib/registry/tests/bindings.py
+++ b/source4/lib/registry/tests/bindings.py
@@ -40,11 +40,11 @@ class HiveTests(samba.tests.TestCaseInTempDir):
     def test_ldb_new(self):
         self.assertTrue(self.hive is not None)
 
-    def test_flush(self):
-        self.hive.flush()
+    #def test_flush(self):
+    #    self.hive.flush()
 
-    def test_del_value(self):
-        self.hive.del_value("FOO")
+    #def test_del_value(self):
+    #    self.hive.del_value("FOO")
 
 
 class RegistryTests(unittest.TestCase):
diff --git a/source4/lib/talloc/talloc.i b/source4/lib/talloc/talloc.i
index c852ae8f9f..a9afb97ed7 100644
--- a/source4/lib/talloc/talloc.i
+++ b/source4/lib/talloc/talloc.i
@@ -19,7 +19,7 @@
 /* Don't expose talloc contexts in Python code. Python does reference 
    counting for us, so just create a new top-level talloc context.
  */
-%typemap(in, numinputs=0) TALLOC_CTX * {
+%typemap(in, numinputs=0, noblock=1) TALLOC_CTX * {
     $1 = NULL;
 }
 
diff --git a/source4/lib/tdb/tdb.i b/source4/lib/tdb/tdb.i
index 03b71fa586..5bb6506d93 100644
--- a/source4/lib/tdb/tdb.i
+++ b/source4/lib/tdb/tdb.i
@@ -49,7 +49,7 @@ typedef TDB_CONTEXT tdb;
 %import exception.i
 %import stdint.i
 
-%typemap(check) TDB_CONTEXT* {
+%typemap(check,noblock=1) TDB_CONTEXT* {
 	if ($1 == NULL)
 		SWIG_exception(SWIG_ValueError, 
 			"tdb context must be non-NULL");
@@ -59,7 +59,7 @@ typedef TDB_CONTEXT tdb;
    and from the Python string type which can contain arbitrary binary
    data.. */
 
-%typemap(in) TDB_DATA {
+%typemap(in,noblock=1) TDB_DATA {
 	if (!PyString_Check($input)) {
 		PyErr_SetString(PyExc_TypeError, "string arg expected");
 		return NULL;
@@ -68,7 +68,7 @@ typedef TDB_CONTEXT tdb;
 	$1.dptr = (uint8_t *)PyString_AsString($input);
 }
 
-%typemap(out) TDB_DATA {
+%typemap(out,noblock=1) TDB_DATA {
 	if ($1.dptr == NULL && $1.dsize == 0) {
 		$result = Py_None;
 	} else {
@@ -115,23 +115,23 @@ enum TDB_ERROR {
 %rename(read_lock_all) tdb_context::lockall_read;
 %rename(read_unlock_all) tdb_context::unlockall_read;
 
-%typemap(default) int tdb_flags {
+%typemap(default,noblock=1) int tdb_flags {
     $1 = TDB_DEFAULT;
 }
 
-%typemap(default) int open_flags {
+%typemap(default,noblock=1) int open_flags {
     $1 = O_RDWR;
 }
 
-%typemap(default) int hash_size {
+%typemap(default,noblock=1) int hash_size {
     $1 = 0;
 }
 
-%typemap(default) mode_t mode {
+%typemap(default,noblock=1) mode_t mode {
     $1 = 0600;
 }
 
-%typemap(default) int flag {
+%typemap(default,noblock=1) int flag {
     $1 = TDB_REPLACE;
 }
 
diff --git a/source4/lib/tdb/tdb_wrap.c b/source4/lib/tdb/tdb_wrap.c
index 841cd78399..1ba7481af0 100644
--- a/source4/lib/tdb/tdb_wrap.c
+++ b/source4/lib/tdb/tdb_wrap.c
@@ -2831,18 +2831,10 @@ SWIGINTERN PyObject *_wrap_new_Tdb(PyObject *SWIGUNUSEDPARM(self), PyObject *arg
     (char *) "name",(char *) "hash_size",(char *) "tdb_flags",(char *) "open_flags",(char *) "mode", NULL 
   };
   
-  {
-    arg2 = 0;
-  }
-  {
-    arg3 = TDB_DEFAULT;
-  }
-  {
-    arg4 = O_RDWR;
-  }
-  {
-    arg5 = 0600;
-  }
+  arg2 = 0;
+  arg3 = TDB_DEFAULT;
+  arg4 = O_RDWR;
+  arg5 = 0600;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_Tdb",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
@@ -2977,22 +2969,18 @@ SWIGINTERN PyObject *_wrap_tdb_append(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_append" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
-  {
-    if (!PyString_Check(obj2)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg3)->dsize = PyString_Size(obj2);
-    (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj2)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg3)->dsize = PyString_Size(obj2);
+  (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
   result = (int)tdb_append(arg1,arg2,arg3);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
@@ -3043,22 +3031,18 @@ SWIGINTERN PyObject *_wrap_tdb_fetch(PyObject *SWIGUNUSEDPARM(self), PyObject *a
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_fetch" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
   result = tdb_fetch(arg1,arg2);
-  {
-    if ((&result)->dptr == NULL && (&result)->dsize == 0) {
-      resultobj = Py_None;
-    } else {
-      resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
-      free((&result)->dptr);
-    }
+  if ((&result)->dptr == NULL && (&result)->dsize == 0) {
+    resultobj = Py_None;
+  } else {
+    resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
+    free((&result)->dptr);
   }
   return resultobj;
 fail:
@@ -3085,14 +3069,12 @@ SWIGINTERN PyObject *_wrap_tdb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_delete" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
   result = (int)tdb_delete(arg1,arg2);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
@@ -3120,31 +3102,25 @@ SWIGINTERN PyObject *_wrap_tdb_store(PyObject *SWIGUNUSEDPARM(self), PyObject *a
     (char *) "self",(char *) "key",(char *) "dbuf",(char *) "flag", NULL 
   };
   
-  {
-    arg4 = TDB_REPLACE;
-  }
+  arg4 = TDB_REPLACE;
   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:tdb_store",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_store" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
-  {
-    if (!PyString_Check(obj2)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg3)->dsize = PyString_Size(obj2);
-    (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj2)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg3)->dsize = PyString_Size(obj2);
+  (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
   if (obj3) {
     ecode4 = SWIG_AsVal_int(obj3, &val4);
     if (!SWIG_IsOK(ecode4)) {
@@ -3179,14 +3155,12 @@ SWIGINTERN PyObject *_wrap_tdb_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_exists" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
   result = (int)tdb_exists(arg1,arg2);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
@@ -3211,13 +3185,11 @@ SWIGINTERN PyObject *_wrap_tdb_firstkey(PyObject *SWIGUNUSEDPARM(self), PyObject
   }
   arg1 = (tdb *)(argp1);
   result = tdb_firstkey(arg1);
-  {
-    if ((&result)->dptr == NULL && (&result)->dsize == 0) {
-      resultobj = Py_None;
-    } else {
-      resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
-      free((&result)->dptr);
-    }
+  if ((&result)->dptr == NULL && (&result)->dsize == 0) {
+    resultobj = Py_None;
+  } else {
+    resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
+    free((&result)->dptr);
   }
   return resultobj;
 fail:
@@ -3244,22 +3216,18 @@ SWIGINTERN PyObject *_wrap_tdb_nextkey(PyObject *SWIGUNUSEDPARM(self), PyObject
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tdb_nextkey" "', argument " "1"" of type '" "tdb *""'"); 
   }
   arg1 = (tdb *)(argp1);
-  {
-    if (!PyString_Check(obj1)) {
-      PyErr_SetString(PyExc_TypeError, "string arg expected");
-      return NULL;
-    }
-    (&arg2)->dsize = PyString_Size(obj1);
-    (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
+  if (!PyString_Check(obj1)) {
+    PyErr_SetString(PyExc_TypeError, "string arg expected");
+    return NULL;
   }
+  (&arg2)->dsize = PyString_Size(obj1);
+  (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
   result = tdb_nextkey(arg1,arg2);
-  {
-    if ((&result)->dptr == NULL && (&result)->dsize == 0) {
-      resultobj = Py_None;
-    } else {
-      resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
-      free((&result)->dptr);
-    }
+  if ((&result)->dptr == NULL && (&result)->dsize == 0) {
+    resultobj = Py_None;
+  } else {
+    resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
+    free((&result)->dptr);
   }
   return resultobj;
 fail: