Merge branch 'v4-0-test' of git://git.samba.org/samba into 4-0-local

(This used to be commit d8a805a2544c8864136f77e9086b2a01ae79a1d5)

62 files changed, 1921 insertions, 612 deletions

diff --git a/source4/auth/credentials/credentials.i b/source4/auth/credentials/credentials.i
index 8f09ff4b18..ee09b43a75 100644
--- a/source4/auth/credentials/credentials.i
+++ b/source4/auth/credentials/credentials.i
@@ -95,3 +95,20 @@ typedef struct cli_credentials {
         bool wrong_password(void);
     }
 } cli_credentials;
+
+%{
+struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj)
+{
+    struct cli_credentials *ret;
+
+    if (py_obj == Py_None) {
+        return cli_credentials_init_anon(NULL);
+    }
+
+    if (SWIG_ConvertPtr(py_obj, (void *)&ret, SWIGTYPE_p_cli_credentials, 0 |  0 ) < 0) {
+        return NULL; 
+    }
+    return ret;
+}
+
+%}
diff --git a/source4/auth/credentials/credentials_wrap.c b/source4/auth/credentials/credentials_wrap.c
index ebf7162c5b..146a81abaf 100644
--- a/source4/auth/credentials/credentials_wrap.c
+++ b/source4/auth/credentials/credentials_wrap.c
@@ -2774,6 +2774,22 @@ SWIGINTERNINLINE PyObject*
 }
 
 SWIGINTERN void delete_cli_credentials(cli_credentials *self){ talloc_free(self); }
+
+struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj)
+{
+    struct cli_credentials *ret;
+
+    if (py_obj == Py_None) {
+        return cli_credentials_init_anon(NULL);
+    }
+
+    if (SWIG_ConvertPtr(py_obj, (void *)&ret, SWIGTYPE_p_cli_credentials, 0 |  0 ) < 0) {
+        return NULL; 
+    }
+    return ret;
+}
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/source4/auth/gensec/spnego_parse.c b/source4/auth/gensec/spnego_parse.c
index 37f4f12278..8012a83ba8 100644
--- a/source4/auth/gensec/spnego_parse.c
+++ b/source4/auth/gensec/spnego_parse.c
@@ -23,7 +23,7 @@
 #include "includes.h"
 #include "auth/gensec/spnego.h"
 #include "auth/gensec/gensec.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 
 static bool read_negTokenInit(struct asn1_data *asn1, TALLOC_CTX *mem_ctx,
 			      struct spnego_negTokenInit *token)
diff --git a/source4/auth/kerberos/gssapi_parse.c b/source4/auth/kerberos/gssapi_parse.c
index 4b1b178238..77e907d3fa 100644
--- a/source4/auth/kerberos/gssapi_parse.c
+++ b/source4/auth/kerberos/gssapi_parse.c
@@ -22,7 +22,7 @@
 */
 
 #include "includes.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "auth/gensec/gensec.h"
 
 /*
diff --git a/source4/headermap.txt b/source4/headermap.txt
index 6ace20519f..acbe81328e 100644
--- a/source4/headermap.txt
+++ b/source4/headermap.txt
@@ -103,8 +103,8 @@ dsdb/samdb/samdb_proto.h: samdb/proto.h
 dsdb/schema/schema.h: samdb/schema.h
 dsdb/schema/proto.h: samdb/schema_proto.h
 dsdb/common/proto.h: samdb/common_proto.h
-libcli/util/asn_1.h: samba/asn1.h
-libcli/util/asn1_proto.h: samba/asn1/proto.h
+lib/util/asn1.h: samba/asn1.h
+lib/util/asn1_proto.h: samba/asn1/proto.h
 libcli/util/error.h: core/error.h
 libcli/util/proto.h: core/error_proto.h
 lib/tdb_wrap.h: tdb_wrap.h
diff --git a/source4/ldap_server/ldap_server.c b/source4/ldap_server/ldap_server.c
index fcc9435ead..8380775c28 100644
--- a/source4/ldap_server/ldap_server.c
+++ b/source4/ldap_server/ldap_server.c
@@ -27,7 +27,7 @@
 #include "auth/credentials/credentials.h"
 #include "librpc/gen_ndr/ndr_samr.h"
 #include "lib/util/dlinklist.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "ldap_server/ldap_server.h"
 #include "smbd/service_task.h"
 #include "smbd/service_stream.h"
diff --git a/source4/lib/ldb/tests/python/ldap.py b/source4/lib/ldb/tests/python/ldap.py
index cede927f7a..01b66a3890 100755
--- a/source4/lib/ldb/tests/python/ldap.py
+++ b/source4/lib/ldb/tests/python/ldap.py
@@ -11,7 +11,10 @@ sys.path.append("scripting/python")
 import samba.getopt as options
 
 from auth import system_session
-from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
+from ldb import (SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError,
+                 LDB_ERR_NO_SUCH_OBJECT, LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS,
+                 LDB_ERR_ENTRY_ALREADY_EXISTS, LDB_ERR_UNWILLING_TO_PERFORM,
+                 LDB_ERR_NOT_ALLOWED_ON_NON_LEAF)
 from samba import Ldb
 import param
 
@@ -38,7 +41,7 @@ def delete_force(ldb, dn):
     try:
         ldb.delete(dn)
     except LdbError, (num, _): 
-        if num != 32: # LDAP_NO_SUCH_OBJECT
+        if num != LDB_ERR_NO_SUCH_OBJECT:
             assert False
 
 def assertEquals(a1, a2):
@@ -57,7 +60,7 @@ def basic_tests(ldb, gc_ldb, base_dn, configuration_dn, schema_dn):
         "objectclass": "group",
         "member": "cn=ldaptestuser,cn=useRs," + base_dn})
     except LdbError, (num, _): 
-        if num != 32: # LDAP_NO_SUCH_OBJECT
+        if num != LDB_ERR_NO_SUCH_OBJECT:
             assert False
     else:
         assert False
@@ -122,8 +125,7 @@ servicePrincipalName: host/ldaptest2computer
 servicePrincipalName: cifs/ldaptest2computer
 """)
     except LdbError, (num, msg):
-        #LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
-        assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got : %s" % msg
+        assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
 
         ldb.modify_ldif("""
 dn: cn=ldaptest2computer,cn=computers,""" + base_dn + """
@@ -140,7 +142,7 @@ add: servicePrincipalName
 servicePrincipalName: host/ldaptest2computer
 """)
         except LdbError, (num, msg):
-            assert num == 20, "Expected error LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS, got :" + msg
+            assert num == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
         
         print "Testing ranged results"
         ldb.modify_ldif("""
@@ -347,7 +349,7 @@ add: member
 member: cn=ldaptestuser3,cn=users,""" + base_dn + """
 """)
     except LdbError, (num, _):
-        assert num == 32
+        assert num == LDB_ERR_NO_SUCH_OBJECT
     else:
         assert False
 
@@ -391,7 +393,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
                   "objectClass": ["person", "user"],
                   "cn": "LDAPtestUSER3"})
     except LdbError, (num, _):
-        assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS
+        assert num == LDB_ERR_ENTRY_ALREADY_EXISTS
     else:
         assert False
 
@@ -402,7 +404,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
     try:
         ldb.rename("cn=ldaptestuser3,cn=users," + base_dn, "cn=ldaptestuser2,cn=users," + base_dn)
     except LdbError, (num, _): 
-        assert num == 32 # LDAP_NO_SUCH_OBJECT
+        assert num == LDB_ERR_NO_SUCH_OBJECT
     else:
         assert False
 
@@ -415,7 +417,7 @@ member: cn=ldaptestuser3,cn=users,""" + base_dn + """
     try:
         ldb.rename("cn=ldaptestuser2,cn=users," + base_dn, "cn=ldaptestuser3,cn=users," + base_dn)
     except LdbError, (num, _):
-        assert num == 68 #LDB_ERR_ENTRY_ALREADY_EXISTS
+        assert num == LDB_ERR_ENTRY_ALREADY_EXISTS
     else:
         assert False
     try:
@@ -468,7 +470,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
                 expression="(&(cn=ldaptestuser4)(objectClass=user))", 
                 scope=SCOPE_SUBTREE)
     except LdbError, (num, _):
-        assert num == 32
+        assert num == LDB_ERR_NO_SUCH_OBJECT
     else:
         assert False
 
@@ -476,7 +478,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
     try:
         res = ldb.search("cn=ldaptestcontainer," + base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_ONELEVEL)
     except LdbError, (num, _):
-        assert num == 32
+        assert num == LDB_ERR_NO_SUCH_OBJECT
     else:
         assert False
 
@@ -495,7 +497,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
     try:
         ldb.rename("cn=ldaptestcontainer2," + base_dn, "cn=ldaptestcontainer,cn=ldaptestcontainer2," + base_dn)
     except LdbError, (num, _):
-        assert num == 53 # LDAP_UNWILLING_TO_PERFORM
+        assert num == LDB_ERR_UNWILLING_TO_PERFORM
     else:
         assert False
 
@@ -511,7 +513,7 @@ member: cn=ldaptestuser4,cn=ldaptestcontainer,""" + base_dn + """
     try:
         ldb.delete("cn=ldaptestcontainer2," + base_dn)
     except LdbError, (num, _):
-        assert num == 66
+        assert num == LDB_ERR_NOT_ALLOWED_ON_NON_LEAF
     else:
         assert False
 
diff --git a/source4/lib/replace/getpass.m4 b/source4/lib/replace/getpass.m4
index 17dfdf7bf5..c4da9aae59 100644
--- a/source4/lib/replace/getpass.m4
+++ b/source4/lib/replace/getpass.m4
@@ -1,3 +1,11 @@
+AC_CHECK_FUNC(getpass, samba_cv_HAVE_GETPASS=yes)
+AC_CHECK_FUNC(getpassphrase, samba_cv_HAVE_GETPASSPHRASE=yes)
+if test x"$samba_cv_HAVE_GETPASS" = x"yes" -a x"$samba_cv_HAVE_GETPASSPHRASE" = x"yes"; then
+        AC_DEFINE(REPLACE_GETPASS_BY_GETPASSPHRASE, 1, [getpass returns <9 chars where getpassphrase returns <265 chars])
+	AC_DEFINE(REPLACE_GETPASS,1,[Whether getpass should be replaced])
+	LIBREPLACEOBJ="${LIBREPLACEOBJ} getpass.o"
+else
+
 AC_CACHE_CHECK([whether getpass should be replaced],samba_cv_REPLACE_GETPASS,[
 SAVE_CPPFLAGS="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS -I$libreplacedir/"
@@ -12,3 +20,5 @@ if test x"$samba_cv_REPLACE_GETPASS" = x"yes"; then
 	AC_DEFINE(REPLACE_GETPASS,1,[Whether getpass should be replaced])
 	LIBREPLACEOBJ="${LIBREPLACEOBJ} getpass.o"
 fi
+
+fi
diff --git a/source4/lib/replace/libreplace.m4 b/source4/lib/replace/libreplace.m4
index a577285639..6d1d6b8afc 100644
--- a/source4/lib/replace/libreplace.m4
+++ b/source4/lib/replace/libreplace.m4
@@ -100,6 +100,7 @@ AC_CHECK_HEADERS(sys/socket.h netinet/in.h netdb.h arpa/inet.h)
 AC_CHECK_HEADERS(netinet/ip.h netinet/tcp.h netinet/in_systm.h netinet/in_ip.h)
 AC_CHECK_HEADERS(sys/sockio.h sys/un.h)
 AC_CHECK_HEADERS(sys/mount.h mntent.h)
+AC_CHECK_HEADERS(stropts.h)
 
 dnl we need to check that net/if.h really can be used, to cope with hpux
 dnl where including it always fails
diff --git a/source4/lib/replace/libreplace_ld.m4 b/source4/lib/replace/libreplace_ld.m4
index 0ca6f7a34d..2aec698967 100644
--- a/source4/lib/replace/libreplace_ld.m4
+++ b/source4/lib/replace/libreplace_ld.m4
@@ -265,7 +265,7 @@ AC_DEFUN([AC_LIBREPLACE_LD_SHLIB_ALLOW_UNDEF_FLAG],
 			LD_SHLIB_ALLOW_UNDEF_FLAG="-Wl,--allow-shlib-undefined"
 			;;
 		*osf*)
-			LD_SHLIB_ALLOW_UNDEF_FLAG="-Wl,-expect_unresolved,*"
+			LD_SHLIB_ALLOW_UNDEF_FLAG="-Wl,-expect_unresolved,\"*\""
 			;;
 		*darwin*)
 			LD_SHLIB_ALLOW_UNDEF_FLAG="-undefined dynamic_lookup"
diff --git a/source4/lib/replace/replace.c b/source4/lib/replace/replace.c
index cec158be31..b2a240e8ab 100644
--- a/source4/lib/replace/replace.c
+++ b/source4/lib/replace/replace.c
@@ -218,7 +218,7 @@ long nap(long milliseconds) {
 #ifndef HAVE_MEMMOVE
 /*******************************************************************
 safely copies memory, ensuring no overlap problems.
-this is only used if the machine does not have it's own memmove().
+this is only used if the machine does not have its own memmove().
 this is not the fastest algorithm in town, but it will do for our
 needs.
 ********************************************************************/
diff --git a/source4/lib/replace/replace.h b/source4/lib/replace/replace.h
index f8a89a7213..3f91544e97 100644
--- a/source4/lib/replace/replace.h
+++ b/source4/lib/replace/replace.h
@@ -546,4 +546,12 @@ typedef int bool;
 #define QSORT_CAST (int (*)(const void *, const void *))
 #endif
 
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
+#ifndef MAX_DNS_NAME_LENGTH
+#define MAX_DNS_NAME_LENGTH 256 /* Actually 255 but +1 for terminating null. */
+#endif
+
 #endif /* _LIBREPLACE_REPLACE_H */
diff --git a/source4/lib/replace/system/network.h b/source4/lib/replace/system/network.h
index e2fad5f686..53bef66d48 100644
--- a/source4/lib/replace/system/network.h
+++ b/source4/lib/replace/system/network.h
@@ -79,6 +79,10 @@
 #include <sys/ioctl.h>
 #endif
 
+#ifdef HAVE_STROPTS_H
+#include <stropts.h>
+#endif
+
 #ifdef REPLACE_INET_NTOA
 /* define is in "replace.h" */
 char *rep_inet_ntoa(struct in_addr ip);
diff --git a/source4/lib/replace/system/passwd.h b/source4/lib/replace/system/passwd.h
index 36fca7b4f8..cad3197ccb 100644
--- a/source4/lib/replace/system/passwd.h
+++ b/source4/lib/replace/system/passwd.h
@@ -68,9 +68,13 @@
 #endif
 
 #ifdef REPLACE_GETPASS
+#if defined(REPLACE_GETPASS_BY_GETPASSPHRASE)
+#define getpass(prompt) getpassphrase(prompt)
+#else
 #define getpass(prompt) rep_getpass(prompt)
 char *rep_getpass(const char *prompt);
 #endif
+#endif
 
 #ifndef NGROUPS_MAX
 #define NGROUPS_MAX 32 /* Guess... */
diff --git a/source4/lib/tdb/common/freelist.c b/source4/lib/tdb/common/freelist.c
index b109643f23..c086c151fa 100644
--- a/source4/lib/tdb/common/freelist.c
+++ b/source4/lib/tdb/common/freelist.c
@@ -27,6 +27,12 @@
 
 #include "tdb_private.h"
 
+/* 'right' merges can involve O(n^2) cost when combined with a
+   traverse, so they are disabled until we find a way to do them in 
+   O(1) time
+*/
+#define USE_RIGHT_MERGES 0
+
 /* read a freelist record and check for simple errors */
 int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off, struct list_struct *rec)
 {
@@ -56,7 +62,7 @@ int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off, struct list_struct
 }
 
 
