r1983: a completely new implementation of talloc

This version does the following:

  1) talloc_free(), talloc_realloc() and talloc_steal() lose their
     (redundent) first arguments

  2) you can use _any_ talloc pointer as a talloc context to allocate
     more memory. This allows you to create complex data structures
     where the top level structure is the logical parent of the next
     level down, and those are the parents of the level below
     that. Then destroy either the lot with a single talloc_free() or
     destroy any sub-part with a talloc_free() of that part

  3) you can name any pointer. Use talloc_named() which is just like
     talloc() but takes the printf style name argument as well as the
     parent context and the size.

The whole thing ends up being a very simple piece of code, although
some of the pointer walking gets hairy.

So far, I'm just using the new talloc() like the old one. The next
step is to actually take advantage of the new interface
properly. Expect some new commits soon that simplify some common
coding styles in samba4 by using the new talloc().
(This used to be commit e35bb094c52e550b3105dd1638d8d90de71d854f)

43 files changed, 284 insertions, 474 deletions

diff --git a/source4/auth/auth_sam.c b/source4/auth/auth_sam.c
index b4dc29be85..d83d25c42c 100644
--- a/source4/auth/auth_sam.c
+++ b/source4/auth/auth_sam.c
@@ -339,7 +339,7 @@ static NTSTATUS check_sam_security(const struct auth_context *auth_context,
 		}
 		
 		if (group_ret > 0 && 
-		    !(groupSIDs = talloc_realloc_p((*server_info)->mem_ctx, groupSIDs, 
+		    !(groupSIDs = talloc_realloc_p(groupSIDs, 
 						   struct dom_sid *, group_ret))) {
 			talloc_destroy((*server_info)->mem_ctx);
 			samdb_close(sam_ctx);
diff --git a/source4/include/talloc.h b/source4/include/talloc.h
index 8c1a726778..dec004b7ef 100644
--- a/source4/include/talloc.h
+++ b/source4/include/talloc.h
@@ -3,8 +3,8 @@
 /* 
    Unix SMB/CIFS implementation.
    Samba temporary memory allocation functions
-   Copyright (C) Andrew Tridgell 2000
-   Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+   Copyright (C) Andrew Tridgell 2004
    
    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
@@ -21,40 +21,19 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/**
- * @ingroup talloc
- * @{
- * @sa talloc.c
- */
-
-/**
- * talloc allocation pool.  All allocated blocks can be freed in one go.
- **/
-typedef struct talloc_ctx TALLOC_CTX;
-
-TALLOC_CTX *talloc_init(char const *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
-
-char *talloc_vasprintf(TALLOC_CTX *t, const char *fmt, va_list ap)
-	PRINTF_ATTRIBUTE(2, 0);
-
-char *talloc_asprintf(TALLOC_CTX *t, const char *fmt, ...)
-	PRINTF_ATTRIBUTE(2, 3);
-
-char *talloc_vasprintf_append(TALLOC_CTX *t, char *, const char *, va_list ap)
-	PRINTF_ATTRIBUTE(3, 0);
-
-char *talloc_asprintf_append(TALLOC_CTX *t, char *, const char *, ...)
-	PRINTF_ATTRIBUTE(3, 4);
+/* this is only needed for compatibility with the old talloc */
+typedef void TALLOC_CTX;
 
 /* useful macros for creating type checked pointers */
 #define talloc_p(ctx, type) (type *)talloc(ctx, sizeof(type))
-#define talloc_array_p(ctx, type, count) (type *)talloc_realloc_array(ctx, NULL, sizeof(type), count)
-#define talloc_realloc_p(ctx, p, type, count) (type *)talloc_realloc_array(ctx, p, sizeof(type), count)
+#define talloc_array_p(ctx, type, count) (type *)talloc_array(ctx, sizeof(type), count)
+#define talloc_realloc_p(p, type, count) (type *)talloc_realloc_array(p, sizeof(type), count)
+
+#define talloc_destroy(ctx) talloc_free(ctx)
 
 #define malloc_p(type) (type *)malloc(sizeof(type))
 #define malloc_array_p(type, count) (type *)realloc_array(NULL, sizeof(type), count)
 #define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count)
 
-/** @} */
+#endif
 
-#endif /* ndef _TALLOC_H_ */
diff --git a/source4/lib/data_blob.c b/source4/lib/data_blob.c
index ee7bffdc1b..bc5cf9abc8 100644
--- a/source4/lib/data_blob.c
+++ b/source4/lib/data_blob.c
@@ -108,7 +108,7 @@ DATA_BLOB data_blob_talloc_steal(TALLOC_CTX *old_ctx, TALLOC_CTX *new_ctx,
 {
 	DATA_BLOB new;
 	new = *old;
-	new.data = talloc_steal(old_ctx, new_ctx, old->data);
+	new.data = talloc_steal(new_ctx, old->data);
 	if (new.data == NULL) {
 		smb_panic("data_blob_talloc_steal: talloc_steal failed.\n");
 	}
diff --git a/source4/lib/registry/common/reg_interface.c b/source4/lib/registry/common/reg_interface.c
index 0a0cf05c2e..e7024d23fe 100644
--- a/source4/lib/registry/common/reg_interface.c
+++ b/source4/lib/registry/common/reg_interface.c
@@ -214,7 +214,7 @@ WERROR reg_open_key(REG_KEY *parent, const char *name, REG_KEY **result)
 	(*result)->path = talloc_asprintf((*result)->mem_ctx, "%s\\%s", 
 								 reg_key_get_path_abs(parent), (*result)->name);
 	(*result)->hive = parent->hive;
-	talloc_steal(mem_ctx, (*result)->mem_ctx, fullname);
+	talloc_steal((*result)->mem_ctx, fullname);
 
 	talloc_destroy(mem_ctx);
 
diff --git a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c b/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
index cac54f8437..b2bd34bf71 100644
--- a/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
+++ b/source4/lib/registry/reg_backend_dir/reg_backend_dir.c
@@ -65,7 +65,7 @@ static WERROR reg_dir_open_key(REG_HANDLE *h, int hive, const char *name, REG_KE
 	}
 	closedir(d);
 	ret = reg_key_new_abs(name, h, fullpath);
-	talloc_steal(mem_ctx, ret->mem_ctx, fullpath);
+	talloc_steal(ret->mem_ctx, fullpath);
 	talloc_destroy(mem_ctx);
 	*subkey = ret;
 	return WERR_OK;
diff --git a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c b/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
index c705a2e3cb..15a8319711 100644
--- a/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
+++ b/source4/lib/registry/reg_backend_gconf/reg_backend_gconf.c
@@ -126,7 +126,7 @@ static WERROR gconf_fetch_values(REG_KEY *p, int *count, REG_VAL ***vals)
 		} else newval->data_type = REG_NONE; 
 
 		ar[(*count)] = newval;
-		ar = talloc_realloc(p->mem_ctx, ar, sizeof(REG_VAL *) * ((*count)+2));
+		ar = talloc_realloc(ar, sizeof(REG_VAL *) * ((*count)+2));
 		(*count)++;
 		g_free(cur->data);
 		cur = cur->next;
@@ -151,7 +151,7 @@ static WERROR gconf_fetch_subkeys(REG_KEY *p, int *count, REG_KEY ***subs)
 		ar[(*count)] = reg_key_new_abs(winpath, p->handle,NULL);
 		free(winpath);
 		ar[(*count)]->backend_data = reg_path_win2unix(talloc_strdup(ar[*count]->mem_ctx, cur->data));
-		ar = talloc_realloc_p(p->mem_ctx, ar, REG_KEY *, (*count)+2);
+		ar = talloc_realloc_p(ar, REG_KEY *, (*count)+2);
 		(*count)++;
 		g_free(cur->data);
 		cur = cur->next;
diff --git a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c b/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
index 9dfd3329e0..fa7e22d010 100644
--- a/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
+++ b/source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c
@@ -188,7 +188,7 @@ static WERROR ldb_open_key(REG_HANDLE *h, int num, const char *name, REG_KEY **k
 	}
 
 	*key = reg_key_new_abs(name, h, ldap_path);
-	talloc_steal(mem_ctx, (*key)->mem_ctx, ldap_path);
+	talloc_steal((*key)->mem_ctx, ldap_path);
 	printf("Got something!\n");
 	/* FIXME */
 
diff --git a/source4/lib/talloc.c b/source4/lib/talloc.c
index 21c3bdac6e..8a67f83a7f 100644
--- a/source4/lib/talloc.c
+++ b/source4/lib/talloc.c
@@ -1,8 +1,9 @@
 /* 
    Samba Unix SMB/CIFS implementation.
-   Samba temporary memory allocation functions
-   Copyright (C) Andrew Tridgell 2000-2004
-   Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+
+   Samba temporary memory allocation functions - new interface
+
+   Copyright (C) Andrew Tridgell 2004
    
    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
@@ -19,208 +20,175 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/**
-   @defgroup talloc Simple memory allocator
-   @{
-   
-   This is a very simple temporary memory allocator. To use it do the following:
-
-   1) when you first want to allocate a pool of meomry use
-   talloc_init() and save the resulting context pointer somewhere
-
-   2) to allocate memory use talloc()
-
-   3) when _all_ of the memory allocated using this context is no longer needed
-   use talloc_destroy()
-
-   talloc does not zero the memory. 
-
-   @sa talloc.h
-*/
-
-/**
- * If you want testing for memory corruption use valgrind
- **/
-
 #include "includes.h"
 
 #define MAX_TALLOC_SIZE 0x10000000
-#define TALLOC_MAGIC 0x06052004
+#define TALLOC_MAGIC 0x14082004
 #define TALLOC_MAGIC_FREE 0x3421abcd
 
 struct talloc_chunk {
 	struct talloc_chunk *next, *prev;
-	TALLOC_CTX *context;
+	struct talloc_chunk *parent, *child;
 	size_t size;
-	void *ptr;
 	uint_t magic;
+	char *name;
 };
 
 
-struct talloc_ctx {
-	struct talloc_chunk *list;
-	off_t total_alloc_size;
-
-	/** The name recorded for this pool, if any.  Should describe
-	 * the purpose for which it was allocated.  The string is
-	 * allocated within the pool. **/
-	char *name;
+/* 
+   Allocate a bit of memory as a child of an existing pointer
+*/
+void *talloc(void *context, size_t size)
+{
+	struct talloc_chunk *tc;
 
-	/** Pointer to the next allocate talloc pool, so that we can
-	 * summarize all talloc memory usage. **/
-	struct talloc_ctx *next, *prev;
-};
+	if (size >= MAX_TALLOC_SIZE) {
+		return NULL;
+	}
 
+	tc = malloc(sizeof(*tc)+size);
+	if (tc == NULL) {
+		return NULL;
+	}
 
-/**
- * Start of linked list of all talloc pools.
- *
- * @todo We should turn the global list off when using Insure++,
- * otherwise all the memory will be seen as still reachable.
- **/
-static TALLOC_CTX *list_head;
+	tc->size = size;
+	tc->magic = TALLOC_MAGIC;
+	tc->child = NULL;
+	tc->name = NULL;
 
-/**
- * Add to the global list
- **/
-static void talloc_enroll(TALLOC_CTX *t)
-{
-#if 0
-	/* disabled enrole/disenrole until we have __thread support */
-	MUTEX_LOCK_BY_ID(MUTEX_TALLOC);
-	DLIST_ADD(list_head, t);
-	MUTEX_UNLOCK_BY_ID(MUTEX_TALLOC);
-#endif
-}
+	if (context) {
+		struct talloc_chunk *parent = ((struct talloc_chunk *)context)-1;
 
+		if (parent->magic != TALLOC_MAGIC) {
+			DEBUG(0,("Bad magic in context - 0x%08x\n", parent->magic));
+			free(tc);
+			return NULL;
+		}
 
-static void talloc_disenroll(TALLOC_CTX *t)
-{
-#if 0
-	/* disabled enrole/disenrole until we have __thread support */
-	MUTEX_LOCK_BY_ID(MUTEX_TALLOC);
-	DLIST_REMOVE(list_head, t);
-	MUTEX_UNLOCK_BY_ID(MUTEX_TALLOC);
-#endif
-}
+		tc->parent = parent;
 
+		if (parent->child) {
+			parent->child->parent = NULL;
+		}
 
-/** Create a new talloc context. **/
-static TALLOC_CTX *talloc_init_internal(void)
-{
-	TALLOC_CTX *t;
-
-	t = (TALLOC_CTX *)malloc(sizeof(TALLOC_CTX));
-	if (t) {
-		t->list = NULL;
-		t->total_alloc_size = 0;
-		t->name = NULL;
-		talloc_enroll(t);
+		DLIST_ADD(parent->child, tc);
+	} else {
+		tc->next = tc->prev = tc->parent = NULL;
 	}
 
-	return t;
+	return (void *)(tc+1);
 }
 
 
-
-/**
- * Create a new talloc context, with a name specifying its purpose.
- **/
-
- TALLOC_CTX *talloc_init(char const *fmt, ...) 
+/*
+  create a named talloc pointer
+*/
+void *talloc_named(void *context, size_t size, 
+		   const char *fmt, ...) _PRINTF_ATTRIBUTE(3,4)
 {
-	TALLOC_CTX *t;
 	va_list ap;
+	void *ptr;
+	struct talloc_chunk *tc;
 
-	t = talloc_init_internal();
-	if (t && fmt) {
-		/*
-		 * t->name must not be talloced.
-		 * as destroying the pool would destroy it. JRA.
-		 */
-		t->name = NULL;
-		va_start(ap, fmt);
-		vasprintf(&t->name, fmt, ap);
-		va_end(ap);
-		if (!t->name) {
-			talloc_destroy(t);
-			t = NULL;
-		}
+	ptr = talloc(context, size);
+	if (ptr == NULL) {
+		return NULL;
 	}
-	
-	return t;
-}
 
+	tc = ((struct talloc_chunk *)ptr)-1;
+
+	va_start(ap, fmt);
+	vasprintf(&tc->name, fmt, ap);
+	va_end(ap);
+
+	return ptr;
+}
 
 /*
-  return the talloc context given a pointer that has been allocated using
-  talloc
+  this is for compatibility with older versions of talloc
 */
-TALLOC_CTX *talloc_get_context(void *ptr)
+void *talloc_init(const char *fmt, ...) _PRINTF_ATTRIBUTE(1,2)
 {
+	va_list ap;
+	void *ptr;
 	struct talloc_chunk *tc;
-	tc = ((struct talloc_chunk *)ptr)-1;
 
-	if (tc->magic == TALLOC_MAGIC) {
-		return tc->context;
-	} else {
+	ptr = talloc(NULL, 0);
+	if (ptr == NULL) {
 		return NULL;
 	}
+
+	tc = ((struct talloc_chunk *)ptr)-1;
+
+	va_start(ap, fmt);
+	vasprintf(&tc->name, fmt, ap);
+	va_end(ap);
+
+	return ptr;
 }
 
-/** Allocate a bit of memory from the specified pool **/
-void *talloc(TALLOC_CTX *t, size_t size)
+
+
+/* 
+   free a talloc pointer. This also frees all child pointers of this 
+   pointer recursively
+*/
+void talloc_free(void *ptr)
 {
 	struct talloc_chunk *tc;
 
-	if (!t || size == 0) {
-		return NULL;
-	}
+	if (ptr == NULL) return;
 
-	tc = malloc(sizeof(*tc)+size);
-	if (!tc) {
-		return NULL;
+	tc = ((struct talloc_chunk *)ptr)-1;
+
+	if (tc->magic != TALLOC_MAGIC) {
+		DEBUG(0,("Bad talloc magic 0x%08x in talloc_free\n", tc->magic));
+		return;
 	}
 
-	tc->context = t;
-	tc->size = size;
-	tc->magic = TALLOC_MAGIC;
+	while (tc->child) {
+		talloc_free(tc->child + 1);
+	}
 
-	DLIST_ADD(t->list, tc);
+	if (tc->parent) {
+		DLIST_REMOVE(tc->parent->child, tc);
+		if (tc->parent->child) {
+			tc->parent->child->parent = tc->parent;
+		}
+	} else {
+		if (tc->prev) tc->prev->next = tc->next;
+		if (tc->next) tc->next->prev = tc->prev;
+	}
 
-	t->total_alloc_size += size;
+	tc->magic = TALLOC_MAGIC_FREE;
+	if (tc->name) free(tc->name);
 
-	return (void *)(tc+1);
+	free(tc);
 }
 
-/** A talloc version of realloc */
-void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
+
+
+/*
+  A talloc version of realloc 
+*/
+void *talloc_realloc(void *ptr, size_t size)
 {
 	struct talloc_chunk *tc;
 	void *new_ptr;
 
 	/* size zero is equivalent to free() */
-	if (!t) {
-		return NULL;
-	}
-
 	if (size == 0) {
-		talloc_free(t, ptr);
+		talloc_free(ptr);
 		return NULL;
 	}
 
 	/* realloc(NULL) is equavalent to malloc() */
 	if (ptr == NULL) {
-		return talloc(t, size);
+		return talloc(NULL, size);
 	}
 
 	tc = ((struct talloc_chunk *)ptr)-1;
 
-	if (tc->context != t) {
-		DEBUG(0,("Bad talloc context passed to talloc_realloc\n"));
-		return NULL;
-	}
-
 	if (tc->magic != TALLOC_MAGIC) {
 		DEBUG(0,("Bad talloc magic 0x%08x in talloc_realloc\n", tc->magic));
 		return NULL;
@@ -235,11 +203,11 @@ void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
 		return NULL;
 	}
 
-	if (tc == t->list) {
-		t->list = new_ptr;
-	}
 	tc = new_ptr;
 	tc->magic = TALLOC_MAGIC;
+	if (tc->parent) {
+		tc->parent->child = new_ptr;
+	}
 
 	if (tc->prev) {
 		tc->prev->next = tc;
@@ -248,129 +216,74 @@ void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
 		tc->next->prev = tc;
 	}
 
-	t->total_alloc_size += (size - tc->size);
 	tc->size = size;
 
 	return (void *)(tc+1);
 }
 
 /* 
-   free a lump from a pool. Use sparingly please.
+   move a lump of memory from one talloc context to another return the
+   ptr on success, or NUL if it could not be transferred
 */
-void talloc_free(TALLOC_CTX *ctx, void *ptr)
+void *talloc_steal(void *new_ctx, void *ptr)
 {
-	struct talloc_chunk *tc;
-
-	if (!ptr || !ctx->list) return;
-
-	tc = ((struct talloc_chunk *)ptr)-1;
-
-	if (tc->context != ctx) {
-		DEBUG(0,("Bad talloc context passed to talloc_free\n"));
-	}
-
-	if (tc->magic != TALLOC_MAGIC) {
-		DEBUG(0,("Bad talloc magic 0x%08x in talloc_free\n", tc->magic));
-	}
-
-	DLIST_REMOVE(ctx->list, tc);
-
-	ctx->total_alloc_size -= tc->size;
-	tc->magic = TALLOC_MAGIC_FREE;
-
-	free(tc);
-}
-
-
-/* 
-   move a lump of memory from one talloc context to another
-   return the ptr on success, or NULL if it could not be found
-   in the old context or could not be transferred
-*/
-void *talloc_steal(TALLOC_CTX *old_ctx, TALLOC_CTX *new_ctx, void *ptr)
-{
-	struct talloc_chunk *tc;
+	struct talloc_chunk *tc, *new_tc;
 
 	if (!ptr) {
 		return NULL;
 	}
 
 	tc = ((struct talloc_chunk *)ptr)-1;
-
-	if (tc->context != old_ctx) {
-		DEBUG(0,("Bad talloc context passed to talloc_steal\n"));
-		return NULL;
-	}
+	new_tc = ((struct talloc_chunk *)new_ctx)-1;
 
 	if (tc->magic != TALLOC_MAGIC) {
 		DEBUG(0,("Bad talloc magic 0x%08x in talloc_steal\n", tc->magic));
 		return NULL;
 	}
-
-	DLIST_REMOVE(old_ctx->list, tc);
-	DLIST_ADD(new_ctx->list, tc);
-
-	tc->context = new_ctx;
-
-	old_ctx->total_alloc_size -= tc->size;
-	new_ctx->total_alloc_size += tc->size;
-	
-	return ptr;
-}
-
-
-
-/** Destroy all the memory allocated inside @p t, but not @p t
- * itself. */
-void talloc_destroy_pool(TALLOC_CTX *t)
-{
-	if (!t) {
-		return;
+	if (new_tc->magic != TALLOC_MAGIC) {
+		DEBUG(0,("Bad new talloc magic 0x%08x in talloc_steal\n", new_tc->magic));
+		return NULL;
 	}
 
-	while (t->list) {
-		struct talloc_chunk *tc = t->list;
-		if (tc->magic != TALLOC_MAGIC) {
-			DEBUG(0,("Bad magic 0x%08x in talloc_destroy_pool\n", 
-				 tc->magic));
-			return;
+	if (tc->parent) {
+		DLIST_REMOVE(tc->parent->child, tc);
+		if (tc->parent->child) {
+			tc->parent->child->parent = tc->parent;
 		}
-		DLIST_REMOVE(t->list, tc);
-		tc->magic = TALLOC_MAGIC_FREE;
-		free(tc);
+	} else {
+		if (tc->prev) tc->prev->next = tc->next;
+		if (tc->next) tc->next->prev = tc->prev;
 	}
 
-	t->total_alloc_size = 0;
-}
-
-/** Destroy a whole pool including the context */
-void talloc_destroy(TALLOC_CTX *t)
-{
-	if (!t)
-		return;
+	tc->parent = new_tc;
+	if (new_tc->child) new_tc->child->parent = NULL;
+	DLIST_ADD(new_tc->child, tc);
 
-	talloc_destroy_pool(t);
-	talloc_disenroll(t);
-	SAFE_FREE(t->name);
-	SAFE_FREE(t);
+	return ptr;
 }
 
-/** Return the current total size of the pool. */
-size_t talloc_pool_size(TALLOC_CTX *t)
+/*
+  return the total size of a talloc pool (subtree)
+*/
+off_t talloc_total_size(void *p)
 {
-	return t->total_alloc_size;
-}
+	off_t total = 0;
+	struct talloc_chunk *c, *tc;
 
-const char *talloc_pool_name(TALLOC_CTX const *t)
-{
-	if (t) return t->name;
+	tc = ((struct talloc_chunk *)p)-1;
 
-	return NULL;
+	total = tc->size;
+	for (c=tc->child;c;c=c->next) {
+		total += talloc_total_size(c+1);
+	}
+	return total;
 }
 
 
-/** talloc and zero memory. */
-void *talloc_zero(TALLOC_CTX *t, size_t size)
+/* 
+   talloc and zero memory. 
+*/
+void *talloc_zero(void *t, size_t size)
 {
 	void *p = talloc(t, size);
 
@@ -382,8 +295,10 @@ void *talloc_zero(TALLOC_CTX *t, size_t size)
 }
 
 
-/** memdup with a talloc. */
-void *talloc_memdup(TALLOC_CTX *t, const void *p, size_t size)
+/*
+  memdup with a talloc. 
+*/
+void *talloc_memdup(void *t, const void *p, size_t size)
 {
 	void *newp = talloc(t,size);
 
@@ -394,8 +309,10 @@ void *talloc_memdup(TALLOC_CTX *t, const void *p, size_t size)
 	return newp;
 }
 
-/** strdup with a talloc */
-char *talloc_strdup(TALLOC_CTX *t, const char *p)
+/*
+  strdup with a talloc 
+*/
+char *talloc_strdup(void *t, const char *p)
 {
 	if (!p) {
 		return NULL;
@@ -403,8 +320,10 @@ char *talloc_strdup(TALLOC_CTX *t, const char *p)
 	return talloc_memdup(t, p, strlen(p) + 1);
 }
 
-/** strndup with a talloc */
-char *talloc_strndup(TALLOC_CTX *t, const char *p, size_t n)
+/*
+  strndup with a talloc 
+*/
+char *talloc_strndup(void *t, const char *p, size_t n)
 {
 	size_t len = strnlen(p, n);
 	char *ret;
@@ -416,23 +335,7 @@ char *talloc_strndup(TALLOC_CTX *t, const char *p, size_t n)
 	return ret;
 }
 
-/**
- * Perform string formatting, and return a pointer to newly allocated
- * memory holding the result, inside a memory pool.
- **/
- char *talloc_asprintf(TALLOC_CTX *t, const char *fmt, ...)
-{
-	va_list ap;
-	char *ret;
-
-	va_start(ap, fmt);
-	ret = talloc_vasprintf(t, fmt, ap);
-	va_end(ap);
-	return ret;
-}
-
-
- char *talloc_vasprintf(TALLOC_CTX *t, const char *fmt, va_list ap)
+ char *talloc_vasprintf(void *t, const char *fmt, va_list ap)
 {	
 	int len;
 	char *ret;
@@ -452,31 +355,29 @@ char *talloc_strndup(TALLOC_CTX *t, const char *p, size_t n)
 }
 
 
-/**
- * Realloc @p s to append the formatted result of @p fmt and return @p
- * s, which may have moved.  Good for gradually accumulating output
- * into a string buffer.
- **/
- char *talloc_asprintf_append(TALLOC_CTX *t, char *s,
-			      const char *fmt, ...)
+/*
+  Perform string formatting, and return a pointer to newly allocated
+  memory holding the result, inside a memory pool.
+ */
+char *talloc_asprintf(void *t, const char *fmt, ...) _PRINTF_ATTRIBUTE(2,3)
 {
 	va_list ap;
+	char *ret;
 
 	va_start(ap, fmt);
-	s = talloc_vasprintf_append(t, s, fmt, ap);
+	ret = talloc_vasprintf(t, fmt, ap);
 	va_end(ap);
-	return s;
+	return ret;
 }
 
 
-
 /**
  * Realloc @p s to append the formatted result of @p fmt and @p ap,
  * and return @p s, which may have moved.  Good for gradually
  * accumulating output into a string buffer.
  **/
- char *talloc_vasprintf_append(TALLOC_CTX *t, char *s,
-			       const char *fmt, va_list ap)
+char *talloc_vasprintf_append(char *s,
+			      const char *fmt, va_list ap)
 {	
 	int len, s_len;
 	va_list ap2;
@@ -486,11 +387,11 @@ char *talloc_strndup(TALLOC_CTX *t, const char *p, size_t n)
 	if (s) {
 		s_len = strlen(s);
 	} else {
-		s = 0;
+		s_len = 0;
 	}
 	len = vsnprintf(NULL, 0, fmt, ap2);
 
-	s = talloc_realloc(t, s, s_len + len+1);
+	s = talloc_realloc(s, s_len + len+1);
 	if (!s) return NULL;
 
 	VA_COPY(ap2, ap);
@@ -500,109 +401,45 @@ char *talloc_strndup(TALLOC_CTX *t, const char *p, size_t n)
 	return s;
 }
 
-
-/**
- * Return a human-readable description of all talloc memory usage.
- * The result is allocated from @p t.
- **/
-char *talloc_describe_all(TALLOC_CTX *rt)
+/*
+  Realloc @p s to append the formatted result of @p fmt and return @p
+  s, which may have moved.  Good for gradually accumulating output
+  into a string buffer.
+ */
+char *talloc_asprintf_append(char *s,
+			     const char *fmt, ...) _PRINTF_ATTRIBUTE(2,3)
 {
-	int n_pools = 0, total_chunks = 0;
-	size_t total_bytes = 0;
-	TALLOC_CTX *it;
-	char *s;
-
-	if (!rt) return NULL;
-
-	s = talloc_asprintf(rt, "global talloc allocations in pid: %u\n",
-			    (uint_t) getpid());
-	s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
-				   "name", "chunks", "bytes");
-	s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
-				   "----------------------------------------",
-				   "--------",
-				   "--------");	
-	MUTEX_LOCK_BY_ID(MUTEX_TALLOC);
-	
-	for (it = list_head; it; it = it->next) {
-		size_t bytes;
-		int n_chunks;
-		fstring what;
-		
-		n_pools++;
-		
-		talloc_get_allocation(it, &bytes, &n_chunks);
-
-		if (it->name)
-			fstrcpy(what, it->name);
-		else
-			slprintf(what, sizeof(what), "@%p", it);
-		
-		s = talloc_asprintf_append(rt, s, "%-40s %8u %8u\n",
-					   what,
-					   (uint_t) n_chunks,
-					   (uint_t) bytes);
-		total_bytes += bytes;
-		total_chunks += n_chunks;
-	}
-
-	MUTEX_UNLOCK_BY_ID(MUTEX_TALLOC);
-
-	s = talloc_asprintf_append(rt, s, "%-40s %8s %8s\n",
-				   "----------------------------------------",
-				   "--------",
-				   "--------");	
-
-	s = talloc_asprintf_append(rt, s, "%-40s %8u %8u\n",
-				   "TOTAL",
-				   (uint_t) total_chunks, (uint_t) total_bytes);
+	va_list ap;
 
+	va_start(ap, fmt);
+	s = talloc_vasprintf_append(s, fmt, ap);
+	va_end(ap);
 	return s;
 }
 
-
-
-/**
- * Return an estimated memory usage for the specified pool.  This does
- * not include memory used by the underlying malloc implementation.
- **/
-void talloc_get_allocation(TALLOC_CTX *t,
-			   size_t *total_bytes,
-			   int *n_chunks)
-{
-	struct talloc_chunk *tc;
-
-	if (t) {
-		*total_bytes = 0;
-		*n_chunks = 0;
-
-		for (tc = t->list; tc; tc = tc->next) {
-			n_chunks[0]++;
-			*total_bytes += tc->size;
-		}
-	}
-}
-
 /*
-  realloc an array, checking for integer overflow in the array size
+  alloc an array, checking for integer overflow in the array size
 */
-void *talloc_realloc_array(TALLOC_CTX *ctx, void *ptr, size_t el_size, uint_t count)
+void *talloc_array(void *ctx, size_t el_size, uint_t count)
 {
 	if (count == 0 ||
 	    count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
 	}
-	return talloc_realloc(ctx, ptr, el_size * count);
+	return talloc(ctx, el_size * count);
 }
 
 
 /*
-  we really should get rid of this
+  realloc an array, checking for integer overflow in the array size
 */
-void *talloc_strdup_w(TALLOC_CTX *mem_ctx, void *s)
+void *talloc_realloc_array(void *ptr, size_t el_size, uint_t count)
 {
-	size_t len = strlen_w(s);
-	return talloc_memdup(mem_ctx, s, (len+1)*2);
+	if (count == 0 ||
+	    count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+	return talloc_realloc(ptr, el_size * count);
 }
 
 /*
@@ -610,8 +447,12 @@ void *talloc_strdup_w(TALLOC_CTX *mem_ctx, void *s)
 */
 void *talloc_ldb_alloc(void *context, void *ptr, size_t size)
 {
-	return talloc_realloc((TALLOC_CTX *)context, ptr, size);
+	if (ptr == NULL) {
+		return talloc(context, size);
+	}
+	if (size == 0) {
+		talloc_free(ptr);
+		return NULL;
+	}
+	return talloc_realloc(ptr, size);
 }
-
-
-/** @} */
diff --git a/source4/lib/tallocmsg.c b/source4/lib/tallocmsg.c
index bbe1ee60a4..22870a934a 100644
--- a/source4/lib/tallocmsg.c
+++ b/source4/lib/tallocmsg.c
@@ -33,15 +33,16 @@
 void msg_pool_usage(int msg_type, pid_t src_pid,
 		    void *UNUSED(buf), size_t UNUSED(len))
 {
-	char *reply;
+	const char *reply="NOT IMPLEMENTED\n";
 	TALLOC_CTX *reply_pool = talloc_init("msg_pool_usage");
 
 	SMB_ASSERT(msg_type == MSG_REQ_POOL_USAGE);
 	
 	DEBUG(2,("Got POOL_USAGE\n"));
 
+#if 0
 	reply = talloc_describe_all(reply_pool);
-	
+#endif
 	message_send_pid(src_pid, MSG_POOL_USAGE,
 			 reply, strlen(reply)+1, True);
 
diff --git a/source4/lib/util_str.c b/source4/lib/util_str.c
index a6f54f9a8d..a66a363c17 100644
--- a/source4/lib/util_str.c
+++ b/source4/lib/util_str.c
@@ -1452,7 +1452,7 @@ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 {
 	char *dup_str = talloc_strdup(mem_ctx, str);
 
-	*strings = talloc_realloc(mem_ctx, *strings,
+	*strings = talloc_realloc(*strings,
 				  ((*num)+1) * sizeof(**strings));
 
 	if ((*strings == NULL) || (dup_str == NULL))
diff --git a/source4/lib/util_unistr.c b/source4/lib/util_unistr.c
index 09a1c9a4df..2bd990836e 100644
--- a/source4/lib/util_unistr.c
+++ b/source4/lib/util_unistr.c
@@ -249,14 +249,6 @@ const smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 	return NULL;
 }
 
-static int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
-{
-	size_t n = 0;
-	while ((n < len) && *b && *a == *b) { a++; b++; n++;}
-	return (len - n)?(*a - *b):0;	
-}
-
-
 /*******************************************************************
  Convert a string to lower case.
  return True if any char is converted
diff --git a/source4/lib/util_uuid.c b/source4/lib/util_uuid.c
index 156f20e53e..a11b7bd3ed 100644
--- a/source4/lib/util_uuid.c
+++ b/source4/lib/util_uuid.c
@@ -24,7 +24,7 @@
 
 void uuid_generate_random(struct GUID *out)
 {
-	generate_random_buffer(out, sizeof(struct GUID));
+	generate_random_buffer((unsigned char *)out, sizeof(struct GUID));
 	out->clock_seq[0] = (out->clock_seq[0] & 0x3F) | 0x80;
 	out->time_hi_and_version = (out->time_hi_and_version & 0x0FFF) | 0x4000;
 }
diff --git a/source4/libads/ldap.c b/source4/libads/ldap.c
index f038b23d23..8992cb9dcf 100644
--- a/source4/libads/ldap.c
+++ b/source4/libads/ldap.c
@@ -795,7 +795,7 @@ static ADS_STATUS ads_modlist_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 	for (curmod=0; modlist[curmod] && modlist[curmod] != (LDAPMod *) -1;
 	     curmod++);
 	if (modlist[curmod] == (LDAPMod *) -1) {
-		if (!(modlist = talloc_realloc(ctx, modlist, 
+		if (!(modlist = talloc_realloc(modlist, 
 			(curmod+ADS_MODLIST_ALLOC_SIZE+1)*sizeof(LDAPMod *))))
 			return ADS_ERROR(LDAP_NO_MEMORY);
 		memset(&modlist[curmod], 0, 
@@ -1703,7 +1703,7 @@ char **ads_pull_strings_range(ADS_STRUCT *ads,
 		return NULL;
 	}
 
-	strings = talloc_realloc(mem_ctx, current_strings,
+	strings = talloc_realloc(current_strings,
 				 sizeof(*current_strings) *
 				 (*num_strings + num_new_strings));
 	
diff --git a/source4/libcli/clilist.c b/source4/libcli/clilist.c
index e2c267cc96..0e2cdabc0a 100644
--- a/source4/libcli/clilist.c
+++ b/source4/libcli/clilist.c
@@ -83,8 +83,8 @@ static BOOL smbcli_list_new_callback(void *private, union smb_search_data *file)
 	file_info *tdl;
  
 	/* add file info to the dirlist pool */
-	tdl = talloc_realloc(state->mem_ctx, state->dirlist,
-			state->dirlist_len + sizeof(struct file_info));
+	tdl = talloc_realloc(state->dirlist,
+			     state->dirlist_len + sizeof(struct file_info));
 
 	if (!tdl) {
 		return False;
@@ -225,8 +225,8 @@ static BOOL smbcli_list_old_callback(void *private, union smb_search_data *file)
 	file_info *tdl;
 	
 	/* add file info to the dirlist pool */
-	tdl = talloc_realloc(state->mem_ctx, state->dirlist,
-			state->dirlist_len + sizeof(struct file_info));
+	tdl = talloc_realloc(state->dirlist,
+			     state->dirlist_len + sizeof(struct file_info));
 
 	if (!tdl) {
 		return False;
diff --git a/source4/libcli/ldap/ldap.c b/source4/libcli/ldap/ldap.c
index 123def9416..7e60e48293 100644
--- a/source4/libcli/ldap/ldap.c
+++ b/source4/libcli/ldap/ldap.c
@@ -179,7 +179,7 @@ static struct ldap_parse_tree *ldap_parse_filterlist(TALLOC_CTX *mem_ctx,
 
 	while (*s && (next = ldap_parse_filter(mem_ctx, &s))) {
 		struct ldap_parse_tree **e;
-		e = talloc_realloc(mem_ctx, ret->u.list.elements,
+		e = talloc_realloc(ret->u.list.elements,
 				   sizeof(struct ldap_parse_tree) *
 				   (ret->u.list.num_elements+1));
 		if (!e) {
diff --git a/source4/libcli/ldap/ldap_ldif.c b/source4/libcli/ldap/ldap_ldif.c
index 2f23dd16a6..2ec3b827ce 100644
--- a/source4/libcli/ldap/ldap_ldif.c
+++ b/source4/libcli/ldap/ldap_ldif.c
@@ -51,7 +51,7 @@ static char *next_chunk(TALLOC_CTX *mem_ctx,
 		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
-			c2 = talloc_realloc(mem_ctx, chunk, alloc_size);
+			c2 = talloc_realloc(chunk, alloc_size);
 			if (!c2) {
 				errno = ENOMEM;
 				return NULL;
@@ -158,7 +158,7 @@ static int next_attr(char **s, const char **attr, struct ldap_val *value)
 BOOL add_value_to_attrib(TALLOC_CTX *mem_ctx, struct ldap_val *value,
 				struct ldap_attribute *attrib)
 {
-	attrib->values = talloc_realloc(mem_ctx, attrib->values,
+	attrib->values = talloc_realloc(attrib->values,
 					sizeof(*attrib->values) *
 					(attrib->num_values+1));
 	if (attrib->values == NULL)
@@ -175,7 +175,7 @@ BOOL add_attrib_to_array_talloc(TALLOC_CTX *mem_ctx,
 				       struct ldap_attribute **attribs,
 				       int *num_attribs)
 {
-	*attribs = talloc_realloc(mem_ctx, *attribs,
+	*attribs = talloc_realloc(*attribs,
 				  sizeof(**attribs) * (*num_attribs+1));
 
 	if (*attribs == NULL)
@@ -207,8 +207,7 @@ static BOOL fill_add_attributes(struct ldap_message *msg, char **chunk)
 		}
 
 		if (attrib == NULL) {
-			r->attributes = talloc_realloc(msg->mem_ctx,
-						       r->attributes,
+			r->attributes = talloc_realloc(r->attributes,
 						       sizeof(*r->attributes) *
 						       (r->num_attributes+1));
 			if (r->attributes == NULL)
@@ -232,7 +231,7 @@ BOOL add_mod_to_array_talloc(TALLOC_CTX *mem_ctx,
 				    struct ldap_mod **mods,
 				    int *num_mods)
 {
-	*mods = talloc_realloc(mem_ctx, *mods,
+	*mods = talloc_realloc(*mods,
 			       sizeof(**mods) * ((*num_mods)+1));
 
 	if (*mods == NULL)
diff --git a/source4/libcli/raw/clisession.c b/source4/libcli/raw/clisession.c
index f46c238378..0ee631a549 100644
--- a/source4/libcli/raw/clisession.c
+++ b/source4/libcli/raw/clisession.c
@@ -69,7 +69,7 @@ void smbcli_session_close(struct smbcli_session *session)
 ****************************************************************************/
 struct smbcli_request *smb_raw_session_setup_send(struct smbcli_session *session, union smb_sesssetup *parms) 
 {
-	struct smbcli_request *req;
+	struct smbcli_request *req = NULL;
 
 	switch (parms->generic.level) {
 	case RAW_SESSSETUP_GENERIC:
diff --git a/source4/libcli/raw/clisocket.c b/source4/libcli/raw/clisocket.c
index 343904999a..2bb50d200f 100644
--- a/source4/libcli/raw/clisocket.c
+++ b/source4/libcli/raw/clisocket.c
@@ -181,7 +181,7 @@ BOOL smbcli_sock_connect_byname(struct smbcli_socket *sock, const char *host, in
 	ret = smbcli_sock_connect(sock, &ip, port);
 
 	if (ret) {
-		sock->hostname = talloc_steal(mem_ctx, sock->mem_ctx, name);
+		sock->hostname = talloc_steal(sock->mem_ctx, name);
 	}
 
 	talloc_destroy(mem_ctx);
diff --git a/source4/libcli/raw/clitransport.c b/source4/libcli/raw/clitransport.c
index 91f0f0f8f5..82939467ae 100644
--- a/source4/libcli/raw/clitransport.c
+++ b/source4/libcli/raw/clitransport.c
@@ -296,7 +296,7 @@ static void smbcli_transport_finish_recv(struct smbcli_transport *transport)
 {
 	uint8_t *buffer, *hdr, *vwv;
 	int len;
-	uint16_t wct, mid = 0;
+	uint16_t wct=0, mid = 0;
 	struct smbcli_request *req;
 
 	buffer = transport->recv_buffer.buffer;
@@ -309,7 +309,7 @@ static void smbcli_transport_finish_recv(struct smbcli_transport *transport)
 
 	/* see if it could be an oplock break request */
 	if (handle_oplock_break(transport, len, hdr, vwv)) {
-		talloc_free(transport->mem_ctx, buffer);
+		talloc_free(buffer);
 		return;
 	}
 
@@ -325,7 +325,7 @@ static void smbcli_transport_finish_recv(struct smbcli_transport *transport)
 		if (!req) goto error;
 
 		req->in.buffer = buffer;
-		talloc_steal(transport->mem_ctx, req->mem_ctx, buffer);
+		talloc_steal(req->mem_ctx, buffer);
 		req->in.size = len;
 		req->in.allocated = req->in.size;
 		goto async;
@@ -349,7 +349,7 @@ static void smbcli_transport_finish_recv(struct smbcli_transport *transport)
 
 	/* fill in the 'in' portion of the matching request */
 	req->in.buffer = buffer;
-	talloc_steal(transport->mem_ctx, req->mem_ctx, buffer);
+	talloc_steal(req->mem_ctx, buffer);
 	req->in.size = len;
 	req->in.allocated = req->in.size;
 
diff --git a/source4/libcli/raw/clitree.c b/source4/libcli/raw/clitree.c
index 97c0910451..57e322da32 100644
--- a/source4/libcli/raw/clitree.c
+++ b/source4/libcli/raw/clitree.c
@@ -70,7 +70,7 @@ void smbcli_tree_close(struct smbcli_tree *tree)
 ****************************************************************************/
 struct smbcli_request *smb_tree_connect_send(struct smbcli_tree *tree, union smb_tcon *parms)
 {
-	struct smbcli_request *req;
+	struct smbcli_request *req = NULL;
 
 	switch (parms->tcon.level) {
 	case RAW_TCON_TCON:
diff --git a/source4/libcli/raw/raweas.c b/source4/libcli/raw/raweas.c
index e07fbcd288..d78f10fe1a 100644
--- a/source4/libcli/raw/raweas.c
+++ b/source4/libcli/raw/raweas.c
@@ -128,7 +128,7 @@ NTSTATUS ea_pull_list(const DATA_BLOB *blob,
 		blob2.data = blob->data + ofs;
 		blob2.length = ea_size - ofs;
 
-		*eas = talloc_realloc(mem_ctx, *eas, sizeof(**eas) * (n+1));
+		*eas = talloc_realloc(*eas, sizeof(**eas) * (n+1));
 		if (! *eas) return NT_STATUS_NO_MEMORY;
 
 		len = ea_pull_struct(&blob2, mem_ctx, &(*eas)[n]);
diff --git a/source4/libcli/raw/rawfile.c b/source4/libcli/raw/rawfile.c
index 8bd8e5d8af..1b858d489a 100644
--- a/source4/libcli/raw/rawfile.c
+++ b/source4/libcli/raw/rawfile.c
@@ -34,7 +34,7 @@
 struct smbcli_request *smb_raw_rename_send(struct smbcli_tree *tree,
 					union smb_rename *parms)
 {
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_RENAME_RENAME:
@@ -490,7 +490,7 @@ NTSTATUS smb_raw_open(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_o
 ****************************************************************************/
 struct smbcli_request *smb_raw_close_send(struct smbcli_tree *tree, union smb_close *parms)
 {
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_CLOSE_GENERIC:
@@ -536,7 +536,7 @@ NTSTATUS smb_raw_close(struct smbcli_tree *tree, union smb_close *parms)
 ****************************************************************************/
 struct smbcli_request *smb_raw_lock_send(struct smbcli_tree *tree, union smb_lock *parms)
 {
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_LOCK_GENERIC:
diff --git a/source4/libcli/raw/rawfileinfo.c b/source4/libcli/raw/rawfileinfo.c
index 9b82bf6fa0..aac8f2657b 100644
--- a/source4/libcli/raw/rawfileinfo.c
+++ b/source4/libcli/raw/rawfileinfo.c
@@ -174,7 +174,7 @@ static NTSTATUS smb_raw_info_backend(struct smbcli_session *session,
 		while (blob->length - ofs >= 24) {
 			uint_t n = parms->stream_info.out.num_streams;
 			parms->stream_info.out.streams = 
-				talloc_realloc(mem_ctx,parms->stream_info.out.streams,
+				talloc_realloc(parms->stream_info.out.streams,
 					       (n+1) * sizeof(parms->stream_info.out.streams[0]));
 			if (!parms->stream_info.out.streams) {
 				return NT_STATUS_NO_MEMORY;
diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index f0a9a063ed..dbca6fb7a5 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -33,7 +33,7 @@
 struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
 {
 	BOOL bigoffset = False;
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_READ_GENERIC:
@@ -185,7 +185,7 @@ NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
 {
 	BOOL bigoffset = False;
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_WRITE_GENERIC:
diff --git a/source4/libcli/raw/rawrequest.c b/source4/libcli/raw/rawrequest.c
index bc87af4297..20a389af4c 100644
--- a/source4/libcli/raw/rawrequest.c
+++ b/source4/libcli/raw/rawrequest.c
@@ -224,7 +224,7 @@ static void smbcli_req_grow_allocation(struct smbcli_request *req, uint_t new_si
 
 	/* we need to realloc */
 	req->out.allocated = req->out.size + delta + REQ_OVER_ALLOCATION;
-	buf2 = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
+	buf2 = talloc_realloc(req->out.buffer, req->out.allocated);
 	if (buf2 == NULL) {
 		smb_panic("out of memory in req_grow_allocation");
 	}
@@ -915,7 +915,7 @@ size_t smbcli_blob_append_string(struct smbcli_session *session,
 
 	max_len = (strlen(str)+2) * MAX_BYTES_PER_CHAR;		
 
-	blob->data = talloc_realloc(mem_ctx, blob->data, blob->length + max_len);
+	blob->data = talloc_realloc(blob->data, blob->length + max_len);
 	if (!blob->data) {
 		return 0;
 	}
diff --git a/source4/libcli/raw/rawtrans.c b/source4/libcli/raw/rawtrans.c
index 53f8075822..49b43dd930 100644
--- a/source4/libcli/raw/rawtrans.c
+++ b/source4/libcli/raw/rawtrans.c
@@ -84,7 +84,7 @@ NTSTATUS smb_raw_trans2_recv(struct smbcli_request *req,
 
 	/* allocate it */
 	if (total_data != 0) {
-		tdata = talloc_realloc(mem_ctx, parms->out.data.data,total_data);
+		tdata = talloc_realloc(parms->out.data.data,total_data);
 		if (!tdata) {
 			DEBUG(0,("smb_raw_receive_trans: failed to enlarge data buffer to %d bytes\n", total_data));
 			req->status = NT_STATUS_NO_MEMORY;
@@ -94,7 +94,7 @@ NTSTATUS smb_raw_trans2_recv(struct smbcli_request *req,
 	}
 
 	if (total_param != 0) {
-		tparam = talloc_realloc(mem_ctx, parms->out.params.data,total_param);
+		tparam = talloc_realloc(parms->out.params.data,total_param);
 		if (!tparam) {
 			DEBUG(0,("smb_raw_receive_trans: failed to enlarge param buffer to %d bytes\n", total_param));
 			req->status = NT_STATUS_NO_MEMORY;
diff --git a/source4/librpc/ndr/ndr.c b/source4/librpc/ndr/ndr.c
index 1d50d95afa..cbb1046281 100644
--- a/source4/librpc/ndr/ndr.c
+++ b/source4/librpc/ndr/ndr.c
@@ -188,7 +188,7 @@ NTSTATUS ndr_push_expand(struct ndr_push *ndr, uint32_t size)
 	if (size > ndr->alloc_size) {
 		ndr->alloc_size = size;
 	}
-	ndr->data = talloc_realloc(ndr->mem_ctx, ndr->data, ndr->alloc_size);
+	ndr->data = talloc_realloc(ndr->data, ndr->alloc_size);
 	if (!ndr->data) {
 		return ndr_push_error(ndr, NDR_ERR_ALLOC, "Failed to push_expand to %u",
 				      ndr->alloc_size);
diff --git a/source4/librpc/rpc/dcerpc.c b/source4/librpc/rpc/dcerpc.c
index 438a9a4cf3..0e8828acbd 100644
--- a/source4/librpc/rpc/dcerpc.c
+++ b/source4/librpc/rpc/dcerpc.c
@@ -660,8 +660,7 @@ NTSTATUS dcerpc_request(struct dcerpc_pipe *p,
 
 		length = pkt.u.response.stub_and_verifier.length;
 
-		payload.data = talloc_realloc(mem_ctx, 
-					      payload.data, 
+		payload.data = talloc_realloc(payload.data, 
 					      payload.length + length);
 		if (!payload.data) {
 			return NT_STATUS_NO_MEMORY;
diff --git a/source4/librpc/rpc/dcerpc_smb.c b/source4/librpc/rpc/dcerpc_smb.c
index 51722c8a04..d3a0a42d10 100644
--- a/source4/librpc/rpc/dcerpc_smb.c
+++ b/source4/librpc/rpc/dcerpc_smb.c
@@ -98,7 +98,7 @@ static NTSTATUS dcerpc_raw_recv(struct dcerpc_pipe *p,
 	}
 
 	/* make sure the payload can hold the whole fragment */
-	payload.data = talloc_realloc(mem_ctx, payload.data, frag_length);
+	payload.data = talloc_realloc(payload.data, frag_length);
 	if (!payload.data) {
 		return NT_STATUS_NO_MEMORY;
 	}
@@ -203,7 +203,7 @@ static NTSTATUS smb_secondary_request(struct dcerpc_pipe *p,
 		return status;
 	}
 
-	blob->data = talloc_realloc(mem_ctx, blob->data, frag_length);
+	blob->data = talloc_realloc(blob->data, frag_length);
 	if (!blob->data) {
 		return NT_STATUS_NO_MEMORY;
 	}
diff --git a/source4/ntvfs/ipc/ipc_rap.c b/source4/ntvfs/ipc/ipc_rap.c
index d2cd0b38d5..347ff39d97 100644
--- a/source4/ntvfs/ipc/ipc_rap.c
+++ b/source4/ntvfs/ipc/ipc_rap.c
@@ -178,7 +178,7 @@ static NTSTATUS rap_push_string(struct ndr_push *data_push,
 	NDR_CHECK(ndr_push_uint16(data_push, heap->offset));
 	NDR_CHECK(ndr_push_uint16(data_push, 0));
 
-	heap->strings = talloc_realloc(heap->mem_ctx, heap->strings,
+	heap->strings = talloc_realloc(heap->strings,
 				       sizeof(*heap->strings) *
 				       (heap->num_strings + 1));
 
diff --git a/source4/ntvfs/reference/ref_util.c b/source4/ntvfs/reference/ref_util.c
index e221086950..8be80183c5 100644
--- a/source4/ntvfs/reference/ref_util.c
+++ b/source4/ntvfs/reference/ref_util.c
@@ -104,7 +104,7 @@ struct svfs_dir *svfs_list(TALLOC_CTX *mem_ctx, struct smbsrv_request *req, cons
 		
 		if (dir->count >= allocated) {
 			allocated = (allocated + 100) * 1.2;
-			dir->files = talloc_realloc(mem_ctx, dir->files, allocated * sizeof(dir->files[0]));
+			dir->files = talloc_realloc(dir->files, allocated * sizeof(dir->files[0]));
 			if (!dir->files) { 
 				closedir(odir);
 				return NULL;
diff --git a/source4/ntvfs/simple/svfs_util.c b/source4/ntvfs/simple/svfs_util.c
index 7da9667e3c..1949ecb235 100644
--- a/source4/ntvfs/simple/svfs_util.c
+++ b/source4/ntvfs/simple/svfs_util.c
@@ -105,7 +105,7 @@ struct svfs_dir *svfs_list_unix(TALLOC_CTX *mem_ctx, struct smbsrv_request *req,
 		
 		if (dir->count >= allocated) {
 			allocated = (allocated + 100) * 1.2;
-			dir->files = talloc_realloc(mem_ctx, dir->files, allocated * sizeof(dir->files[0]));
+			dir->files = talloc_realloc(dir->files, allocated * sizeof(dir->files[0]));
 			if (!dir->files) { 
 				closedir(odir);
 				return NULL;
diff --git a/source4/ntvfs/simple/vfs_simple.c b/source4/ntvfs/simple/vfs_simple.c
index ad889daf36..ae64c96c75 100644
--- a/source4/ntvfs/simple/vfs_simple.c
+++ b/source4/ntvfs/simple/vfs_simple.c
@@ -580,8 +580,8 @@ static NTSTATUS svfs_close(struct smbsrv_request *req, union smb_close *io)
 	}
 
 	DLIST_REMOVE(private->open_files, f);
-	talloc_free(req->tcon->mem_ctx, f->name);
-	talloc_free(req->tcon->mem_ctx, f);
+	talloc_free(f->name);
+	talloc_free(f);
 
 	return NT_STATUS_OK;
 }
@@ -766,7 +766,7 @@ static NTSTATUS svfs_search_first(struct smbsrv_request *req, union smb_search_f
 
 	dir = svfs_list(mem_ctx, req, io->t2ffirst.in.pattern);
 	if (!dir) {
-		talloc_destroy_pool(mem_ctx);
+		talloc_free(mem_ctx);
 		return NT_STATUS_FOOBAR;
 	}
 
diff --git a/source4/rpc_server/dcerpc_server.c b/source4/rpc_server/dcerpc_server.c
index f83916f3c9..ab61ba3911 100644
--- a/source4/rpc_server/dcerpc_server.c
+++ b/source4/rpc_server/dcerpc_server.c
@@ -734,7 +734,7 @@ NTSTATUS dcesrv_input_process(struct dcesrv_connection *dce_conn)
 	}
 	call = talloc_p(mem_ctx, struct dcesrv_call_state);
 	if (!call) {
-		talloc_free(dce_conn->mem_ctx, dce_conn->partial_input.data);
+		talloc_free(dce_conn->partial_input.data);
 		talloc_destroy(mem_ctx);
 		return NT_STATUS_NO_MEMORY;
 	}
@@ -747,7 +747,7 @@ NTSTATUS dcesrv_input_process(struct dcesrv_connection *dce_conn)
 
 	ndr = ndr_pull_init_blob(&blob, mem_ctx);
 	if (!ndr) {
-		talloc_free(dce_conn->mem_ctx, dce_conn->partial_input.data);
+		talloc_free(dce_conn->partial_input.data);
 		talloc_destroy(mem_ctx);
 		return NT_STATUS_NO_MEMORY;
 	}
@@ -758,7 +758,7 @@ NTSTATUS dcesrv_input_process(struct dcesrv_connection *dce_conn)
 
 	status = ndr_pull_dcerpc_packet(ndr, NDR_SCALARS|NDR_BUFFERS, &call->pkt);
 	if (!NT_STATUS_IS_OK(status)) {
-		talloc_free(dce_conn->mem_ctx, dce_conn->partial_input.data);
+		talloc_free(dce_conn->partial_input.data);
 		talloc_destroy(mem_ctx);
 		return status;
 	}
@@ -801,8 +801,7 @@ NTSTATUS dcesrv_input_process(struct dcesrv_connection *dce_conn)
 		}
 
 		call->pkt.u.request.stub_and_verifier.data = 
-			talloc_realloc(call->mem_ctx,
-				       call->pkt.u.request.stub_and_verifier.data, alloc_size);
+			talloc_realloc(call->pkt.u.request.stub_and_verifier.data, alloc_size);
 		if (!call->pkt.u.request.stub_and_verifier.data) {
 			return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
 		}
diff --git a/source4/rpc_server/epmapper/rpc_epmapper.c b/source4/rpc_server/epmapper/rpc_epmapper.c
index f2c7b78335..62c545cd94 100644
--- a/source4/rpc_server/epmapper/rpc_epmapper.c
+++ b/source4/rpc_server/epmapper/rpc_epmapper.c
@@ -129,7 +129,7 @@ static uint32_t build_ep_list(TALLOC_CTX *mem_ctx,
 		struct dcesrv_if_list *iface;
 
 		for (iface=d->interface_list;iface;iface=iface->next) {
-			(*eps) = talloc_realloc_p(mem_ctx, *eps, 
+			(*eps) = talloc_realloc_p(*eps, 
 						  struct dcesrv_ep_iface,
 						  total + 1);
 			if (!*eps) {
diff --git a/source4/rpc_server/netlogon/dcerpc_netlogon.c b/source4/rpc_server/netlogon/dcerpc_netlogon.c
index a4ef06128c..d01c0c577b 100644
--- a/source4/rpc_server/netlogon/dcerpc_netlogon.c
+++ b/source4/rpc_server/netlogon/dcerpc_netlogon.c
@@ -265,14 +265,14 @@ static NTSTATUS netr_ServerAuthenticate3(struct dcesrv_call_state *dce_call, TAL
 
 	if (pipe_state->account_name) {
 		/* We don't want a memory leak on this long-lived talloc context */
-		talloc_free(pipe_state->mem_ctx, pipe_state->account_name);
+		talloc_free(pipe_state->account_name);
 	}
 
 	pipe_state->account_name = talloc_strdup(pipe_state->mem_ctx, r->in.account_name);
 	
 	if (pipe_state->computer_name) {
 		/* We don't want a memory leak on this long-lived talloc context */
-		talloc_free(pipe_state->mem_ctx, pipe_state->account_name);
+		talloc_free(pipe_state->account_name);
 	}
 
 	pipe_state->computer_name = talloc_strdup(pipe_state->mem_ctx, r->in.computer_name);
diff --git a/source4/rpc_server/samr/dcesrv_samr.c b/source4/rpc_server/samr/dcesrv_samr.c
index 4028a853d7..d670a2f8dc 100644
--- a/source4/rpc_server/samr/dcesrv_samr.c
+++ b/source4/rpc_server/samr/dcesrv_samr.c
@@ -572,7 +572,7 @@ static NTSTATUS samr_CreateDomainGroup(struct dcesrv_call_state *dce_call, TALLO
 	a_state->sam_ctx = d_state->sam_ctx;
 	a_state->access_mask = r->in.access_mask;
 	a_state->domain_state = d_state;
-	a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msg.dn);
+	a_state->account_dn = talloc_steal(mem_ctx2, msg.dn);
 	a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 	a_state->account_name = talloc_strdup(mem_ctx2, groupname);
 	if (!a_state->account_name || !a_state->account_sid) {
@@ -756,7 +756,7 @@ static NTSTATUS samr_CreateUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX
 	a_state->sam_ctx = d_state->sam_ctx;
 	a_state->access_mask = r->in.access_mask;
 	a_state->domain_state = d_state;
-	a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msg.dn);
+	a_state->account_dn = talloc_steal(mem_ctx2, msg.dn);
 	a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 	a_state->account_name = talloc_strdup(mem_ctx2, account_name);
 	if (!a_state->account_name || !a_state->account_sid) {
@@ -1074,7 +1074,7 @@ static NTSTATUS samr_OpenGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *m
 	a_state->sam_ctx = d_state->sam_ctx;
 	a_state->access_mask = r->in.access_mask;
 	a_state->domain_state = d_state;
-	a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msgs[0]->dn);
+	a_state->account_dn = talloc_steal(mem_ctx2, msgs[0]->dn);
 	a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 	a_state->account_name = talloc_strdup(mem_ctx2, groupname);
 	if (!a_state->account_name || !a_state->account_sid) {
@@ -1453,7 +1453,7 @@ static NTSTATUS samr_OpenUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *me
 	a_state->sam_ctx = d_state->sam_ctx;
 	a_state->access_mask = r->in.access_mask;
 	a_state->domain_state = d_state;
-	a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msgs[0]->dn);
+	a_state->account_dn = talloc_steal(mem_ctx2, msgs[0]->dn);
 	a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 	a_state->account_name = talloc_strdup(mem_ctx2, account_name);
 	if (!a_state->account_name || !a_state->account_sid) {
diff --git a/source4/smb_server/request.c b/source4/smb_server/request.c
index e9aeb168bc..e3f54bde65 100644
--- a/source4/smb_server/request.c
+++ b/source4/smb_server/request.c
@@ -89,7 +89,7 @@ static void req_setup_chain_reply(struct smbsrv_request *req, uint_t wct, uint_t
 	/* over allocate by a small amount */
 	req->out.allocated = req->out.size + REQ_OVER_ALLOCATION; 
 
-	req->out.buffer = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
+	req->out.buffer = talloc_realloc(req->out.buffer, req->out.allocated);
 	if (!req->out.buffer) {
 		smbsrv_terminate_connection(req->smb_conn, "allocation failed");
 	}
@@ -203,7 +203,7 @@ static void req_grow_allocation(struct smbsrv_request *req, uint_t new_size)
 
 	/* we need to realloc */
 	req->out.allocated = req->out.size + delta + REQ_OVER_ALLOCATION;
-	buf2 = talloc_realloc(req->mem_ctx, req->out.buffer, req->out.allocated);
+	buf2 = talloc_realloc(req->out.buffer, req->out.allocated);
 	if (buf2 == NULL) {
 		smb_panic("out of memory in req_grow_allocation");
 	}
diff --git a/source4/smb_server/trans2.c b/source4/smb_server/trans2.c
index f080cd2abc..5f73dc7497 100644
--- a/source4/smb_server/trans2.c
+++ b/source4/smb_server/trans2.c
@@ -39,7 +39,7 @@ static void trans2_grow_data_allocation(struct smbsrv_request *req,
 	if (new_size <= trans->out.data.length) {
 		return;
 	}
-	trans->out.data.data = talloc_realloc(req->mem_ctx, trans->out.data.data, new_size);
+	trans->out.data.data = talloc_realloc(trans->out.data.data, new_size);
 }
 
 
diff --git a/source4/torture/rap/rap.c b/source4/torture/rap/rap.c
index 0a5ef6d34e..7dc9e7fcbc 100644
--- a/source4/torture/rap/rap.c
+++ b/source4/torture/rap/rap.c
@@ -79,7 +79,7 @@ static void rap_cli_push_paramdesc(struct rap_call *call, char desc)
 	if (call->paramdesc != NULL)
 		len = strlen(call->paramdesc);
 
-	call->paramdesc = talloc_realloc(call->mem_ctx, call->paramdesc,
+	call->paramdesc = talloc_realloc(call->paramdesc,
 					 len+2);
 	call->paramdesc[len] = desc;
 	call->paramdesc[len+1] = '\0';
diff --git a/source4/torture/raw/open.c b/source4/torture/raw/open.c
index 8cdc18fe2f..2cb39b3231 100644
--- a/source4/torture/raw/open.c
+++ b/source4/torture/raw/open.c
@@ -150,7 +150,7 @@ static BOOL test_open(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 	union smb_fileinfo finfo;
 	const char *fname = BASEDIR "\\torture_open.txt";
 	NTSTATUS status;
-	int fnum, fnum2;
+	int fnum = -1, fnum2;
 	BOOL ret = True;
 
 	printf("Checking RAW_OPEN_OPEN\n");
@@ -261,7 +261,7 @@ static BOOL test_openx(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 	union smb_fileinfo finfo;
 	const char *fname = BASEDIR "\\torture_openx.txt";
 	NTSTATUS status;
-	int fnum, fnum2;
+	int fnum = -1, fnum2;
 	BOOL ret = True;
 	int i;
 	struct {
@@ -579,7 +579,7 @@ static BOOL test_ntcreatex(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 	const char *fname = BASEDIR "\\torture_ntcreatex.txt";
 	const char *dname = BASEDIR "\\torture_ntcreatex.dir";
 	NTSTATUS status;
-	int fnum;
+	int fnum = -1;
 	BOOL ret = True;
 	int i;
 	struct {
@@ -822,7 +822,7 @@ static BOOL test_mknew(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 	union smb_open io;
 	const char *fname = BASEDIR "\\torture_mknew.txt";
 	NTSTATUS status;
-	int fnum;
+	int fnum = -1;
 	BOOL ret = True;
 	time_t basetime = (time(NULL) + 3600*24*3) & ~1;
 	union smb_fileinfo finfo;
@@ -876,7 +876,7 @@ static BOOL test_create(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 	union smb_open io;
 	const char *fname = BASEDIR "\\torture_create.txt";
 	NTSTATUS status;
-	int fnum;
+	int fnum = -1;
 	BOOL ret = True;
 	time_t basetime = (time(NULL) + 3600*24*3) & ~1;
 	union smb_fileinfo finfo;
@@ -930,7 +930,7 @@ static BOOL test_ctemp(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 {
 	union smb_open io;
 	NTSTATUS status;
-	int fnum;
+	int fnum = -1;
 	BOOL ret = True;
 	time_t basetime = (time(NULL) + 3600*24*3) & ~1;
 	union smb_fileinfo finfo;
diff --git a/source4/torture/raw/search.c b/source4/torture/raw/search.c
index f1d51a8c69..19dfcc51d4 100644
--- a/source4/torture/raw/search.c
+++ b/source4/torture/raw/search.c
@@ -377,8 +377,7 @@ static BOOL multiple_search_callback(void *private, union smb_search_data *file)
 
 
 	data->count++;
-	data->list = talloc_realloc(data->mem_ctx, 
-				    data->list, 
+	data->list = talloc_realloc(data->list, 
 				    data->count * (sizeof(data->list[0])));
 
 	data->list[data->count-1] = *file;
diff --git a/source4/torture/rpc/winreg.c b/source4/torture/rpc/winreg.c
index 86b91eacc2..59f0fc4a04 100644
--- a/source4/torture/rpc/winreg.c
+++ b/source4/torture/rpc/winreg.c
@@ -488,8 +488,9 @@ static BOOL test_Open(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, void *fn)
 	BOOL ret = True;
 	winreg_open_fn *open_fn = (winreg_open_fn *)fn;
 
-	if (!open_fn(p, mem_ctx, &handle))
+	if (!open_fn(p, mem_ctx, &handle)) {
 		return False;
+	}
 
 	if (!test_CreateKey(p, mem_ctx, &handle, "spottyfoot", NULL)) {
 		printf("CreateKey failed\n");