-
+#if USE_RIGHT_MERGES
 /* Remove an element from the freelist.  Must have alloc lock. */
 static int remove_from_freelist(struct tdb_context *tdb, tdb_off_t off, tdb_off_t next)
 {
@@ -75,6 +81,7 @@ static int remove_from_freelist(struct tdb_context *tdb, tdb_off_t off, tdb_off_
 	TDB_LOG((tdb, TDB_DEBUG_FATAL,"remove_from_freelist: not on list at off=%d\n", off));
 	return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
 }
+#endif
 
 
 /* update a record tailer (must hold allocation lock) */
@@ -93,8 +100,6 @@ static int update_tailer(struct tdb_context *tdb, tdb_off_t offset,
    neccessary. */
 int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
 {
-	tdb_off_t right, left;
-
 	/* Allocation and tailer lock */
 	if (tdb_lock(tdb, -1, F_WRLCK) != 0)
 		return -1;
@@ -105,9 +110,10 @@ int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
 		goto fail;
 	}
 
+#if USE_RIGHT_MERGES
 	/* Look right first (I'm an Australian, dammit) */
-	right = offset + sizeof(*rec) + rec->rec_len;
-	if (right + sizeof(*rec) <= tdb->map_size) {
+	if (offset + sizeof(*rec) + rec->rec_len + sizeof(*rec) <= tdb->map_size) {
+		tdb_off_t right = offset + sizeof(*rec) + rec->rec_len;
 		struct list_struct r;
 
 		if (tdb->methods->tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
@@ -122,13 +128,18 @@ int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
 				goto left;
 			}
 			rec->rec_len += sizeof(r) + r.rec_len;
+			if (update_tailer(tdb, offset, rec) == -1) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_tailer failed at %u\n", offset));
+				goto fail;
+			}
 		}
 	}
-
 left:
+#endif
+
 	/* Look left */
-	left = offset - sizeof(tdb_off_t);
-	if (left > TDB_DATA_START(tdb->header.hash_size)) {
+	if (offset - sizeof(tdb_off_t) > TDB_DATA_START(tdb->header.hash_size)) {
+		tdb_off_t left = offset - sizeof(tdb_off_t);
 		struct list_struct l;
 		tdb_off_t leftsize;
 		
@@ -145,7 +156,12 @@ left:
 
 		left = offset - leftsize;
 
-		/* Now read in record */
+		if (leftsize > offset ||
+		    left < TDB_DATA_START(tdb->header.hash_size)) {
+			goto update;
+		}
+
+		/* Now read in the left record */
 		if (tdb->methods->tdb_read(tdb, left, &l, sizeof(l), DOCONV()) == -1) {
 			TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: left read failed at %u (%u)\n", left, leftsize));
 			goto update;
@@ -153,21 +169,24 @@ left:
 
 		/* If it's free, expand to include it. */
 		if (l.magic == TDB_FREE_MAGIC) {
-			if (remove_from_freelist(tdb, left, l.next) == -1) {
-				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: left free failed at %u\n", left));
-				goto update;
-			} else {
-				offset = left;
-				rec->rec_len += leftsize;
+			/* we now merge the new record into the left record, rather than the other 
+			   way around. This makes the operation O(1) instead of O(n). This change
+			   prevents traverse from being O(n^2) after a lot of deletes */
+			l.rec_len += sizeof(*rec) + rec->rec_len;
+			if (tdb_rec_write(tdb, left, &l) == -1) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_left failed at %u\n", left));
+				goto fail;
 			}
+			if (update_tailer(tdb, left, &l) == -1) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_tailer failed at %u\n", offset));
+				goto fail;
+			}
+			tdb_unlock(tdb, -1, F_WRLCK);
+			return 0;
 		}
 	}
 
 update:
-	if (update_tailer(tdb, offset, rec) == -1) {
-		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_tailer failed at %u\n", offset));
-		goto fail;
-	}
 
 	/* Now, prepend to free list */
 	rec->magic = TDB_FREE_MAGIC;
@@ -261,6 +280,7 @@ tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_st
 		tdb_off_t rec_ptr, last_ptr;
 		tdb_len_t rec_len;
 	} bestfit;
+	float multiplier = 1.0;
 
 	if (tdb_lock(tdb, -1, F_WRLCK) == -1)
 		return 0;
@@ -295,18 +315,27 @@ tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_st
 				bestfit.rec_len = rec->rec_len;
 				bestfit.rec_ptr = rec_ptr;
 				bestfit.last_ptr = last_ptr;
-				/* consider a fit to be good enough if
-				   we aren't wasting more than half
-				   the space */
-				if (bestfit.rec_len < 2*length) {
-					break;
-				}
 			}
 		}
 
 		/* move to the next record */
 		last_ptr = rec_ptr;
 		rec_ptr = rec->next;
+
+		/* if we've found a record that is big enough, then
+		   stop searching if its also not too big. The
+		   definition of 'too big' changes as we scan
+		   through */
+		if (bestfit.rec_len > 0 &&
+		    bestfit.rec_len < length * multiplier) {
+			break;
+		}
+		
+		/* this multiplier means we only extremely rarely
+		   search more than 50 or so records. At 50 records we
+		   accept records up to 11 times larger than what we
+		   want */
+		multiplier *= 1.05;
 	}
 
 	if (bestfit.rec_ptr != 0) {
@@ -328,3 +357,25 @@ tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_st
 	return 0;
 }
 
+
+
+/* 
+   return the size of the freelist - used to decide if we should repack 
+*/
+int tdb_freelist_size(struct tdb_context *tdb)
+{
+	tdb_off_t ptr;
+	int count=0;
+
+	if (tdb_lock(tdb, -1, F_RDLCK) == -1) {
+		return -1;
+	}
+
+	ptr = FREELIST_TOP;
+	while (tdb_ofs_read(tdb, ptr, &ptr) == 0 && ptr != 0) {
+		count++;
+	}
+
+	tdb_unlock(tdb, -1, F_RDLCK);
+	return count;
+}
diff --git a/source4/lib/tdb/common/io.c b/source4/lib/tdb/common/io.c
index 8ab0768883..172ab69d8c 100644
--- a/source4/lib/tdb/common/io.c
+++ b/source4/lib/tdb/common/io.c
@@ -101,8 +101,8 @@ static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
 					 off+written);
 		}
 		if (written == -1) {
-			/* Ensure ecode is set for log fn. */
-			tdb->ecode = TDB_ERR_IO;
+		/* Ensure ecode is set for log fn. */
+		tdb->ecode = TDB_ERR_IO;
 			TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
 				 "len=%d (%s)\n", off, len, strerror(errno)));
 			return TDB_ERRCODE(TDB_ERR_IO, -1);
@@ -111,8 +111,8 @@ static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
 				 "write %d bytes at %d in two attempts\n",
 				 len, off));
 			errno = ENOSPC;
-			return TDB_ERRCODE(TDB_ERR_IO, -1);
-		}
+		return TDB_ERRCODE(TDB_ERR_IO, -1);
+	}
 	}
 	return 0;
 }
@@ -230,7 +230,7 @@ void tdb_mmap(struct tdb_context *tdb)
   says to use for mmap expansion */
 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
 {
-	char buf[1024];
+	char buf[8192];
 
 	if (tdb->read_only || tdb->traverse_read) {
 		tdb->ecode = TDB_ERR_RDONLY;
@@ -294,7 +294,7 @@ static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t ad
 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
 {
 	struct list_struct rec;
-	tdb_off_t offset;
+	tdb_off_t offset, new_size;	
 
 	if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 		TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
@@ -304,9 +304,11 @@ int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
 	/* must know about any previous expansions by another process */
 	tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
 
-	/* always make room for at least 10 more records, and round
-           the database up to a multiple of the page size */
-	size = TDB_ALIGN(tdb->map_size + size*10, tdb->page_size) - tdb->map_size;
+	/* always make room for at least 100 more records, and at
+           least 25% more space. Round the database up to a multiple
+           of the page size */
+	new_size = MAX(tdb->map_size + size*100, tdb->map_size * 1.25);
+	size = TDB_ALIGN(new_size, tdb->page_size) - tdb->map_size;
 
 	if (!(tdb->flags & TDB_INTERNAL))
 		tdb_munmap(tdb);
diff --git a/source4/lib/tdb/common/lock.c b/source4/lib/tdb/common/lock.c
index e3fe888c46..f156c0fa7b 100644
--- a/source4/lib/tdb/common/lock.c
+++ b/source4/lib/tdb/common/lock.c
@@ -505,6 +505,9 @@ int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
 /* record lock stops delete underneath */
 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
 {
+	if (tdb->global_lock.count) {
+		return 0;
+	}
 	return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0, 1) : 0;
 }
 
@@ -537,6 +540,10 @@ int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 	struct tdb_traverse_lock *i;
 	uint32_t count = 0;
 
+	if (tdb->global_lock.count) {
+		return 0;
+	}
+
 	if (off == 0)
 		return 0;
 	for (i = &tdb->travlocks; i; i = i->next)
diff --git a/source4/lib/tdb/common/open.c b/source4/lib/tdb/common/open.c
index 0bd1c91a5e..6bd8fda2bf 100644
--- a/source4/lib/tdb/common/open.c
+++ b/source4/lib/tdb/common/open.c
@@ -35,7 +35,7 @@ static struct tdb_context *tdbs = NULL;
 static unsigned int default_tdb_hash(TDB_DATA *key)
 {
 	uint32_t value;	/* Used to compute the hash value.  */
-	uint32_t i;	/* Used to cycle through random values. */
+	uint32_t   i;	/* Used to cycle through random values. */
 
 	/* Set the initial value from the key size. */
 	for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
@@ -90,7 +90,7 @@ static int tdb_new_database(struct tdb_context *tdb, int hash_size)
 		size -= written;
 		written = write(tdb->fd, newdb+written, size);
 		if (written == size) {
-			ret = 0;
+		ret = 0;
 		} else if (written >= 0) {
 			/* a second incomplete write - we give up.
 			 * guessing the errno... */
@@ -152,6 +152,7 @@ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
 	int rev = 0, locked = 0;
 	unsigned char *vp;
 	uint32_t vertest;
+	unsigned v;
 
 	if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
 		/* Can't log this */
@@ -215,6 +216,10 @@ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
 		goto fail;	/* errno set by open(2) */
 	}
 
+	/* on exec, don't inherit the fd */
+	v = fcntl(tdb->fd, F_GETFD, 0);
+        fcntl(tdb->fd, F_SETFD, v | FD_CLOEXEC);
+
 	/* ensure there is only one process initialising at once */
 	if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
 		TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get global lock on %s: %s\n",
@@ -242,7 +247,7 @@ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
 		/* its not a valid database - possibly initialise it */
 		if (!(open_flags & O_CREAT) || tdb_new_database(tdb, hash_size) == -1) {
 			if (errno == 0) {
-				errno = EIO; /* ie bad format or something */
+			errno = EIO; /* ie bad format or something */
 			}
 			goto fail;
 		}
diff --git a/source4/lib/tdb/common/tdb.c b/source4/lib/tdb/common/tdb.c
index 0e9d1dbd74..fd4e1cc8af 100644
--- a/source4/lib/tdb/common/tdb.c
+++ b/source4/lib/tdb/common/tdb.c
@@ -102,8 +102,7 @@ static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
 }
 
 /* As tdb_find, but if you succeed, keep the lock */
-tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, 
-							 uint32_t hash, int locktype,
+tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
 			   struct list_struct *rec)
 {
 	uint32_t rec_ptr;
@@ -237,14 +236,15 @@ int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
 }
 
 /* actually delete an entry in the database given the offset */
-int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct*rec)
+int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
 {
 	tdb_off_t last_ptr, i;
 	struct list_struct lastrec;
 
 	if (tdb->read_only || tdb->traverse_read) return -1;
 
-	if (tdb_write_lock_record(tdb, rec_ptr) == -1) {
+	if (tdb->traverse_write != 0 || 
+	    tdb_write_lock_record(tdb, rec_ptr) == -1) {
 		/* Someone traversing here: mark it as dead */
 		rec->magic = TDB_DEAD_MAGIC;
 		return tdb_rec_write(tdb, rec_ptr, rec);
@@ -666,6 +666,16 @@ int tdb_get_flags(struct tdb_context *tdb)
 	return tdb->flags;
 }
 
+void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
+{
+	tdb->flags |= flags;
+}
+
+void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
+{
+	tdb->flags &= ~flags;
+}
+
 
 /*
   enable sequence number handling on an open tdb
@@ -674,3 +684,104 @@ void tdb_enable_seqnum(struct tdb_context *tdb)
 {
 	tdb->flags |= TDB_SEQNUM;
 }
+
+
+/*
+  wipe the entire database, deleting all records. This can be done
+  very fast by using a global lock. The entire data portion of the
+  file becomes a single entry in the freelist.
+ */
+int tdb_wipe_all(struct tdb_context *tdb)
+{
+	int i;
+	tdb_off_t offset = 0;
+	ssize_t data_len;
+
+	if (tdb_lockall(tdb) != 0) {
+		return -1;
+	}
+
+	/* wipe the hashes */
+	for (i=0;i<tdb->header.hash_size;i++) {
+		if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
+			TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
+			goto failed;
+		}
+	}
+
+	/* wipe the freelist */
+	if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
+		goto failed;
+	}
+
+	if (tdb_ofs_write(tdb, TDB_RECOVERY_HEAD, &offset) == -1) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write recovery head\n"));
+		goto failed;		
+	}
+
+	/* add all the rest of the file to the freelist */
+	data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size)) - sizeof(struct list_struct);
+	if (data_len > 0) {
+		struct list_struct rec;
+		memset(&rec,'\0',sizeof(rec));
+		rec.rec_len = data_len;
+		if (tdb_free(tdb, TDB_DATA_START(tdb->header.hash_size), &rec) == -1) {
+			TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to add free record\n"));
+			goto failed;
+		}
+	}
+
+	if (tdb_unlockall(tdb) != 0) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
+		goto failed;
+	}
+
+	return 0;
+
+failed:
+	tdb_unlockall(tdb);
+	return -1;
+}
+
+
+/* 
+   validate the integrity of all tdb hash chains. Useful when debugging
+ */
+int tdb_validate(struct tdb_context *tdb)
+{
+	int h;
+	for (h=-1;h<(int)tdb->header.hash_size;h++) {
+		tdb_off_t rec_ptr;
+		uint32_t count = 0;
+		if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &rec_ptr) == -1) {
+			TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_validate: failed ofs_read at top of hash %d\n", h));
+			return -1;
+		}
+		while (rec_ptr) {
+			struct list_struct r;
+			tdb_off_t size;
+
+			if (tdb_rec_read(tdb, rec_ptr, &r) == -1) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_validate: failed rec_read h=%d rec_ptr=%u count=%u\n",
+					 h, rec_ptr, count));
+				return -1;
+			}
+			if (tdb_ofs_read(tdb, rec_ptr + sizeof(r) + r.rec_len - sizeof(tdb_off_t), &size) == -1) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_validate: failed ofs_read h=%d rec_ptr=%u count=%u\n",
+					 h, rec_ptr, count));
+				return -1;
+			}
+			if (size != r.rec_len + sizeof(r)) {
+				TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_validate: failed size check size=%u h=%d rec_ptr=%u count=%u\n",
+					 size, h, rec_ptr, count));
+				return -1;
+			}
+			rec_ptr = r.next;
+			count++;
+		}		
+	}
+	return 0;
+}
+
+
diff --git a/source4/lib/tdb/common/tdb_private.h b/source4/lib/tdb/common/tdb_private.h
index 00bd0eb537..63a6d04e72 100644
--- a/source4/lib/tdb/common/tdb_private.h
+++ b/source4/lib/tdb/common/tdb_private.h
@@ -38,6 +38,10 @@
 typedef uint32_t tdb_len_t;
 typedef uint32_t tdb_off_t;
 
+#ifndef offsetof
+#define offsetof(t,f) ((unsigned int)&((t *)0)->f)
+#endif
+
 #define TDB_MAGIC_FOOD "TDB file\n"
 #define TDB_VERSION (0x26011967 + 6)
 #define TDB_MAGIC (0x26011999U)
@@ -54,7 +58,7 @@ typedef uint32_t tdb_off_t;
 #define TDB_BAD_MAGIC(r) ((r)->magic != TDB_MAGIC && !TDB_DEAD(r))
 #define TDB_HASH_TOP(hash) (FREELIST_TOP + (BUCKET(hash)+1)*sizeof(tdb_off_t))
 #define TDB_HASHTABLE_SIZE(tdb) ((tdb->header.hash_size+1)*sizeof(tdb_off_t))
-#define TDB_DATA_START(hash_size) TDB_HASH_TOP(hash_size-1)
+#define TDB_DATA_START(hash_size) (TDB_HASH_TOP(hash_size-1) + sizeof(tdb_off_t))
 #define TDB_RECOVERY_HEAD offsetof(struct tdb_header, recovery_start)
 #define TDB_SEQNUM_OFS    offsetof(struct tdb_header, sequence_number)
 #define TDB_PAD_BYTE 0x42
@@ -144,6 +148,7 @@ struct tdb_context {
 	tdb_len_t map_size; /* how much space has been mapped */
 	int read_only; /* opened read-only */
 	int traverse_read; /* read-only traversal */
+	int traverse_write; /* read-write traversal */
 	struct tdb_lock_type global_lock;
 	int num_lockrecs;
 	struct tdb_lock_type *lockrecs; /* only real locks, all with count>0 */
diff --git a/source4/lib/tdb/common/transaction.c b/source4/lib/tdb/common/transaction.c
index 7eaacf7a16..0ecfb9b7ff 100644
--- a/source4/lib/tdb/common/transaction.c
+++ b/source4/lib/tdb/common/transaction.c
@@ -87,12 +87,6 @@
 
 */
 
-struct tdb_transaction_el {
-	struct tdb_transaction_el *next, *prev;
-	tdb_off_t offset;
-	tdb_len_t length;
-	unsigned char *data;
-};
 
 /*
   hold the context of any current transaction
@@ -105,12 +99,12 @@ struct tdb_transaction {
 	/* the original io methods - used to do IOs to the real db */
 	const struct tdb_methods *io_methods;
 
-	/* the list of transaction elements. We use a doubly linked
-	   list with a last pointer to allow us to keep the list
-	   ordered, with first element at the front of the list. It
-	   needs to be doubly linked as the read/write traversals need
-	   to be backwards, while the commit needs to be forwards */
-	struct tdb_transaction_el *elements, *elements_last;
+	/* the list of transaction blocks. When a block is first
+	   written to, it gets created in this list */
+	uint8_t **blocks;
+	uint32_t num_blocks;
+	uint32_t block_size;      /* bytes in each block */
+	uint32_t last_block_size; /* number of valid bytes in the last block */
 
 	/* non-zero when an internal transaction error has
 	   occurred. All write operations will then fail until the
@@ -134,52 +128,48 @@ struct tdb_transaction {
 static int transaction_read(struct tdb_context *tdb, tdb_off_t off, void *buf, 
 			    tdb_len_t len, int cv)
 {
-	struct tdb_transaction_el *el;
-
-	/* we need to walk the list backwards to get the most recent data */
-	for (el=tdb->transaction->elements_last;el;el=el->prev) {
-		tdb_len_t partial;
+	uint32_t blk;
 
-		if (off+len <= el->offset) {
-			continue;
-		}
-		if (off >= el->offset + el->length) {
-			continue;
+	/* break it down into block sized ops */
+	while (len + (off % tdb->transaction->block_size) > tdb->transaction->block_size) {
+		tdb_len_t len2 = tdb->transaction->block_size - (off % tdb->transaction->block_size);
+		if (transaction_read(tdb, off, buf, len2, cv) != 0) {
+			return -1;
 		}
+		len -= len2;
+		off += len2;
+		buf = (void *)(len2 + (char *)buf);
+	}
 
-		/* an overlapping read - needs to be split into up to
-		   2 reads and a memcpy */
-		if (off < el->offset) {
-			partial = el->offset - off;
-			if (transaction_read(tdb, off, buf, partial, cv) != 0) {
-				goto fail;
-			}
-			len -= partial;
-			off += partial;
-			buf = (void *)(partial + (char *)buf);
-		}
-		if (off + len <= el->offset + el->length) {
-			partial = len;
-		} else {
-			partial = el->offset + el->length - off;
-		}
-		memcpy(buf, el->data + (off - el->offset), partial);
-		if (cv) {
-			tdb_convert(buf, len);
-		}
-		len -= partial;
-		off += partial;
-		buf = (void *)(partial + (char *)buf);
-		
-		if (len != 0 && transaction_read(tdb, off, buf, len, cv) != 0) {
+	if (len == 0) {
+		return 0;
+	}
+
+	blk = off / tdb->transaction->block_size;
+
+	/* see if we have it in the block list */
+	if (tdb->transaction->num_blocks <= blk ||
+	    tdb->transaction->blocks[blk] == NULL) {
+		/* nope, do a real read */
+		if (tdb->transaction->io_methods->tdb_read(tdb, off, buf, len, cv) != 0) {
 			goto fail;
 		}
-
 		return 0;
 	}
 
-	/* its not in the transaction elements - do a real read */
-	return tdb->transaction->io_methods->tdb_read(tdb, off, buf, len, cv);
+	/* it is in the block list. Now check for the last block */
+	if (blk == tdb->transaction->num_blocks-1) {
+		if (len > tdb->transaction->last_block_size) {
+			goto fail;
+		}
+	}
+	
+	/* now copy it out of this block */
+	memcpy(buf, tdb->transaction->blocks[blk] + (off % tdb->transaction->block_size), len);
+	if (cv) {
+		tdb_convert(buf, len);
+	}
+	return 0;
 
 fail:
 	TDB_LOG((tdb, TDB_DEBUG_FATAL, "transaction_read: failed at off=%d len=%d\n", off, len));
@@ -195,12 +185,8 @@ fail:
 static int transaction_write(struct tdb_context *tdb, tdb_off_t off, 
 			     const void *buf, tdb_len_t len)
 {
-	struct tdb_transaction_el *el, *best_el=NULL;
+	uint32_t blk;
 
-	if (len == 0) {
-		return 0;
-	}
-	
 	/* if the write is to a hash head, then update the transaction
 	   hash heads */
 	if (len == sizeof(tdb_off_t) && off >= FREELIST_TOP &&
@@ -209,110 +195,149 @@ static int transaction_write(struct tdb_context *tdb, tdb_off_t off,
 		memcpy(&tdb->transaction->hash_heads[chain], buf, len);
 	}
 
-	/* first see if we can replace an existing entry */
-	for (el=tdb->transaction->elements_last;el;el=el->prev) {
-		tdb_len_t partial;
-
-		if (best_el == NULL && off == el->offset+el->length) {
-			best_el = el;
-		}
-
-		if (off+len <= el->offset) {
-			continue;
+	/* break it up into block sized chunks */
+	while (len + (off % tdb->transaction->block_size) > tdb->transaction->block_size) {
+		tdb_len_t len2 = tdb->transaction->block_size - (off % tdb->transaction->block_size);
+		if (transaction_write(tdb, off, buf, len2) != 0) {
+			return -1;
 		}
-		if (off >= el->offset + el->length) {
-			continue;
+		len -= len2;
+		off += len2;
+		if (buf != NULL) {
+			buf = (const void *)(len2 + (const char *)buf);
 		}
+	}
 
-		/* an overlapping write - needs to be split into up to
-		   2 writes and a memcpy */
-		if (off < el->offset) {
-			partial = el->offset - off;
-			if (transaction_write(tdb, off, buf, partial) != 0) {
-				goto fail;
-			}
-			len -= partial;
-			off += partial;
-			buf = (const void *)(partial + (const char *)buf);
-		}
-		if (off + len <= el->offset + el->length) {
-			partial = len;
+	if (len == 0) {
+		return 0;
+	}
+
+	blk = off / tdb->transaction->block_size;
+	off = off % tdb->transaction->block_size;
+
+	if (tdb->transaction->num_blocks <= blk) {
+		uint8_t **new_blocks;
+		/* expand the blocks array */
+		if (tdb->transaction->blocks == NULL) {
+			new_blocks = malloc((blk+1)*sizeof(uint8_t *));
 		} else {
-			partial = el->offset + el->length - off;
+			new_blocks = realloc(tdb->transaction->blocks, (blk+1)*sizeof(uint8_t *));
 		}
-		memcpy(el->data + (off - el->offset), buf, partial);
-		len -= partial;
-		off += partial;
-		buf = (const void *)(partial + (const char *)buf);
-		
-		if (len != 0 && transaction_write(tdb, off, buf, len) != 0) {
+		if (new_blocks == NULL) {
+			tdb->ecode = TDB_ERR_OOM;
 			goto fail;
 		}
-
-		return 0;
+		memset(&new_blocks[tdb->transaction->num_blocks], 0, 
+		       (1+(blk - tdb->transaction->num_blocks))*sizeof(uint8_t *));
+		tdb->transaction->blocks = new_blocks;
+		tdb->transaction->num_blocks = blk+1;
+		tdb->transaction->last_block_size = 0;
 	}
 
-	/* see if we can append the new entry to an existing entry */
-	if (best_el && best_el->offset + best_el->length == off && 
-	    (off+len < tdb->transaction->old_map_size ||
-	     off > tdb->transaction->old_map_size)) {
-		unsigned char *data = best_el->data;
-		el = best_el;
-		el->data = (unsigned char *)realloc(el->data,
-						    el->length + len);
-		if (el->data == NULL) {
+	/* allocate and fill a block? */
+	if (tdb->transaction->blocks[blk] == NULL) {
+		tdb->transaction->blocks[blk] = (uint8_t *)calloc(tdb->transaction->block_size, 1);
+		if (tdb->transaction->blocks[blk] == NULL) {
 			tdb->ecode = TDB_ERR_OOM;
 			tdb->transaction->transaction_error = 1;
-			el->data = data;
+			return -1;			
+		}
+		if (tdb->transaction->old_map_size > blk * tdb->transaction->block_size) {
+			tdb_len_t len2 = tdb->transaction->block_size;
+			if (len2 + (blk * tdb->transaction->block_size) > tdb->transaction->old_map_size) {
+				len2 = tdb->transaction->old_map_size - (blk * tdb->transaction->block_size);
+			}
+			if (tdb->transaction->io_methods->tdb_read(tdb, blk * tdb->transaction->block_size, 
+								   tdb->transaction->blocks[blk], 
+								   len2, 0) != 0) {
+				SAFE_FREE(tdb->transaction->blocks[blk]);				
+				tdb->ecode = TDB_ERR_IO;
+				goto fail;
+			}
+			if (blk == tdb->transaction->num_blocks-1) {
+				tdb->transaction->last_block_size = len2;
+			}			
+		}
+	}
+	
+	/* overwrite part of an existing block */
+	if (buf == NULL) {
+		memset(tdb->transaction->blocks[blk] + off, 0, len);
+	} else {
+		memcpy(tdb->transaction->blocks[blk] + off, buf, len);
+	}
+	if (blk == tdb->transaction->num_blocks-1) {
+		if (len + off > tdb->transaction->last_block_size) {
+			tdb->transaction->last_block_size = len + off;
+		}
+	}
+
+	return 0;
+
+fail:
+	TDB_LOG((tdb, TDB_DEBUG_FATAL, "transaction_write: failed at off=%d len=%d\n", 
+		 (blk*tdb->transaction->block_size) + off, len));
+	tdb->transaction->transaction_error = 1;
+	return -1;
+}
+
+
+/*
+  write while in a transaction - this varient never expands the transaction blocks, it only
+  updates existing blocks. This means it cannot change the recovery size
+*/
+static int transaction_write_existing(struct tdb_context *tdb, tdb_off_t off, 
+				      const void *buf, tdb_len_t len)
+{
+	uint32_t blk;
+
+	/* break it up into block sized chunks */
+	while (len + (off % tdb->transaction->block_size) > tdb->transaction->block_size) {
+		tdb_len_t len2 = tdb->transaction->block_size - (off % tdb->transaction->block_size);
+		if (transaction_write_existing(tdb, off, buf, len2) != 0) {
 			return -1;
 		}
-		if (buf) {
-			memcpy(el->data + el->length, buf, len);
-		} else {
-			memset(el->data + el->length, TDB_PAD_BYTE, len);
+		len -= len2;
+		off += len2;
+		if (buf != NULL) {
+			buf = (const void *)(len2 + (const char *)buf);
 		}
-		el->length += len;
-		return 0;
 	}
 
-	/* add a new entry at the end of the list */
-	el = (struct tdb_transaction_el *)malloc(sizeof(*el));
-	if (el == NULL) {
-		tdb->ecode = TDB_ERR_OOM;
-		tdb->transaction->transaction_error = 1;		
-		return -1;
+	if (len == 0) {
+		return 0;
 	}
-	el->next = NULL;
-	el->prev = tdb->transaction->elements_last;
-	el->offset = off;
-	el->length = len;
-	el->data = (unsigned char *)malloc(len);
-	if (el->data == NULL) {
-		free(el);
-		tdb->ecode = TDB_ERR_OOM;
-		tdb->transaction->transaction_error = 1;		
-		return -1;
+
+	blk = off / tdb->transaction->block_size;
+	off = off % tdb->transaction->block_size;
+
+	if (tdb->transaction->num_blocks <= blk ||
+	    tdb->transaction->blocks[blk] == NULL) {
+		return 0;
 	}
-	if (buf) {
-		memcpy(el->data, buf, len);
+
+	/* overwrite part of an existing block */
+	if (buf == NULL) {
+		memset(tdb->transaction->blocks[blk] + off, 0, len);
 	} else {
-		memset(el->data, TDB_PAD_BYTE, len);
+		memcpy(tdb->transaction->blocks[blk] + off, buf, len);
 	}
-	if (el->prev) {
-		el->prev->next = el;
-	} else {
-		tdb->transaction->elements = el;
+	if (blk == tdb->transaction->num_blocks-1) {
+		if (len + off > tdb->transaction->last_block_size) {
+			tdb->transaction->last_block_size = len + off;
+		}
 	}
-	tdb->transaction->elements_last = el;
+
 	return 0;
 
 fail:
-	TDB_LOG((tdb, TDB_DEBUG_FATAL, "transaction_write: failed at off=%d len=%d\n", off, len));
-	tdb->ecode = TDB_ERR_IO;
+	TDB_LOG((tdb, TDB_DEBUG_FATAL, "transaction_write: failed at off=%d len=%d\n", 
+		 (blk*tdb->transaction->block_size) + off, len));
 	tdb->transaction->transaction_error = 1;
 	return -1;
 }
 
+
 /*
   accelerated hash chain head search, using the cached hash heads
 */
@@ -419,10 +444,14 @@ int tdb_transaction_start(struct tdb_context *tdb)
 		return -1;
 	}
 
+	/* a page at a time seems like a reasonable compromise between compactness and efficiency */
+	tdb->transaction->block_size = tdb->page_size;
+
 	/* get the transaction write lock. This is a blocking lock. As
 	   discussed with Volker, there are a number of ways we could
 	   make this async, which we will probably do in the future */
 	if (tdb_transaction_lock(tdb, F_WRLCK) == -1) {
+		SAFE_FREE(tdb->transaction->blocks);
 		SAFE_FREE(tdb->transaction);
 		return -1;
 	}
@@ -460,21 +489,12 @@ int tdb_transaction_start(struct tdb_context *tdb)
 	tdb->transaction->io_methods = tdb->methods;
 	tdb->methods = &transaction_methods;
 
-	/* by calling this transaction write here, we ensure that we don't grow the
-	   transaction linked list due to hash table updates */
-	if (transaction_write(tdb, FREELIST_TOP, tdb->transaction->hash_heads, 
-			      TDB_HASHTABLE_SIZE(tdb)) != 0) {
-		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_start: failed to prime hash table\n"));
-		tdb->ecode = TDB_ERR_IO;
-		tdb->methods = tdb->transaction->io_methods;
-		goto fail;
-	}
-
 	return 0;
 	
 fail:
 	tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
 	tdb_transaction_unlock(tdb);
+	SAFE_FREE(tdb->transaction->blocks);
 	SAFE_FREE(tdb->transaction->hash_heads);
 	SAFE_FREE(tdb->transaction);
 	return -1;
@@ -486,6 +506,8 @@ fail:
 */
 int tdb_transaction_cancel(struct tdb_context *tdb)
 {	
+	int i;
+
 	if (tdb->transaction == NULL) {
 		TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_cancel: no transaction\n"));
 		return -1;
@@ -499,13 +521,13 @@ int tdb_transaction_cancel(struct tdb_context *tdb)
 
 	tdb->map_size = tdb->transaction->old_map_size;
 
-	/* free all the transaction elements */
-	while (tdb->transaction->elements) {
-		struct tdb_transaction_el *el = tdb->transaction->elements;
-		tdb->transaction->elements = el->next;
-		free(el->data);
-		free(el);
+	/* free all the transaction blocks */
+	for (i=0;i<tdb->transaction->num_blocks;i++) {
+		if (tdb->transaction->blocks[i] != NULL) {
+			free(tdb->transaction->blocks[i]);
+		}
 	}
+	SAFE_FREE(tdb->transaction->blocks);
 
 	/* remove any global lock created during the transaction */
 	if (tdb->global_lock.count != 0) {
@@ -515,7 +537,6 @@ int tdb_transaction_cancel(struct tdb_context *tdb)
 
 	/* remove any locks created during the transaction */
 	if (tdb->num_locks != 0) {
-		int i;
 		for (i=0;i<tdb->num_lockrecs;i++) {
 			tdb_brlock(tdb,FREELIST_TOP+4*tdb->lockrecs[i].list,
 				   F_UNLCK,F_SETLKW, 0, 1);
@@ -567,16 +588,24 @@ static int transaction_sync(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t
 */
 static tdb_len_t tdb_recovery_size(struct tdb_context *tdb)
 {
-	struct tdb_transaction_el *el;
 	tdb_len_t recovery_size = 0;
+	int i;
 
 	recovery_size = sizeof(uint32_t);
-	for (el=tdb->transaction->elements;el;el=el->next) {
-		if (el->offset >= tdb->transaction->old_map_size) {
+	for (i=0;i<tdb->transaction->num_blocks;i++) {
+		if (i * tdb->transaction->block_size >= tdb->transaction->old_map_size) {
+			break;
+		}
+		if (tdb->transaction->blocks[i] == NULL) {
 			continue;
 		}
-		recovery_size += 2*sizeof(tdb_off_t) + el->length;
-	}
+		recovery_size += 2*sizeof(tdb_off_t);
+		if (i == tdb->transaction->num_blocks-1) {
+			recovery_size += tdb->transaction->last_block_size;
+		} else {
+			recovery_size += tdb->transaction->block_size;
+		}
+	}	
 
 	return recovery_size;
 }
@@ -658,6 +687,10 @@ static int tdb_recovery_allocate(struct tdb_context *tdb,
 		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to write recovery head\n"));
 		return -1;
 	}
+	if (transaction_write_existing(tdb, TDB_RECOVERY_HEAD, &recovery_head, sizeof(tdb_off_t)) == -1) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to write recovery head\n"));
+		return -1;
+	}
 
 	return 0;
 }
@@ -669,7 +702,6 @@ static int tdb_recovery_allocate(struct tdb_context *tdb,
 static int transaction_setup_recovery(struct tdb_context *tdb, 
 				      tdb_off_t *magic_offset)
 {
-	struct tdb_transaction_el *el;
 	tdb_len_t recovery_size;
 	unsigned char *data, *p;
 	const struct tdb_methods *methods = tdb->transaction->io_methods;
@@ -677,6 +709,7 @@ static int transaction_setup_recovery(struct tdb_context *tdb,
 	tdb_off_t recovery_offset, recovery_max_size;
 	tdb_off_t old_map_size = tdb->transaction->old_map_size;
 	uint32_t magic, tailer;
+	int i;
 
 	/*
 	  check that the recovery area has enough space
@@ -704,30 +737,43 @@ static int transaction_setup_recovery(struct tdb_context *tdb,
 	/* build the recovery data into a single blob to allow us to do a single
 	   large write, which should be more efficient */
 	p = data + sizeof(*rec);
-	for (el=tdb->transaction->elements;el;el=el->next) {
-		if (el->offset >= old_map_size) {
+	for (i=0;i<tdb->transaction->num_blocks;i++) {
+		tdb_off_t offset;
+		tdb_len_t length;
+
+		if (tdb->transaction->blocks[i] == NULL) {
+			continue;
+		}
+
+		offset = i * tdb->transaction->block_size;
+		length = tdb->transaction->block_size;
+		if (i == tdb->transaction->num_blocks-1) {
+			length = tdb->transaction->last_block_size;
+		}
+		
+		if (offset >= old_map_size) {
 			continue;
 		}
-		if (el->offset + el->length > tdb->transaction->old_map_size) {
+		if (offset + length > tdb->transaction->old_map_size) {
 			TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_setup_recovery: transaction data over new region boundary\n"));
 			free(data);
 			tdb->ecode = TDB_ERR_CORRUPT;
 			return -1;
 		}
-		memcpy(p, &el->offset, 4);
-		memcpy(p+4, &el->length, 4);
+		memcpy(p, &offset, 4);
+		memcpy(p+4, &length, 4);
 		if (DOCONV()) {
 			tdb_convert(p, 8);
 		}
 		/* the recovery area contains the old data, not the
 		   new data, so we have to call the original tdb_read
 		   method to get it */
-		if (methods->tdb_read(tdb, el->offset, p + 8, el->length, 0) != 0) {
+		if (methods->tdb_read(tdb, offset, p + 8, length, 0) != 0) {
 			free(data);
 			tdb->ecode = TDB_ERR_IO;
 			return -1;
 		}
-		p += 8 + el->length;
+		p += 8 + length;
 	}
 
 	/* and the tailer */
@@ -742,6 +788,12 @@ static int transaction_setup_recovery(struct tdb_context *tdb,
 		tdb->ecode = TDB_ERR_IO;
 		return -1;
 	}
+	if (transaction_write_existing(tdb, recovery_offset, data, sizeof(*rec) + recovery_size) == -1) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_setup_recovery: failed to write secondary recovery data\n"));
+		free(data);
+		tdb->ecode = TDB_ERR_IO;
+		return -1;
+	}
 
 	/* as we don't have ordered writes, we have to sync the recovery
 	   data before we update the magic to indicate that the recovery
@@ -763,6 +815,11 @@ static int transaction_setup_recovery(struct tdb_context *tdb,
 		tdb->ecode = TDB_ERR_IO;
 		return -1;
 	}
+	if (transaction_write_existing(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
+		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_setup_recovery: failed to write secondary recovery magic\n"));
+		tdb->ecode = TDB_ERR_IO;
+		return -1;
+	}
 
 	/* ensure the recovery magic marker is on disk */
 	if (transaction_sync(tdb, *magic_offset, sizeof(magic)) == -1) {
@@ -780,6 +837,7 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 	const struct tdb_methods *methods;
 	tdb_off_t magic_offset = 0;
 	uint32_t zero = 0;
+	int i;
 
 	if (tdb->transaction == NULL) {
 		TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_commit: no transaction\n"));
@@ -793,13 +851,14 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 		return -1;
 	}
 
+
 	if (tdb->transaction->nesting != 0) {
 		tdb->transaction->nesting--;
 		return 0;
 	}		
 
 	/* check for a null transaction */
-	if (tdb->transaction->elements == NULL) {
+	if (tdb->transaction->blocks == NULL) {
 		tdb_transaction_cancel(tdb);
 		return 0;
 	}
@@ -858,10 +917,21 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 	}
 
 	/* perform all the writes */
-	while (tdb->transaction->elements) {
-		struct tdb_transaction_el *el = tdb->transaction->elements;
+	for (i=0;i<tdb->transaction->num_blocks;i++) {
+		tdb_off_t offset;
+		tdb_len_t length;
 
-		if (methods->tdb_write(tdb, el->offset, el->data, el->length) == -1) {
+		if (tdb->transaction->blocks[i] == NULL) {
+			continue;
+		}
+
+		offset = i * tdb->transaction->block_size;
+		length = tdb->transaction->block_size;
+		if (i == tdb->transaction->num_blocks-1) {
+			length = tdb->transaction->last_block_size;
+		}
+
+		if (methods->tdb_write(tdb, offset, tdb->transaction->blocks[i], length) == -1) {
 			TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed during commit\n"));
 			
 			/* we've overwritten part of the data and
@@ -876,11 +946,12 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 			TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed\n"));
 			return -1;
 		}
-		tdb->transaction->elements = el->next;
-		free(el->data); 
-		free(el);
+		SAFE_FREE(tdb->transaction->blocks[i]);
 	} 
 
+	SAFE_FREE(tdb->transaction->blocks);
+	tdb->transaction->num_blocks = 0;
+
 	if (!(tdb->flags & TDB_NOSYNC)) {
 		/* ensure the new data is on disk */
 		if (transaction_sync(tdb, 0, tdb->map_size) == -1) {
@@ -919,6 +990,7 @@ int tdb_transaction_commit(struct tdb_context *tdb)
 	/* use a transaction cancel to free memory and remove the
 	   transaction locks */
 	tdb_transaction_cancel(tdb);
+
 	return 0;
 }
 
diff --git a/source4/lib/tdb/common/traverse.c b/source4/lib/tdb/common/traverse.c
index 6fc576a55a..2bde1270a0 100644
--- a/source4/lib/tdb/common/traverse.c
+++ b/source4/lib/tdb/common/traverse.c
@@ -238,7 +238,9 @@ int tdb_traverse(struct tdb_context *tdb,
 		return -1;
 	}
 
+	tdb->traverse_write++;
 	ret = tdb_traverse_internal(tdb, fn, private_data, &tl);
+	tdb->traverse_write--;
 
 	tdb_transaction_unlock(tdb);
 
@@ -330,3 +332,4 @@ TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
 		TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
 	return key;
 }
+
diff --git a/source4/lib/tdb/include/tdb.h b/source4/lib/tdb/include/tdb.h
index 7de4c419a8..0058d55793 100644
--- a/source4/lib/tdb/include/tdb.h
+++ b/source4/lib/tdb/include/tdb.h
@@ -135,6 +135,8 @@ int tdb_get_seqnum(struct tdb_context *tdb);
 int tdb_hash_size(struct tdb_context *tdb);
 size_t tdb_map_size(struct tdb_context *tdb);
 int tdb_get_flags(struct tdb_context *tdb);
+void tdb_add_flags(struct tdb_context *tdb, unsigned flag);
+void tdb_remove_flags(struct tdb_context *tdb, unsigned flag);
 void tdb_enable_seqnum(struct tdb_context *tdb);
 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb);
 
@@ -153,6 +155,9 @@ void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *sigptr)
 void tdb_dump_all(struct tdb_context *tdb);
 int tdb_printfreelist(struct tdb_context *tdb);
 int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries);
+int tdb_wipe_all(struct tdb_context *tdb);
+int tdb_freelist_size(struct tdb_context *tdb);
+int tdb_validate(struct tdb_context *tdb);
 
 extern TDB_DATA tdb_null;
 
diff --git a/source4/libcli/util/asn1.c b/source4/lib/util/asn1.c
index aad55382d9..4756c0640d 100644
--- a/source4/libcli/util/asn1.c
+++ b/source4/lib/util/asn1.c
@@ -18,7 +18,7 @@
 */
 
 #include "includes.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 
 /* allocate an asn1 structure */
 struct asn1_data *asn1_init(TALLOC_CTX *mem_ctx)
diff --git a/source4/libcli/util/asn_1.h b/source4/lib/util/asn1.h
index 612a8a932f..34aa1e2cb9 100644
--- a/source4/libcli/util/asn_1.h
+++ b/source4/lib/util/asn1.h
@@ -49,6 +49,6 @@ struct asn1_data {
 
 #define ASN1_MAX_OIDS 20
 
-#include "libcli/util/asn1_proto.h"
+#include "lib/util/asn1_proto.h"
 
 #endif /* _ASN_1_H */
diff --git a/source4/lib/util/config.mk b/source4/lib/util/config.mk
index 01ad14aa95..53a55bf7af 100644
--- a/source4/lib/util/config.mk
+++ b/source4/lib/util/config.mk
@@ -34,6 +34,11 @@ PUBLIC_DEPENDENCIES = \
 		SOCKET_WRAPPER EXT_NSL \
 		CHARSET EXECINFO
 
+[SUBSYSTEM::ASN1_UTIL]
+PUBLIC_PROTO_HEADER = asn1_proto.h
+PUBLIC_HEADERS = asn1.h
+OBJ_FILES = asn1.o
+
 [SUBSYSTEM::UNIX_PRIVS]
 PRIVATE_PROTO_HEADER = unix_privs.h
 OBJ_FILES = unix_privs.o
diff --git a/source4/libcli/cldap/cldap.h b/source4/libcli/cldap/cldap.h
index 8aa98f0331..7a222e0652 100644
--- a/source4/libcli/cldap/cldap.h
+++ b/source4/libcli/cldap/cldap.h
@@ -19,7 +19,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "librpc/gen_ndr/nbt.h"
 
 struct ldap_message;
diff --git a/source4/libcli/config.mk b/source4/libcli/config.mk
index adb51c6c9a..eb3c56cf7f 100644
--- a/source4/libcli/config.mk
+++ b/source4/libcli/config.mk
@@ -8,11 +8,6 @@ OBJ_FILES = util/doserr.o \
 		    util/errormap.o \
 		    util/nterr.o \
 
-[SUBSYSTEM::ASN1_UTIL]
-PUBLIC_PROTO_HEADER = util/asn1_proto.h
-PUBLIC_HEADERS = util/asn_1.h
-OBJ_FILES = util/asn1.o
-
 [SUBSYSTEM::LIBCLI_LSA]
 PRIVATE_PROTO_HEADER = util/clilsa.h
 OBJ_FILES = util/clilsa.o
diff --git a/source4/libcli/ldap/ldap.c b/source4/libcli/ldap/ldap.c
index 586f2fa653..00a0631753 100644
--- a/source4/libcli/ldap/ldap.c
+++ b/source4/libcli/ldap/ldap.c
@@ -23,7 +23,7 @@
 */
 
 #include "includes.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "libcli/ldap/ldap.h"
 
 
diff --git a/source4/libcli/ldap/ldap_client.c b/source4/libcli/ldap/ldap_client.c
index 6b8a7a3f28..d99851ee15 100644
--- a/source4/libcli/ldap/ldap_client.c
+++ b/source4/libcli/ldap/ldap_client.c
@@ -23,7 +23,7 @@
 */
 
 #include "includes.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "lib/util/dlinklist.h"
 #include "lib/events/events.h"
 #include "lib/socket/socket.h"
diff --git a/source4/libcli/ldap/ldap_controls.c b/source4/libcli/ldap/ldap_controls.c
index 34e5cccf75..3b94580033 100644
--- a/source4/libcli/ldap/ldap_controls.c
+++ b/source4/libcli/ldap/ldap_controls.c
@@ -20,7 +20,7 @@
 */
 
 #include "includes.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 #include "libcli/ldap/ldap.h"
 #include "lib/ldb/include/ldb.h"
 
diff --git a/source4/librpc/config.mk b/source4/librpc/config.mk
index debfbb6869..8774f2fd17 100644
--- a/source4/librpc/config.mk
+++ b/source4/librpc/config.mk
@@ -597,4 +597,45 @@ PUBLIC_DEPENDENCIES = LIBCLI_SMB NDR_MISC LIBSAMBA-UTIL LIBSAMBA-CONFIG dcerpc_s
 
 [PYTHON::python_echo]
 OBJ_FILES = gen_ndr/py_echo.o
-PRIVATE_DEPENDENCIES = NDR_ECHO
+PRIVATE_DEPENDENCIES = RPC_NDR_ECHO
+
+[PYTHON::python_winreg]
+OBJ_FILES = gen_ndr/py_winreg.o
+PRIVATE_DEPENDENCIES = RPC_NDR_WINREG python_misc
+
+[PYTHON::python_dcerpc_misc]
+OBJ_FILES = gen_ndr/py_misc.o
+
+[PYTHON::python_initshutdown]
+OBJ_FILES = gen_ndr/py_initshutdown.o
+PRIVATE_DEPENDENCIES = RPC_NDR_INITSHUTDOWN
+
+[PYTHON::python_epmapper]
+OBJ_FILES = gen_ndr/py_epmapper.o
+
+[PYTHON::python_mgmt]
+OBJ_FILES = gen_ndr/py_mgmt.o
+PRIVATE_DEPENDENCIES = dcerpc_mgmt
+
+[PYTHON::python_atsvc]
+OBJ_FILES = gen_ndr/py_atsvc.o
+PRIVATE_DEPENDENCIES = dcerpc_atsvc
+
+[PYTHON::python_samr]
+OBJ_FILES = gen_ndr/py_samr.o
+PRIVATE_DEPENDENCIES = dcerpc_samr
+
+[PYTHON::python_svcctl]
+OBJ_FILES = gen_ndr/py_svcctl.o
+PRIVATE_DEPENDENCIES = RPC_NDR_SVCCTL
+
+[PYTHON::python_lsa]
+OBJ_FILES = gen_ndr/py_lsa.o
+PRIVATE_DEPENDENCIES = RPC_NDR_LSA
+
+[PYTHON::python_wkssvc]
+OBJ_FILES = gen_ndr/py_wkssvc.o
+PRIVATE_DEPENDENCIES = RPC_NDR_WKSSVC
+
+[PYTHON::python_dcerpc_security]
+OBJ_FILES = gen_ndr/py_security.o
diff --git a/source4/librpc/idl/lsa.idl b/source4/librpc/idl/lsa.idl
index ea94458936..705c86e39b 100644
--- a/source4/librpc/idl/lsa.idl
+++ b/source4/librpc/idl/lsa.idl
@@ -214,7 +214,7 @@ import "security.idl";
 		LSA_POLICY_INFO_AUDIT_FULL_SET=10,
 		LSA_POLICY_INFO_AUDIT_FULL_QUERY=11,
 		LSA_POLICY_INFO_DNS=12
-	} lsaPolicyInfo;
+	} lsa_PolicyInfo;
 
 	typedef [switch_type(uint16)] union {
 		[case(LSA_POLICY_INFO_AUDIT_LOG)]        lsa_AuditLogInfo       audit_log;
@@ -233,13 +233,17 @@ import "security.idl";
 
 	NTSTATUS lsa_QueryInfoPolicy (
 		[in]                            policy_handle *handle,
-		[in]                            uint16 level,
+		[in]                            lsa_PolicyInfo level,
 		[out,unique,switch_is(level)]   lsa_PolicyInformation *info
 		);
 
 	/******************/
 	/* Function:       0x08 */
-	NTSTATUS lsa_SetInfoPolicy ();
+	NTSTATUS lsa_SetInfoPolicy (
+		[in]                            policy_handle *handle,
+		[in]                            lsa_PolicyInfo level,
+		[in,switch_is(level)]           lsa_PolicyInformation *info
+		);
 
 	/******************/
 	/* Function:       0x09 */
@@ -722,12 +726,16 @@ import "security.idl";
 
 	NTSTATUS lsa_QueryInfoPolicy2(
 		[in]                 policy_handle *handle,
-		[in]                     uint16 level,
+		[in]                     lsa_PolicyInfo level,
 		[out,unique,switch_is(level)]   lsa_PolicyInformation *info
 		);
 
 	/* Function 0x2f */
-	NTSTATUS lsa_SetInfoPolicy2();
+	NTSTATUS lsa_SetInfoPolicy2(
+		[in]                            policy_handle *handle,
+		[in]                            lsa_PolicyInfo level,
+		[in,switch_is(level)]           lsa_PolicyInformation *info
+		);
 
 	/**********************/
 	/* Function 0x30 */
diff --git a/source4/librpc/idl/mgmt.idl b/source4/librpc/idl/mgmt.idl
index 60d1ebdc85..35857f26cd 100644
--- a/source4/librpc/idl/mgmt.idl
+++ b/source4/librpc/idl/mgmt.idl
@@ -2,6 +2,8 @@
   dcerpc remote management interface
 */
 
+import "misc.idl";
+
 [
   uuid("afa8bd80-7d8a-11c9-bef4-08002b102989"), 
   version(1.0),
diff --git a/source4/librpc/idl/svcctl.idl b/source4/librpc/idl/svcctl.idl
index 2fbdb71e74..d9f8233a0e 100644
--- a/source4/librpc/idl/svcctl.idl
+++ b/source4/librpc/idl/svcctl.idl
@@ -4,6 +4,7 @@
   svcctl interface definitions
 */
 
+import "misc.idl";
 [ uuid("367abb81-9844-35f1-ad32-98f038001003"),
   version(2.0),
   pointer_default(unique),
diff --git a/source4/librpc/ndr/ndr_drsuapi.c b/source4/librpc/ndr/ndr_drsuapi.c
index dedcb0601d..9f755ffaab 100644
--- a/source4/librpc/ndr/ndr_drsuapi.c
+++ b/source4/librpc/ndr/ndr_drsuapi.c
@@ -23,7 +23,7 @@
 #include "includes.h"
 #include "librpc/gen_ndr/ndr_drsuapi.h"
 #include "librpc/gen_ndr/ndr_misc.h"
-#include "libcli/util/asn_1.h"
+#include "lib/util/asn1.h"
 
 void ndr_print_drsuapi_DsReplicaObjectListItem(struct ndr_print *ndr, const char *name, 
 					       const struct drsuapi_DsReplicaObjectListItem *r)
diff --git a/source4/param/param.i b/source4/param/param.i
index 353fa3ced6..eeecb0e5b9 100644
--- a/source4/param/param.i
+++ b/source4/param/param.i
@@ -290,3 +290,24 @@ typedef struct param_section {
 
 %rename(default_config) global_loadparm;
 struct loadparm_context *global_loadparm;
+
+%{
+
+struct loadparm_context *lp_from_py_object(PyObject *py_obj)
+{
+    struct loadparm_context *lp_ctx;
+    if (PyString_Check(py_obj)) {
+        lp_ctx = loadparm_init(NULL);
+        if (!lp_load(lp_ctx, PyString_AsString(py_obj))) {
+            talloc_free(lp_ctx);
+            return NULL;
+        }
+        return lp_ctx;
+    }
+
+    if (SWIG_ConvertPtr(py_obj, (void *)&lp_ctx, SWIGTYPE_p_loadparm_context, 0 |  0 ) < 0)
+        return NULL;
+    return lp_ctx;
+}
+
+%}
diff --git a/source4/param/param_wrap.c b/source4/param/param_wrap.c
index ca9fbb77b8..d8be725c5e 100644
--- a/source4/param/param_wrap.c
+++ b/source4/param/param_wrap.c
@@ -2760,6 +2760,26 @@ SWIGINTERN char const *param_opt___str__(param_opt *self){ return self->value; }
 SWIGINTERN void delete_param_opt(param_opt *self){ talloc_free(self); }
 SWIGINTERN struct param_opt *param_section_first_parameter(param_section *self){ return self->parameters; }
 SWIGINTERN struct param_opt *param_section_next_parameter(param_section *self,struct param_opt *s){ return s->next; }
+
+
+struct loadparm_context *lp_from_py_object(PyObject *py_obj)
+{
+    struct loadparm_context *lp_ctx;
+    if (PyString_Check(py_obj)) {
+        lp_ctx = loadparm_init(NULL);
+        if (!lp_load(lp_ctx, PyString_AsString(py_obj))) {
+            talloc_free(lp_ctx);
+            return NULL;
+        }
+        return lp_ctx;
+    }
+
+    if (SWIG_ConvertPtr(py_obj, (void *)&lp_ctx, SWIGTYPE_p_loadparm_context, 0 |  0 ) < 0)
+        return NULL;
+    return lp_ctx;
+}
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm
index 1d059ebdf7..fc6bfe4c96 100644
--- a/source4/pidl/lib/Parse/Pidl/NDR.pm
+++ b/source4/pidl/lib/Parse/Pidl/NDR.pm
@@ -35,7 +35,7 @@ use vars qw($VERSION);
 $VERSION = '0.01';
 @ISA = qw(Exporter);
 @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString);
-@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred);
+@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred is_charset_array);
 
 use strict;
 use Parse::Pidl qw(warning fatal);
@@ -1181,4 +1181,19 @@ sub Validate($)
 	}
 }
 
+sub is_charset_array($$)
+{
+	my ($e,$l) = @_;
+
+	return 0 if ($l->{TYPE} ne "ARRAY");
+
+	my $nl = GetNextLevel($e,$l);
+
+	return 0 unless ($nl->{TYPE} eq "DATA");
+
+	return has_property($e, "charset");
+}
+
+
+
 1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
index b7372a802a..86b8951026 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm
@@ -9,7 +9,7 @@ package Parse::Pidl::Samba3::ClientNDR;
 
 use Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(GenerateFunctionInEnv ParseFunction $res $res_hdr);
+@EXPORT_OK = qw(ParseFunction $res $res_hdr);
 
 use strict;
 use Parse::Pidl qw(fatal warning);
@@ -17,7 +17,7 @@ use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference);
 use Parse::Pidl::Util qw(has_property is_constant ParseExpr);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
 use Parse::Pidl::Samba4 qw(DeclLong);
-use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionInEnv);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
index 24270340b9..efb3f2858d 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm
@@ -15,7 +15,7 @@ use Parse::Pidl::Typelist qw(typeHasBody);
 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of);
 use Parse::Pidl::Util qw(has_property ParseExpr);
 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel);
-use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv
+use Parse::Pidl::Samba4::Header qw(GenerateStructEnv GenerateFunctionInEnv
                                         GenerateFunctionOutEnv);
 
 use vars qw($VERSION);
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
index b96a58783c..2b3a9df80f 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm
@@ -6,10 +6,15 @@
 
 package Parse::Pidl::Samba4::Header;
 
+require Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
+
 use strict;
 use Parse::Pidl qw(fatal);
 use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference);
-use Parse::Pidl::Util qw(has_property is_constant unmake_str);
+use Parse::Pidl::Util qw(has_property is_constant unmake_str ParseExpr);
 use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets choose_header);
 
 use vars qw($VERSION);
@@ -406,4 +411,66 @@ sub Parse($)
 	return $res;
 }
 
+sub GenerateStructEnv($$)
+{
+	my ($x, $v) = @_;
+	my %env;
+
+	foreach my $e (@{$x->{ELEMENTS}}) {
+		$env{$e->{NAME}} = "$v->$e->{NAME}";
+	}
+
+	$env{"this"} = $v;
+
+	return \%env;
+}
+
+sub EnvSubstituteValue($$)
+{
+	my ($env,$s) = @_;
+
+	# Substitute the value() values in the env
+	foreach my $e (@{$s->{ELEMENTS}}) {
+		next unless (defined(my $v = has_property($e, "value")));
+		
+		$env->{$e->{NAME}} = ParseExpr($v, $env, $e);
+	}
+
+	return $env;
+}
+
+sub GenerateFunctionInEnv($;$)
+{
+	my ($fn, $base) = @_;
+	my %env;
+
+	$base = "r->" unless defined($base);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
+sub GenerateFunctionOutEnv($;$)
+{
+	my ($fn, $base) = @_;
+	my %env;
+
+	$base = "r->" unless defined($base);
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep (/out/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."out.$e->{NAME}";
+		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
+			$env{$e->{NAME}} = $base."in.$e->{NAME}";
+		}
+	}
+
+	return \%env;
+}
+
 1;
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
index 8eb2f9ad15..02d3a80992 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm
@@ -9,14 +9,15 @@ package Parse::Pidl::Samba4::NDR::Parser;
 
 require Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint);
+@EXPORT_OK = qw(check_null_pointer NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint);
 
 use strict;
 use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody);
 use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid);
 use Parse::Pidl::CUtil qw(get_pointer_to get_value_of);
-use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
 use Parse::Pidl::Samba4 qw(is_intree choose_header);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
 use Parse::Pidl qw(warning);
 
 use vars qw($VERSION);
@@ -77,19 +78,6 @@ sub has_fast_array($$)
 	return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string");
 }
 
-sub is_charset_array($$)
-{
-	my ($e,$l) = @_;
-
-	return 0 if ($l->{TYPE} ne "ARRAY");
-
-	my $nl = GetNextLevel($e,$l);
-
-	return 0 unless ($nl->{TYPE} eq "DATA");
-
-	return has_property($e, "charset");
-}
-
 
 ####################################
 # pidl() is our basic output routine
@@ -193,68 +181,6 @@ sub end_flags($$)
 	}
 }
 
-sub GenerateStructEnv($$)
-{
-	my ($x, $v) = @_;
-	my %env;
-
-	foreach my $e (@{$x->{ELEMENTS}}) {
-		$env{$e->{NAME}} = "$v->$e->{NAME}";
-	}
-
-	$env{"this"} = $v;
-
-	return \%env;
-}
-
-sub EnvSubstituteValue($$)
-{
-	my ($env,$s) = @_;
-
-	# Substitute the value() values in the env
-	foreach my $e (@{$s->{ELEMENTS}}) {
-		next unless (defined(my $v = has_property($e, "value")));
-		
-		$env->{$e->{NAME}} = ParseExpr($v, $env, $e);
-	}
-
-	return $env;
-}
-
-sub GenerateFunctionInEnv($;$)
-{
-	my ($fn, $base) = @_;
-	my %env;
-
-	$base = "r->" unless defined($base);
-
-	foreach my $e (@{$fn->{ELEMENTS}}) {
-		if (grep (/in/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."in.$e->{NAME}";
-		}
-	}
-
-	return \%env;
-}
-
-sub GenerateFunctionOutEnv($;$)
-{
-	my ($fn, $base) = @_;
-	my %env;
-
-	$base = "r->" unless defined($base);
-
-	foreach my $e (@{$fn->{ELEMENTS}}) {
-		if (grep (/out/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."out.$e->{NAME}";
-		} elsif (grep (/in/, @{$e->{DIRECTION}})) {
-			$env{$e->{NAME}} = $base."in.$e->{NAME}";
-		}
-	}
-
-	return \%env;
-}
-
 #####################################################################
 # parse the data of an array - push side
 sub ParseArrayPushHeader($$$$$$)
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
index 8effff9d5e..2475925377 100644
--- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
+++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm
@@ -1,6 +1,6 @@
 ###################################################
 # Python function wrapper generator
-# Copyright jelmer@samba.org 2007
+# Copyright jelmer@samba.org 2007-2008
 # released under the GNU GPL
 
 package Parse::Pidl::Samba4::Python;
@@ -9,15 +9,19 @@ use Exporter;
 @ISA = qw(Exporter);
 
 use strict;
-use Parse::Pidl::Typelist;
+use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias);
 use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
+use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
 
 use vars qw($VERSION);
 $VERSION = '0.01';
 
 sub new($) {
 	my ($class) = @_;
-	my $self = { res => "", res_hdr => "", tabs => "", constants => {}};
+	my $self = { res => "", res_hdr => "", tabs => "", constants => {},
+	             module_methods => []};
 	bless($self, $class);
 }
 
@@ -63,121 +67,371 @@ sub Import
 sub Const($$)
 {
     my ($self, $const) = @_;
-    $self->{constants}->{$const->{NAME}} = [$const->{DATA}->{TYPE}, $const->{VALUE}];
+	$self->register_constant($const->{NAME}, $const->{DTYPE}, $const->{VALUE});
 }
 
-sub FromTypeToPythonFunction($$)
+sub register_constant($$$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $name, $type, $value) = @_;
 
-	#FIXME
+	$self->{constants}->{$name} = [$type, $value];
 }
 
-sub FromPythonToTypeFunction($$)
+sub EnumAndBitmapConsts($$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $name, $d) = @_;
 
-	#FIXME
+	return unless (defined($d->{ELEMENTS}));
+
+	foreach my $e (@{$d->{ELEMENTS}}) {
+		$e =~ /^([A-Za-z0-9_]+)/;
+		my $cname = $1;
+		
+		$self->register_constant($cname, $d, $cname);
+	}
 }
 
-sub TypeConstructor($$)
+sub FromUnionToPythonFunction($$$$)
 {
-	my ($self, $type) = @_;
+	my ($self, $mem_ctx, $type, $switch, $name) = @_;
+
+	$self->pidl("PyObject *ret;");
+	$self->pidl("");
 
-	$self->pidl("staticforward PyTypeObject $type->{NAME}_ObjectType;");
-	$self->pidl("typedef struct {");
+	$self->pidl("switch ($switch) {");
 	$self->indent;
-	$self->pidl("PyObject_HEAD");
-	$self->pidl("void *object;"); # FIXME: Use real type rather than void
+
+	foreach my $e (@{$type->{ELEMENTS}}) {
+		$self->pidl("$e->{CASE}:");
+
+		$self->indent;
+
+		if ($e->{NAME}) {
+			$self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret");
+		} else {
+			$self->pidl("ret = Py_None;");
+		}
+
+		$self->pidl("return ret;");
+		$self->pidl("");
+
+		$self->deindent;
+	}
+
 	$self->deindent;
-	$self->pidl("} $type->{NAME}_Object;");
+	$self->pidl("}");
 
-	$self->pidl("");
+	$self->pidl("PyErr_SetString(PyExc_TypeError, \"unknown union level\");");
+	$self->pidl("return NULL;");
+}
 
-	$self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)");
-	$self->pidl("{");
+sub FromPythonToUnionFunction($$$$$)
+{
+	my ($self, $type, $typename, $switch, $mem_ctx, $name) = @_;
+
+	my $has_default = 0;
+
+	$self->pidl("$typename *ret = talloc_zero($mem_ctx, $typename);");
+
+	$self->pidl("switch ($switch) {");
 	$self->indent;
-	$self->pidl("return Py_None;");
+
+	foreach my $e (@{$type->{ELEMENTS}}) {
+		$self->pidl("$e->{CASE}:");
+		if ($e->{CASE} eq "default") { $has_default = 1; }
+		$self->indent;
+		if ($e->{NAME}) {
+			$self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
+		}
+		$self->pidl("break;");
+		$self->deindent;
+		$self->pidl("");
+	}
+
+	if (!$has_default) {
+		$self->pidl("default:");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
+		$self->pidl("talloc_free(ret);");
+		$self->pidl("ret = NULL;");
+		$self->deindent;
+	}
+
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
+	$self->pidl("return ret;");
+}
+
+sub PythonStruct($$$$)
+{
+	my ($self, $name, $cname, $d) = @_;
+
+	my $env = GenerateStructEnv($d, "object");
+
+	$self->pidl("");
 
-	$self->pidl("static void py_$type->{NAME}_dealloc(PyObject* self)");
+	$self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}_Object *obj = ($type->{NAME}_Object *)self;");
-	$self->pidl("talloc_free(obj->object);");
-	$self->pidl("PyObject_Del(self);");
+	if ($#{$d->{ELEMENTS}} > -1) {
+		$self->pidl("$cname *object = py_talloc_get_ptr(obj);");
+		foreach my $e (@{$d->{ELEMENTS}}) {
+			$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+			my $varname = "object->$e->{NAME}";
+			$self->indent;
+			$self->pidl("PyObject *py_$e->{NAME};");
+			$self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}");
+			$self->pidl("return py_$e->{NAME};");
+			$self->deindent;
+			$self->pidl("}");
+		}
+	}
+	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
+	$self->pidl("return NULL;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)");
+	$self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("return Py_None;");
+	if ($#{$d->{ELEMENTS}} > -1) {
+		$self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
+		my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
+		foreach my $e (@{$d->{ELEMENTS}}) {
+			$self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {");
+			my $varname = "object->$e->{NAME}";
+			$self->indent;
+			my $l = $e->{LEVELS}[0];
+			my $nl = GetNextLevel($e, $l);
+			if ($l->{TYPE} eq "POINTER" and 
+				not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and
+				not ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
+				$self->pidl("talloc_free($varname);");
+			}
+			$self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
+			$self->pidl("return 0;");
+			$self->deindent;
+			$self->pidl("}");
+		}
+	}
+	$self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");");
+	$self->pidl("return -1;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 
-	$self->pidl("static PyTypeObject $type->{NAME}_ObjectType = {");
+	$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n");
+	$self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n");
+	$self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n");
+	$self->pidl_hdr("\n");
+	$self->pidl("PyTypeObject $name\_Type = {");
 	$self->indent;
 	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
-	$self->pidl(".tp_name = \"$type->{NAME}\",");
-	$self->pidl(".tp_basicsize = sizeof($type->{NAME}_Object),");
-	$self->pidl(".tp_dealloc = (destructor)py_$type->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = (getattrfunc)py_$type->{NAME}_getattr,");
-	$self->pidl(".tp_setattr = (setattrfunc)py_$type->{NAME}_setattr,");
+	$self->pidl(".tp_name = \"$name\",");
+	$self->pidl(".tp_basicsize = sizeof(py_talloc_Object),");
+	$self->pidl(".tp_dealloc = py_talloc_dealloc,");
+	$self->pidl(".tp_getattr = py_$name\_getattr,");
+	$self->pidl(".tp_setattr = py_$name\_setattr,");
+	$self->pidl(".tp_repr = py_talloc_default_repr,");
 	$self->deindent;
 	$self->pidl("};");
 
 	$self->pidl("");
 
-	$self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)");
+	my $py_fnname = "py_$name";
+	$self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)");
 	$self->pidl("{");
 	$self->indent;
-	$self->pidl("$type->{NAME}\_Object *ret;");
-	$self->pidl("ret = PyObject_New($type->{NAME}_Object, &$type->{NAME}_ObjectType);");
-	$self->pidl("return (PyObject *) ret;");
+	$self->pidl("$cname *ret = talloc_zero(NULL, $cname);");
+	$self->pidl("return py_talloc_import(&$name\_Type, ret);");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
+
+	return $py_fnname;
 }
 
 sub PythonFunction($$$)
 {
 	my ($self, $fn, $iface) = @_;
 
-	$self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)");
+	$self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
 	$self->pidl("{");
 	$self->indent;
 	$self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;");
 	$self->pidl("NTSTATUS status;");
+	$self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);");
+	$self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});");
+	$self->pidl("PyObject *result = Py_None;");
+	
+	my $env = GenerateFunctionInEnv($fn, "r->");
+	my $result_size = 0;
+
+	my $args_format = "";
+	my $args_string = "";
+	my $args_names = "";
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		$self->pidl("PyObject *py_$e->{NAME};");
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			$result_size++;
+		}
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			$args_format .= "O";
+			$args_string .= ", &py_$e->{NAME}";
+			$args_names .= "\"$e->{NAME}\", ";
+		}
+	}
+	$self->pidl("const char *kwnames[] = {");
+	$self->indent;
+	$self->pidl($args_names . "NULL");
+	$self->deindent;
+	$self->pidl("};");
+
 	$self->pidl("");
-	# FIXME
-	$self->handle_ntstatus("status", "NULL");
-	$self->pidl("return Py_None;");
+	$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {");
+	$self->indent;
+	$self->pidl("return NULL;");
+	$self->deindent;
+	$self->pidl("}");
+
+	if ($fn->{RETURN_TYPE}) {
+		$result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS");
+	}
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		if (grep(/in/,@{$e->{DIRECTION}})) {
+			$self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;");
+		}
+	}
+	$self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);");
+	$self->handle_ntstatus("status", "NULL", "mem_ctx");
+
+	$env = GenerateFunctionOutEnv($fn, "r->");
+	my $i = 0;
+
+	if ($result_size > 1) {
+		$self->pidl("result = PyTuple_New($result_size);");
+	}
+
+	foreach my $e (@{$fn->{ELEMENTS}}) {
+		my $py_name = "py_$e->{NAME}";
+		if (grep(/out/,@{$e->{DIRECTION}})) {
+			$self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name);
+			if ($result_size > 1) {
+				$self->pidl("PyTuple_SetItem(result, $i, $py_name);");
+				$i++;
+			} else {
+				$self->pidl("result = $py_name;");
+			}
+		}
+	}
+
+	if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
+		$self->handle_ntstatus("r->out.result", "NULL", "mem_ctx");
+	} elsif (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "WERROR") {
+		$self->handle_werror("r->out.result", "NULL", "mem_ctx");
+	} elsif (defined($fn->{RETURN_TYPE})) {
+		my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result");
+		if ($result_size > 1) {
+			$self->pidl("PyTuple_SetItem(result, $i, $conv);");
+		} else {
+			$self->pidl("result = $conv;");
+		}
+	}
+
+	$self->pidl("talloc_free(mem_ctx);");
+	$self->pidl("return result;");
+	$self->deindent;
+	$self->pidl("}");
+	$self->pidl("");
+}
+
+sub handle_werror($$$$)
+{
+	my ($self, $var, $retval, $mem_ctx) = @_;
+
+	$self->pidl("if (!W_ERROR_IS_OK($var)) {");
+	$self->indent;
+	$self->pidl("PyErr_SetString(PyExc_RuntimeError, win_errstr($var));");
+	$self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
+	$self->pidl("return $retval;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 }
 
-sub handle_ntstatus($$$)
+sub handle_ntstatus($$$$)
 {
-	my ($self, $var, $retval) = @_;
+	my ($self, $var, $retval, $mem_ctx) = @_;
 
 	$self->pidl("if (NT_STATUS_IS_ERR($var)) {");
 	$self->indent;
 	$self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));");
+	$self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
 	$self->pidl("return $retval;");
 	$self->deindent;
 	$self->pidl("}");
 	$self->pidl("");
 }
 
-sub Interface($$)
+sub PythonType($$$)
 {
-	my($self,$interface) = @_;
+	my ($self, $d, $interface, $basename) = @_;
+
+	my $actual_ctype = $d;
+	if ($actual_ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $actual_ctype->{DATA};
+	}
+
+	if ($actual_ctype->{TYPE} eq "STRUCT") {
+		my $py_fnname;
+		if ($d->{TYPE} eq "STRUCT") {
+			$py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d);
+		} else {
+			$py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA});
+		}
+
+		my $fn_name = $d->{NAME};
+
+		$fn_name =~ s/^$interface->{NAME}_//;
+		$fn_name =~ s/^$basename\_//;
+
+		$self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", "NULL");
+	}
+
+	if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
+		$self->EnumAndBitmapConsts($d->{NAME}, $d);
+	}
+
+	if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) {
+		$self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
+	}
+
+	if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
+		$self->pidl("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
+		$self->pidl("{");
+		$self->indent;
+		$self->FromUnionToPythonFunction("mem_ctx", $actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+
+		$self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
+		$self->pidl("{");
+		$self->indent;
+		$self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+	}
+}
+
+sub Interface($$$)
+{
+	my($self,$interface,$basename) = @_;
 
 	$self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n");
 	$self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n");
@@ -186,108 +440,454 @@ sub Interface($$)
 
 	$self->Const($_) foreach (@{$interface->{CONSTS}});
 
-	foreach (@{$interface->{TYPES}}) {
-		$self->FromTypeToPythonFunction($_);	
-		$self->FromPythonToTypeFunction($_);	
-		$self->TypeConstructor($_);
+	foreach my $d (@{$interface->{TYPES}}) {
+		next if has_property($d, "nopython");
+
+		$self->PythonType($d, $interface, $basename);
 	}
 
-	$self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;");
-	$self->pidl("typedef struct {");
-	$self->indent;
-	$self->pidl("PyObject_HEAD");
-	$self->pidl("struct dcerpc_pipe *pipe;");
-	$self->deindent;
-	$self->pidl("} $interface->{NAME}_InterfaceObject;");
+	if (defined $interface->{PROPERTIES}->{uuid}) {
+		$self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
+		$self->pidl("typedef struct {");
+		$self->indent;
+		$self->pidl("PyObject_HEAD");
+		$self->pidl("struct dcerpc_pipe *pipe;");
+		$self->deindent;
+		$self->pidl("} $interface->{NAME}_InterfaceObject;");
 
-	$self->pidl("");
+		$self->pidl("");
 
-	foreach my $d (@{$interface->{FUNCTIONS}}) {
-		next if not defined($d->{OPNUM});
-		next if has_property($d, "nopython");
+		foreach my $d (@{$interface->{FUNCTIONS}}) {
+			next if not defined($d->{OPNUM});
+			next if has_property($d, "nopython");
+
+			$self->PythonFunction($d, $interface->{NAME});
+		}
+
+		$self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {");
+		$self->indent;
+		foreach my $d (@{$interface->{FUNCTIONS}}) {
+			next if not defined($d->{OPNUM});
+			next if has_property($d, "nopython");
 
-		$self->PythonFunction($d, $interface->{NAME});
+			my $fn_name = $d->{NAME};
+
+			$fn_name =~ s/^$interface->{NAME}_//;
+			$fn_name =~ s/^$basename\_//;
+
+			$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
+		}
+		$self->pidl("{ NULL, NULL, 0, NULL }");
+		$self->deindent;
+		$self->pidl("};");
+		$self->pidl("");
+
+		$self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;");
+		$self->pidl("talloc_free(interface->pipe);");
+		$self->pidl("PyObject_Del(self);");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+
+		$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);");
+		$self->deindent;
+		$self->pidl("}");
+
+		$self->pidl("");
+
+		$self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
+		$self->indent;
+		$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
+		$self->pidl(".tp_name = \"$interface->{NAME}\",");
+		$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
+		$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
+		$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
+		$self->deindent;
+		$self->pidl("};");
+
+		$self->pidl("");
+
+		$self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL");
+		$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)");
+		$self->pidl("{");
+		$self->indent;
+		$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
+		$self->pidl("const char *binding_string;");
+		$self->pidl("struct cli_credentials *credentials;");
+		$self->pidl("struct loadparm_context *lp_ctx = NULL;");
+		$self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;");
+		$self->pidl("TALLOC_CTX *mem_ctx = NULL;");
+		$self->pidl("NTSTATUS status;");
+		$self->pidl("");
+		$self->pidl("const char *kwnames[] = {");
+		$self->indent;
+		$self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL");
+		$self->deindent;
+		$self->pidl("};");
+		$self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);");
+		$self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);");
+		$self->pidl("");
+		$self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {");
+		$self->indent;
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+		$self->pidl("if (py_lp_ctx != NULL) {");
+		$self->indent;
+		$self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);");
+		$self->pidl("if (lp_ctx == NULL) {");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");");
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
+		$self->deindent;
+		$self->pidl("}");
+		$self->pidl("");
+
+		$self->pidl("credentials = cli_credentials_from_py_object(py_credentials);");
+		$self->pidl("if (credentials == NULL) {");
+		$self->indent;
+		$self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");");
+		$self->pidl("return NULL;");
+		$self->deindent;
+		$self->pidl("}");
+
+		$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
+		$self->pidl("");
+
+		$self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
+		$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
+		$self->handle_ntstatus("status", "NULL", "mem_ctx");
+
+		$self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;");
+
+		$self->pidl("return (PyObject *)ret;");
+		$self->deindent;
+		$self->pidl("}");
+		
+		$self->pidl("");
 	}
 
-	$self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {");
-	$self->indent;
-	foreach my $d (@{$interface->{FUNCTIONS}}) {
-		next if not defined($d->{OPNUM});
-		next if has_property($d, "nopython");
+	$self->pidl_hdr("\n");
+	$self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
+}
 
-		my $fn_name = $d->{NAME};
+sub register_module_method($$$$$)
+{
+	my ($self, $fn_name, $pyfn_name, $flags, $doc) = @_;
 
-		$fn_name =~ s/^$interface->{NAME}_//;
+	push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
+}
 
-		$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
+sub assign($$$)
+{
+	my ($self, $dest, $src) = @_;
+	if ($dest =~ /^\&/) {
+		$self->pidl("memcpy($dest, $src, sizeof(" . get_value_of($dest) . "));");
+	} else {
+		$self->pidl("$dest = $src;");
 	}
-	$self->pidl("{ NULL, NULL, 0, NULL }");
-	$self->deindent;
-	$self->pidl("};");
-	$self->pidl("");
+}
 
-	$self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;");
-	$self->pidl("talloc_free(interface->pipe);");
-	$self->pidl("PyObject_Del(self);");
-	$self->deindent;
-	$self->pidl("}");
-	$self->pidl("");
+sub ConvertObjectFromPythonData($$$$$$)
+{
+	my ($self, $mem_ctx, $cvar, $ctype, $target, $fail) = @_;
 
-	$self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyTypeObject *obj, char *name)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, (PyObject *)obj, name);");
-	$self->deindent;
-	$self->pidl("}");
+	die("undef type for $cvar") unless(defined($ctype));
 
-	$self->pidl("");
+	$ctype = resolveType($ctype);
 
-	$self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {");
-	$self->indent;
-	$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
-	$self->pidl(".tp_name = \"$interface->{NAME}\",");
-	$self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),");
-	$self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,");
-	$self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,");
-	$self->deindent;
-	$self->pidl("};");
+	my $actual_ctype = $ctype;
+	if ($ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $ctype->{DATA};
+	}
 
-	$self->pidl("");
+	if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or 
+		$actual_ctype->{TYPE} eq "SCALAR" and (
+		expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]*|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
+		$self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);");
+		$self->pidl("$target = PyInt_AsLong($cvar);");
+		return;
+	}
 
-	$self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)");
-	$self->pidl("{");
-	$self->indent;
-	$self->pidl("$interface->{NAME}_InterfaceObject *ret;");
-	$self->pidl("const char *binding_string;");
-	$self->pidl("struct cli_credentials *credentials;");
-	$self->pidl("struct loadparm_context *lp_ctx;");
-	$self->pidl("NTSTATUS status;");
-	$self->pidl("");
+	if ($actual_ctype->{TYPE} eq "STRUCT") {
+		$self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);");
+		$self->assign($target, "py_talloc_get_ptr($cvar)");
+		return;
+	}
 
-	# FIXME: Arguments: binding string, credentials, loadparm context
-	$self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);");
-	$self->pidl("");
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
+		$self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));");
+		return;
+	}
 
-	$self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
-	$self->pidl("             &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);");
-	$self->handle_ntstatus("status", "NULL");
+	if ($actual_ctype->{TYPE} eq "SCALAR" and 
+		($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) {
+		$self->pidl("$target = talloc_strdup($mem_ctx, PyString_AsString($cvar));");
+		return;
+	}
 
-	$self->pidl("return (PyObject *)ret;");
-	$self->deindent;
-	$self->pidl("}");
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") {
+		$self->pidl("$target = PyString_AsString($cvar);");
+		return;
+		}
+
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
+		$self->pidl("$target = NT_STATUS(PyInt_AsLong($cvar));");
+		return;
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
+		$self->pidl("$target = W_ERROR(PyInt_AsLong($cvar));");
+		return;
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
+		$self->pidl("$target = PyCObject_AsVoidPtr($cvar);");
+		return;
+	}
+
+	if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
+		$self->assign($target, "PyCObject_AsVoidPtr($cvar)");
+		return;
+	}
+
+	die("unknown type ".mapTypeName($ctype) . ": $cvar");
+
+}
+
+sub ConvertObjectFromPythonLevel($$$$$$$$)
+{
+	my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_;
+	my $nl = GetNextLevel($e, $l);
+
+	if ($l->{TYPE} eq "POINTER") {
+		if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
+			$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail);
+			return;
+		}
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->pidl("if ($py_var == Py_None) {");
+			$self->indent;
+			$self->pidl("$var_name = NULL;");
+			$self->deindent;
+			$self->pidl("} else {");
+			$self->indent;
+		}
+		$self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
+		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, get_value_of($var_name), $fail);
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->deindent;
+			$self->pidl("}");
+		}
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		my $pl = GetPrevLevel($e, $l);
+		if ($pl && $pl->{TYPE} eq "POINTER") {
+			$var_name = get_pointer_to($var_name);
+		}
+
+		if (is_charset_array($e, $l)) {
+			$self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);");
+			# FIXME: Use Unix charset setting rather than utf-8
+			$self->pidl($var_name . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
+		} else {
+			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
+			$self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
+			$self->pidl("{");
+			$self->indent;
+			$self->pidl("int $counter;");
+			if (!$l->{IS_FIXED}) {
+				$self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));");
+			}
+			$self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {");
+			$self->indent;
+			$self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail);
+			$self->deindent;
+			$self->pidl("}");
+			$self->deindent;
+			$self->pidl("}");
+		}
+	} elsif ($l->{TYPE} eq "DATA") {
+
+		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
+			$var_name = get_pointer_to($var_name);
+		}
+		$self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail);
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		$var_name = get_pointer_to($var_name);
+		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
+		$self->assign($var_name, "py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var)");
+	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
+		$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), $var_name, $fail);
+	} else {
+		die("unknown level type $l->{TYPE}");
+	}
+}
+
+sub ConvertObjectFromPython($$$$$$$)
+{
+	my ($self, $env, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
+
+	$self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail);
+}
+
+sub ConvertScalarToPython($$$)
+{
+	my ($self, $ctypename, $cvar) = @_;
+
+	die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH");
+
+	$ctypename = expandAlias($ctypename);
+
+	if ($ctypename =~ /^(char|u?int[0-9]*|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) {
+		return "PyInt_FromLong($cvar)";
+	}
+
+	if ($ctypename eq "DATA_BLOB") {
+		return "PyString_FromStringAndSize((char *)($cvar).data, ($cvar).length)";
+	}
+
+	if ($ctypename eq "NTSTATUS") {
+		return "PyInt_FromLong(NT_STATUS_V($cvar))";
+	}
+
+	if ($ctypename eq "WERROR") {
+		return "PyInt_FromLong(W_ERROR_V($cvar))";
+	}
+
+	if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) {
+		return "PyString_FromString($cvar)";
+	}
+
+	# Not yet supported
+	if ($ctypename eq "string_array") { return "PyCObject_FromVoidPtr($cvar)"; }
+	if ($ctypename eq "ipv4address") { return "PyString_FromString($cvar)"; }
+	if ($ctypename eq "pointer") {
+		return "PyCObject_FromVoidPtr($cvar, talloc_free)";
+	}
+
+	die("Unknown scalar type $ctypename");
+}
+
+sub ConvertObjectToPythonData($$$$$)
+{
+	my ($self, $mem_ctx, $ctype, $cvar) = @_;
+
+	die("undef type for $cvar") unless(defined($ctype));
+
+	$ctype = resolveType($ctype);
+
+	my $actual_ctype = $ctype;
+	if ($ctype->{TYPE} eq "TYPEDEF") {
+		$actual_ctype = $ctype->{DATA};
+	} 
 	
-	$self->pidl("");
+	if ($actual_ctype->{TYPE} eq "ENUM") {
+		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar);
+	} elsif ($actual_ctype->{TYPE} eq "BITMAP") {
+		return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar);
+	} elsif ($actual_ctype->{TYPE} eq "SCALAR") {
+		return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar);
+	} elsif ($actual_ctype->{TYPE} eq "STRUCT") {
+		return "py_talloc_import_ex(&$ctype->{NAME}_Type, $mem_ctx, $cvar)";
+	}
 
-	$self->pidl_hdr("\n");
-	$self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
+	die("unknown type ".mapTypeName($ctype) . ": $cvar");
 }
 
-sub Parse($$$$)
+sub ConvertObjectToPythonLevel($$$$$)
 {
-    my($self,$basename,$ndr,$hdr) = @_;
+	my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_;
+	my $nl = GetNextLevel($e, $l);
+
+	if ($l->{TYPE} eq "POINTER") {
+		if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
+			$self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name, $py_var);
+			return;
+		}
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->pidl("if ($var_name == NULL) {");
+			$self->indent;
+			$self->pidl("$py_var = Py_None;");
+			$self->deindent;
+			$self->pidl("} else {");
+			$self->indent;
+		}
+		$self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, get_value_of($var_name), $py_var);
+		if ($l->{POINTER_TYPE} ne "ref") {
+			$self->deindent;
+			$self->pidl("}");
+		}
+	} elsif ($l->{TYPE} eq "ARRAY") {
+		if (is_charset_array($e, $l)) {
+			$var_name = get_pointer_to($var_name);
+			# FIXME: Use Unix charset setting rather than utf-8
+			$self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");");
+		} else {
+			my $pl = GetPrevLevel($e, $l);
+			if ($pl && $pl->{TYPE} eq "POINTER") {
+				$var_name = get_pointer_to($var_name);
+			}
+
+			die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS}));
+			my $length = $l->{SIZE_IS};
+			if (defined($l->{LENGTH_IS})) {
+				$length = $l->{LENGTH_IS};
+			}
+
+			$length = ParseExpr($length, $env, $e);
+			$self->pidl("$py_var = PyList_New($length);");
+			$self->pidl("{");
+			$self->indent;
+			my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
+			$self->pidl("int $counter;");
+			$self->pidl("for ($counter = 0; $counter < $length; $counter++) {");
+			$self->indent;
+			my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
+			$self->pidl("PyObject *$member_var;");
+			$self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var);
+			$self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
+			$self->deindent;
+			$self->pidl("}");
+			$self->deindent;
+			$self->pidl("}");
+		}
+	} elsif ($l->{TYPE} eq "SWITCH") {
+		$var_name = get_pointer_to($var_name);
+		my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
+		$self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);");
+	} elsif ($l->{TYPE} eq "DATA") {
+		if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
+			$var_name = get_pointer_to($var_name);
+		}
+		my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name);
+		$self->pidl("$py_var = $conv;");
+	} elsif ($l->{TYPE} eq "SUBCONTEXT") {
+		$self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, GetNextLevel($e, $l), $var_name, $py_var);
+	} else {
+		die("Unknown level type $l->{TYPE} $var_name");
+	}
+}
+
+sub ConvertObjectToPython($$$$$$)
+{
+	my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var) = @_;
+
+	$self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var);
+}
+
+sub Parse($$$$$)
+{
+    my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
     
     my $py_hdr = $hdr;
     $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g;
@@ -299,33 +899,24 @@ sub Parse($$$$)
 #include \"includes.h\"
 #include <Python.h>
 #include \"librpc/rpc/dcerpc.h\"
+#include \"scripting/python/pytalloc.h\"
+#include \"scripting/python/pyrpc.h\"
 #include \"$hdr\"
+#include \"$ndr_hdr\"
 #include \"$py_hdr\"
 
 ");
 
 	foreach my $x (@$ndr) {
-	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x);
 		($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}});
+	    ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
 	}
 	
 	$self->pidl("static PyMethodDef $basename\_methods[] = {");
 	$self->indent;
-	foreach my $x (@$ndr) {
-	    next if ($x->{TYPE} ne "INTERFACE");
-		$self->pidl("{ \"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
-
-		foreach my $d (@{$x->{TYPES}}) {
-			next if has_property($d, "nopython");
-			next if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP");
-
-			my $fn_name = $d->{NAME};
-
-			$fn_name =~ s/^$x->{NAME}_//;
-			$fn_name =~ s/^$basename\_//;
-
-			$self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },");
-		}
+	foreach (@{$self->{module_methods}}) {
+		my ($fn_name, $pyfn_name, $flags, $doc) = @$_;
+		$self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },");
 	}
 	
 	$self->pidl("{ NULL, NULL, 0, NULL }");
@@ -339,9 +930,18 @@ sub Parse($$$$)
 	$self->indent;
 	$self->pidl("PyObject *m;");
 	$self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);");
-	foreach (keys %{$self->{constants}}) {
-		# FIXME: Handle non-string constants
-		$self->pidl("PyModule_AddObject(m, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));");
+	foreach my $name (keys %{$self->{constants}}) {
+		my $py_obj;
+		my ($ctype, $cvar) = @{$self->{constants}->{$name}};
+		if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
+			$py_obj = "PyInt_FromLong($cvar)";
+		} elsif ($cvar =~ /^".*"$/) {
+			$py_obj = "PyString_FromString($cvar)";
+		} else {
+			$py_obj = $self->ConvertObjectToPythonData("NULL", expandAlias($ctype), $cvar);
+		}
+
+		$self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);");
 	}
 	$self->deindent;
 	$self->pidl("}");
diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm
index e54ef11b88..8ba1ae47af 100644
--- a/source4/pidl/lib/Parse/Pidl/Typelist.pm
+++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm
@@ -7,7 +7,7 @@ package Parse::Pidl::Typelist;
 
 require Exporter;
 @ISA = qw(Exporter);
-@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias
+@EXPORT_OK = qw(hasType getType resolveType mapTypeName scalar_is_reference expandAlias
 			    mapScalarType addType typeIs is_scalar enum_type_fn
 				bitmap_type_fn mapType typeHasBody
 );
@@ -59,6 +59,7 @@ my %aliases = (
 	"boolean8" => "uint8",
 	"boolean32" => "uint32",
 	"DWORD" => "uint32",
+	"uint" => "uint32",
 	"int" => "int32",
 	"WORD" => "uint16",
 	"char" => "uint8",
@@ -95,6 +96,20 @@ sub addType($)
 	$types{$t->{NAME}} = $t;
 }
 
+sub resolveType($)
+{
+	my ($ctype) = @_;
+
+	if (not hasType($ctype)) {
+		# assume struct typedef
+		return { TYPE => "TYPEDEF", NAME => $ctype, DATA => { TYPE => "STRUCT" } };
+	} else {
+		return getType($ctype);
+	}
+
+	return $ctype;
+}
+
 sub getType($)
 {
 	my $t = shift;
diff --git a/source4/pidl/pidl b/source4/pidl/pidl
index 500b4dcbfc..4dfd57dc20 100755
--- a/source4/pidl/pidl
+++ b/source4/pidl/pidl
@@ -671,7 +671,8 @@ sub process_file($)
 	if (defined($opt_python)) {
 		require Parse::Pidl::Samba4::Python;
 		my $generator = new Parse::Pidl::Samba4::Python(); 
-		my ($hdr,$prsr) = $generator->Parse($basename, $ndr, $h_filename);
+		my ($hdr,$prsr) = $generator->Parse($basename, $ndr, 
+					"$outputdir/ndr_$basename\_c.h", $h_filename);
 		FileSave("$outputdir/py_$basename.c", $prsr);
 		FileSave("$outputdir/py_$basename.h", $hdr);
 	}
diff --git a/source4/pidl/tests/header.pl b/source4/pidl/tests/header.pl
index 8d0dccf507..db59484444 100755
--- a/source4/pidl/tests/header.pl
+++ b/source4/pidl/tests/header.pl
@@ -4,12 +4,14 @@
 use strict;
 use warnings;
 
-use Test::More tests => 16;
+use Test::More tests => 27;
 use FindBin qw($RealBin);
 use lib "$RealBin";
 use Util;
 use Parse::Pidl::Util qw(MyDumper);
-use Parse::Pidl::Samba4::Header;
+use Parse::Pidl::Samba4::Header qw(
+	GenerateFunctionInEnv GenerateFunctionOutEnv GenerateStructEnv
+	EnvSubstituteValue);
 use Parse::Pidl::IDL qw(parse_string);
 use Parse::Pidl::NDR;
 
@@ -56,3 +58,51 @@ like(parse_idl("interface p { typedef struct x { int p; } x; };"),
 
 like(parse_idl("cpp_quote(\"some-foo\")"),
 	qr/some-foo/sm, "cpp quote");
+
+# Make sure GenerateFunctionInEnv and GenerateFunctionOutEnv work
+my $fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
+is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionInEnv($fn));
+
+$fn = { ELEMENTS => [ { DIRECTION => ["out"], NAME => "foo" } ] };
+is_deeply({ "foo" => "r->out.foo" }, GenerateFunctionOutEnv($fn));
+
+$fn = { ELEMENTS => [ { DIRECTION => ["out", "in"], NAME => "foo" } ] };
+is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionInEnv($fn));
+
+$fn = { ELEMENTS => [ { DIRECTION => ["out", "in"], NAME => "foo" } ] };
+is_deeply({ "foo" => "r->out.foo" }, GenerateFunctionOutEnv($fn));
+
+$fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
+is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionOutEnv($fn));
+
+$fn = { ELEMENTS => [ { DIRECTION => ["out"], NAME => "foo" } ] };
+is_deeply({ }, GenerateFunctionInEnv($fn));
+
+$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
+is_deeply({ foo => "r->foo", bar => "r->bar", this => "r" }, 
+		GenerateStructEnv($fn, "r"));
+
+$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
+is_deeply({ foo => "some->complex.variable->foo", 
+		    bar => "some->complex.variable->bar", 
+			this => "some->complex.variable" }, 
+		GenerateStructEnv($fn, "some->complex.variable"));
+
+$fn = { ELEMENTS => [ { NAME => "foo", PROPERTIES => { value => 3 }} ] };
+
+my $env = GenerateStructEnv($fn, "r");
+EnvSubstituteValue($env, $fn);
+is_deeply($env, { foo => 3, this => "r" });
+
+$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
+$env = GenerateStructEnv($fn, "r");
+EnvSubstituteValue($env, $fn);
+is_deeply($env, { foo => 'r->foo', bar => 'r->bar', this => "r" });
+
+$fn = { ELEMENTS => [ { NAME => "foo", PROPERTIES => { value => 0 }} ] };
+
+$env = GenerateStructEnv($fn, "r");
+EnvSubstituteValue($env, $fn);
+is_deeply($env, { foo => 0, this => "r" });
+
+
diff --git a/source4/pidl/tests/samba-ndr.pl b/source4/pidl/tests/samba-ndr.pl
index 05c3c1c0df..a14111961f 100755
--- a/source4/pidl/tests/samba-ndr.pl
+++ b/source4/pidl/tests/samba-ndr.pl
@@ -4,15 +4,14 @@
 use strict;
 use warnings;
 
-use Test::More tests => 41;
+use Test::More tests => 30;
 use FindBin qw($RealBin);
 use lib "$RealBin";
 use Util;
 use strict;
 use Parse::Pidl::Util qw(MyDumper);
 use Parse::Pidl::Samba4::NDR::Parser qw(check_null_pointer 
-	GenerateFunctionInEnv GenerateFunctionOutEnv GenerateStructEnv 
-	EnvSubstituteValue NeededFunction NeededElement NeededType
+	NeededFunction NeededElement NeededType
 	NeededInterface TypeFunctionName ParseElementPrint); 
 
 my $output;
@@ -138,52 +137,6 @@ test_warnings("nofile:2: unknown dereferenced expression `r->in.bla'\n",
 
 is($output, "if (r->in.bla == NULL) return;");
 
-# Make sure GenerateFunctionInEnv and GenerateFunctionOutEnv work
-$fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
-is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionInEnv($fn));
-
-$fn = { ELEMENTS => [ { DIRECTION => ["out"], NAME => "foo" } ] };
-is_deeply({ "foo" => "r->out.foo" }, GenerateFunctionOutEnv($fn));
-
-$fn = { ELEMENTS => [ { DIRECTION => ["out", "in"], NAME => "foo" } ] };
-is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionInEnv($fn));
-
-$fn = { ELEMENTS => [ { DIRECTION => ["out", "in"], NAME => "foo" } ] };
-is_deeply({ "foo" => "r->out.foo" }, GenerateFunctionOutEnv($fn));
-
-$fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
-is_deeply({ "foo" => "r->in.foo" }, GenerateFunctionOutEnv($fn));
-
-$fn = { ELEMENTS => [ { DIRECTION => ["out"], NAME => "foo" } ] };
-is_deeply({ }, GenerateFunctionInEnv($fn));
-
-$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
-is_deeply({ foo => "r->foo", bar => "r->bar", this => "r" }, 
-		GenerateStructEnv($fn, "r"));
-
-$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
-is_deeply({ foo => "some->complex.variable->foo", 
-		    bar => "some->complex.variable->bar", 
-			this => "some->complex.variable" }, 
-		GenerateStructEnv($fn, "some->complex.variable"));
-
-$fn = { ELEMENTS => [ { NAME => "foo", PROPERTIES => { value => 3 }} ] };
-
-my $env = GenerateStructEnv($fn, "r");
-EnvSubstituteValue($env, $fn);
-is_deeply($env, { foo => 3, this => "r" });
-
-$fn = { ELEMENTS => [ { NAME => "foo" }, { NAME => "bar" } ] };
-$env = GenerateStructEnv($fn, "r");
-EnvSubstituteValue($env, $fn);
-is_deeply($env, { foo => 'r->foo', bar => 'r->bar', this => "r" });
-
-$fn = { ELEMENTS => [ { NAME => "foo", PROPERTIES => { value => 0 }} ] };
-
-$env = GenerateStructEnv($fn, "r");
-EnvSubstituteValue($env, $fn);
-is_deeply($env, { foo => 0, this => "r" });
-
 my $needed = {};
 NeededElement({ TYPE => "foo", REPRESENTATION_TYPE => "foo" }, "pull", $needed); 
 is_deeply($needed, { ndr_pull_foo => 1 });
diff --git a/source4/pidl/tests/samba3-cli.pl b/source4/pidl/tests/samba3-cli.pl
index 1b2a3c9785..f5b51b7d34 100755
--- a/source4/pidl/tests/samba3-cli.pl
+++ b/source4/pidl/tests/samba3-cli.pl
@@ -10,7 +10,7 @@ use lib "$RealBin";
 use Util;
 use Parse::Pidl::Util qw(MyDumper);
 use Parse::Pidl::Samba3::ClientNDR qw(ParseFunction);
-use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
+use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
 
 # Make sure GenerateFunctionInEnv and GenerateFunctionOutEnv work
 my $fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
diff --git a/source4/scripting/bin/epdump.py b/source4/scripting/bin/epdump.py
new file mode 100644
index 0000000000..15dee33774
--- /dev/null
+++ b/source4/scripting/bin/epdump.py
@@ -0,0 +1,24 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+#   
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#   
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#   
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import sys
+
+if len(sys.argv) < 2:
+    print "Usage: %s <binding-string>" % sys.argv[0]
+    sys.exit(1)
diff --git a/source4/scripting/bin/winreg.py b/source4/scripting/bin/winreg.py
index 6cdc3a5898..f68f2d12f2 100644..100755
--- a/source4/scripting/bin/winreg.py
+++ b/source4/scripting/bin/winreg.py
@@ -7,87 +7,76 @@
 #
 
 import sys
+import winreg
+import optparse
+import samba.getopt as options
 
-options = GetOptions(ARGV,
-			 "POPT_AUTOHELP",
-			 "POPT_COMMON_SAMBA",
-			 "POPT_COMMON_CREDENTIALS",
-			 "createkey=s")
-if (options == undefined) {
-	print "Failed to parse options"
-	sys.exit(-1)
+parser = optparse.OptionParser("%s <BINDING> [path]" % sys.argv[0])
+parser.add_option_group(options.SambaOptions(parser))
+parser.add_option("--createkey", type="string", metavar="KEYNAME", 
+        help="create a key")
 
-if len(sys.argv < 2:
-	print "Usage: %s <BINDING> [path]" % sys.argv[0]
-	sys.exit(-1)
+opts, args = parser.parse_args()
 
-binding = options.ARGV[0]
-reg = winregObj()
+if len(args) < 1:
+    parser.print_usage()
+    sys.exit(-1)
+
+binding = args[0]
 
 print "Connecting to " + binding
-status = reg.connect(binding)
-if (status.is_ok != true) {
-	print("Failed to connect to " + binding + " - " + status.errstr + "\n")
-	return -1
-}
+conn = winreg.winreg(binding, opts.configfile)
 
-def list_values(path):
-	list = reg.enum_values(path)
-	if (list == undefined) {
-		return
-	}
-	for (i=0;i<list.length;i++) {
-		v = list[i]
-		printf("\ttype=%-30s size=%4d  '%s'\n", reg.typestring(v.type), v.size, v.name)
-		if (v.type == reg.REG_SZ || v.type == reg.REG_EXPAND_SZ) {
-			printf("\t\t'%s'\n", v.value)
-		}
-		if (v.type == reg.REG_MULTI_SZ) {
-			for (j in v.value) {
-				printf("\t\t'%s'\n", v.value[j])
-			}
-		}
-		if (v.type == reg.REG_DWORD || v.type == reg.REG_DWORD_BIG_ENDIAN) {
-			printf("\t\t0x%08x (%d)\n", v.value, v.value)
-		}
-		if (v.type == reg.REG_QWORD) {
-			printf("\t\t0x%llx (%lld)\n", v.value, v.value)
-		}
-	}
+def list_values(key):
+    (num_values, max_valnamelen, max_valbufsize) = conn.QueryInfoKey(key, winreg.String())[4:8]
+    for i in range(num_values):
+        name = winreg.StringBuf()
+        name.size = max_valnamelen
+        (name, type, data, _, data_len) = conn.EnumValue(key, i, name, 0, "", max_valbufsize, 0)
+        print "\ttype=%-30s size=%4d  '%s'" % type, len, name
+        if type in (winreg.REG_SZ, winreg.REG_EXPAND_SZ):
+            print "\t\t'%s'" % data
+#        if (v.type == reg.REG_MULTI_SZ) {
+#            for (j in v.value) {
+#                printf("\t\t'%s'\n", v.value[j])
+#            }
+#        }
+#        if (v.type == reg.REG_DWORD || v.type == reg.REG_DWORD_BIG_ENDIAN) {
+#            printf("\t\t0x%08x (%d)\n", v.value, v.value)
+#        }
+#        if (v.type == reg.REG_QWORD) {
+#            printf("\t\t0x%llx (%lld)\n", v.value, v.value)
+#        }
 
-def list_path(path):
-	count = 0
-	list = reg.enum_path(path)
-	if (list == undefined) {
-		println("Unable to list " + path)
-		return 0
-	}
-	list_values(path)
-	count = count + list.length
-	for (i=0;i<list.length;i++) {
-		if (path) {
-			npath = path + "\\" + list[i]
-		} else {
-			npath = list[i]
-		}
-		println(npath)
-		count = count + list_path(npath)
-	}
-	return count
+def list_path(key, path):
+    count = 0
+    (num_subkeys, max_subkeylen, max_subkeysize) = conn.QueryInfoKey(key, winreg.String())[1:4]
+    for i in range(num_subkeys):
+        name = winreg.StringBuf()
+        name.size = max_subkeysize
+        keyclass = winreg.StringBuf()
+        keyclass.size = max_subkeysize
+        (name, _, _) = conn.EnumKey(key, i, name, keyclass=keyclass, last_changed_time=None)[0]
+        subkey = conn.OpenKey(key, name, 0, winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
+        count += list_path(subkey, "%s\\%s" % (path, name))
+        list_values(subkey)
+    return count
 
-if len(sys.argv) > 2:
-	root = sys.argv[2]
+if len(args) > 1:
+    root = args[1]
 else:
-	root = ''
+    root = "HKLM"
 
-if options.createkey:
-    try:
-	    reg.create_key("HKLM\\SOFTWARE", options.createkey)
-    except:
-		print "Failed to create key"
+if opts.createkey:
+    reg.create_key("HKLM\\SOFTWARE", opt.createkey)
 else:
-	printf("Listing registry tree '%s'\n", root)
-	count = list_path(root)
+    print "Listing registry tree '%s'" % root
+    try:
+        root_key = getattr(conn, "Open%s" % root)(None, winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
+    except AttributeError:
+        print "Unknown root key name %s" % root
+        sys.exit(1)
+    count = list_path(root_key, root)
     if count == 0:
-		println("No entries found")
-		sys.exit(1)
+        print "No entries found"
+        sys.exit(1)
diff --git a/source4/scripting/python/STATUS b/source4/scripting/python/STATUS
index 5972027f59..6e6475bfde 100644
--- a/source4/scripting/python/STATUS
+++ b/source4/scripting/python/STATUS
@@ -3,21 +3,13 @@ lib/ldb/tests/python/ldap.py: Fix remaining 3 FIXME's
 provisioning in LDAP mode(TEST_LDAP=yes PROVISION_PYTHON=yes make test)
 command-line vampire
 provisioning: combine some of the python dictionaries
-hierarchy
-DCE/RPC bindings
- - pidl:
-     Parse::Pidl::Samba::Python
-	 - wrap struct/bitmap/enum/union types
-	  - __ndr_pack__/__ndr_unpack__ members
-	 Parse::Pidl::Samba::NDR::Python
-	 - pidl generated client fns
-	  - one class per interface
-	  - AddOne()
-
- - scripting/bin/smbstatus.py
- - scripting/bin/winreg.py
+finish scripting/bin/smbstatus.py
 
 not important before making Python the default:
+- hierarchy (rename samr -> dcerpc.samr, misc -> samba.misc, etc)
 - scripting/python/samba/upgrade.py
 - install python modules into system
 - SWAT
+- __ndr_pack__/__ndr_unpack__ members for the NDR struct bindings
+- generate docstrings in DCE/RPC bindings
+- eliminate some variables from the python interface because they can be induced
diff --git a/source4/scripting/python/config.mk b/source4/scripting/python/config.mk
index cfd179aff5..f00b477919 100644
--- a/source4/scripting/python/config.mk
+++ b/source4/scripting/python/config.mk
@@ -5,7 +5,7 @@ OBJ_FILES = smbpython.o
 [SUBSYSTEM::LIBPYTHON]
 PUBLIC_DEPENDENCIES = EXT_LIB_PYTHON
 INIT_FUNCTION_SENTINEL = { NULL, NULL }
-OBJ_FILES = modules.o
+OBJ_FILES = modules.o pytalloc.o
 
 [PYTHON::python_uuid]
 PRIVATE_DEPENDENCIES = LIBNDR 
diff --git a/source4/scripting/python/modules.c b/source4/scripting/python/modules.c
index 55df51d881..b2dd50b507 100644
--- a/source4/scripting/python/modules.c
+++ b/source4/scripting/python/modules.c
@@ -35,6 +35,17 @@ extern void init_events(void);
 extern void inituuid(void);
 extern void init_net(void);
 extern void initecho(void);
+extern void initwinreg(void);
+extern void initepmapper(void);
+extern void initinitshutdown(void);
+static void initdcerpc_misc(void) {} 
+extern void initmgmt(void);
+extern void initatsvc(void);
+extern void initsamr(void);
+static void initdcerpc_security(void) {}
+extern void initlsa(void);
+extern void initsvcctl(void);
+extern void initwkssvc(void);
 
 static struct _inittab py_modules[] = { STATIC_LIBPYTHON_MODULES };
 
diff --git a/source4/scripting/python/pyrpc.h b/source4/scripting/python/pyrpc.h
new file mode 100644
index 0000000000..5390c6923d
--- /dev/null
+++ b/source4/scripting/python/pyrpc.h
@@ -0,0 +1,29 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define PY_CHECK_TYPE(type, var, fail) \
+	if (!type ## _Check(var)) {\
+		PyErr_Format(PyExc_TypeError, "Expected type %s", type ## _Type.tp_name); \
+		fail; \
+	}
+
+#define dom_sid2_Type dom_sid_Type
+#define dom_sid28_Type dom_sid_Type
+#define dom_sid2_Check dom_sid_Check
+#define dom_sid28_Check dom_sid28_Check
diff --git a/source4/scripting/python/pytalloc.c b/source4/scripting/python/pytalloc.c
new file mode 100644
index 0000000000..d8d3efe69c
--- /dev/null
+++ b/source4/scripting/python/pytalloc.c
@@ -0,0 +1,45 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Python/Talloc glue
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "scripting/python/pytalloc.h"
+
+void py_talloc_dealloc(PyObject* self)
+{
+	py_talloc_Object *obj = (py_talloc_Object *)self;
+	talloc_free(obj->talloc_ctx);
+	PyObject_Del(self);
+}
+
+PyObject *py_talloc_import_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, 
+						   void *ptr)
+{
+	py_talloc_Object *ret = PyObject_New(py_talloc_Object, py_type);
+	ret->talloc_ctx = talloc_reference(NULL, mem_ctx); 
+	ret->ptr = ptr;
+	return (PyObject *)ret;
+}
+
+PyObject *py_talloc_default_repr(PyObject *py_obj)
+{
+	py_talloc_Object *obj = (py_talloc_Object *)py_obj;
+
+	return PyString_FromFormat("<talloc: %s>", 
+							   talloc_get_name(obj->talloc_ctx));
+}
diff --git a/source4/scripting/python/pytalloc.h b/source4/scripting/python/pytalloc.h
new file mode 100644
index 0000000000..aad5840a67
--- /dev/null
+++ b/source4/scripting/python/pytalloc.h
@@ -0,0 +1,51 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PY_TALLOC_H_
+#define _PY_TALLOC_H_
+
+#include <Python.h>
+
+typedef struct {
+	PyObject_HEAD
+	TALLOC_CTX *talloc_ctx;
+	void *ptr;
+} py_talloc_Object;
+
+/* Deallocate a py_talloc_Object */
+void py_talloc_dealloc(PyObject* self);
+
+/* Retrieve the pointer for a py_talloc_object. Like talloc_get_type() 
+ * but for py_talloc_Objects. */
+
+/* FIXME: Call PyErr_SetString(PyExc_TypeError, "expected " __STR(type) ") 
+ * when talloc_get_type() returns NULL. */
+#define py_talloc_get_type(py_obj, type) \
+	talloc_get_type(py_talloc_get_ptr(py_obj), type)
+
+#define py_talloc_get_ptr(py_obj) ((py_talloc_Object *)py_obj)->ptr
+#define py_talloc_get_mem_ctx(py_obj)  ((py_talloc_Object *)py_obj)->talloc_ctx
+
+PyObject *py_talloc_import_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr);
+#define py_talloc_import(py_type, talloc_ptr) py_talloc_import_ex(py_type, talloc_ptr, talloc_ptr)
+
+/* Sane default implementation of reprfunc. */
+PyObject *py_talloc_default_repr(PyObject *py_obj);
+
+#endif /* _PY_TALLOC_H_ */
diff --git a/source4/scripting/python/samba/tests/dcerpc/__init__.py b/source4/scripting/python/samba/tests/dcerpc/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/source4/scripting/python/samba/tests/dcerpc/__init__.py
diff --git a/source4/scripting/python/samba/tests/dcerpc/registry.py b/source4/scripting/python/samba/tests/dcerpc/registry.py
new file mode 100644
index 0000000000..f3f0b0fb1a
--- /dev/null
+++ b/source4/scripting/python/samba/tests/dcerpc/registry.py
@@ -0,0 +1,50 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+#   
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#   
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#   
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import winreg
+from param import LoadParm
+import unittest
+
+class WinregTests(unittest.TestCase):
+    def setUp(self):
+        lp_ctx = LoadParm()
+        lp_ctx.load("st/client/client.conf")
+        self.conn = winreg.winreg("ncalrpc:", lp_ctx)
+
+    def get_hklm(self):
+        return self.conn.OpenHKLM(None, 
+             winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
+
+    def test_hklm(self):
+        handle = self.conn.OpenHKLM(None, 
+                 winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
+        self.conn.CloseKey(handle)
+
+    def test_getversion(self):
+        handle = self.get_hklm()
+        version = self.conn.GetVersion(handle)
+        self.assertEquals(int, version.__class__)
+        self.conn.CloseKey(handle)
+
+    def test_getkeyinfo(self):
+        handle = self.conn.OpenHKLM(None, 
+                 winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
+        x = self.conn.QueryInfoKey(handle, winreg.String())
+        self.assertEquals(9, len(x)) # should return a 9-tuple
+        self.conn.CloseKey(handle)
diff --git a/source4/scripting/python/samba/tests/dcerpc/rpcecho.py b/source4/scripting/python/samba/tests/dcerpc/rpcecho.py
new file mode 100644
index 0000000000..52c2bb8c72
--- /dev/null
+++ b/source4/scripting/python/samba/tests/dcerpc/rpcecho.py
@@ -0,0 +1,44 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+#   
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#   
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#   
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import echo
+from param import LoadParm
+import unittest
+
+class RpcEchoTests(unittest.TestCase):
+    def setUp(self):
+        lp_ctx = LoadParm()
+        lp_ctx.load("st/client/client.conf")
+        self.conn = echo.rpcecho("ncalrpc:", lp_ctx)
+
+    def test_addone(self):
+        self.assertEquals(2, self.conn.AddOne(1))
+
+    def test_echodata(self):
+        self.assertEquals([1,2,3], self.conn.EchoData(3, [1, 2, 3]))
+
+    def test_call(self):
+        self.assertEquals(u"foobar", self.conn.TestCall(u"foobar"))
+
+    def test_surrounding(self):
+        surrounding_struct = echo.Surrounding()
+        surrounding_struct.x = 4
+        surrounding_struct.surrounding = [1,2,3,4]
+        y = self.conn.TestSurrounding(surrounding_struct)
+        self.assertEquals(8 * [0], y.surrounding)
diff --git a/source4/scripting/python/samba/tests/dcerpc/sam.py b/source4/scripting/python/samba/tests/dcerpc/sam.py
new file mode 100644
index 0000000000..50caaf2348
--- /dev/null
+++ b/source4/scripting/python/samba/tests/dcerpc/sam.py
@@ -0,0 +1,28 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+#   
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#   
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#   
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import samr
+import unittest
+
+class SamrTests(unittest.TestCase):
+    def setUp(self):
+        self.conn = samr.samr("ncalrpc:", "st/client/client.conf")
+
+    def test_connect5(self):
+        (level, info, handle) = self.conn.Connect5(None, 0, 1, samr.ConnectInfo1())
diff --git a/source4/selftest/samba4_tests.sh b/source4/selftest/samba4_tests.sh
index 11daa4bd59..2068a971ca 100755
--- a/source4/selftest/samba4_tests.sh
+++ b/source4/selftest/samba4_tests.sh
@@ -320,8 +320,11 @@ then
 	plantest "samba.python" none $SUBUNITRUN samba.tests
 	plantest "provision.python" none $SUBUNITRUN samba.tests.provision
 	plantest "samba3.python" none $SUBUNITRUN samba.tests.samba3
+	plantest "samr.python" dc $SUBUNITRUN samba.tests.dcerpc.sam
 	plantest "events.python" none PYTHONPATH="$PYTHONPATH:lib/events" $SUBUNITRUN tests
 	plantest "samba3sam.python" none PYTHONPATH="$PYTHONPATH:dsdb/samdb/ldb_modules/tests" $SUBUNITRUN samba3sam
+	plantest "rpcecho.python" dc $SUBUNITRUN samba.tests.dcerpc.rpcecho
+	plantest "winreg.python" dc $SUBUNITRUN samba.tests.dcerpc.registry
 	plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION \$SERVER -U\$USERNAME%\$PASSWORD -W \$DOMAIN
 	plantest "blackbox.samba3dump" none $PYTHON scripting/bin/samba3dump $samba4srcdir/../testdata/samba3
 	rm -rf $PREFIX/upgrade