From 65f96eba32b93ced0717c2639007bba59da55fa4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 2 Jan 2005 07:47:34 +0000
Subject: r4473: - moved talloc into its own lib/talloc/ area

- added gcov flags to Makefile.talloc

- expanded talloc testsuite to add a test for realloc with a child ptr

- fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs
(This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
---
 source4/lib/talloc/talloc.c | 1006 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1006 insertions(+)
 create mode 100644 source4/lib/talloc/talloc.c

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
new file mode 100644
index 0000000000..4666e28288
--- /dev/null
+++ b/source4/lib/talloc/talloc.c
@@ -0,0 +1,1006 @@
+/* 
+   Samba Unix SMB/CIFS implementation.
+
+   Samba trivial allocation library - new interface
+
+   NOTE: Please read talloc_guide.txt for full documentation
+
+   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
+   the Free Software Foundation; either version 2 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, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+  inspired by http://swapped.cc/halloc/
+*/
+
+
+#ifdef _SAMBA_BUILD_
+#include "includes.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include "talloc.h"
+#endif
+
+/* use this to force every realloc to change the pointer, to stress test
+   code that might not cope */
+#define ALWAYS_REALLOC 0
+
+
+#define MAX_TALLOC_SIZE 0x10000000
+#define TALLOC_MAGIC 0xe814ec4f
+#define TALLOC_MAGIC_FREE 0x7faebef3
+#define TALLOC_MAGIC_REFERENCE ((const char *)1)
+
+/* by default we abort when given a bad pointer (such as when talloc_free() is called 
+   on a pointer that came from malloc() */
+#ifndef TALLOC_ABORT
+#define TALLOC_ABORT(reason) abort()
+#endif
+
+#ifndef discard_const_p
+#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
+# define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
+#else
+# define discard_const_p(type, ptr) ((type *)(ptr))
+#endif
+#endif
+
+/* this null_context is only used if talloc_enable_leak_report() or
+   talloc_enable_leak_report_full() is called, otherwise it remains
+   NULL
+*/
+static const void *null_context;
+
+
+struct talloc_reference_handle {
+	struct talloc_reference_handle *next, *prev;
+	void *ptr;
+};
+
+typedef int (*talloc_destructor_t)(void *);
+
+struct talloc_chunk {
+	struct talloc_chunk *next, *prev;
+	struct talloc_chunk *parent, *child;
+	struct talloc_reference_handle *refs;
+	size_t size;
+	unsigned magic;
+	talloc_destructor_t destructor;
+	const char *name;
+};
+
+/* panic if we get a bad magic value */
+static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
+{
+	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
+	if (tc->magic != TALLOC_MAGIC) { 
+		if (tc->magic == TALLOC_MAGIC_FREE) {
+			TALLOC_ABORT("Bad talloc magic value - double free"); 
+		} else {
+			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
+		}
+	}
+
+	return tc;
+}
+
+/* hook into the front of the list */
+#define _TLIST_ADD(list, p) \
+do { \
+        if (!(list)) { \
+		(list) = (p); \
+		(p)->next = (p)->prev = NULL; \
+	} else { \
+		(list)->prev = (p); \
+		(p)->next = (list); \
+		(p)->prev = NULL; \
+		(list) = (p); \
+	}\
+} while (0)
+
+/* remove an element from a list - element doesn't have to be in list. */
+#define _TLIST_REMOVE(list, p) \
+do { \
+	if ((p) == (list)) { \
+		(list) = (p)->next; \
+		if (list) (list)->prev = NULL; \
+	} else { \
+		if ((p)->prev) (p)->prev->next = (p)->next; \
+		if ((p)->next) (p)->next->prev = (p)->prev; \
+	} \
+	if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
+} while (0)
+
+
+/*
+  return the parent chunk of a pointer
+*/
+static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	while (tc->prev) tc=tc->prev;
+	return tc->parent;
+}
+
+/* 
+   Allocate a bit of memory as a child of an existing pointer
+*/
+void *_talloc(const void *context, size_t size)
+{
+	struct talloc_chunk *tc;
+
+	if (context == NULL) {
+		context = null_context;
+	}
+
+	if (size >= MAX_TALLOC_SIZE) {
+		return NULL;
+	}
+
+	tc = malloc(sizeof(*tc)+size);
+	if (tc == NULL) return NULL;
+
+	tc->size = size;
+	tc->magic = TALLOC_MAGIC;
+	tc->destructor = NULL;
+	tc->child = NULL;
+	tc->name = NULL;
+	tc->refs = NULL;
+
+	if (context) {
+		struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
+
+		tc->parent = parent;
+
+		if (parent->child) {
+			parent->child->parent = NULL;
+		}
+
+		_TLIST_ADD(parent->child, tc);
+	} else {
+		tc->next = tc->prev = tc->parent = NULL;
+	}
+
+	return (void *)(tc+1);
+}
+
+
+/*
+  setup a destructor to be called on free of a pointer
+  the destructor should return 0 on success, or -1 on failure.
+  if the destructor fails then the free is failed, and the memory can
+  be continued to be used
+*/
+void talloc_set_destructor(const void *ptr, int (*destructor)(void *))
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	tc->destructor = destructor;
+}
+
+/*
+  increase the reference count on a piece of memory. 
+*/
+void talloc_increase_ref_count(const void *ptr)
+{
+	talloc_reference(null_context, ptr);
+}
+
+/*
+  helper for talloc_reference()
+*/
+static int talloc_reference_destructor(void *ptr)
+{
+	struct talloc_reference_handle *handle = ptr;
+	struct talloc_chunk *tc1 = talloc_chunk_from_ptr(ptr);
+	struct talloc_chunk *tc2 = talloc_chunk_from_ptr(handle->ptr);
+	if (tc1->destructor != (talloc_destructor_t)-1) {
+		tc1->destructor = NULL;
+	}
+	_TLIST_REMOVE(tc2->refs, handle);
+	talloc_free(handle);
+	return 0;
+}
+
+/*
+  make a secondary reference to a pointer, hanging off the given context.
+  the pointer remains valid until both the original caller and this given
+  context are freed.
+  
+  the major use for this is when two different structures need to reference the 
+  same underlying data, and you want to be able to free the two instances separately,
+  and in either order
+*/
+void *talloc_reference(const void *context, const void *ptr)
+{
+	struct talloc_chunk *tc;
+	struct talloc_reference_handle *handle;
+	if (ptr == NULL) return NULL;
+
+	tc = talloc_chunk_from_ptr(ptr);
+	handle = talloc_named_const(context, sizeof(*handle), TALLOC_MAGIC_REFERENCE);
+
+	if (handle == NULL) return NULL;
+
+	/* note that we hang the destructor off the handle, not the
+	   main context as that allows the caller to still setup their
+	   own destructor on the context if they want to */
+	talloc_set_destructor(handle, talloc_reference_destructor);
+	handle->ptr = discard_const_p(void, ptr);
+	_TLIST_ADD(tc->refs, handle);
+	return handle->ptr;
+}
+
+/*
+  remove a secondary reference to a pointer. This undo's what
+  talloc_reference() has done. The context and pointer arguments
+  must match those given to a talloc_reference()
+*/
+static int talloc_unreference(const void *context, const void *ptr)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	struct talloc_reference_handle *h;
+
+	if (context == NULL) {
+		context = null_context;
+	}
+
+	for (h=tc->refs;h;h=h->next) {
+		struct talloc_chunk *p = talloc_parent_chunk(h);
+		if ((p==NULL && context==NULL) || p+1 == context) break;
+	}
+	if (h == NULL) {
+		return -1;
+	}
+
+	talloc_set_destructor(h, NULL);
+	_TLIST_REMOVE(tc->refs, h);
+	talloc_free(h);
+	return 0;
+}
+
+/*
+  remove a specific parent context from a pointer. This is a more
+  controlled varient of talloc_free()
+*/
+int talloc_unlink(const void *context, void *ptr)
+{
+	struct talloc_chunk *tc_p, *new_p;
+	void *new_parent;
+
+	if (ptr == NULL) {
+		return -1;
+	}
+
+	if (context == NULL) {
+		context = null_context;
+	}
+
+	if (talloc_unreference(context, ptr) == 0) {
+		return 0;
+	}
+
+	if (context == NULL) {
+		if (talloc_parent_chunk(ptr) != NULL) {
+			return -1;
+		}
+	} else {
+		if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
+			return -1;
+		}
+	}
+	
+	tc_p = talloc_chunk_from_ptr(ptr);
+
+	if (tc_p->refs == NULL) {
+		return talloc_free(ptr);
+	}
+
+	new_p = talloc_parent_chunk(tc_p->refs);
+	if (new_p) {
+		new_parent = new_p+1;
+	} else {
+		new_parent = NULL;
+	}
+
+	if (talloc_unreference(new_parent, ptr) != 0) {
+		return -1;
+	}
+
+	talloc_steal(new_parent, ptr);
+
+	return 0;
+}
+
+/*
+  add a name to an existing pointer - va_list version
+*/
+static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+
+static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	tc->name = talloc_vasprintf(ptr, fmt, ap);
+	if (tc->name) {
+		talloc_set_name_const(tc->name, ".name");
+	}
+}
+
+/*
+  add a name to an existing pointer
+*/
+void talloc_set_name(const void *ptr, const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	talloc_set_name_v(ptr, fmt, ap);
+	va_end(ap);
+}
+
+/*
+   more efficient way to add a name to a pointer - the name must point to a 
+   true string constant
+*/
+void talloc_set_name_const(const void *ptr, const char *name)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	tc->name = name;
+}
+
+/*
+  create a named talloc pointer. Any talloc pointer can be named, and
+  talloc_named() operates just like talloc() except that it allows you
+  to name the pointer.
+*/
+void *talloc_named(const void *context, size_t size, const char *fmt, ...)
+{
+	va_list ap;
+	void *ptr;
+
+	ptr = _talloc(context, size);
+	if (ptr == NULL) return NULL;
+
+	va_start(ap, fmt);
+	talloc_set_name_v(ptr, fmt, ap);
+	va_end(ap);
+
+	return ptr;
+}
+
+/*
+  create a named talloc pointer. Any talloc pointer can be named, and
+  talloc_named() operates just like talloc() except that it allows you
+  to name the pointer.
+*/
+void *talloc_named_const(const void *context, size_t size, const char *name)
+{
+	void *ptr;
+
+	ptr = _talloc(context, size);
+	if (ptr == NULL) {
+		return NULL;
+	}
+
+	talloc_set_name_const(ptr, name);
+
+	return ptr;
+}
+
+/*
+  return the name of a talloc ptr, or "UNNAMED"
+*/
+const char *talloc_get_name(const void *ptr)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	if (tc->name == TALLOC_MAGIC_REFERENCE) {
+		return ".reference";
+	}
+	if (tc->name) {
+		return tc->name;
+	}
+	return "UNNAMED";
+}
+
+/*
+  this is for compatibility with older versions of talloc
+*/
+void *talloc_init(const char *fmt, ...)
+{
+	va_list ap;
+	void *ptr;
+
+	ptr = _talloc(NULL, 0);
+	if (ptr == NULL) return NULL;
+
+	va_start(ap, fmt);
+	talloc_set_name_v(ptr, fmt, ap);
+	va_end(ap);
+
+	return ptr;
+}
+
+
+/* 
+   free a talloc pointer. This also frees all child pointers of this 
+   pointer recursively
+
+   return 0 if the memory is actually freed, otherwise -1. The memory
+   will not be freed if the ref_count is > 1 or the destructor (if
+   any) returns non-zero
+*/
+int talloc_free(void *ptr)
+{
+	struct talloc_chunk *tc;
+
+	if (ptr == NULL) {
+		return -1;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	if (tc->refs) {
+		talloc_reference_destructor(tc->refs);
+		return -1;
+	}
+
+	if (tc->destructor) {
+		talloc_destructor_t d = tc->destructor;
+		if (d == (talloc_destructor_t)-1) {
+			return -1;
+		}
+		tc->destructor = (talloc_destructor_t)-1;
+		if (d(ptr) == -1) {
+			tc->destructor = d;
+			return -1;
+		}
+		tc->destructor = NULL;
+	}
+
+	while (tc->child) {
+		/* we need to work out who will own an abandoned child
+		   if it cannot be freed. In priority order, the first
+		   choice is owner of any remaining reference to this
+		   pointer, the second choice is our parent, and the
+		   final choice is the null context. */
+		void *child = tc->child+1;
+		const void *new_parent = null_context;
+		if (tc->child->refs) {
+			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
+			if (p) new_parent = p+1;
+		}
+		if (talloc_free(child) == -1) {
+			if (new_parent == null_context) {
+				struct talloc_chunk *p = talloc_parent_chunk(ptr);
+				if (p) new_parent = p+1;
+			}
+			talloc_steal(new_parent, child);
+		}
+	}
+
+	if (tc->parent) {
+		_TLIST_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;
+	}
+
+	tc->magic = TALLOC_MAGIC_FREE;
+
+	free(tc);
+	return 0;
+}
+
+
+
+/*
+  A talloc version of realloc. The context argument is only used if
+  ptr is NULL
+*/
+void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
+{
+	struct talloc_chunk *tc;
+	void *new_ptr;
+
+	/* size zero is equivalent to free() */
+	if (size == 0) {
+		talloc_free(ptr);
+		return NULL;
+	}
+
+	if (size >= MAX_TALLOC_SIZE) {
+		return NULL;
+	}
+
+	/* realloc(NULL) is equavalent to malloc() */
+	if (ptr == NULL) {
+		return talloc_named_const(context, size, name);
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	/* don't allow realloc on referenced pointers */
+	if (tc->refs) {
+		return NULL;
+	}
+
+	/* by resetting magic we catch users of the old memory */
+	tc->magic = TALLOC_MAGIC_FREE;
+
+#if ALWAYS_REALLOC
+	new_ptr = malloc(size + sizeof(*tc));
+	if (new_ptr) {
+		memcpy(new_ptr, tc, tc->size + sizeof(*tc));
+		free(tc);
+	}
+#else
+	new_ptr = realloc(tc, size + sizeof(*tc));
+#endif
+	if (!new_ptr) {	
+		tc->magic = TALLOC_MAGIC; 
+		return NULL; 
+	}
+
+	tc = new_ptr;
+	tc->magic = TALLOC_MAGIC;
+	if (tc->parent) {
+		tc->parent->child = new_ptr;
+	}
+	if (tc->child) {
+		tc->child->parent = new_ptr;
+	}
+
+	if (tc->prev) {
+		tc->prev->next = tc;
+	}
+	if (tc->next) {
+		tc->next->prev = tc;
+	}
+
+	tc->size = size;
+	talloc_set_name_const(tc+1, name);
+
+	return (void *)(tc+1);
+}
+
+/* 
+   move a lump of memory from one talloc context to another return the
+   ptr on success, or NULL if it could not be transferred
+*/
+void *talloc_steal(const void *new_ctx, const void *ptr)
+{
+	struct talloc_chunk *tc, *new_tc;
+
+	if (!ptr) {
+		return NULL;
+	}
+
+	if (new_ctx == NULL) {
+		new_ctx = null_context;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	if (new_ctx == NULL) {
+		if (tc->parent) {
+			_TLIST_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;
+		}
+		
+		tc->parent = tc->next = tc->prev = NULL;
+		return discard_const_p(void, ptr);
+	}
+
+	new_tc = talloc_chunk_from_ptr(new_ctx);
+
+	if (tc == new_tc) {
+		return discard_const_p(void, ptr);
+	}
+
+	if (tc->parent) {
+		_TLIST_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;
+	}
+
+	tc->parent = new_tc;
+	if (new_tc->child) new_tc->child->parent = NULL;
+	_TLIST_ADD(new_tc->child, tc);
+
+	return discard_const_p(void, ptr);
+}
+
+/*
+  return the total size of a talloc pool (subtree)
+*/
+off_t talloc_total_size(const void *ptr)
+{
+	off_t total = 0;
+	struct talloc_chunk *c, *tc;
+	
+	if (ptr == NULL) {
+		ptr = null_context;
+	}
+	if (ptr == NULL) {
+		return 0;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	total = tc->size;
+	for (c=tc->child;c;c=c->next) {
+		total += talloc_total_size(c+1);
+	}
+	return total;
+}
+
+/*
+  return the total number of blocks in a talloc pool (subtree)
+*/
+off_t talloc_total_blocks(const void *ptr)
+{
+	off_t total = 0;
+	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
+
+	total++;
+	for (c=tc->child;c;c=c->next) {
+		total += talloc_total_blocks(c+1);
+	}
+	return total;
+}
+
+/*
+  return the number of external references to a pointer
+*/
+static int talloc_reference_count(const void *ptr)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	struct talloc_reference_handle *h;
+	int ret = 0;
+
+	for (h=tc->refs;h;h=h->next) {
+		ret++;
+	}
+	return ret;
+}
+
+/*
+  report on memory usage by all children of a pointer, giving a full tree view
+*/
+static void talloc_report_depth(const void *ptr, FILE *f, int depth)
+{
+	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
+
+	for (c=tc->child;c;c=c->next) {
+		if (c->name == TALLOC_MAGIC_REFERENCE) {
+			struct talloc_reference_handle *handle = (void *)(c+1);
+			const char *name2 = talloc_get_name(handle->ptr);
+			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
+		} else {
+			const char *name = talloc_get_name(c+1);
+			fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
+				depth*4, "",
+				name,
+				(unsigned long)talloc_total_size(c+1),
+				(unsigned long)talloc_total_blocks(c+1),
+				talloc_reference_count(c+1));
+			talloc_report_depth(c+1, f, depth+1);
+		}
+	}
+
+}
+
+/*
+  report on memory usage by all children of a pointer, giving a full tree view
+*/
+void talloc_report_full(const void *ptr, FILE *f)
+{
+	if (ptr == NULL) {
+		ptr = null_context;
+	}
+	if (ptr == NULL) return;
+
+	fprintf(f,"full talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
+		talloc_get_name(ptr), 
+		(unsigned long)talloc_total_size(ptr),
+		(unsigned long)talloc_total_blocks(ptr));
+
+	talloc_report_depth(ptr, f, 1);
+}
+
+/*
+  report on memory usage by all children of a pointer
+*/
+void talloc_report(const void *ptr, FILE *f)
+{
+	struct talloc_chunk *c, *tc;
+
+	if (ptr == NULL) {
+		ptr = null_context;
+	}
+	if (ptr == NULL) return;
+       
+	fprintf(f,"talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
+		talloc_get_name(ptr), 
+		(unsigned long)talloc_total_size(ptr),
+		(unsigned long)talloc_total_blocks(ptr));
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	for (c=tc->child;c;c=c->next) {
+		fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
+			talloc_get_name(c+1),
+			(unsigned long)talloc_total_size(c+1),
+			(unsigned long)talloc_total_blocks(c+1));
+	}
+
+}
+
+/*
+  report on any memory hanging off the null context
+*/
+static void talloc_report_null(void)
+{
+	if (talloc_total_size(null_context) != 0) {
+		talloc_report(null_context, stderr);
+	}
+}
+
+/*
+  report on any memory hanging off the null context
+*/
+static void talloc_report_null_full(void)
+{
+	if (talloc_total_size(null_context) != 0) {
+		talloc_report_full(null_context, stderr);
+	}
+}
+
+/*
+  enable leak reporting on exit
+*/
+void talloc_enable_leak_report(void)
+{
+	null_context = talloc_named_const(NULL, 0, "null_context");
+	atexit(talloc_report_null);
+}
+
+/*
+  enable full leak reporting on exit
+*/
+void talloc_enable_leak_report_full(void)
+{
+	null_context = talloc_named_const(NULL, 0, "null_context");
+	atexit(talloc_report_null_full);
+}
+
+/* 
+   talloc and zero memory. 
+*/
+void *_talloc_zero(const void *ctx, size_t size, const char *name)
+{
+	void *p = talloc_named_const(ctx, size, name);
+
+	if (p) {
+		memset(p, '\0', size);
+	}
+
+	return p;
+}
+
+
+/*
+  memdup with a talloc. 
+*/
+void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
+{
+	void *newp = talloc_named_const(t, size, name);
+
+	if (newp) {
+		memcpy(newp, p, size);
+	}
+
+	return newp;
+}
+
+/*
+  strdup with a talloc 
+*/
+char *talloc_strdup(const void *t, const char *p)
+{
+	char *ret;
+	if (!p) {
+		return NULL;
+	}
+	ret = talloc_memdup(t, p, strlen(p) + 1);
+	if (ret) {
+		talloc_set_name_const(ret, ret);
+	}
+	return ret;
+}
+
+/*
+  strndup with a talloc 
+*/
+char *talloc_strndup(const void *t, const char *p, size_t n)
+{
+	size_t len;
+	char *ret;
+
+	for (len=0; p[len] && len<n; len++) ;
+
+	ret = talloc(t, len + 1);
+	if (!ret) { return NULL; }
+	memcpy(ret, p, len);
+	ret[len] = 0;
+	talloc_set_name_const(ret, ret);
+	return ret;
+}
+
+#ifndef VA_COPY
+#ifdef HAVE_VA_COPY
+#define VA_COPY(dest, src) __va_copy(dest, src)
+#else
+#define VA_COPY(dest, src) (dest) = (src)
+#endif
+#endif
+
+char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
+{	
+	int len;
+	char *ret;
+	va_list ap2;
+	
+	VA_COPY(ap2, ap);
+
+	len = vsnprintf(NULL, 0, fmt, ap2);
+
+	ret = talloc(t, len+1);
+	if (ret) {
+		VA_COPY(ap2, ap);
+		vsnprintf(ret, len+1, fmt, ap2);
+		talloc_set_name_const(ret, ret);
+	}
+
+	return ret;
+}
+
+
+/*
+  Perform string formatting, and return a pointer to newly allocated
+  memory holding the result, inside a memory pool.
+ */
+char *talloc_asprintf(const void *t, const char *fmt, ...)
+{
+	va_list ap;
+	char *ret;
+
+	va_start(ap, fmt);
+	ret = talloc_vasprintf(t, fmt, ap);
+	va_end(ap);
+	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.
+ **/
+
+static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+
+static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+{	
+	int len, s_len;
+	va_list ap2;
+
+	VA_COPY(ap2, ap);
+
+	if (s) {
+		s_len = strlen(s);
+	} else {
+		s_len = 0;
+	}
+	len = vsnprintf(NULL, 0, fmt, ap2);
+
+	s = talloc_realloc(NULL, s, s_len + len+1);
+	if (!s) return NULL;
+
+	VA_COPY(ap2, ap);
+
+	vsnprintf(s+s_len, len+1, fmt, ap2);
+	talloc_set_name_const(s, s);
+
+	return s;
+}
+
+/*
+  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, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	s = talloc_vasprintf_append(s, fmt, ap);
+	va_end(ap);
+	return s;
+}
+
+/*
+  alloc an array, checking for integer overflow in the array size
+*/
+void *talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
+	if (count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+	return talloc_named_const(ctx, el_size * count, name);
+}
+
+/*
+  alloc an zero array, checking for integer overflow in the array size
+*/
+void *talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
+	if (count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+	return _talloc_zero(ctx, el_size * count, name);
+}
+
+
+/*
+  realloc an array, checking for integer overflow in the array size
+*/
+void *talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
+{
+	if (count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+	ptr = talloc_realloc(ctx, ptr, el_size * count);
+	if (ptr) {
+		talloc_set_name_const(ptr, name);
+	}
+	return ptr;
+}
+
+/*
+  a function version of talloc_realloc(), so it can be passed as a function pointer
+  to libraries that want a realloc function (a realloc function encapsulates
+  all the basic capabilities of an allocation library, which is why this is useful)
+*/
+void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
+{
+	return _talloc_realloc(context, ptr, size, NULL);
+}
-- 
cgit 


From f4b349127bdfe233476fe2efba961912f39a5cbd Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 2 Jan 2005 12:55:33 +0000
Subject: r4479: added the function talloc_autofree_context() which returns a
 talloc context that will automatically be freed on program exit. This is
 useful for reducing clutter in leak reports (This used to be commit
 cf73dda652e0a121901f22771104be6751c0fcb9)

---
 source4/lib/talloc/talloc.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 4666e28288..9e8868191f 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -67,6 +67,7 @@
    NULL
 */
 static const void *null_context;
+static void *cleanup_context;
 
 
 struct talloc_reference_handle {
@@ -1004,3 +1005,23 @@ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
 {
 	return _talloc_realloc(context, ptr, size, NULL);
 }
+
+
+static void talloc_autofree(void)
+{
+	talloc_free(cleanup_context);
+	cleanup_context = NULL;
+}
+
+/*
+  return a context which will be auto-freed on exit
+  this is useful for reducing the noise in leak reports
+*/
+void *talloc_autofree_context(void)
+{
+	if (cleanup_context == NULL) {
+		cleanup_context = talloc_named_const(NULL, 0, "autofree_context");
+		atexit(talloc_autofree);
+	}
+	return cleanup_context;
+}
-- 
cgit 


From e159e42d8472f36f51e400e351fc43f2a7dc44f5 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 Jan 2005 03:20:56 +0000
Subject: r4550: talloc() is now typesafe. It is exactly equivalent to the old
 talloc_p() macro. Use talloc_size() if you want the old behaviour.

I have kept talloc_p() as an alias for now. Once we change all calls
to be plain talloc() then we can remove it.
(This used to be commit 2011bbeb841fd6bfccf3d44a49f79203f7f55baa)
---
 source4/lib/talloc/talloc.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 9e8868191f..bcadf40cfb 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -857,7 +857,7 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 
 	for (len=0; p[len] && len<n; len++) ;
 
-	ret = talloc(t, len + 1);
+	ret = _talloc(t, len + 1);
 	if (!ret) { return NULL; }
 	memcpy(ret, p, len);
 	ret[len] = 0;
@@ -883,7 +883,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 
 	len = vsnprintf(NULL, 0, fmt, ap2);
 
-	ret = talloc(t, len+1);
+	ret = _talloc(t, len+1);
 	if (ret) {
 		VA_COPY(ap2, ap);
 		vsnprintf(ret, len+1, fmt, ap2);
-- 
cgit 


From 11ce2cfd70df264c5c91b4daaa9a01c5abc673b0 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 7 Jan 2005 04:39:16 +0000
Subject: r4591: - converted the other _p talloc functions to not need _p

- added #if TALLOC_DEPRECATED around the _p functions

- fixes the code that broke from the above

while doing this I fixed quite a number of places that were
incorrectly using the non type-safe talloc functions to use the type
safe ones. Some were even doing multiplies for array allocation, which
is potentially unsafe.
(This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
---
 source4/lib/talloc/talloc.c | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index bcadf40cfb..6d11cb00e9 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -932,7 +932,7 @@ static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	}
 	len = vsnprintf(NULL, 0, fmt, ap2);
 
-	s = talloc_realloc(NULL, s, s_len + len+1);
+	s = talloc_realloc(NULL, s, char, s_len + len+1);
 	if (!s) return NULL;
 
 	VA_COPY(ap2, ap);
@@ -961,7 +961,7 @@ char *talloc_asprintf_append(char *s, const char *fmt, ...)
 /*
   alloc an array, checking for integer overflow in the array size
 */
-void *talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
@@ -972,7 +972,7 @@ void *talloc_array(const void *ctx, size_t el_size, unsigned count, const char *
 /*
   alloc an zero array, checking for integer overflow in the array size
 */
-void *talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
@@ -984,16 +984,12 @@ void *talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const c
 /*
   realloc an array, checking for integer overflow in the array size
 */
-void *talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
+void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
 	}
-	ptr = talloc_realloc(ctx, ptr, el_size * count);
-	if (ptr) {
-		talloc_set_name_const(ptr, name);
-	}
-	return ptr;
+	return _talloc_realloc(ctx, ptr, el_size * count, name);
 }
 
 /*
-- 
cgit 


From 90d65c2e85c8042391b8219eeaedd780e6eb3c7c Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 11 Jan 2005 15:38:25 +0000
Subject: r4689: - make talloc_report_depth() public

- add talloc_parent() to return the parent context of a pointer

these are very use full for debuging

metze
(This used to be commit 9b9501bc03ef8d4b53049f6b3531d06ed7ef7f89)
---
 source4/lib/talloc/talloc.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6d11cb00e9..4c8cc31028 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -140,6 +140,12 @@ static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 	return tc->parent;
 }
 
+void *talloc_parent(const void *ptr)
+{
+	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
+	return (void *)(tc+1);
+}
+
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
@@ -695,7 +701,7 @@ static int talloc_reference_count(const void *ptr)
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-static void talloc_report_depth(const void *ptr, FILE *f, int depth)
+void talloc_report_depth(const void *ptr, FILE *f, int depth)
 {
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
-- 
cgit 


From c710c0671fad507b07cbc2094244fe6f2f909955 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Jan 2005 22:30:54 +0000
Subject: r4718: don't use the deprecated __va_copy() unless va_copy() is
 unavailable (This used to be commit 603ef69be075821e3ffe2084bb5cfb0bc9cce180)

---
 source4/lib/talloc/talloc.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 4c8cc31028..e05b196592 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -873,6 +873,8 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 
 #ifndef VA_COPY
 #ifdef HAVE_VA_COPY
+#define VA_COPY(dest, src) va_copy(dest, src)
+#elif defined(HAVE___VA_COPY)
 #define VA_COPY(dest, src) __va_copy(dest, src)
 #else
 #define VA_COPY(dest, src) (dest) = (src)
-- 
cgit 


From 7b79694eadc288592729567c3caa7c70f6662760 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 16 Jan 2005 23:21:52 +0000
Subject: r4790: added type checking helper macros in talloc. These take
 advantage of the type names that talloc already keeps around for pointers,
 and allows the user to type check void* private pointers. It can also be used
 to implement polymorphism in C, as I'm sure someone would have pointed out to
 me sooner or later :-) (This used to be commit
 c283e1a3efac3a92e29a35856e20eb61ef4c221e)

---
 source4/lib/talloc/talloc.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index e05b196592..f6f7e899d1 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -424,6 +424,23 @@ const char *talloc_get_name(const void *ptr)
 	return "UNNAMED";
 }
 
+
+/*
+  check if a pointer has the given name. If it does, return the pointer,
+  otherwise return NULL
+*/
+void *talloc_check_name(const void *ptr, const char *name)
+{
+	const char *pname;
+	if (ptr == NULL) return NULL;
+	pname = talloc_get_name(ptr);
+	if (pname == name || strcmp(pname, name) == 0) {
+		return discard_const_p(void, ptr);
+	}
+	return NULL;
+}
+
+
 /*
   this is for compatibility with older versions of talloc
 */
@@ -1029,3 +1046,5 @@ void *talloc_autofree_context(void)
 	}
 	return cleanup_context;
 }
+
+
-- 
cgit 


From 784dde73bc2f59108c6f5123b9206851b97afc32 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 31 Jan 2005 04:51:50 +0000
Subject: r5119: fflush after talloc reports to ensure they are fully on disk
 when using tee (This used to be commit
 e73e49aaa64f6f976918f087cf196b00eecc3eb2)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index f6f7e899d1..291ee5a8bf 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -757,6 +757,7 @@ void talloc_report_full(const void *ptr, FILE *f)
 		(unsigned long)talloc_total_blocks(ptr));
 
 	talloc_report_depth(ptr, f, 1);
+	fflush(f);
 }
 
 /*
@@ -784,7 +785,7 @@ void talloc_report(const void *ptr, FILE *f)
 			(unsigned long)talloc_total_size(c+1),
 			(unsigned long)talloc_total_blocks(c+1));
 	}
-
+	fflush(f);
 }
 
 /*
-- 
cgit 


From 340d35be2d3f29a3176d86c0960398c2e36f921f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 22 Mar 2005 04:22:39 +0000
Subject: r5937: - performance improvement to talloc_asprintf_append()

- allow standalone talloc to use gcc printf attributes
(This used to be commit e25aa54e962796e6e7385afed57aa287ef6f869d)
---
 source4/lib/talloc/talloc.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 291ee5a8bf..72765448c7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -946,16 +946,13 @@ static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINT
 
 static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 {	
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(s);
 	int len, s_len;
 	va_list ap2;
 
 	VA_COPY(ap2, ap);
 
-	if (s) {
-		s_len = strlen(s);
-	} else {
-		s_len = 0;
-	}
+	s_len = tc->size - 1;
 	len = vsnprintf(NULL, 0, fmt, ap2);
 
 	s = talloc_realloc(NULL, s, char, s_len + len+1);
-- 
cgit 


From 689a803ac7600c1d8bff5e33cce1c098a332c02a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 22 Mar 2005 05:51:41 +0000
Subject: r5938: - allow NULL string argument to talloc_vasprintf_append()

- default to using va_copy(), thus assuming a modern libc
(This used to be commit 3060b26c9e745330682f6209d97e723113b65b56)
---
 source4/lib/talloc/talloc.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 72765448c7..31796a247b 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -36,6 +36,8 @@
 #include <stdarg.h>
 #include <stdint.h>
 #include "talloc.h"
+/* assume a modern system */
+#define HAVE_VA_COPY
 #endif
 
 /* use this to force every realloc to change the pointer, to stress test
@@ -946,10 +948,16 @@ static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINT
 
 static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 {	
-	struct talloc_chunk *tc = talloc_chunk_from_ptr(s);
+	struct talloc_chunk *tc;
 	int len, s_len;
 	va_list ap2;
 
+	if (s == NULL) {
+		return talloc_vasprintf(NULL, fmt, ap);
+	}
+
+	tc = talloc_chunk_from_ptr(s);
+
 	VA_COPY(ap2, ap);
 
 	s_len = tc->size - 1;
-- 
cgit 


From ae1ea5619b18be9c37f9647756e06718b17b88f2 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 24 Mar 2005 08:00:15 +0000
Subject: r6033: Patch from 'lifeless' to clarify behaviour with NULL pointers.

Andrew Bartlett
(This used to be commit 48c518796797f021c9c7f319ca8cd0a0c185f64c)
---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 31796a247b..0d78dd8d24 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -609,7 +609,8 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
 /* 
    move a lump of memory from one talloc context to another return the
-   ptr on success, or NULL if it could not be transferred
+   ptr on success, or NULL if it could not be transferred.
+   passing NULL as ptr will always return NULL with no side effects.
 */
 void *talloc_steal(const void *new_ctx, const void *ptr)
 {
-- 
cgit 


From 0d36266cd4e0034ca5ed2755084a64db3e235ac4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 26 Mar 2005 10:47:44 +0000
Subject: r6075: added talloc_enable_null_tracking() (asked for by lifeless)
 (This used to be commit 40b8ee186af3e7f771c680dbbb03fdcf559bf103)

---
 source4/lib/talloc/talloc.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 0d78dd8d24..661282a87d 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -811,12 +811,22 @@ static void talloc_report_null_full(void)
 	}
 }
 
+/*
+  enable tracking of the NULL context
+*/
+void talloc_enable_null_tracking(void)
+{
+	if (null_context == NULL) {
+		null_context = talloc_named_const(NULL, 0, "null_context");
+	}
+}
+
 /*
   enable leak reporting on exit
 */
 void talloc_enable_leak_report(void)
 {
-	null_context = talloc_named_const(NULL, 0, "null_context");
+	talloc_enable_null_tracking();
 	atexit(talloc_report_null);
 }
 
@@ -825,7 +835,7 @@ void talloc_enable_leak_report(void)
 */
 void talloc_enable_leak_report_full(void)
 {
-	null_context = talloc_named_const(NULL, 0, "null_context");
+	talloc_enable_null_tracking();
 	atexit(talloc_report_null_full);
 }
 
-- 
cgit 


From a53548d0741421b57b450d3ef62d3ac42c233030 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Thu, 28 Apr 2005 14:54:17 +0000
Subject: r6513: Commit talloc_free_children.

Volker
(This used to be commit 9fa26d2c971a7baee64d8938e31909cac80f0e5a)
---
 source4/lib/talloc/talloc.c | 57 +++++++++++++++++++++++++++++----------------
 1 file changed, 37 insertions(+), 20 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 661282a87d..da3a2300b0 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -461,6 +461,42 @@ void *talloc_init(const char *fmt, ...)
 	return ptr;
 }
 
+/*
+  this is a replacement for the Samba3 talloc_destroy_pool functionality. It
+  should probably not be used in new code. It's in here to keep the talloc
+  code consistent across Samba 3 and 4.
+*/
+void talloc_free_children(void *ptr)
+{
+	struct talloc_chunk *tc;
+
+	if (ptr == NULL) {
+		return;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	while (tc->child) {
+		/* we need to work out who will own an abandoned child
+		   if it cannot be freed. In priority order, the first
+		   choice is owner of any remaining reference to this
+		   pointer, the second choice is our parent, and the
+		   final choice is the null context. */
+		void *child = tc->child+1;
+		const void *new_parent = null_context;
+		if (tc->child->refs) {
+			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
+			if (p) new_parent = p+1;
+		}
+		if (talloc_free(child) == -1) {
+			if (new_parent == null_context) {
+				struct talloc_chunk *p = talloc_parent_chunk(ptr);
+				if (p) new_parent = p+1;
+			}
+			talloc_steal(new_parent, child);
+		}
+	}
+}
 
 /* 
    free a talloc pointer. This also frees all child pointers of this 
@@ -498,26 +534,7 @@ int talloc_free(void *ptr)
 		tc->destructor = NULL;
 	}
 
-	while (tc->child) {
-		/* we need to work out who will own an abandoned child
-		   if it cannot be freed. In priority order, the first
-		   choice is owner of any remaining reference to this
-		   pointer, the second choice is our parent, and the
-		   final choice is the null context. */
-		void *child = tc->child+1;
-		const void *new_parent = null_context;
-		if (tc->child->refs) {
-			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
-			if (p) new_parent = p+1;
-		}
-		if (talloc_free(child) == -1) {
-			if (new_parent == null_context) {
-				struct talloc_chunk *p = talloc_parent_chunk(ptr);
-				if (p) new_parent = p+1;
-			}
-			talloc_steal(new_parent, child);
-		}
-	}
+	talloc_free_children(ptr);
 
 	if (tc->parent) {
 		_TLIST_REMOVE(tc->parent->child, tc);
-- 
cgit 


From 157a32956a111b8cffcfa8d1c62a0ca67cdc0b22 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 7 May 2005 15:22:45 +0000
Subject: r6645: Add talloc_get_size() function. Sometimes it is usefull to
 know this data.

Simo.
(This used to be commit df401847827ef660d8b9d55af9b27bb85bad6b5f)
---
 source4/lib/talloc/talloc.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index da3a2300b0..248af6ea3e 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1082,3 +1082,13 @@ void *talloc_autofree_context(void)
 }
 
 
+size_t talloc_get_size(const void *context) {
+	struct talloc_chunk *tc;
+
+	if (context == NULL)
+		return 0;
+
+	tc = talloc_chunk_from_ptr(context);
+
+	return tc->size;
+}
-- 
cgit 


From 13bb5c34863c85f7d0cec13d7649ade242acbd52 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 7 May 2005 16:27:56 +0000
Subject: r6650: keep style consistent (This used to be commit
 34671674ee326ea835408f8c1fdb105ea50ccc55)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 248af6ea3e..cb5e91341e 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1082,7 +1082,8 @@ void *talloc_autofree_context(void)
 }
 
 
-size_t talloc_get_size(const void *context) {
+size_t talloc_get_size(const void *context)
+{
 	struct talloc_chunk *tc;
 
 	if (context == NULL)
-- 
cgit 


From c1d31ac8fc22a46d3ce7d99058e48058464f4e06 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sat, 7 May 2005 22:10:26 +0000
Subject: r6660: Sorry for the spam... I think now I've got a version that
 should compile on trunk, 3_0 and 4_0.

Volker
(This used to be commit 777c489cad610fef140ec80d5644111b04a314c1)
---
 source4/lib/talloc/talloc.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index cb5e91341e..3650ab7f51 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -29,6 +29,16 @@
 
 #ifdef _SAMBA_BUILD_
 #include "includes.h"
+#if ((SAMBA_VERSION_MAJOR==3)&&(SAMBA_VERSION_MINOR<9))
+/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
+ * we trust ourselves... */
+#ifdef malloc
+#undef malloc
+#endif
+#ifdef realloc
+#undef realloc
+#endif
+#endif
 #else
 #include <stdio.h>
 #include <stdlib.h>
@@ -1081,7 +1091,6 @@ void *talloc_autofree_context(void)
 	return cleanup_context;
 }
 
-
 size_t talloc_get_size(const void *context)
 {
 	struct talloc_chunk *tc;
-- 
cgit 


From 9add53863f4bfd870e8af102057a1084e9849d20 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 12 May 2005 02:54:42 +0000
Subject: r6741: prevent talloc_strndup() from reading one byte past the end of
 a buffer, giving valgrind errors (This used to be commit
 7af0c547e0c0da3bc78a1ee6c2ab29114d8625cc)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 3650ab7f51..46abd89bac 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -919,7 +919,7 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 	size_t len;
 	char *ret;
 
-	for (len=0; p[len] && len<n; len++) ;
+	for (len=0; len<n && p[len]; len++) ;
 
 	ret = _talloc(t, len + 1);
 	if (!ret) { return NULL; }
-- 
cgit 


From 1f474c2692af8ba704a4071fe6e496cb43e19bae Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 16 May 2005 01:57:27 +0000
Subject: r6804: Add config.h for talloc (and use it) (This used to be commit
 c2ce09d38003fd43212de9cd08e4a781cc2aff88)

---
 source4/lib/talloc/talloc.c | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 46abd89bac..ca2fd9a288 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -28,7 +28,6 @@
 
 
 #ifdef _SAMBA_BUILD_
-#include "includes.h"
 #if ((SAMBA_VERSION_MAJOR==3)&&(SAMBA_VERSION_MINOR<9))
 /* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
  * we trust ourselves... */
@@ -39,17 +38,26 @@
 #undef realloc
 #endif
 #endif
-#else
+#endif
+
+#include "config.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#ifdef HAVE_STDARG_H
 #include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
-#include "talloc.h"
-/* assume a modern system */
-#define HAVE_VA_COPY
 #endif
 
+#include "talloc.h"
+
 /* use this to force every realloc to change the pointer, to stress test
    code that might not cope */
 #define ALWAYS_REALLOC 0
-- 
cgit 


From 9e044848e394e4395f88b77361e7be06833e3bb8 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 May 2005 02:45:36 +0000
Subject: r6808: - test for gcov not needed

- samba malloc wrapper avoidance not needed now we don't use includes.h

- make testsuite work when BOOL, True, False already defined
(This used to be commit c8a274c8735957a8a8dd21421abd65a8a1af20f7)
---
 source4/lib/talloc/talloc.c | 13 -------------
 1 file changed, 13 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ca2fd9a288..01d1b9f255 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -27,19 +27,6 @@
 */
 
 
-#ifdef _SAMBA_BUILD_
-#if ((SAMBA_VERSION_MAJOR==3)&&(SAMBA_VERSION_MINOR<9))
-/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
- * we trust ourselves... */
-#ifdef malloc
-#undef malloc
-#endif
-#ifdef realloc
-#undef realloc
-#endif
-#endif
-#endif
-
 #include "config.h"
 
 #include <stdio.h>
-- 
cgit 


From 3fd2a38e62a9c7c444d7dd9f56673fa216a00fdd Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 May 2005 06:33:37 +0000
Subject: r6812: more talloc portability tweaks (This used to be commit
 450ac2e4dea25910ee5384747bdb6ad7323e967d)

---
 source4/lib/talloc/talloc.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 01d1b9f255..d3fa961c74 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -32,6 +32,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #ifdef HAVE_STDARG_H
 #include <stdarg.h>
-- 
cgit 


From a0e786c4464a0b25574093295751afd906034c6b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 16 May 2005 21:08:44 +0000
Subject: r6828: More portability fixes (This used to be commit
 f46c532883e18b8780ff73d3ac0899690eeab3f4)

---
 source4/lib/talloc/talloc.c | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d3fa961c74..8a29c8c014 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -27,12 +27,21 @@
 */
 
 
+#ifdef HAVE_CONFIG_H
 #include "config.h"
+#endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
+#endif
 
 #ifdef HAVE_STDARG_H
 #include <stdarg.h>
-- 
cgit 


From 2cb07b0f1bab01a406d8d75d19d1039ce5ed3105 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 May 2005 21:42:11 +0000
Subject: r6831: talloc now requires config.h (this fixes ldb build) (This used
 to be commit aac86583a9bff7d882ed56633126a1d9f27eea6a)

---
 source4/lib/talloc/talloc.c | 2 --
 1 file changed, 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 8a29c8c014..e0f4cf9aff 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -27,9 +27,7 @@
 */
 
 
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <stdio.h>
 #include <stdlib.h>
-- 
cgit 


From 57bbd16b4172ce53cc631cb4d66918f9a9e8f6ba Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 17 May 2005 05:48:30 +0000
Subject: r6845: make the talloc header align to 40 bytes, which costs us an
 extra 4 bytes per allocation, but makes it much more portable (This used to
 be commit 257027a571da254c16b0b456cb1cbec284d7fda0)

---
 source4/lib/talloc/talloc.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index e0f4cf9aff..6b6eb87f21 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -97,17 +97,20 @@ struct talloc_chunk {
 	struct talloc_chunk *parent, *child;
 	struct talloc_reference_handle *refs;
 	size_t size;
-	unsigned magic;
 	talloc_destructor_t destructor;
 	const char *name;
+	union {
+		unsigned magic;
+		double align_dummy;
+	} u;
 };
 
 /* panic if we get a bad magic value */
 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
 	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
-	if (tc->magic != TALLOC_MAGIC) { 
-		if (tc->magic == TALLOC_MAGIC_FREE) {
+	if (tc->u.magic != TALLOC_MAGIC) { 
+		if (tc->u.magic == TALLOC_MAGIC_FREE) {
 			TALLOC_ABORT("Bad talloc magic value - double free"); 
 		} else {
 			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
@@ -180,7 +183,7 @@ void *_talloc(const void *context, size_t size)
 	if (tc == NULL) return NULL;
 
 	tc->size = size;
-	tc->magic = TALLOC_MAGIC;
+	tc->u.magic = TALLOC_MAGIC;
 	tc->destructor = NULL;
 	tc->child = NULL;
 	tc->name = NULL;
@@ -559,7 +562,7 @@ int talloc_free(void *ptr)
 		if (tc->next) tc->next->prev = tc->prev;
 	}
 
-	tc->magic = TALLOC_MAGIC_FREE;
+	tc->u.magic = TALLOC_MAGIC_FREE;
 
 	free(tc);
 	return 0;
@@ -599,7 +602,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	/* by resetting magic we catch users of the old memory */
-	tc->magic = TALLOC_MAGIC_FREE;
+	tc->u.magic = TALLOC_MAGIC_FREE;
 
 #if ALWAYS_REALLOC
 	new_ptr = malloc(size + sizeof(*tc));
@@ -611,12 +614,12 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	new_ptr = realloc(tc, size + sizeof(*tc));
 #endif
 	if (!new_ptr) {	
-		tc->magic = TALLOC_MAGIC; 
+		tc->u.magic = TALLOC_MAGIC; 
 		return NULL; 
 	}
 
 	tc = new_ptr;
-	tc->magic = TALLOC_MAGIC;
+	tc->u.magic = TALLOC_MAGIC;
 	if (tc->parent) {
 		tc->parent->child = new_ptr;
 	}
-- 
cgit 


From 545203d9154a9ce0f5cc3800796581f62380074b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 20 Jun 2005 05:03:54 +0000
Subject: r7778: added talloc_find_parent_bytype() and
 talloc_find_parent_byname()

These provide a way to find a parent of a ptr that is of a given
type. I will be using this to find the event context in smbd, relying
on the fact that everything is a child of the top level event
context. I did look at the alternatives, and found that passing the
event context to just about every call in smbd was getting way too
complex (we need to get it to anything that can do a ldb operation, as
that can invoke ldap).

So this method avoids a global, and seems to work nicely
(This used to be commit bdb55c7a10a516b75652065e14f5acd09d24ab35)
---
 source4/lib/talloc/talloc.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6b6eb87f21..c6f748ea3b 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1108,3 +1108,27 @@ size_t talloc_get_size(const void *context)
 
 	return tc->size;
 }
+
+/*
+  find a parent of this context that has the given name, if any
+*/
+void *talloc_find_parent_byname(const void *context, const char *name)
+{
+	struct talloc_chunk *tc;
+
+	if (context == NULL) {
+		return NULL;
+	}
+
+	tc = talloc_chunk_from_ptr(context);
+	while (tc->prev) {
+		tc = tc->prev;
+	}
+	while (tc->parent && (!tc->name || strcmp(tc->name, name))) {
+		tc = tc->parent;
+	}
+	if (tc == NULL) {
+		return NULL;
+	}
+	return (void *)(tc+1);
+}
-- 
cgit 


From bb8d0c76b4f2ad61421f33aae6b268f3de98870f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 20 Jun 2005 05:21:11 +0000
Subject: r7780: fixed a bug in talloc_find_parent_byname() (This used to be
 commit ee3fe42fb16821eedd564201d953042190f7826f)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index c6f748ea3b..9dd7ef36c7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1127,7 +1127,7 @@ void *talloc_find_parent_byname(const void *context, const char *name)
 	while (tc->parent && (!tc->name || strcmp(tc->name, name))) {
 		tc = tc->parent;
 	}
-	if (tc == NULL) {
+	if (tc == NULL || tc->name == NULL || strcmp(tc->name, name)) {
 		return NULL;
 	}
 	return (void *)(tc+1);
-- 
cgit 


From a124028b660ba5de566442302a8ee3b925595850 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 20 Jun 2005 06:15:35 +0000
Subject: r7781: finding the parent of a talloc ptr is trickier than it looks
 due to the two-way tree nature of the data structure. I think I've finally
 got it right

also added talloc_show_parents() for debugging
(This used to be commit 5760ed20eed509b0b6e09e78c942dd0f70350fa9)
---
 source4/lib/talloc/talloc.c | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 9dd7ef36c7..08d4cb93a6 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1121,14 +1121,33 @@ void *talloc_find_parent_byname(const void *context, const char *name)
 	}
 
 	tc = talloc_chunk_from_ptr(context);
-	while (tc->prev) {
-		tc = tc->prev;
-	}
-	while (tc->parent && (!tc->name || strcmp(tc->name, name))) {
+	while (tc) {
+		if (tc->name && strcmp(tc->name, name) == 0) {
+			return (void*)(tc+1);
+		}
+		while (tc && tc->prev) tc = tc->prev;
 		tc = tc->parent;
 	}
-	if (tc == NULL || tc->name == NULL || strcmp(tc->name, name)) {
-		return NULL;
+	return NULL;
+}
+
+/*
+  show the parentage of a context
+*/
+void talloc_show_parents(const void *context, FILE *file)
+{
+	struct talloc_chunk *tc;
+
+	if (context == NULL) {
+		fprintf(file, "talloc no parents for NULL\n");
+		return;
+	}
+
+	tc = talloc_chunk_from_ptr(context);
+	fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
+	while (tc) {
+		fprintf(file, "\t'%s'\n", talloc_get_name(tc+1));
+		while (tc && tc->prev) tc = tc->prev;
+		tc = tc->parent;
 	}
-	return (void *)(tc+1);
 }
-- 
cgit 


From 1702f52498168c0437416dec1014cedead634774 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 26 Jun 2005 23:59:22 +0000
Subject: r7936: new ldb_dn_explode and ldb_dn_casefold functions and co (This
 used to be commit 7ccf21ab4eeb9821e457308a239f2103a106fb12)

---
 source4/lib/talloc/talloc.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 08d4cb93a6..3adf741870 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -917,6 +917,28 @@ char *talloc_strdup(const void *t, const char *p)
 	return ret;
 }
 
+/*
+ append to a talloced string 
+*/
+char *talloc_append_string(const void *t, char *orig, const char *append)
+{
+	char *ret;
+	size_t olen = strlen(orig);
+	size_t alenz = strlen(append) + 1;
+
+	if (!append)
+		return orig;
+
+	ret = talloc_realloc(t, orig, char, olen + alenz);
+	if (!ret)
+		return NULL;
+
+	/* append the string with the trailing \0 */
+	memcpy(&ret[olen], append, alenz);
+
+	return ret;
+}
+
 /*
   strndup with a talloc 
 */
-- 
cgit 


From 9cfe2d83f1103f83ace2ead46e31d7368a29f3c0 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 1 Jul 2005 01:25:55 +0000
Subject: r8032: added loop detection into talloc. Robert Collins found a way
 to make a memory loop with talloc_unlink(), so now we detect it and handle it
 (This used to be commit 563058e78b8c74e821fabf6a43fa861c1ad09944)

---
 source4/lib/talloc/talloc.c | 62 +++++++++++++++++++++++++++++++++------------
 1 file changed, 46 insertions(+), 16 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 3adf741870..3a068f4eaa 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -59,8 +59,9 @@
 
 
 #define MAX_TALLOC_SIZE 0x10000000
-#define TALLOC_MAGIC 0xe814ec4f
-#define TALLOC_MAGIC_FREE 0x7faebef3
+#define TALLOC_MAGIC 0xe814ec70
+#define TALLOC_FLAG_FREE 0x01
+#define TALLOC_FLAG_LOOP 0x02
 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
 
 /* by default we abort when given a bad pointer (such as when talloc_free() is called 
@@ -100,7 +101,7 @@ struct talloc_chunk {
 	talloc_destructor_t destructor;
 	const char *name;
 	union {
-		unsigned magic;
+		unsigned flags;
 		double align_dummy;
 	} u;
 };
@@ -109,14 +110,12 @@ struct talloc_chunk {
 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
 	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
-	if (tc->u.magic != TALLOC_MAGIC) { 
-		if (tc->u.magic == TALLOC_MAGIC_FREE) {
-			TALLOC_ABORT("Bad talloc magic value - double free"); 
-		} else {
-			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
-		}
+	if ((tc->u.flags & ~0xF) != TALLOC_MAGIC) { 
+		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
+	}
+	if (tc->u.flags & TALLOC_FLAG_FREE) {
+		TALLOC_ABORT("Bad talloc magic value - double free"); 
 	}
-
 	return tc;
 }
 
@@ -183,7 +182,7 @@ void *_talloc(const void *context, size_t size)
 	if (tc == NULL) return NULL;
 
 	tc->size = size;
-	tc->u.magic = TALLOC_MAGIC;
+	tc->u.flags = TALLOC_MAGIC;
 	tc->destructor = NULL;
 	tc->child = NULL;
 	tc->name = NULL;
@@ -537,6 +536,11 @@ int talloc_free(void *ptr)
 		return -1;
 	}
 
+	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+		/* we have a free loop - stop looping */
+		return 0;
+	}
+
 	if (tc->destructor) {
 		talloc_destructor_t d = tc->destructor;
 		if (d == (talloc_destructor_t)-1) {
@@ -550,6 +554,8 @@ int talloc_free(void *ptr)
 		tc->destructor = NULL;
 	}
 
+	tc->u.flags |= TALLOC_FLAG_LOOP;
+
 	talloc_free_children(ptr);
 
 	if (tc->parent) {
@@ -562,7 +568,7 @@ int talloc_free(void *ptr)
 		if (tc->next) tc->next->prev = tc->prev;
 	}
 
-	tc->u.magic = TALLOC_MAGIC_FREE;
+	tc->u.flags |= TALLOC_FLAG_FREE;
 
 	free(tc);
 	return 0;
@@ -602,7 +608,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	/* by resetting magic we catch users of the old memory */
-	tc->u.magic = TALLOC_MAGIC_FREE;
+	tc->u.flags |= TALLOC_FLAG_FREE;
 
 #if ALWAYS_REALLOC
 	new_ptr = malloc(size + sizeof(*tc));
@@ -614,12 +620,12 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	new_ptr = realloc(tc, size + sizeof(*tc));
 #endif
 	if (!new_ptr) {	
-		tc->u.magic = TALLOC_MAGIC; 
+		tc->u.flags &= ~TALLOC_FLAG_FREE; 
 		return NULL; 
 	}
 
 	tc = new_ptr;
-	tc->u.magic = TALLOC_MAGIC;
+	tc->u.flags &= ~TALLOC_FLAG_FREE; 
 	if (tc->parent) {
 		tc->parent->child = new_ptr;
 	}
@@ -714,10 +720,19 @@ off_t talloc_total_size(const void *ptr)
 
 	tc = talloc_chunk_from_ptr(ptr);
 
+	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+		return 0;
+	}
+
+	tc->u.flags |= TALLOC_FLAG_LOOP;
+
 	total = tc->size;
 	for (c=tc->child;c;c=c->next) {
 		total += talloc_total_size(c+1);
 	}
+
+	tc->u.flags &= ~TALLOC_FLAG_LOOP;
+
 	return total;
 }
 
@@ -729,10 +744,19 @@ off_t talloc_total_blocks(const void *ptr)
 	off_t total = 0;
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
+	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+		return 0;
+	}
+
+	tc->u.flags |= TALLOC_FLAG_LOOP;
+
 	total++;
 	for (c=tc->child;c;c=c->next) {
 		total += talloc_total_blocks(c+1);
 	}
+
+	tc->u.flags &= ~TALLOC_FLAG_LOOP;
+
 	return total;
 }
 
@@ -758,6 +782,12 @@ void talloc_report_depth(const void *ptr, FILE *f, int depth)
 {
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
+	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+		return;
+	}
+
+	tc->u.flags |= TALLOC_FLAG_LOOP;
+
 	for (c=tc->child;c;c=c->next) {
 		if (c->name == TALLOC_MAGIC_REFERENCE) {
 			struct talloc_reference_handle *handle = (void *)(c+1);
@@ -774,7 +804,7 @@ void talloc_report_depth(const void *ptr, FILE *f, int depth)
 			talloc_report_depth(c+1, f, depth+1);
 		}
 	}
-
+	tc->u.flags &= ~TALLOC_FLAG_LOOP;
 }
 
 /*
-- 
cgit 


From b9e8935188c75a007683979b208757e6c5c7aa67 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 4 Jul 2005 07:10:21 +0000
Subject: r8126: - moved to 16 byte alignment for talloc. This is in response
 to a bug   report from robert collins.

- updated talloc guide to reflect the fact that over the last few
  months talloc overhead compared to malloc has dropped, probably due
  to a bunch of small changes. It now costs about 4% more than malloc
  on my box
(This used to be commit 689a9ccf91f9de560a500787d85321abe096b948)
---
 source4/lib/talloc/talloc.c | 103 +++++++++++++++++++++++---------------------
 1 file changed, 53 insertions(+), 50 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 3a068f4eaa..1081302d09 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -97,23 +97,26 @@ struct talloc_chunk {
 	struct talloc_chunk *next, *prev;
 	struct talloc_chunk *parent, *child;
 	struct talloc_reference_handle *refs;
-	size_t size;
 	talloc_destructor_t destructor;
 	const char *name;
-	union {
-		unsigned flags;
-		double align_dummy;
-	} u;
+	size_t size;
+	unsigned flags;
 };
 
+/* 16 byte alignment seems to keep everyone happy */
+#define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
+#define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
+
 /* panic if we get a bad magic value */
 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
-	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
-	if ((tc->u.flags & ~0xF) != TALLOC_MAGIC) { 
+	const char *pp = ptr;
+	pp -= TC_HDR_SIZE;
+	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp);
+	if ((tc->flags & ~0xF) != TALLOC_MAGIC) { 
 		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
 	}
-	if (tc->u.flags & TALLOC_FLAG_FREE) {
+	if (tc->flags & TALLOC_FLAG_FREE) {
 		TALLOC_ABORT("Bad talloc magic value - double free"); 
 	}
 	return tc;
@@ -160,7 +163,7 @@ static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 void *talloc_parent(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
-	return (void *)(tc+1);
+	return TC_PTR_FROM_CHUNK(tc);
 }
 
 /* 
@@ -178,11 +181,11 @@ void *_talloc(const void *context, size_t size)
 		return NULL;
 	}
 
-	tc = malloc(sizeof(*tc)+size);
+	tc = malloc(TC_HDR_SIZE+size);
 	if (tc == NULL) return NULL;
 
 	tc->size = size;
-	tc->u.flags = TALLOC_MAGIC;
+	tc->flags = TALLOC_MAGIC;
 	tc->destructor = NULL;
 	tc->child = NULL;
 	tc->name = NULL;
@@ -202,7 +205,7 @@ void *_talloc(const void *context, size_t size)
 		tc->next = tc->prev = tc->parent = NULL;
 	}
 
-	return (void *)(tc+1);
+	return TC_PTR_FROM_CHUNK(tc);
 }
 
 
@@ -287,7 +290,7 @@ static int talloc_unreference(const void *context, const void *ptr)
 
 	for (h=tc->refs;h;h=h->next) {
 		struct talloc_chunk *p = talloc_parent_chunk(h);
-		if ((p==NULL && context==NULL) || p+1 == context) break;
+		if ((p==NULL && context==NULL) || TC_PTR_FROM_CHUNK(p) == context) break;
 	}
 	if (h == NULL) {
 		return -1;
@@ -338,7 +341,7 @@ int talloc_unlink(const void *context, void *ptr)
 
 	new_p = talloc_parent_chunk(tc_p->refs);
 	if (new_p) {
-		new_parent = new_p+1;
+		new_parent = TC_PTR_FROM_CHUNK(new_p);
 	} else {
 		new_parent = NULL;
 	}
@@ -497,16 +500,16 @@ void talloc_free_children(void *ptr)
 		   choice is owner of any remaining reference to this
 		   pointer, the second choice is our parent, and the
 		   final choice is the null context. */
-		void *child = tc->child+1;
+		void *child = TC_PTR_FROM_CHUNK(tc->child);
 		const void *new_parent = null_context;
 		if (tc->child->refs) {
 			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
-			if (p) new_parent = p+1;
+			if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 		}
 		if (talloc_free(child) == -1) {
 			if (new_parent == null_context) {
 				struct talloc_chunk *p = talloc_parent_chunk(ptr);
-				if (p) new_parent = p+1;
+				if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 			}
 			talloc_steal(new_parent, child);
 		}
@@ -536,7 +539,7 @@ int talloc_free(void *ptr)
 		return -1;
 	}
 
-	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+	if (tc->flags & TALLOC_FLAG_LOOP) {
 		/* we have a free loop - stop looping */
 		return 0;
 	}
@@ -554,7 +557,7 @@ int talloc_free(void *ptr)
 		tc->destructor = NULL;
 	}
 
-	tc->u.flags |= TALLOC_FLAG_LOOP;
+	tc->flags |= TALLOC_FLAG_LOOP;
 
 	talloc_free_children(ptr);
 
@@ -568,7 +571,7 @@ int talloc_free(void *ptr)
 		if (tc->next) tc->next->prev = tc->prev;
 	}
 
-	tc->u.flags |= TALLOC_FLAG_FREE;
+	tc->flags |= TALLOC_FLAG_FREE;
 
 	free(tc);
 	return 0;
@@ -608,24 +611,24 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	/* by resetting magic we catch users of the old memory */
-	tc->u.flags |= TALLOC_FLAG_FREE;
+	tc->flags |= TALLOC_FLAG_FREE;
 
 #if ALWAYS_REALLOC
-	new_ptr = malloc(size + sizeof(*tc));
+	new_ptr = malloc(size + TC_HDR_SIZE);
 	if (new_ptr) {
-		memcpy(new_ptr, tc, tc->size + sizeof(*tc));
+		memcpy(new_ptr, tc, tc->size + TC_HDR_SIZE);
 		free(tc);
 	}
 #else
-	new_ptr = realloc(tc, size + sizeof(*tc));
+	new_ptr = realloc(tc, size + TC_HDR_SIZE);
 #endif
 	if (!new_ptr) {	
-		tc->u.flags &= ~TALLOC_FLAG_FREE; 
+		tc->flags &= ~TALLOC_FLAG_FREE; 
 		return NULL; 
 	}
 
 	tc = new_ptr;
-	tc->u.flags &= ~TALLOC_FLAG_FREE; 
+	tc->flags &= ~TALLOC_FLAG_FREE; 
 	if (tc->parent) {
 		tc->parent->child = new_ptr;
 	}
@@ -641,9 +644,9 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	tc->size = size;
-	talloc_set_name_const(tc+1, name);
+	talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
 
-	return (void *)(tc+1);
+	return TC_PTR_FROM_CHUNK(tc);
 }
 
 /* 
@@ -720,18 +723,18 @@ off_t talloc_total_size(const void *ptr)
 
 	tc = talloc_chunk_from_ptr(ptr);
 
-	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+	if (tc->flags & TALLOC_FLAG_LOOP) {
 		return 0;
 	}
 
-	tc->u.flags |= TALLOC_FLAG_LOOP;
+	tc->flags |= TALLOC_FLAG_LOOP;
 
 	total = tc->size;
 	for (c=tc->child;c;c=c->next) {
-		total += talloc_total_size(c+1);
+		total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
 	}
 
-	tc->u.flags &= ~TALLOC_FLAG_LOOP;
+	tc->flags &= ~TALLOC_FLAG_LOOP;
 
 	return total;
 }
@@ -744,18 +747,18 @@ off_t talloc_total_blocks(const void *ptr)
 	off_t total = 0;
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
-	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+	if (tc->flags & TALLOC_FLAG_LOOP) {
 		return 0;
 	}
 
-	tc->u.flags |= TALLOC_FLAG_LOOP;
+	tc->flags |= TALLOC_FLAG_LOOP;
 
 	total++;
 	for (c=tc->child;c;c=c->next) {
-		total += talloc_total_blocks(c+1);
+		total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
 	}
 
-	tc->u.flags &= ~TALLOC_FLAG_LOOP;
+	tc->flags &= ~TALLOC_FLAG_LOOP;
 
 	return total;
 }
@@ -782,29 +785,29 @@ void talloc_report_depth(const void *ptr, FILE *f, int depth)
 {
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
-	if (tc->u.flags & TALLOC_FLAG_LOOP) {
+	if (tc->flags & TALLOC_FLAG_LOOP) {
 		return;
 	}
 
-	tc->u.flags |= TALLOC_FLAG_LOOP;
+	tc->flags |= TALLOC_FLAG_LOOP;
 
 	for (c=tc->child;c;c=c->next) {
 		if (c->name == TALLOC_MAGIC_REFERENCE) {
-			struct talloc_reference_handle *handle = (void *)(c+1);
+			struct talloc_reference_handle *handle = TC_PTR_FROM_CHUNK(c);
 			const char *name2 = talloc_get_name(handle->ptr);
 			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
 		} else {
-			const char *name = talloc_get_name(c+1);
+			const char *name = talloc_get_name(TC_PTR_FROM_CHUNK(c));
 			fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
 				depth*4, "",
 				name,
-				(unsigned long)talloc_total_size(c+1),
-				(unsigned long)talloc_total_blocks(c+1),
-				talloc_reference_count(c+1));
-			talloc_report_depth(c+1, f, depth+1);
+				(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
+				(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)),
+				talloc_reference_count(TC_PTR_FROM_CHUNK(c)));
+			talloc_report_depth(TC_PTR_FROM_CHUNK(c), f, depth+1);
 		}
 	}
-	tc->u.flags &= ~TALLOC_FLAG_LOOP;
+	tc->flags &= ~TALLOC_FLAG_LOOP;
 }
 
 /*
@@ -847,9 +850,9 @@ void talloc_report(const void *ptr, FILE *f)
 
 	for (c=tc->child;c;c=c->next) {
 		fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
-			talloc_get_name(c+1),
-			(unsigned long)talloc_total_size(c+1),
-			(unsigned long)talloc_total_blocks(c+1));
+			talloc_get_name(TC_PTR_FROM_CHUNK(c)),
+			(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
+			(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)));
 	}
 	fflush(f);
 }
@@ -1175,7 +1178,7 @@ void *talloc_find_parent_byname(const void *context, const char *name)
 	tc = talloc_chunk_from_ptr(context);
 	while (tc) {
 		if (tc->name && strcmp(tc->name, name) == 0) {
-			return (void*)(tc+1);
+			return TC_PTR_FROM_CHUNK(tc);
 		}
 		while (tc && tc->prev) tc = tc->prev;
 		tc = tc->parent;
@@ -1198,7 +1201,7 @@ void talloc_show_parents(const void *context, FILE *file)
 	tc = talloc_chunk_from_ptr(context);
 	fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
 	while (tc) {
-		fprintf(file, "\t'%s'\n", talloc_get_name(tc+1));
+		fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
 		while (tc && tc->prev) tc = tc->prev;
 		tc = tc->parent;
 	}
-- 
cgit 


From ab65303fe8e7123b1567e9159adbfd6bd4697e78 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 4 Jul 2005 07:26:27 +0000
Subject: r8127: fixed code in function error (This used to be commit
 46632e2048f0b87de351cd3f26229cfc4b3384ca)

---
 source4/lib/talloc/talloc.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 1081302d09..6af08a2ac9 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -111,8 +111,7 @@ struct talloc_chunk {
 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
 	const char *pp = ptr;
-	pp -= TC_HDR_SIZE;
-	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp);
+	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
 	if ((tc->flags & ~0xF) != TALLOC_MAGIC) { 
 		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
 	}
-- 
cgit 


From 7838e13e917041fa3786eaa442765ab88b9f0039 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 5 Oct 2005 06:32:00 +0000
Subject: r10726: fix to talloc_parent() from Michael O'Brien (This used to be
 commit f31a2376f3fef1cc2b40b37fb4d94a4b67eec6d4)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6af08a2ac9..d2de2ecde0 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -162,7 +162,7 @@ static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 void *talloc_parent(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
-	return TC_PTR_FROM_CHUNK(tc);
+	return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
 }
 
 /* 
-- 
cgit 


From 51a8581dea6511eef6f3e3dbb438c003e1912276 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 1 Dec 2005 00:23:01 +0000
Subject: r11983: make talloc LGPL. This makes more sense given that ldb
 depends on talloc, and ldb is now LGPL (This used to be commit
 5bdd50fa38b1be28cf7bcddc561c743437e70cae)

---
 source4/lib/talloc/talloc.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d2de2ecde0..8393d9acb7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -7,19 +7,23 @@
 
    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
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
+     ** NOTE! The following LGPL license applies to the talloc
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
    
-   This program is distributed in the hope that it will be useful,
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library 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, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
 /*
-- 
cgit 


From e4b7e8cdf1590d8ed9b1f190cad9ee6734ffe4de Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 31 Dec 2005 04:26:34 +0000
Subject: r12633: expose talloc_vasprintf_append() (This used to be commit
 7a0e7074f6d3d38ce92f2b617549d5dbbaf968ef)

---
 source4/lib/talloc/talloc.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 8393d9acb7..ac2fedebdc 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1045,10 +1045,7 @@ char *talloc_asprintf(const void *t, const char *fmt, ...)
  * and return @p s, which may have moved.  Good for gradually
  * accumulating output into a string buffer.
  **/
-
-static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
-
-static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 {	
 	struct talloc_chunk *tc;
 	int len, s_len;
-- 
cgit 


From f9f55ad5fcda943f6747d6bef72f6d9d00a263c4 Mon Sep 17 00:00:00 2001
From: James Peach <jpeach@samba.org>
Date: Wed, 8 Feb 2006 23:44:17 +0000
Subject: r13397: Propagate the error return from vsnprintf to trap the case
 where we aren't linked against a C99 vsnprintf. (This used to be commit
 23782f899aaa5fe488d86d5e67e91be99ff7a146)

---
 source4/lib/talloc/talloc.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ac2fedebdc..6b3328420d 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1011,7 +1011,9 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	
 	VA_COPY(ap2, ap);
 
-	len = vsnprintf(NULL, 0, fmt, ap2);
+	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
+		return NULL;
+	}
 
 	ret = _talloc(t, len+1);
 	if (ret) {
@@ -1060,7 +1062,15 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	VA_COPY(ap2, ap);
 
 	s_len = tc->size - 1;
-	len = vsnprintf(NULL, 0, fmt, ap2);
+	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
+		/* Either the vsnprintf failed or the format resulted in
+		 * no characters being formatted. In the former case, we
+		 * ought to return NULL, in the latter we ought to return
+		 * the original string. Most current callers of this 
+		 * function expect it to never return NULL.
+		 */
+		return s;
+	}
 
 	s = talloc_realloc(NULL, s, char, s_len + len+1);
 	if (!s) return NULL;
-- 
cgit 


From b56dab83a4537175b998b137e7ea2f2558042593 Mon Sep 17 00:00:00 2001
From: James Peach <jpeach@samba.org>
Date: Thu, 9 Feb 2006 00:49:03 +0000
Subject: r13400: Only return NULL from talloc_asprintf if vsnprintf returns an
 error (ie. zero is not an error). (This used to be commit
 1ab4674196b9df0b2b7b6eb4991358cc2f86c0d9)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6b3328420d..577fa4a182 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1011,7 +1011,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	
 	VA_COPY(ap2, ap);
 
-	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
+	if ((len = vsnprintf(NULL, 0, fmt, ap2)) < 0) {
 		return NULL;
 	}
 
-- 
cgit 


From 640509e6a71556f95c2688a1d62df27da6ff8da1 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Fri, 10 Mar 2006 08:47:59 +0000
Subject: r14131: Fix Coverity bug # 127 (This used to be commit
 4d0aa6f525c4756ca6942439468b484e3ca4b2fa)

---
 source4/lib/talloc/talloc.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 577fa4a182..5bb21ee6e6 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -960,11 +960,13 @@ char *talloc_append_string(const void *t, char *orig, const char *append)
 {
 	char *ret;
 	size_t olen = strlen(orig);
-	size_t alenz = strlen(append) + 1;
+	size_t alenz;
 
 	if (!append)
 		return orig;
 
+	alenz = strlen(append) + 1;
+
 	ret = talloc_realloc(t, orig, char, olen + alenz);
 	if (!ret)
 		return NULL;
-- 
cgit 


From 335d07d8114dbb654601ecb8d6d8ea45f94b5b67 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 13 Mar 2006 04:04:38 +0000
Subject: r14288:  - make the snprintf call in talloc portable to older solaris
 boxes

 - fixed an error found sing the beam analyser
(This used to be commit bc45451ddd6eceb9bf1ca02f84932759d99a1744)
---
 source4/lib/talloc/talloc.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 5bb21ee6e6..99ede462b8 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -293,7 +293,11 @@ static int talloc_unreference(const void *context, const void *ptr)
 
 	for (h=tc->refs;h;h=h->next) {
 		struct talloc_chunk *p = talloc_parent_chunk(h);
-		if ((p==NULL && context==NULL) || TC_PTR_FROM_CHUNK(p) == context) break;
+		if (p == NULL) {
+			if (context == NULL) break;
+		} else if (TC_PTR_FROM_CHUNK(p) == context) {
+			break;
+		}
 	}
 	if (h == NULL) {
 		return -1;
@@ -1010,10 +1014,12 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	int len;
 	char *ret;
 	va_list ap2;
+	char c;
 	
 	VA_COPY(ap2, ap);
 
-	if ((len = vsnprintf(NULL, 0, fmt, ap2)) < 0) {
+	/* this call looks strange, but it makes it work on older solaris boxes */
+	if ((len = vsnprintf(&c, 1, fmt, ap2)) < 0) {
 		return NULL;
 	}
 
-- 
cgit 


From 4a61e4901ebc751fea57880424f9045e3bdf238e Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 8 Apr 2006 16:05:21 +0000
Subject: r14999: Remove more unused autoconf code Simplify va_copy()
 replacement code a bit (This used to be commit
 a5c87360a7f14a90b831ea372277f4f89ee4c5f1)

---
 source4/lib/talloc/talloc.c | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 99ede462b8..8f046a02b8 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -999,13 +999,11 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 	return ret;
 }
 
-#ifndef VA_COPY
-#ifdef HAVE_VA_COPY
-#define VA_COPY(dest, src) va_copy(dest, src)
-#elif defined(HAVE___VA_COPY)
-#define VA_COPY(dest, src) __va_copy(dest, src)
+#ifndef HAVE_VA_COPY
+#ifdef HAVE___VA_COPY
+#define va_copy(dest, src) __va_copy(dest, src)
 #else
-#define VA_COPY(dest, src) (dest) = (src)
+#define va_copy(dest, src) (dest) = (src)
 #endif
 #endif
 
@@ -1016,7 +1014,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	va_list ap2;
 	char c;
 	
-	VA_COPY(ap2, ap);
+	va_copy(ap2, ap);
 
 	/* this call looks strange, but it makes it work on older solaris boxes */
 	if ((len = vsnprintf(&c, 1, fmt, ap2)) < 0) {
@@ -1025,7 +1023,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 
 	ret = _talloc(t, len+1);
 	if (ret) {
-		VA_COPY(ap2, ap);
+		va_copy(ap2, ap);
 		vsnprintf(ret, len+1, fmt, ap2);
 		talloc_set_name_const(ret, ret);
 	}
@@ -1067,7 +1065,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 
 	tc = talloc_chunk_from_ptr(s);
 
-	VA_COPY(ap2, ap);
+	va_copy(ap2, ap);
 
 	s_len = tc->size - 1;
 	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
@@ -1083,7 +1081,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	s = talloc_realloc(NULL, s, char, s_len + len+1);
 	if (!s) return NULL;
 
-	VA_COPY(ap2, ap);
+	va_copy(ap2, ap);
 
 	vsnprintf(s+s_len, len+1, fmt, ap2);
 	talloc_set_name_const(s, s);
-- 
cgit 


From 5da75f5c3631247615efdf73fae2481df6908cb8 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 23 May 2006 03:51:44 +0000
Subject: r15824: fixed a subtle talloc bug to do with memory context loops.
 When you have a structure that references one of its parents, and a parent of
 that parent is freed, then the whole structure should be freed, not just the
 reference.

this was found by the change notify code, as a side effect of fixing
the memory leak yesterday
(This used to be commit 70531dcaeeb9314d410baa0d285df6a265311541)
---
 source4/lib/talloc/talloc.c | 36 ++++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 8f046a02b8..823ae4ffb3 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -542,7 +542,13 @@ int talloc_free(void *ptr)
 	tc = talloc_chunk_from_ptr(ptr);
 
 	if (tc->refs) {
+		int is_child;
+		struct talloc_reference_handle *handle = tc->refs;
+		is_child = talloc_is_parent(handle, handle->ptr);
 		talloc_reference_destructor(tc->refs);
+		if (is_child) {
+			return talloc_free(ptr);
+		}
 		return -1;
 	}
 
@@ -1197,7 +1203,9 @@ void *talloc_find_parent_byname(const void *context, const char *name)
 			return TC_PTR_FROM_CHUNK(tc);
 		}
 		while (tc && tc->prev) tc = tc->prev;
-		tc = tc->parent;
+		if (tc) {
+			tc = tc->parent;
+		}
 	}
 	return NULL;
 }
@@ -1219,6 +1227,30 @@ void talloc_show_parents(const void *context, FILE *file)
 	while (tc) {
 		fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
 		while (tc && tc->prev) tc = tc->prev;
-		tc = tc->parent;
+		if (tc) {
+			tc = tc->parent;
+		}
+	}
+}
+
+/*
+  return 1 if ptr is a parent of context
+*/
+int talloc_is_parent(const void *context, const char *ptr)
+{
+	struct talloc_chunk *tc;
+
+	if (context == NULL) {
+		return 0;
+	}
+
+	tc = talloc_chunk_from_ptr(context);
+	while (tc) {
+		if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
+		while (tc && tc->prev) tc = tc->prev;
+		if (tc) {
+			tc = tc->parent;
+		}
 	}
+	return 0;
 }
-- 
cgit 


From 0db0de619070c171dacdf40022011abad8a73cbc Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 23 May 2006 04:36:28 +0000
Subject: r15828: a talloc steal optimisation spotted by metze (This used to be
 commit e00ff9f35eed28aeecdc779cee06b87c34d82124)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 823ae4ffb3..67478fc9d4 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -698,7 +698,7 @@ void *talloc_steal(const void *new_ctx, const void *ptr)
 
 	new_tc = talloc_chunk_from_ptr(new_ctx);
 
-	if (tc == new_tc) {
+	if (tc == new_tc || tc->parent == new_tc) {
 		return discard_const_p(void, ptr);
 	}
 
-- 
cgit 


From a665cccd2ef81e704e90bb228bbd14c0afb031af Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 24 May 2006 07:31:02 +0000
Subject: r15852: patch from Rusty to make talloc_set_destructor() and
 talloc_steal() type safe. This only works on recent gcc versions. With other
 compilers it reverts to a non-typesafe cast

The patch also ensures that talloc_free() does not change error on
systems where free() can change errno
(This used to be commit babbff5f777642f559747f6d0697bc7c3a5e798d)
---
 source4/lib/talloc/talloc.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 67478fc9d4..b34369cb16 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -30,12 +30,12 @@
   inspired by http://swapped.cc/halloc/
 */
 
-
 #include "config.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
@@ -218,7 +218,7 @@ void *_talloc(const void *context, size_t size)
   if the destructor fails then the free is failed, and the memory can
   be continued to be used
 */
-void talloc_set_destructor(const void *ptr, int (*destructor)(void *))
+void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	tc->destructor = destructor;
@@ -235,10 +235,9 @@ void talloc_increase_ref_count(const void *ptr)
 /*
   helper for talloc_reference()
 */
-static int talloc_reference_destructor(void *ptr)
+static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 {
-	struct talloc_reference_handle *handle = ptr;
-	struct talloc_chunk *tc1 = talloc_chunk_from_ptr(ptr);
+	struct talloc_chunk *tc1 = talloc_chunk_from_ptr(handle);
 	struct talloc_chunk *tc2 = talloc_chunk_from_ptr(handle->ptr);
 	if (tc1->destructor != (talloc_destructor_t)-1) {
 		tc1->destructor = NULL;
@@ -534,6 +533,7 @@ void talloc_free_children(void *ptr)
 int talloc_free(void *ptr)
 {
 	struct talloc_chunk *tc;
+	int old_errno;
 
 	if (ptr == NULL) {
 		return -1;
@@ -586,7 +586,9 @@ int talloc_free(void *ptr)
 
 	tc->flags |= TALLOC_FLAG_FREE;
 
+	old_errno = errno;
 	free(tc);
+	errno = old_errno;
 	return 0;
 }
 
@@ -667,7 +669,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
    ptr on success, or NULL if it could not be transferred.
    passing NULL as ptr will always return NULL with no side effects.
 */
-void *talloc_steal(const void *new_ctx, const void *ptr)
+void *_talloc_steal(const void *new_ctx, const void *ptr)
 {
 	struct talloc_chunk *tc, *new_tc;
 
-- 
cgit 


From d5e3f86ecef324415a056737b94d80510a22118f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 24 May 2006 07:45:19 +0000
Subject: r15856: fixed talloc_asprintf_append() on solaris (This used to be
 commit bba33a976b1954b5e9e557c9323afc92616439a3)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index b34369cb16..d480cc2689 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1066,6 +1066,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	struct talloc_chunk *tc;
 	int len, s_len;
 	va_list ap2;
+	char c;
 
 	if (s == NULL) {
 		return talloc_vasprintf(NULL, fmt, ap);
@@ -1076,7 +1077,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	va_copy(ap2, ap);
 
 	s_len = tc->size - 1;
-	if ((len = vsnprintf(NULL, 0, fmt, ap2)) <= 0) {
+	if ((len = vsnprintf(&c, 1, fmt, ap2)) <= 0) {
 		/* Either the vsnprintf failed or the format resulted in
 		 * no characters being formatted. In the former case, we
 		 * ought to return NULL, in the latter we ought to return
-- 
cgit 


From 816c055123ab2706ec09811e6375e6e8d8c8dd13 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 21 Jun 2006 19:28:24 +0000
Subject: r16446: talloc_set_name() allocates and can fail... pass the error to
 the callers

metze
(This used to be commit 7aa07a1e0b2abd1a6ecd490410685d20c0201094)
---
 source4/lib/talloc/talloc.c | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d480cc2689..ab199678c1 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -364,26 +364,29 @@ int talloc_unlink(const void *context, void *ptr)
 /*
   add a name to an existing pointer - va_list version
 */
-static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
 
-static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
+static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	tc->name = talloc_vasprintf(ptr, fmt, ap);
 	if (tc->name) {
 		talloc_set_name_const(tc->name, ".name");
 	}
+	return tc->name;
 }
 
 /*
   add a name to an existing pointer
 */
-void talloc_set_name(const void *ptr, const char *fmt, ...)
+const char *talloc_set_name(const void *ptr, const char *fmt, ...)
 {
+	const char *name;
 	va_list ap;
 	va_start(ap, fmt);
-	talloc_set_name_v(ptr, fmt, ap);
+	name = talloc_set_name_v(ptr, fmt, ap);
 	va_end(ap);
+	return name;
 }
 
 /*
@@ -405,14 +408,20 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 {
 	va_list ap;
 	void *ptr;
+	const char *name;
 
 	ptr = _talloc(context, size);
 	if (ptr == NULL) return NULL;
 
 	va_start(ap, fmt);
-	talloc_set_name_v(ptr, fmt, ap);
+	name = talloc_set_name_v(ptr, fmt, ap);
 	va_end(ap);
 
+	if (name == NULL) {
+		talloc_free(ptr);
+		return NULL;
+	}
+
 	return ptr;
 }
 
@@ -474,14 +483,20 @@ void *talloc_init(const char *fmt, ...)
 {
 	va_list ap;
 	void *ptr;
+	const char *name;
 
 	ptr = _talloc(NULL, 0);
 	if (ptr == NULL) return NULL;
 
 	va_start(ap, fmt);
-	talloc_set_name_v(ptr, fmt, ap);
+	name = talloc_set_name_v(ptr, fmt, ap);
 	va_end(ap);
 
+	if (name == NULL) {
+		talloc_free(ptr);
+		return NULL;
+	}
+
 	return ptr;
 }
 
-- 
cgit 


From cab68a413b55818c3ed5003832d65f976abce28f Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 15 Jul 2006 13:28:52 +0000
Subject: r17061: - remove the currect talloc chunk from it's parent before
 freeing the children   this fixes an endless loop bug! - reenable the test
 for this

should I merge this to samba3?

metze
(This used to be commit 0559222b62930765519aaab5d33609ece29014d6)
---
 source4/lib/talloc/talloc.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ab199678c1..05bc09a21e 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -585,10 +585,6 @@ int talloc_free(void *ptr)
 		tc->destructor = NULL;
 	}
 
-	tc->flags |= TALLOC_FLAG_LOOP;
-
-	talloc_free_children(ptr);
-
 	if (tc->parent) {
 		_TLIST_REMOVE(tc->parent->child, tc);
 		if (tc->parent->child) {
@@ -599,8 +595,10 @@ int talloc_free(void *ptr)
 		if (tc->next) tc->next->prev = tc->prev;
 	}
 
-	tc->flags |= TALLOC_FLAG_FREE;
+	tc->flags |= TALLOC_FLAG_LOOP;
+	talloc_free_children(ptr);
 
+	tc->flags |= TALLOC_FLAG_FREE;
 	old_errno = errno;
 	free(tc);
 	errno = old_errno;
-- 
cgit 


From 4e4e698f2b59716464d2514bea3e6049170e7272 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 15 Jul 2006 14:09:21 +0000
Subject: r17062: make correct use of talloc destructors, and make the code
 much simpler

should I merge that aslo to samba3?

metze
(This used to be commit c5672a54a02e3f457effd7cc693a6f6ac2dcc621)
---
 source4/lib/talloc/talloc.c | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 05bc09a21e..2ebaafbb83 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -237,13 +237,8 @@ void talloc_increase_ref_count(const void *ptr)
 */
 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 {
-	struct talloc_chunk *tc1 = talloc_chunk_from_ptr(handle);
-	struct talloc_chunk *tc2 = talloc_chunk_from_ptr(handle->ptr);
-	if (tc1->destructor != (talloc_destructor_t)-1) {
-		tc1->destructor = NULL;
-	}
-	_TLIST_REMOVE(tc2->refs, handle);
-	talloc_free(handle);
+	struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
+	_TLIST_REMOVE(ptr_tc->refs, handle);
 	return 0;
 }
 
@@ -302,10 +297,7 @@ static int talloc_unreference(const void *context, const void *ptr)
 		return -1;
 	}
 
-	talloc_set_destructor(h, NULL);
-	_TLIST_REMOVE(tc->refs, h);
-	talloc_free(h);
-	return 0;
+	return talloc_free(h);
 }
 
 /*
@@ -558,9 +550,15 @@ int talloc_free(void *ptr)
 
 	if (tc->refs) {
 		int is_child;
-		struct talloc_reference_handle *handle = tc->refs;
-		is_child = talloc_is_parent(handle, handle->ptr);
-		talloc_reference_destructor(tc->refs);
+		/* check this is a reference from a child or grantchild
+		 * back to it's parent or grantparent
+		 *
+		 * in that case we need to remove the reference and
+		 * call another instance of talloc_free() on the current
+		 * pointer.
+		 */
+		is_child = talloc_is_parent(tc->refs, ptr);
+		talloc_free(tc->refs);
 		if (is_child) {
 			return talloc_free(ptr);
 		}
-- 
cgit 


From 550f5fb26e67f46eead182476f7a9bcfd1ac5dc0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 21 Jul 2006 10:34:10 +0000
Subject: r17176: remove off_t from talloc. size_t is large enough to hold the
 max amount of memory of one process

metze
(This used to be commit f47b7bb656c8854c16c5a28ba24d18eeb22b6e22)
---
 source4/lib/talloc/talloc.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 2ebaafbb83..ca76b05332 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -735,11 +735,11 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
 /*
   return the total size of a talloc pool (subtree)
 */
-off_t talloc_total_size(const void *ptr)
+size_t talloc_total_size(const void *ptr)
 {
-	off_t total = 0;
+	size_t total = 0;
 	struct talloc_chunk *c, *tc;
-	
+
 	if (ptr == NULL) {
 		ptr = null_context;
 	}
@@ -768,9 +768,9 @@ off_t talloc_total_size(const void *ptr)
 /*
   return the total number of blocks in a talloc pool (subtree)
 */
-off_t talloc_total_blocks(const void *ptr)
+size_t talloc_total_blocks(const void *ptr)
 {
-	off_t total = 0;
+	size_t total = 0;
 	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
 
 	if (tc->flags & TALLOC_FLAG_LOOP) {
-- 
cgit 


From da9723c22428254fddaf2a83cf96777c82416950 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 26 Jul 2006 17:34:50 +0000
Subject: r17264: - remove unused includes from talloc - check explicit check
 for varargs.h as fallback from stdarg.h   and fail the build if both are not
 present

metze
(This used to be commit b091d182fe8f36dfb67b7ede933a963b74034d91)
---
 source4/lib/talloc/talloc.c | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ca76b05332..5a14109190 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -37,22 +37,12 @@
 #include <string.h>
 #include <errno.h>
 
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_STDARG_H
+#if defined(HAVE_STDARG_H)
 #include <stdarg.h>
-#else
+#elif defined (HAVE_VARARGS_H)
 #include <varargs.h>
-#endif
-
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
+#else
+#error "no var arg header"
 #endif
 
 #include "talloc.h"
-- 
cgit 


From c0e60d053598a1d8cd1e3367a38a001ef7c1992a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 17 Aug 2006 01:49:42 +0000
Subject: r17578: in standalone talloc build ensure we get intptr_t if
 available (which makes the discard_const stuff nicer) (This used to be commit
 662f01f8ba861a5ef1d5ee724ed2b3ab9812597a)

---
 source4/lib/talloc/talloc.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 5a14109190..fc0462929c 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -36,6 +36,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
 
 #if defined(HAVE_STDARG_H)
 #include <stdarg.h>
-- 
cgit 


From 45b8c41038c587b5993c6219bf6698323cf93494 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 28 Aug 2006 17:38:49 +0000
Subject: r17891: remove c++ warnings from talloc

metze
(This used to be commit fb73ce8d4364a1da3c320034d90c0556529c61c4)
---
 source4/lib/talloc/talloc.c | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index fc0462929c..293775b1ca 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -107,7 +107,7 @@ struct talloc_chunk {
 /* panic if we get a bad magic value */
 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
-	const char *pp = ptr;
+	const char *pp = (const char *)ptr;
 	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
 	if ((tc->flags & ~0xF) != TALLOC_MAGIC) { 
 		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
@@ -177,7 +177,7 @@ void *_talloc(const void *context, size_t size)
 		return NULL;
 	}
 
-	tc = malloc(TC_HDR_SIZE+size);
+	tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
 	if (tc == NULL) return NULL;
 
 	tc->size = size;
@@ -251,8 +251,9 @@ void *talloc_reference(const void *context, const void *ptr)
 	if (ptr == NULL) return NULL;
 
 	tc = talloc_chunk_from_ptr(ptr);
-	handle = talloc_named_const(context, sizeof(*handle), TALLOC_MAGIC_REFERENCE);
-
+	handle = (struct talloc_reference_handle *)talloc_named_const(context,
+						   sizeof(struct talloc_reference_handle),
+						   TALLOC_MAGIC_REFERENCE);
 	if (handle == NULL) return NULL;
 
 	/* note that we hang the destructor off the handle, not the
@@ -646,13 +647,13 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 		return NULL; 
 	}
 
-	tc = new_ptr;
+	tc = (struct talloc_chunk *)new_ptr;
 	tc->flags &= ~TALLOC_FLAG_FREE; 
 	if (tc->parent) {
-		tc->parent->child = new_ptr;
+		tc->parent->child = tc;
 	}
 	if (tc->child) {
-		tc->child->parent = new_ptr;
+		tc->child->parent = tc;
 	}
 
 	if (tc->prev) {
@@ -962,7 +963,7 @@ char *talloc_strdup(const void *t, const char *p)
 	if (!p) {
 		return NULL;
 	}
-	ret = talloc_memdup(t, p, strlen(p) + 1);
+	ret = (char *)talloc_memdup(t, p, strlen(p) + 1);
 	if (ret) {
 		talloc_set_name_const(ret, ret);
 	}
@@ -1003,7 +1004,7 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 
 	for (len=0; len<n && p[len]; len++) ;
 
-	ret = _talloc(t, len + 1);
+	ret = (char *)_talloc(t, len + 1);
 	if (!ret) { return NULL; }
 	memcpy(ret, p, len);
 	ret[len] = 0;
@@ -1033,7 +1034,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 		return NULL;
 	}
 
-	ret = _talloc(t, len+1);
+	ret = (char *)_talloc(t, len+1);
 	if (ret) {
 		va_copy(ap2, ap);
 		vsnprintf(ret, len+1, fmt, ap2);
@@ -1243,7 +1244,7 @@ void talloc_show_parents(const void *context, FILE *file)
 /*
   return 1 if ptr is a parent of context
 */
-int talloc_is_parent(const void *context, const char *ptr)
+int talloc_is_parent(const void *context, const void *ptr)
 {
 	struct talloc_chunk *tc;
 
-- 
cgit 


From 98a1bd7fb3c3affa88972d5766753e6810cd1410 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 28 Aug 2006 17:40:31 +0000
Subject: r17892: fix the last talloc c++ warning

metze
(This used to be commit 6955ffe4544eddd9e34461f57858480b1acf49c9)
---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 293775b1ca..7ba3e5f3ab 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -813,7 +813,8 @@ void talloc_report_depth(const void *ptr, FILE *f, int depth)
 
 	for (c=tc->child;c;c=c->next) {
 		if (c->name == TALLOC_MAGIC_REFERENCE) {
-			struct talloc_reference_handle *handle = TC_PTR_FROM_CHUNK(c);
+			struct talloc_reference_handle *handle =
+				(struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
 			const char *name2 = talloc_get_name(handle->ptr);
 			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
 		} else {
-- 
cgit 


From 3400d91197aef446d6d113363f12edd7f14525a4 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 28 Aug 2006 17:50:26 +0000
Subject: r17893: add a function to disable the null_context

metze
(This used to be commit 7cab4285b1b61ad5cb425e42d89bcf7d645b0710)
---
 source4/lib/talloc/talloc.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 7ba3e5f3ab..cc04a2425a 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -79,10 +79,9 @@
    talloc_enable_leak_report_full() is called, otherwise it remains
    NULL
 */
-static const void *null_context;
+static void *null_context;
 static void *cleanup_context;
 
-
 struct talloc_reference_handle {
 	struct talloc_reference_handle *next, *prev;
 	void *ptr;
@@ -908,6 +907,15 @@ void talloc_enable_null_tracking(void)
 	}
 }
 
+/*
+  disable tracking of the NULL context
+*/
+void talloc_disable_null_tracking(void)
+{
+	talloc_free(null_context);
+	null_context = NULL;
+}
+
 /*
   enable leak reporting on exit
 */
-- 
cgit 


From 59057c8d56629a941ab412fa195dea7c8c486b21 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 28 Aug 2006 18:21:21 +0000
Subject: r17895: - talloc_increase_ref_count() can fail - make
 talloc_reference() typesafe when gcc >= 3 is used

metze
(This used to be commit 933d1b47ad614d02cc02b602e704948b342febdb)
---
 source4/lib/talloc/talloc.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index cc04a2425a..ba457afd6b 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -219,9 +219,12 @@ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 /*
   increase the reference count on a piece of memory. 
 */
-void talloc_increase_ref_count(const void *ptr)
+int talloc_increase_ref_count(const void *ptr)
 {
-	talloc_reference(null_context, ptr);
+	if (!talloc_reference(null_context, ptr)) {
+		return -1;
+	}
+	return 0;
 }
 
 /*
@@ -243,7 +246,7 @@ static int talloc_reference_destructor(struct talloc_reference_handle *handle)
   same underlying data, and you want to be able to free the two instances separately,
   and in either order
 */
-void *talloc_reference(const void *context, const void *ptr)
+void *_talloc_reference(const void *context, const void *ptr)
 {
 	struct talloc_chunk *tc;
 	struct talloc_reference_handle *handle;
-- 
cgit 


From 832ac85ba3e58d42f4342d79062bedf01e64c687 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 29 Aug 2006 09:51:49 +0000
Subject: r17907: - add a generic talloc_report_depth_cb() function which takes
 a callback   to do the actual report. - make the talloc_report_depth_file() a
 wrapper of it - and talloc_report() and talloc_report_full() are wrapper of  
 talloc_report_depth_file()

metze
(This used to be commit b199557b358e6216d89d233513079fcd56b307aa)
---
 source4/lib/talloc/talloc.c | 129 +++++++++++++++++++++++++++-----------------
 1 file changed, 80 insertions(+), 49 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ba457afd6b..2fb8fb2530 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -6,6 +6,7 @@
    NOTE: Please read talloc_guide.txt for full documentation
 
    Copyright (C) Andrew Tridgell 2004
+   Copyright (C) Stefan Metzmacher 2006
    
      ** NOTE! The following LGPL license applies to the talloc
      ** library. This does NOT imply that all of Samba is released
@@ -30,6 +31,23 @@
   inspired by http://swapped.cc/halloc/
 */
 
+#ifdef _SAMBA_BUILD_
+#include "version.h"
+#if (SAMBA_VERSION_MAJOR<4)
+#include "includes.h"
+/* This is to circumvent SAMBA3's paranoid malloc checker. Here in this file
+ * we trust ourselves... */
+#ifdef malloc
+#undef malloc
+#endif
+#ifdef realloc
+#undef realloc
+#endif
+#define _TALLOC_SAMBA3
+#endif /* (SAMBA_VERSION_MAJOR<4) */
+#endif /* _SAMBA_BUILD_ */
+
+#ifndef _TALLOC_SAMBA3
 #include "config.h"
 
 #include <stdio.h>
@@ -49,6 +67,7 @@
 #endif
 
 #include "talloc.h"
+#endif /* not _TALLOC_SAMBA3 */
 
 /* use this to force every realloc to change the pointer, to stress test
    code that might not cope */
@@ -788,11 +807,11 @@ size_t talloc_total_blocks(const void *ptr)
 /*
   return the number of external references to a pointer
 */
-static int talloc_reference_count(const void *ptr)
+size_t talloc_reference_count(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	struct talloc_reference_handle *h;
-	int ret = 0;
+	size_t ret = 0;
 
 	for (h=tc->refs;h;h=h->next) {
 		ret++;
@@ -803,81 +822,93 @@ static int talloc_reference_count(const void *ptr)
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-void talloc_report_depth(const void *ptr, FILE *f, int depth)
+void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+			    void (*callback)(const void *ptr,
+			  		     int depth, int max_depth,
+					     int is_ref,
+					     void *private_data),
+			    void *private_data)
 {
-	struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
+	struct talloc_chunk *c, *tc;
+
+	if (ptr == NULL) {
+		ptr = null_context;
+	}
+	if (ptr == NULL) return;
+
+	tc = talloc_chunk_from_ptr(ptr);
 
 	if (tc->flags & TALLOC_FLAG_LOOP) {
 		return;
 	}
 
-	tc->flags |= TALLOC_FLAG_LOOP;
+	callback(ptr, depth, max_depth, 0, private_data);
 
+	if (max_depth >= 0 && depth >= max_depth) {
+		return;
+	}
+
+	tc->flags |= TALLOC_FLAG_LOOP;
 	for (c=tc->child;c;c=c->next) {
 		if (c->name == TALLOC_MAGIC_REFERENCE) {
-			struct talloc_reference_handle *handle =
-				(struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
-			const char *name2 = talloc_get_name(handle->ptr);
-			fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
+			struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
+			callback(h->ptr, depth + 1, max_depth, 1, private_data);
 		} else {
-			const char *name = talloc_get_name(TC_PTR_FROM_CHUNK(c));
-			fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
-				depth*4, "",
-				name,
-				(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
-				(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)),
-				talloc_reference_count(TC_PTR_FROM_CHUNK(c)));
-			talloc_report_depth(TC_PTR_FROM_CHUNK(c), f, depth+1);
+			talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
 		}
 	}
 	tc->flags &= ~TALLOC_FLAG_LOOP;
 }
 
-/*
-  report on memory usage by all children of a pointer, giving a full tree view
-*/
-void talloc_report_full(const void *ptr, FILE *f)
+static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
 {
-	if (ptr == NULL) {
-		ptr = null_context;
+	const char *name = talloc_get_name(ptr);
+	FILE *f = (FILE *)_f;
+
+	if (is_ref) {
+		fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
+		return;
+	}
+
+	if (depth == 0) {
+		fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n", 
+			(max_depth < 0 ? "full " :""), name,
+			(unsigned long)talloc_total_size(ptr),
+			(unsigned long)talloc_total_blocks(ptr));
+		return;
 	}
-	if (ptr == NULL) return;
 
-	fprintf(f,"full talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
-		talloc_get_name(ptr), 
+	fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
+		depth*4, "",
+		name,
 		(unsigned long)talloc_total_size(ptr),
-		(unsigned long)talloc_total_blocks(ptr));
+		(unsigned long)talloc_total_blocks(ptr),
+		talloc_reference_count(ptr));
+}
 
-	talloc_report_depth(ptr, f, 1);
+/*
+  report on memory usage by all children of a pointer, giving a full tree view
+*/
+void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
+{
+	talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
 	fflush(f);
 }
 
+/*
+  report on memory usage by all children of a pointer, giving a full tree view
+*/
+void talloc_report_full(const void *ptr, FILE *f)
+{
+	talloc_report_depth_file(ptr, 0, -1, f);
+}
+
 /*
   report on memory usage by all children of a pointer
 */
 void talloc_report(const void *ptr, FILE *f)
 {
-	struct talloc_chunk *c, *tc;
-
-	if (ptr == NULL) {
-		ptr = null_context;
-	}
-	if (ptr == NULL) return;
-       
-	fprintf(f,"talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
-		talloc_get_name(ptr), 
-		(unsigned long)talloc_total_size(ptr),
-		(unsigned long)talloc_total_blocks(ptr));
-
-	tc = talloc_chunk_from_ptr(ptr);
-
-	for (c=tc->child;c;c=c->next) {
-		fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
-			talloc_get_name(TC_PTR_FROM_CHUNK(c)),
-			(unsigned long)talloc_total_size(TC_PTR_FROM_CHUNK(c)),
-			(unsigned long)talloc_total_blocks(TC_PTR_FROM_CHUNK(c)));
-	}
-	fflush(f);
+	talloc_report_depth_file(ptr, 0, 1, f);
 }
 
 /*
-- 
cgit 


From 4ce057c3f41ce759ab5b197087c5b38b40a1f1d3 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 31 Aug 2006 06:33:54 +0000
Subject: r17950: sync talloc with samba3

metze
(This used to be commit 5697841e2949d2f7a053b4766c48906943a5a04e)
---
 source4/lib/talloc/talloc.c | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 2fb8fb2530..b7284e9317 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -492,6 +492,13 @@ void *talloc_init(const char *fmt, ...)
 	void *ptr;
 	const char *name;
 
+	/*
+	 * samba3 expects talloc_report_depth_cb(NULL, ...)
+	 * reports all talloc'ed memory, so we need to enable
+	 * null_tracking
+	 */
+	talloc_enable_null_tracking();
+
 	ptr = _talloc(NULL, 0);
 	if (ptr == NULL) return NULL;
 
-- 
cgit 


From f6f4d868ea7d3a01ec28c6855240882911cae039 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Mon, 4 Sep 2006 08:55:58 +0000
Subject: r18027: Fix some 64-bit warnings (This used to be commit
 cd495d89314a653b5976b1690e075fd7bac2f59b)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index b7284e9317..43c95a86e5 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -890,7 +890,7 @@ static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_
 		name,
 		(unsigned long)talloc_total_size(ptr),
 		(unsigned long)talloc_total_blocks(ptr),
-		talloc_reference_count(ptr));
+		(int)talloc_reference_count(ptr));
 }
 
 /*
-- 
cgit 


From 3c6ce57101eb555d01152b1fe5ea15fcf5bb8133 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 5 Sep 2006 16:16:27 +0000
Subject: r18100: actually make usage of libreplace :-)

metze
(This used to be commit 357882e6ec20b559b7053a8dffb72b7dec26b82f)
---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 43c95a86e5..f92d76bb3d 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -48,7 +48,7 @@
 #endif /* _SAMBA_BUILD_ */
 
 #ifndef _TALLOC_SAMBA3
-#include "config.h"
+#include "replace.h"
 
 #include <stdio.h>
 #include <stdlib.h>
-- 
cgit 


From a983b06d37c3b87a02444d9a9862777b88629344 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 6 Sep 2006 04:44:32 +0000
Subject: r18129: moved the system includes into libreplace - this gives much
 more isolation of our portability environment from the main code, and also
 simplifies the includes system (no separate #ifdef _SAMBA_BUILD for tdb. ldb
 etc now) (This used to be commit 77d1a468e06290aba789e2f3affc769fc5159a21)

---
 source4/lib/talloc/talloc.c | 17 -----------------
 1 file changed, 17 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index f92d76bb3d..d2f7a5d828 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -49,23 +49,6 @@
 
 #ifndef _TALLOC_SAMBA3
 #include "replace.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#endif
-
-#if defined(HAVE_STDARG_H)
-#include <stdarg.h>
-#elif defined (HAVE_VARARGS_H)
-#include <varargs.h>
-#else
-#error "no var arg header"
-#endif
-
 #include "talloc.h"
 #endif /* not _TALLOC_SAMBA3 */
 
-- 
cgit 


From 1a5978445199a1d8697a5604761899aa065059fe Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 13 Sep 2006 00:05:07 +0000
Subject: r18435: added a function talloc_move() which is like talloc_steal(),
 but is meant for moving pointers between structures. The difference is that
 talloc_move() will zero the source pointer, thus ensuring you don't reference
 the pointer in the old context.

talloc_move() is appropriate in some, but not all cases where we use
talloc_steal() now. The interface came out of a discussion with
Jeremy.
(This used to be commit 200756017e1867faa207703eddc00a75ae4527df)
---
 source4/lib/talloc/talloc.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d2f7a5d828..2b80594e80 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -737,6 +737,17 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
 	return discard_const_p(void, ptr);
 }
 
+/*
+  a wrapper around talloc_steal() for situations where you are moving a pointer
+  between two structures, and want the old pointer to be set to NULL
+*/
+void *_talloc_move(const void *new_ctx, const void **pptr)
+{
+	void *ret = _talloc_steal(new_ctx, *pptr);
+	(*pptr) = NULL;
+	return ret;
+}
+
 /*
   return the total size of a talloc pool (subtree)
 */
-- 
cgit 


From c902a8927c517f1d8c8c5e083db48fd797ece8f4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 14 Sep 2006 12:18:44 +0000
Subject: r18521: implement volkers suggestion for avoiding the type punning
 warnings (This used to be commit 9b9f058edb033c999c4430add4f05459ac43c9e2)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 2b80594e80..d790c6c26b 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -741,8 +741,9 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
   a wrapper around talloc_steal() for situations where you are moving a pointer
   between two structures, and want the old pointer to be set to NULL
 */
-void *_talloc_move(const void *new_ctx, const void **pptr)
+void *_talloc_move(const void *new_ctx, const void *_pptr)
 {
+	const void **pptr = (const void **)_pptr;
 	void *ret = _talloc_steal(new_ctx, *pptr);
 	(*pptr) = NULL;
 	return ret;
-- 
cgit 


From ee97148354090aa63b99abc02fe2811bf18a549e Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 27 Sep 2006 06:48:24 +0000
Subject: r18946: fix compiler warning

metze
(This used to be commit 450595822441ebaa199d6b10d568274940b1a91b)
---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d790c6c26b..58028a85b8 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -743,7 +743,7 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
 */
 void *_talloc_move(const void *new_ctx, const void *_pptr)
 {
-	const void **pptr = (const void **)_pptr;
+	const void **pptr = discard_const_p(const void *,_pptr);
 	void *ret = _talloc_steal(new_ctx, *pptr);
 	(*pptr) = NULL;
 	return ret;
-- 
cgit 


From 4ccdd5370416a90088ad5a5879eca5f7cb1161a4 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 29 Sep 2006 10:50:12 +0000
Subject: r18995: - fix bug 4078 - talloc_free(talloc_autofree_context());
 should not result   in a SIGABORT on exit - add a test for this, but this
 test can also pass in the standalone build   and samba3, as samba4 uses
 talloc_autofree_context()

metze
(This used to be commit 2be48c1b033dceb9517826054b8ea97df2c94472)
---
 source4/lib/talloc/talloc.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 58028a85b8..15b27c61ee 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -82,7 +82,7 @@
    NULL
 */
 static void *null_context;
-static void *cleanup_context;
+static void *autofree_context;
 
 struct talloc_reference_handle {
 	struct talloc_reference_handle *next, *prev;
@@ -1208,10 +1208,15 @@ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
 }
 
 
+static int talloc_autofree_destructor(void *ptr)
+{
+	autofree_context = NULL;
+	return 0;
+}
+
 static void talloc_autofree(void)
 {
-	talloc_free(cleanup_context);
-	cleanup_context = NULL;
+	talloc_free(autofree_context);
 }
 
 /*
@@ -1220,11 +1225,12 @@ static void talloc_autofree(void)
 */
 void *talloc_autofree_context(void)
 {
-	if (cleanup_context == NULL) {
-		cleanup_context = talloc_named_const(NULL, 0, "autofree_context");
+	if (autofree_context == NULL) {
+		autofree_context = talloc_named_const(NULL, 0, "autofree_context");
+		talloc_set_destructor(autofree_context, talloc_autofree_destructor);
 		atexit(talloc_autofree);
 	}
-	return cleanup_context;
+	return autofree_context;
 }
 
 size_t talloc_get_size(const void *context)
-- 
cgit 


From 666a72e39a09d820284bedccc6c5fe712c2e6f08 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 16 Oct 2006 01:00:47 +0000
Subject: r19304: If you really want to look at the contents undef this one
 (This used to be commit fe20ac404d654abe31729664584391f3b3cd0214)

---
 source4/lib/talloc/talloc.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 15b27c61ee..87b4d51ba4 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -886,6 +886,23 @@ static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_
 		(unsigned long)talloc_total_size(ptr),
 		(unsigned long)talloc_total_blocks(ptr),
 		(int)talloc_reference_count(ptr));
+
+#if 0
+	fprintf(f, "content: ");
+	if (talloc_total_size(ptr)) {
+		int tot = talloc_total_size(ptr);
+		int i;
+
+		for (i = 0; i < tot; i++) {
+			if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
+				fprintf(f, "%c", ((char *)ptr)[i]);
+			} else {
+				fprintf(f, "~%02x", ((char *)ptr)[i]);
+			}
+		}
+	}
+	fprintf(f, "\n");
+#endif
 }
 
 /*
-- 
cgit 


From 5370afe8c2d9f4b77711010f2ce9ea4fc33886c4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 19 Oct 2006 10:02:26 +0000
Subject: r19412: some rather strange looking changes to talloc that gain us
 about 50% in the talloc benchmark. These changes were driven by some
 cachegrind profiles, with the biggest improvements coming from inlining some
 functions.

I don't think it would be a good idea to start spreading inline and
likely()/unlikely() in other parts of Samba, as the benefit in most
code will be very small, but talloc() is such a speed critical part of
Samba that I think these changes are worthwhile
(This used to be commit 8644708c3f42d249b5d1fd2bde37aeb35288da13)
---
 source4/lib/talloc/talloc.c | 510 ++++++++++++++++++++++++++------------------
 1 file changed, 299 insertions(+), 211 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 87b4d51ba4..bae1942f43 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -77,6 +77,17 @@
 #endif
 #endif
 
+/* these macros gain us a few percent of speed on gcc */
+#if (__GNUC__ >= 3)
+/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
+   as its first argument */
+#define likely(x)   __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+#define likely(x) x
+#define unlikely(x) x
+#endif
+
 /* this null_context is only used if talloc_enable_leak_report() or
    talloc_enable_leak_report_full() is called, otherwise it remains
    NULL
@@ -106,15 +117,16 @@ struct talloc_chunk {
 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 
 /* panic if we get a bad magic value */
-static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
+static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
 	const char *pp = (const char *)ptr;
 	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
-	if ((tc->flags & ~0xF) != TALLOC_MAGIC) { 
-		TALLOC_ABORT("Bad talloc magic value - unknown value"); 
-	}
-	if (tc->flags & TALLOC_FLAG_FREE) {
-		TALLOC_ABORT("Bad talloc magic value - double free"); 
+	if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) { 
+		if (tc->flags & TALLOC_FLAG_FREE) {
+			TALLOC_ABORT("Bad talloc magic value - double free"); 
+		} else {
+			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
+		}
 	}
 	return tc;
 }
@@ -163,23 +175,43 @@ void *talloc_parent(const void *ptr)
 	return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
 }
 
+/*
+  find parents name
+*/
+const char *talloc_parent_name(const void *context)
+{
+	struct talloc_chunk *tc;
+
+	if (unlikely(context == NULL)) {
+		return NULL;
+	}
+
+	tc = talloc_chunk_from_ptr(context);
+	while (tc && tc->prev) tc = tc->prev;
+	if (tc) {
+		tc = tc->parent;
+	}
+	return tc->name;
+}
+
+
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
-void *_talloc(const void *context, size_t size)
+static inline void *__talloc(const void *context, size_t size)
 {
 	struct talloc_chunk *tc;
 
-	if (context == NULL) {
+	if (unlikely(context == NULL)) {
 		context = null_context;
 	}
 
-	if (size >= MAX_TALLOC_SIZE) {
+	if (unlikely(size >= MAX_TALLOC_SIZE)) {
 		return NULL;
 	}
 
 	tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
-	if (tc == NULL) return NULL;
+	if (unlikely(tc == NULL)) return NULL;
 
 	tc->size = size;
 	tc->flags = TALLOC_MAGIC;
@@ -188,16 +220,19 @@ void *_talloc(const void *context, size_t size)
 	tc->name = NULL;
 	tc->refs = NULL;
 
-	if (context) {
+	if (likely(context)) {
 		struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
 
-		tc->parent = parent;
-
 		if (parent->child) {
 			parent->child->parent = NULL;
+			tc->next = parent->child;
+			tc->next->prev = tc;
+		} else {
+			tc->next = NULL;
 		}
-
-		_TLIST_ADD(parent->child, tc);
+		tc->parent = parent;
+		tc->prev = NULL;
+		parent->child = tc;
 	} else {
 		tc->next = tc->prev = tc->parent = NULL;
 	}
@@ -205,7 +240,6 @@ void *_talloc(const void *context, size_t size)
 	return TC_PTR_FROM_CHUNK(tc);
 }
 
-
 /*
   setup a destructor to be called on free of a pointer
   the destructor should return 0 on success, or -1 on failure.
@@ -223,7 +257,7 @@ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 */
 int talloc_increase_ref_count(const void *ptr)
 {
-	if (!talloc_reference(null_context, ptr)) {
+	if (unlikely(!talloc_reference(null_context, ptr))) {
 		return -1;
 	}
 	return 0;
@@ -239,6 +273,33 @@ static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 	return 0;
 }
 
+/*
+   more efficient way to add a name to a pointer - the name must point to a 
+   true string constant
+*/
+static inline void _talloc_set_name_const(const void *ptr, const char *name)
+{
+	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	tc->name = name;
+}
+
+/*
+  internal talloc_named_const()
+*/
+static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
+{
+	void *ptr;
+
+	ptr = __talloc(context, size);
+	if (unlikely(ptr == NULL)) {
+		return NULL;
+	}
+
+	_talloc_set_name_const(ptr, name);
+
+	return ptr;
+}
+
 /*
   make a secondary reference to a pointer, hanging off the given context.
   the pointer remains valid until both the original caller and this given
@@ -252,13 +313,13 @@ void *_talloc_reference(const void *context, const void *ptr)
 {
 	struct talloc_chunk *tc;
 	struct talloc_reference_handle *handle;
-	if (ptr == NULL) return NULL;
+	if (unlikely(ptr == NULL)) return NULL;
 
 	tc = talloc_chunk_from_ptr(ptr);
-	handle = (struct talloc_reference_handle *)talloc_named_const(context,
+	handle = (struct talloc_reference_handle *)_talloc_named_const(context,
 						   sizeof(struct talloc_reference_handle),
 						   TALLOC_MAGIC_REFERENCE);
-	if (handle == NULL) return NULL;
+	if (unlikely(handle == NULL)) return NULL;
 
 	/* note that we hang the destructor off the handle, not the
 	   main context as that allows the caller to still setup their
@@ -269,6 +330,152 @@ void *_talloc_reference(const void *context, const void *ptr)
 	return handle->ptr;
 }
 
+
+/* 
+   internal talloc_free call
+*/
+static inline int _talloc_free(void *ptr)
+{
+	struct talloc_chunk *tc;
+
+	if (unlikely(ptr == NULL)) {
+		return -1;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	if (unlikely(tc->refs)) {
+		int is_child;
+		/* check this is a reference from a child or grantchild
+		 * back to it's parent or grantparent
+		 *
+		 * in that case we need to remove the reference and
+		 * call another instance of talloc_free() on the current
+		 * pointer.
+		 */
+		is_child = talloc_is_parent(tc->refs, ptr);
+		_talloc_free(tc->refs);
+		if (is_child) {
+			return _talloc_free(ptr);
+		}
+		return -1;
+	}
+
+	if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
+		/* we have a free loop - stop looping */
+		return 0;
+	}
+
+	if (unlikely(tc->destructor)) {
+		talloc_destructor_t d = tc->destructor;
+		if (d == (talloc_destructor_t)-1) {
+			return -1;
+		}
+		tc->destructor = (talloc_destructor_t)-1;
+		if (d(ptr) == -1) {
+			tc->destructor = d;
+			return -1;
+		}
+		tc->destructor = NULL;
+	}
+
+	if (tc->parent) {
+		_TLIST_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;
+	}
+
+	tc->flags |= TALLOC_FLAG_LOOP;
+
+	while (tc->child) {
+		/* we need to work out who will own an abandoned child
+		   if it cannot be freed. In priority order, the first
+		   choice is owner of any remaining reference to this
+		   pointer, the second choice is our parent, and the
+		   final choice is the null context. */
+		void *child = TC_PTR_FROM_CHUNK(tc->child);
+		const void *new_parent = null_context;
+		if (unlikely(tc->child->refs)) {
+			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
+			if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+		}
+		if (unlikely(_talloc_free(child) == -1)) {
+			if (new_parent == null_context) {
+				struct talloc_chunk *p = talloc_parent_chunk(ptr);
+				if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+			}
+			talloc_steal(new_parent, child);
+		}
+	}
+
+	tc->flags |= TALLOC_FLAG_FREE;
+	free(tc);
+	return 0;
+}
+
+/* 
+   move a lump of memory from one talloc context to another return the
+   ptr on success, or NULL if it could not be transferred.
+   passing NULL as ptr will always return NULL with no side effects.
+*/
+void *_talloc_steal(const void *new_ctx, const void *ptr)
+{
+	struct talloc_chunk *tc, *new_tc;
+
+	if (unlikely(!ptr)) {
+		return NULL;
+	}
+
+	if (unlikely(new_ctx == NULL)) {
+		new_ctx = null_context;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
+
+	if (unlikely(new_ctx == NULL)) {
+		if (tc->parent) {
+			_TLIST_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;
+		}
+		
+		tc->parent = tc->next = tc->prev = NULL;
+		return discard_const_p(void, ptr);
+	}
+
+	new_tc = talloc_chunk_from_ptr(new_ctx);
+
+	if (unlikely(tc == new_tc || tc->parent == new_tc)) {
+		return discard_const_p(void, ptr);
+	}
+
+	if (tc->parent) {
+		_TLIST_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;
+	}
+
+	tc->parent = new_tc;
+	if (new_tc->child) new_tc->child->parent = NULL;
+	_TLIST_ADD(new_tc->child, tc);
+
+	return discard_const_p(void, ptr);
+}
+
+
+
 /*
   remove a secondary reference to a pointer. This undo's what
   talloc_reference() has done. The context and pointer arguments
@@ -279,7 +486,7 @@ static int talloc_unreference(const void *context, const void *ptr)
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	struct talloc_reference_handle *h;
 
-	if (context == NULL) {
+	if (unlikely(context == NULL)) {
 		context = null_context;
 	}
 
@@ -295,7 +502,7 @@ static int talloc_unreference(const void *context, const void *ptr)
 		return -1;
 	}
 
-	return talloc_free(h);
+	return _talloc_free(h);
 }
 
 /*
@@ -332,7 +539,7 @@ int talloc_unlink(const void *context, void *ptr)
 	tc_p = talloc_chunk_from_ptr(ptr);
 
 	if (tc_p->refs == NULL) {
-		return talloc_free(ptr);
+		return _talloc_free(ptr);
 	}
 
 	new_p = talloc_parent_chunk(tc_p->refs);
@@ -360,8 +567,8 @@ static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list a
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	tc->name = talloc_vasprintf(ptr, fmt, ap);
-	if (tc->name) {
-		talloc_set_name_const(tc->name, ".name");
+	if (likely(tc->name)) {
+		_talloc_set_name_const(tc->name, ".name");
 	}
 	return tc->name;
 }
@@ -379,15 +586,6 @@ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
 	return name;
 }
 
-/*
-   more efficient way to add a name to a pointer - the name must point to a 
-   true string constant
-*/
-void talloc_set_name_const(const void *ptr, const char *name)
-{
-	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
-	tc->name = name;
-}
 
 /*
   create a named talloc pointer. Any talloc pointer can be named, and
@@ -400,50 +598,31 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 	void *ptr;
 	const char *name;
 
-	ptr = _talloc(context, size);
-	if (ptr == NULL) return NULL;
+	ptr = __talloc(context, size);
+	if (unlikely(ptr == NULL)) return NULL;
 
 	va_start(ap, fmt);
 	name = talloc_set_name_v(ptr, fmt, ap);
 	va_end(ap);
 
-	if (name == NULL) {
-		talloc_free(ptr);
+	if (unlikely(name == NULL)) {
+		_talloc_free(ptr);
 		return NULL;
 	}
 
 	return ptr;
 }
 
-/*
-  create a named talloc pointer. Any talloc pointer can be named, and
-  talloc_named() operates just like talloc() except that it allows you
-  to name the pointer.
-*/
-void *talloc_named_const(const void *context, size_t size, const char *name)
-{
-	void *ptr;
-
-	ptr = _talloc(context, size);
-	if (ptr == NULL) {
-		return NULL;
-	}
-
-	talloc_set_name_const(ptr, name);
-
-	return ptr;
-}
-
 /*
   return the name of a talloc ptr, or "UNNAMED"
 */
 const char *talloc_get_name(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
-	if (tc->name == TALLOC_MAGIC_REFERENCE) {
+	if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
 		return ".reference";
 	}
-	if (tc->name) {
+	if (likely(tc->name)) {
 		return tc->name;
 	}
 	return "UNNAMED";
@@ -457,9 +636,9 @@ const char *talloc_get_name(const void *ptr)
 void *talloc_check_name(const void *ptr, const char *name)
 {
 	const char *pname;
-	if (ptr == NULL) return NULL;
+	if (unlikely(ptr == NULL)) return NULL;
 	pname = talloc_get_name(ptr);
-	if (pname == name || strcmp(pname, name) == 0) {
+	if (likely(pname == name || strcmp(pname, name) == 0)) {
 		return discard_const_p(void, ptr);
 	}
 	return NULL;
@@ -482,15 +661,15 @@ void *talloc_init(const char *fmt, ...)
 	 */
 	talloc_enable_null_tracking();
 
-	ptr = _talloc(NULL, 0);
-	if (ptr == NULL) return NULL;
+	ptr = __talloc(NULL, 0);
+	if (unlikely(ptr == NULL)) return NULL;
 
 	va_start(ap, fmt);
 	name = talloc_set_name_v(ptr, fmt, ap);
 	va_end(ap);
 
-	if (name == NULL) {
-		talloc_free(ptr);
+	if (unlikely(name == NULL)) {
+		_talloc_free(ptr);
 		return NULL;
 	}
 
@@ -506,7 +685,7 @@ void talloc_free_children(void *ptr)
 {
 	struct talloc_chunk *tc;
 
-	if (ptr == NULL) {
+	if (unlikely(ptr == NULL)) {
 		return;
 	}
 
@@ -520,11 +699,11 @@ void talloc_free_children(void *ptr)
 		   final choice is the null context. */
 		void *child = TC_PTR_FROM_CHUNK(tc->child);
 		const void *new_parent = null_context;
-		if (tc->child->refs) {
+		if (unlikely(tc->child->refs)) {
 			struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
 			if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 		}
-		if (talloc_free(child) == -1) {
+		if (unlikely(_talloc_free(child) == -1)) {
 			if (new_parent == null_context) {
 				struct talloc_chunk *p = talloc_parent_chunk(ptr);
 				if (p) new_parent = TC_PTR_FROM_CHUNK(p);
@@ -534,6 +713,32 @@ void talloc_free_children(void *ptr)
 	}
 }
 
+/* 
+   Allocate a bit of memory as a child of an existing pointer
+*/
+void *_talloc(const void *context, size_t size)
+{
+	return __talloc(context, size);
+}
+
+/*
+  externally callable talloc_set_name_const()
+*/
+void talloc_set_name_const(const void *ptr, const char *name)
+{
+	_talloc_set_name_const(ptr, name);
+}
+
+/*
+  create a named talloc pointer. Any talloc pointer can be named, and
+  talloc_named() operates just like talloc() except that it allows you
+  to name the pointer.
+*/
+void *talloc_named_const(const void *context, size_t size, const char *name)
+{
+	return _talloc_named_const(context, size, name);
+}
+
 /* 
    free a talloc pointer. This also frees all child pointers of this 
    pointer recursively
@@ -544,68 +749,7 @@ void talloc_free_children(void *ptr)
 */
 int talloc_free(void *ptr)
 {
-	struct talloc_chunk *tc;
-	int old_errno;
-
-	if (ptr == NULL) {
-		return -1;
-	}
-
-	tc = talloc_chunk_from_ptr(ptr);
-
-	if (tc->refs) {
-		int is_child;
-		/* check this is a reference from a child or grantchild
-		 * back to it's parent or grantparent
-		 *
-		 * in that case we need to remove the reference and
-		 * call another instance of talloc_free() on the current
-		 * pointer.
-		 */
-		is_child = talloc_is_parent(tc->refs, ptr);
-		talloc_free(tc->refs);
-		if (is_child) {
-			return talloc_free(ptr);
-		}
-		return -1;
-	}
-
-	if (tc->flags & TALLOC_FLAG_LOOP) {
-		/* we have a free loop - stop looping */
-		return 0;
-	}
-
-	if (tc->destructor) {
-		talloc_destructor_t d = tc->destructor;
-		if (d == (talloc_destructor_t)-1) {
-			return -1;
-		}
-		tc->destructor = (talloc_destructor_t)-1;
-		if (d(ptr) == -1) {
-			tc->destructor = d;
-			return -1;
-		}
-		tc->destructor = NULL;
-	}
-
-	if (tc->parent) {
-		_TLIST_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;
-	}
-
-	tc->flags |= TALLOC_FLAG_LOOP;
-	talloc_free_children(ptr);
-
-	tc->flags |= TALLOC_FLAG_FREE;
-	old_errno = errno;
-	free(tc);
-	errno = old_errno;
-	return 0;
+	return _talloc_free(ptr);
 }
 
 
@@ -620,24 +764,24 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	void *new_ptr;
 
 	/* size zero is equivalent to free() */
-	if (size == 0) {
-		talloc_free(ptr);
+	if (unlikely(size == 0)) {
+		_talloc_free(ptr);
 		return NULL;
 	}
 
-	if (size >= MAX_TALLOC_SIZE) {
+	if (unlikely(size >= MAX_TALLOC_SIZE)) {
 		return NULL;
 	}
 
 	/* realloc(NULL) is equavalent to malloc() */
 	if (ptr == NULL) {
-		return talloc_named_const(context, size, name);
+		return _talloc_named_const(context, size, name);
 	}
 
 	tc = talloc_chunk_from_ptr(ptr);
 
 	/* don't allow realloc on referenced pointers */
-	if (tc->refs) {
+	if (unlikely(tc->refs)) {
 		return NULL;
 	}
 
@@ -653,7 +797,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 #else
 	new_ptr = realloc(tc, size + TC_HDR_SIZE);
 #endif
-	if (!new_ptr) {	
+	if (unlikely(!new_ptr)) {	
 		tc->flags &= ~TALLOC_FLAG_FREE; 
 		return NULL; 
 	}
@@ -675,68 +819,11 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	tc->size = size;
-	talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
+	_talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
 
 	return TC_PTR_FROM_CHUNK(tc);
 }
 
-/* 
-   move a lump of memory from one talloc context to another return the
-   ptr on success, or NULL if it could not be transferred.
-   passing NULL as ptr will always return NULL with no side effects.
-*/
-void *_talloc_steal(const void *new_ctx, const void *ptr)
-{
-	struct talloc_chunk *tc, *new_tc;
-
-	if (!ptr) {
-		return NULL;
-	}
-
-	if (new_ctx == NULL) {
-		new_ctx = null_context;
-	}
-
-	tc = talloc_chunk_from_ptr(ptr);
-
-	if (new_ctx == NULL) {
-		if (tc->parent) {
-			_TLIST_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;
-		}
-		
-		tc->parent = tc->next = tc->prev = NULL;
-		return discard_const_p(void, ptr);
-	}
-
-	new_tc = talloc_chunk_from_ptr(new_ctx);
-
-	if (tc == new_tc || tc->parent == new_tc) {
-		return discard_const_p(void, ptr);
-	}
-
-	if (tc->parent) {
-		_TLIST_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;
-	}
-
-	tc->parent = new_tc;
-	if (new_tc->child) new_tc->child->parent = NULL;
-	_TLIST_ADD(new_tc->child, tc);
-
-	return discard_const_p(void, ptr);
-}
-
 /*
   a wrapper around talloc_steal() for situations where you are moving a pointer
   between two structures, and want the old pointer to be set to NULL
@@ -880,12 +967,12 @@ static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_
 		return;
 	}
 
-	fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
+	fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n", 
 		depth*4, "",
 		name,
 		(unsigned long)talloc_total_size(ptr),
 		(unsigned long)talloc_total_blocks(ptr),
-		(int)talloc_reference_count(ptr));
+		(int)talloc_reference_count(ptr), ptr);
 
 #if 0
 	fprintf(f, "content: ");
@@ -956,7 +1043,7 @@ static void talloc_report_null_full(void)
 void talloc_enable_null_tracking(void)
 {
 	if (null_context == NULL) {
-		null_context = talloc_named_const(NULL, 0, "null_context");
+		null_context = _talloc_named_const(NULL, 0, "null_context");
 	}
 }
 
@@ -965,7 +1052,7 @@ void talloc_enable_null_tracking(void)
 */
 void talloc_disable_null_tracking(void)
 {
-	talloc_free(null_context);
+	_talloc_free(null_context);
 	null_context = NULL;
 }
 
@@ -992,7 +1079,7 @@ void talloc_enable_leak_report_full(void)
 */
 void *_talloc_zero(const void *ctx, size_t size, const char *name)
 {
-	void *p = talloc_named_const(ctx, size, name);
+	void *p = _talloc_named_const(ctx, size, name);
 
 	if (p) {
 		memset(p, '\0', size);
@@ -1007,9 +1094,9 @@ void *_talloc_zero(const void *ctx, size_t size, const char *name)
 */
 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
 {
-	void *newp = talloc_named_const(t, size, name);
+	void *newp = _talloc_named_const(t, size, name);
 
-	if (newp) {
+	if (likely(newp)) {
 		memcpy(newp, p, size);
 	}
 
@@ -1026,8 +1113,8 @@ char *talloc_strdup(const void *t, const char *p)
 		return NULL;
 	}
 	ret = (char *)talloc_memdup(t, p, strlen(p) + 1);
-	if (ret) {
-		talloc_set_name_const(ret, ret);
+	if (likely(ret)) {
+		_talloc_set_name_const(ret, ret);
 	}
 	return ret;
 }
@@ -1066,11 +1153,11 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 
 	for (len=0; len<n && p[len]; len++) ;
 
-	ret = (char *)_talloc(t, len + 1);
+	ret = (char *)__talloc(t, len + 1);
 	if (!ret) { return NULL; }
 	memcpy(ret, p, len);
 	ret[len] = 0;
-	talloc_set_name_const(ret, ret);
+	_talloc_set_name_const(ret, ret);
 	return ret;
 }
 
@@ -1096,11 +1183,11 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 		return NULL;
 	}
 
-	ret = (char *)_talloc(t, len+1);
+	ret = (char *)__talloc(t, len+1);
 	if (ret) {
 		va_copy(ap2, ap);
 		vsnprintf(ret, len+1, fmt, ap2);
-		talloc_set_name_const(ret, ret);
+		_talloc_set_name_const(ret, ret);
 	}
 
 	return ret;
@@ -1160,7 +1247,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	va_copy(ap2, ap);
 
 	vsnprintf(s+s_len, len+1, fmt, ap2);
-	talloc_set_name_const(s, s);
+	_talloc_set_name_const(s, s);
 
 	return s;
 }
@@ -1188,7 +1275,7 @@ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
 	}
-	return talloc_named_const(ctx, el_size * count, name);
+	return _talloc_named_const(ctx, el_size * count, name);
 }
 
 /*
@@ -1233,7 +1320,7 @@ static int talloc_autofree_destructor(void *ptr)
 
 static void talloc_autofree(void)
 {
-	talloc_free(autofree_context);
+	_talloc_free(autofree_context);
 }
 
 /*
@@ -1243,7 +1330,7 @@ static void talloc_autofree(void)
 void *talloc_autofree_context(void)
 {
 	if (autofree_context == NULL) {
-		autofree_context = talloc_named_const(NULL, 0, "autofree_context");
+		autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
 		talloc_set_destructor(autofree_context, talloc_autofree_destructor);
 		atexit(talloc_autofree);
 	}
@@ -1307,6 +1394,7 @@ void talloc_show_parents(const void *context, FILE *file)
 			tc = tc->parent;
 		}
 	}
+	fflush(file);
 }
 
 /*
-- 
cgit 


From bfbf6d546bcea8ea3051a4ff93ed69f1dbf45ffe Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 22:45:36 +0000
Subject: r20193: - let talloc_parent_chunk() handle a NULL pointer - use
 talloc_parent_chunk() in talloc_parent_name() - add prototype of
 talloc_parent_name()

metze
(This used to be commit 85fc18f047cd2132d0c455f739ee76ce5005d7ed)
---
 source4/lib/talloc/talloc.c | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index bae1942f43..dafb6d9075 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -164,8 +164,15 @@ do { \
 */
 static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 {
-	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
+	struct talloc_chunk *tc;
+
+	if (unlikely(ptr == NULL)) {
+		return NULL;
+	}
+
+	tc = talloc_chunk_from_ptr(ptr);
 	while (tc->prev) tc=tc->prev;
+
 	return tc->parent;
 }
 
@@ -178,23 +185,12 @@ void *talloc_parent(const void *ptr)
 /*
   find parents name
 */
-const char *talloc_parent_name(const void *context)
+const char *talloc_parent_name(const void *ptr)
 {
-	struct talloc_chunk *tc;
-
-	if (unlikely(context == NULL)) {
-		return NULL;
-	}
-
-	tc = talloc_chunk_from_ptr(context);
-	while (tc && tc->prev) tc = tc->prev;
-	if (tc) {
-		tc = tc->parent;
-	}
-	return tc->name;
+	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
+	return tc? tc->name : NULL;
 }
 
-
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
-- 
cgit 


From 0d2bedbdd7c5ee5b955a28629ef838d1a35edc45 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 22:47:50 +0000
Subject: r20194: inline all static talloc functions

metze
(This used to be commit ee47b404412299ac0e341f0d269adc21a7ebc603)
---
 source4/lib/talloc/talloc.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index dafb6d9075..a23de0c8a7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -162,7 +162,7 @@ do { \
 /*
   return the parent chunk of a pointer
 */
-static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
+static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 {
 	struct talloc_chunk *tc;
 
@@ -261,6 +261,8 @@ int talloc_increase_ref_count(const void *ptr)
 
 /*
   helper for talloc_reference()
+
+  this is referenced by a function pointer and should not be inline
 */
 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 {
@@ -477,7 +479,7 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
   talloc_reference() has done. The context and pointer arguments
   must match those given to a talloc_reference()
 */
-static int talloc_unreference(const void *context, const void *ptr)
+static inline int talloc_unreference(const void *context, const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	struct talloc_reference_handle *h;
@@ -557,9 +559,9 @@ int talloc_unlink(const void *context, void *ptr)
 /*
   add a name to an existing pointer - va_list version
 */
-static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
 
-static const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
+static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	tc->name = talloc_vasprintf(ptr, fmt, ap);
-- 
cgit 


From 90d106de8a73d395689b39e3e2c6ada5cfd46f61 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 22:51:31 +0000
Subject: r20195: fix typo

metze
(This used to be commit 9d06a4b6e22e18bdaa4383c7b9ab8af058c157c0)
---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index a23de0c8a7..15a44bd0d9 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -771,7 +771,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 		return NULL;
 	}
 
-	/* realloc(NULL) is equavalent to malloc() */
+	/* realloc(NULL) is equivalent to malloc() */
 	if (ptr == NULL) {
 		return _talloc_named_const(context, size, name);
 	}
-- 
cgit 


From 8538af1107a6e894d4941708b77e79fac587e35d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 6 Feb 2007 05:26:25 +0000
Subject: r21174: many thanks to Paul Wayper for pointing out that C99 requires
 a matching va_end() for each va_copy(). This doesn't matter for most
 architectures, but there could be some obscure ones where it does matter.

some of this should be ported to Samba3
(This used to be commit 21eb316473486cb6b73bb3ff9c5f3a44ecd57e4a)
---
 source4/lib/talloc/talloc.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 15a44bd0d9..028b44a8c7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1174,10 +1174,11 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	va_list ap2;
 	char c;
 	
-	va_copy(ap2, ap);
-
 	/* this call looks strange, but it makes it work on older solaris boxes */
-	if ((len = vsnprintf(&c, 1, fmt, ap2)) < 0) {
+	va_copy(ap2, ap);
+	len = vsnprintf(&c, 1, fmt, ap2);
+	va_end(ap2);
+	if (len < 0) {
 		return NULL;
 	}
 
@@ -1185,6 +1186,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	if (ret) {
 		va_copy(ap2, ap);
 		vsnprintf(ret, len+1, fmt, ap2);
+		va_end(ap2);
 		_talloc_set_name_const(ret, ret);
 	}
 
@@ -1226,10 +1228,13 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 
 	tc = talloc_chunk_from_ptr(s);
 
+	s_len = tc->size - 1;
+
 	va_copy(ap2, ap);
+	len = vsnprintf(&c, 1, fmt, ap2);
+	va_end(ap2);
 
-	s_len = tc->size - 1;
-	if ((len = vsnprintf(&c, 1, fmt, ap2)) <= 0) {
+	if (len <= 0) {
 		/* Either the vsnprintf failed or the format resulted in
 		 * no characters being formatted. In the former case, we
 		 * ought to return NULL, in the latter we ought to return
@@ -1243,8 +1248,8 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 	if (!s) return NULL;
 
 	va_copy(ap2, ap);
-
 	vsnprintf(s+s_len, len+1, fmt, ap2);
+	va_end(ap2);
 	_talloc_set_name_const(s, s);
 
 	return s;
-- 
cgit 


From b06fc3b53c2f17cfa3f86ef1472a5778400c0fc9 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 27 Apr 2007 21:09:16 +0000
Subject: r22539: Added _strict varients of the talloc calls to return NULL on
 size == 0 varients. Jeremy. (This used to be commit
 1ef269067ca501e2a4ded4ca8654c6a6cc26f385)

---
 source4/lib/talloc/talloc.c | 87 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 028b44a8c7..8f7906d0d8 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1087,6 +1087,28 @@ void *_talloc_zero(const void *ctx, size_t size, const char *name)
 }
 
 
+/* 
+   talloc and zero memory. 
+   Strict version - returns NULL if size is zero.
+*/
+void *_talloc_zero_strict(const void *ctx, size_t size, const char *name)
+{
+	void *p;
+
+	if (unlikely(size == 0)) {
+		return NULL;
+	}
+
+	p = _talloc_named_const(ctx, size, name);
+
+	if (p) {
+		memset(p, '\0', size);
+	}
+
+	return p;
+}
+
+
 /*
   memdup with a talloc. 
 */
@@ -1101,6 +1123,26 @@ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name
 	return newp;
 }
 
+/*
+  memdup with a talloc. 
+  Strict version - returns NULL if size is zero.
+*/
+void *_talloc_memdup_strict(const void *t, const void *p, size_t size, const char *name)
+{
+	void *newp;
+
+	if (unlikely(size == 0)) {
+		return NULL;
+	}
+
+	newp = _talloc_named_const(t, size, name);
+	if (likely(newp)) {
+		memcpy(newp, p, size);
+	}
+
+	return newp;
+}
+
 /*
   strdup with a talloc 
 */
@@ -1281,6 +1323,23 @@ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char
 	return _talloc_named_const(ctx, el_size * count, name);
 }
 
+/*
+  alloc an array, checking for integer overflow in the array size.
+  Strict version - returns NULL if count or el_size are zero.
+*/
+void *_talloc_array_strict(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
+	if (count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+
+	if (el_size == 0 || count == 0) {
+		return NULL;
+	}
+
+	return _talloc_named_const(ctx, el_size * count, name);
+}
+
 /*
   alloc an zero array, checking for integer overflow in the array size
 */
@@ -1292,6 +1351,23 @@ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const
 	return _talloc_zero(ctx, el_size * count, name);
 }
 
+/*
+  alloc an zero array, checking for integer overflow in the array size
+  Strict version - returns NULL if count or el_size are zero.
+*/
+void *_talloc_zero_array_strict(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
+	if (count >= MAX_TALLOC_SIZE/el_size) {
+		return NULL;
+	}
+
+	if (el_size == 0 || count == 0) {
+		return NULL;
+	}
+
+	return _talloc_zero(ctx, el_size * count, name);
+}
+
 
 /*
   realloc an array, checking for integer overflow in the array size
@@ -1421,3 +1497,14 @@ int talloc_is_parent(const void *context, const void *ptr)
 	}
 	return 0;
 }
+
+/*
+  Talloc wrapper that returns NULL if size == 0.
+*/
+void *talloc_strict(const void *context, size_t size, const char *name)
+{
+	if (unlikely(size == 0)) {
+		return NULL;
+	}
+	return _talloc_named_const(context, size, name);
+}
-- 
cgit 


From 522f9ace1446e360ba84ed3cbe6cdb15946cc6c3 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sat, 28 Apr 2007 23:23:24 +0000
Subject: r22563: As tridge requested remove the _strict calls - for Samba3 I'm
 moving to a separate file. Jeremy. (This used to be commit
 80706cf98d31593a899652acb2cdedaa8bf3dfab)

---
 source4/lib/talloc/talloc.c | 89 ---------------------------------------------
 1 file changed, 89 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 8f7906d0d8..b2b00d8c65 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1086,29 +1086,6 @@ void *_talloc_zero(const void *ctx, size_t size, const char *name)
 	return p;
 }
 
-
-/* 
-   talloc and zero memory. 
-   Strict version - returns NULL if size is zero.
-*/
-void *_talloc_zero_strict(const void *ctx, size_t size, const char *name)
-{
-	void *p;
-
-	if (unlikely(size == 0)) {
-		return NULL;
-	}
-
-	p = _talloc_named_const(ctx, size, name);
-
-	if (p) {
-		memset(p, '\0', size);
-	}
-
-	return p;
-}
-
-
 /*
   memdup with a talloc. 
 */
@@ -1123,26 +1100,6 @@ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name
 	return newp;
 }
 
-/*
-  memdup with a talloc. 
-  Strict version - returns NULL if size is zero.
-*/
-void *_talloc_memdup_strict(const void *t, const void *p, size_t size, const char *name)
-{
-	void *newp;
-
-	if (unlikely(size == 0)) {
-		return NULL;
-	}
-
-	newp = _talloc_named_const(t, size, name);
-	if (likely(newp)) {
-		memcpy(newp, p, size);
-	}
-
-	return newp;
-}
-
 /*
   strdup with a talloc 
 */
@@ -1323,23 +1280,6 @@ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char
 	return _talloc_named_const(ctx, el_size * count, name);
 }
 
-/*
-  alloc an array, checking for integer overflow in the array size.
-  Strict version - returns NULL if count or el_size are zero.
-*/
-void *_talloc_array_strict(const void *ctx, size_t el_size, unsigned count, const char *name)
-{
-	if (count >= MAX_TALLOC_SIZE/el_size) {
-		return NULL;
-	}
-
-	if (el_size == 0 || count == 0) {
-		return NULL;
-	}
-
-	return _talloc_named_const(ctx, el_size * count, name);
-}
-
 /*
   alloc an zero array, checking for integer overflow in the array size
 */
@@ -1351,24 +1291,6 @@ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const
 	return _talloc_zero(ctx, el_size * count, name);
 }
 
-/*
-  alloc an zero array, checking for integer overflow in the array size
-  Strict version - returns NULL if count or el_size are zero.
-*/
-void *_talloc_zero_array_strict(const void *ctx, size_t el_size, unsigned count, const char *name)
-{
-	if (count >= MAX_TALLOC_SIZE/el_size) {
-		return NULL;
-	}
-
-	if (el_size == 0 || count == 0) {
-		return NULL;
-	}
-
-	return _talloc_zero(ctx, el_size * count, name);
-}
-
-
 /*
   realloc an array, checking for integer overflow in the array size
 */
@@ -1497,14 +1419,3 @@ int talloc_is_parent(const void *context, const void *ptr)
 	}
 	return 0;
 }
-
-/*
-  Talloc wrapper that returns NULL if size == 0.
-*/
-void *talloc_strict(const void *context, size_t size, const char *name)
-{
-	if (unlikely(size == 0)) {
-		return NULL;
-	}
-	return _talloc_named_const(context, size, name);
-}
-- 
cgit 


From 7ef755d150af6ee730ecaa078307706ad753428d Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 8 May 2007 09:54:01 +0000
Subject: r22758: - add missing _talloc_set_name_const(ret, ret); to
 talloc_append_string() - update manpage and add comments about
 _talloc_set_name_const(ret, ret);   in all places which use them

metze
(This used to be commit 5cd100de829b75b83e49bd572a33a267cf86f215)
---
 source4/lib/talloc/talloc.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index b2b00d8c65..abc1e9438e 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1137,6 +1137,8 @@ char *talloc_append_string(const void *t, char *orig, const char *append)
 	/* append the string with the trailing \0 */
 	memcpy(&ret[olen], append, alenz);
 
+	_talloc_set_name_const(ret, ret);
+
 	return ret;
 }
 
-- 
cgit 


From b8d69a7ea2505b706ff7c74d7c97bc89d82dfa07 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:46:15 +0000
Subject: r23795: more v2->v3 conversion (This used to be commit
 84b468b2f8f2dffda89593f816e8bc6a8b6d42ac)

---
 source4/lib/talloc/talloc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index abc1e9438e..a28e9defad 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -15,7 +15,7 @@
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+   version 3 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
-- 
cgit 


From 6c973f4e8ccbcb6c9275f8a54e26abb19df7e15a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 03:42:26 +0000
Subject: r23798: updated old Temple Place FSF addresses to new URL (This used
 to be commit 40c0919aaa9c1b14bbaebb95ecce53eb0380fdbb)

---
 source4/lib/talloc/talloc.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index a28e9defad..6ebdada42f 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -23,8 +23,7 @@
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
 /*
-- 
cgit 


From 69de8f9ac8eaa9bb8ec12facb66fe3e26de5f47c Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 22 Aug 2007 12:44:22 +0000
Subject: r24626: as TALLOC_ABORT() is defined to abort() by default wrap it
 into a function so that the function name in the backtrace shows what
 happens.

metze
(This used to be commit 0216ff6daa276e413811ca32cca0a66b4b2abe55)
---
 source4/lib/talloc/talloc.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6ebdada42f..c073a8c774 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -115,6 +115,16 @@ struct talloc_chunk {
 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 
+static void talloc_abort_double_free(void)
+{
+	TALLOC_ABORT("Bad talloc magic value - double free"); 
+}
+
+static void talloc_abort_unknown_value(void)
+{
+	TALLOC_ABORT("Bad talloc magic value - unknown value"); 
+}
+
 /* panic if we get a bad magic value */
 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 {
@@ -122,9 +132,9 @@ static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 	struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
 	if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) { 
 		if (tc->flags & TALLOC_FLAG_FREE) {
-			TALLOC_ABORT("Bad talloc magic value - double free"); 
+			talloc_abort_double_free();
 		} else {
-			TALLOC_ABORT("Bad talloc magic value - unknown value"); 
+			talloc_abort_unknown_value();
 		}
 	}
 	return tc;
-- 
cgit 


From d8a5ed33b36d7666b04673298a9b67f06cc36687 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 12 Sep 2007 21:41:36 +0000
Subject: r25116: Fix talloc_asprintf_append to do the right thing with
 truncated strings. Jeremy. (This used to be commit
 948d32bb62b0e8c68cc961a380eae602ffc71870)

---
 source4/lib/talloc/talloc.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index c073a8c774..c3e5d2c076 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1226,8 +1226,7 @@ char *talloc_asprintf(const void *t, const char *fmt, ...)
  * accumulating output into a string buffer.
  **/
 char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
-{	
-	struct talloc_chunk *tc;
+{
 	int len, s_len;
 	va_list ap2;
 	char c;
@@ -1236,9 +1235,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 		return talloc_vasprintf(NULL, fmt, ap);
 	}
 
-	tc = talloc_chunk_from_ptr(s);
-
-	s_len = tc->size - 1;
+	s_len = strlen(s);
 
 	va_copy(ap2, ap);
 	len = vsnprintf(&c, 1, fmt, ap2);
-- 
cgit 


From 151f422247e4f9a9645baf639adaf2dbd9557f13 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 14 Sep 2007 17:40:58 +0000
Subject: r25164: Add talloc_asprintf_append_buffer() and the docs for it.
 Jeremy. (This used to be commit 5bb8613b86a6788efde840d5b50710f9afd22fed)

---
 source4/lib/talloc/talloc.c | 65 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 63 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index c3e5d2c076..7920a66d64 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1223,7 +1223,8 @@ char *talloc_asprintf(const void *t, const char *fmt, ...)
 /**
  * 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.
+ * accumulating output into a string buffer. Appends at the end
+ * of the string.
  **/
 char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 {
@@ -1245,7 +1246,52 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 		/* Either the vsnprintf failed or the format resulted in
 		 * no characters being formatted. In the former case, we
 		 * ought to return NULL, in the latter we ought to return
-		 * the original string. Most current callers of this 
+		 * the original string. Most current callers of this
+		 * function expect it to never return NULL.
+		 */
+		return s;
+	}
+
+	s = talloc_realloc(NULL, s, char, s_len + len+1);
+	if (!s) return NULL;
+
+	va_copy(ap2, ap);
+	vsnprintf(s+s_len, len+1, fmt, ap2);
+	va_end(ap2);
+	_talloc_set_name_const(s, s);
+
+	return s;
+}
+
+/**
+ * Realloc @p s to append the formatted result of @p fmt and @p ap,
+ * and return @p s, which may have moved. Always appends at the
+ * end of the talloc'ed buffer, not the end of the string.
+ **/
+char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
+{
+	struct talloc_chunk *tc;
+	int len, s_len;
+	va_list ap2;
+	char c;
+
+	if (s == NULL) {
+		return talloc_vasprintf(NULL, fmt, ap);
+	}
+
+	tc = talloc_chunk_from_ptr(s);
+
+	s_len = tc->size - 1;
+
+	va_copy(ap2, ap);
+	len = vsnprintf(&c, 1, fmt, ap2);
+	va_end(ap2);
+
+	if (len <= 0) {
+		/* Either the vsnprintf failed or the format resulted in
+		 * no characters being formatted. In the former case, we
+		 * ought to return NULL, in the latter we ought to return
+		 * the original string. Most current callers of this
 		 * function expect it to never return NULL.
 		 */
 		return s;
@@ -1277,6 +1323,21 @@ char *talloc_asprintf_append(char *s, const char *fmt, ...)
 	return s;
 }
 
+/*
+  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 buffer.
+ */
+char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	s = talloc_vasprintf_append_buffer(s, fmt, ap);
+	va_end(ap);
+	return s;
+}
+
 /*
   alloc an array, checking for integer overflow in the array size
 */
-- 
cgit 


From 3e58b6fd46518abfd6b6b86623448cae63606bc0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 11:51:41 +0000
Subject: r25206: unify logic of talloc_strdup() and talloc_strndup(), only
 strlen() vs. strnlen() is the difference now.

metze
(This used to be commit 92106e6b7e4ed3b6e1aa942b6dc8ae52fdf5805b)
---
 source4/lib/talloc/talloc.c | 42 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 7920a66d64..d4c845fa88 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1109,20 +1109,27 @@ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name
 	return newp;
 }
 
+static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
+{
+	char *ret;
+
+	ret = (char *)__talloc(t, len + 1);
+	if (unlikely(!ret)) return NULL;
+
+	memcpy(ret, p, len);
+	ret[len] = 0;
+
+	_talloc_set_name_const(ret, ret);
+	return ret;
+}
+
 /*
-  strdup with a talloc 
+  strdup with a talloc
 */
 char *talloc_strdup(const void *t, const char *p)
 {
-	char *ret;
-	if (!p) {
-		return NULL;
-	}
-	ret = (char *)talloc_memdup(t, p, strlen(p) + 1);
-	if (likely(ret)) {
-		_talloc_set_name_const(ret, ret);
-	}
-	return ret;
+	if (unlikely(!p)) return NULL;
+	return __talloc_strlendup(t, p, strlen(p));
 }
 
 /*
@@ -1152,21 +1159,12 @@ char *talloc_append_string(const void *t, char *orig, const char *append)
 }
 
 /*
-  strndup with a talloc 
+  strndup with a talloc
 */
 char *talloc_strndup(const void *t, const char *p, size_t n)
 {
-	size_t len;
-	char *ret;
-
-	for (len=0; len<n && p[len]; len++) ;
-
-	ret = (char *)__talloc(t, len + 1);
-	if (!ret) { return NULL; }
-	memcpy(ret, p, len);
-	ret[len] = 0;
-	_talloc_set_name_const(ret, ret);
-	return ret;
+	if (unlikely(!p)) return NULL;
+	return __talloc_strlendup(t, p, strnlen(p, n));
 }
 
 #ifndef HAVE_VA_COPY
-- 
cgit 


From 22b827ccbdbac3d1b682b877050356b7a31f5c11 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 11:52:35 +0000
Subject: r25207: remove one nesting level and use unlikely()

metze
(This used to be commit c2931540bc6e2d7665ef46a123f1c0618c3b55b7)
---
 source4/lib/talloc/talloc.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index d4c845fa88..92970426e8 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1186,18 +1186,18 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 	va_copy(ap2, ap);
 	len = vsnprintf(&c, 1, fmt, ap2);
 	va_end(ap2);
-	if (len < 0) {
+	if (unlikely(len < 0)) {
 		return NULL;
 	}
 
 	ret = (char *)__talloc(t, len+1);
-	if (ret) {
-		va_copy(ap2, ap);
-		vsnprintf(ret, len+1, fmt, ap2);
-		va_end(ap2);
-		_talloc_set_name_const(ret, ret);
-	}
+	if (unlikely(!ret)) return NULL;
+
+	va_copy(ap2, ap);
+	vsnprintf(ret, len+1, fmt, ap2);
+	va_end(ap2);
 
+	_talloc_set_name_const(ret, ret);
 	return ret;
 }
 
-- 
cgit 


From 46d369b0f0ad9213e461457ec960cb43ec918ebe Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 11:54:10 +0000
Subject: r25208: add talloc_str[n]dup_append[_buffer]() functions

metze
(This used to be commit 8532076720ddaf3409db1196550cd7c6884380fc)
---
 source4/lib/talloc/talloc.c | 96 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 92970426e8..0b4d977aa7 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1167,6 +1167,102 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 	return __talloc_strlendup(t, p, strnlen(p, n));
 }
 
+static inline char *__talloc_strlendup_append(char *s, size_t slen,
+					      const char *a, size_t alen)
+{
+	char *ret;
+
+	ret = talloc_realloc(NULL, s, char, slen + alen + 1);
+	if (unlikely(!ret)) return NULL;
+
+	/* append the string and the trailing \0 */
+	memcpy(&ret[slen], a, alen);
+	ret[slen+alen] = 0;
+
+	_talloc_set_name_const(ret, ret);
+	return ret;
+}
+
+/*
+ * Appends at the end of the string.
+ */
+char *talloc_strdup_append(char *s, const char *a)
+{
+	if (unlikely(!s)) {
+		return talloc_strdup(NULL, a);
+	}
+
+	if (unlikely(!a)) {
+		return s;
+	}
+
+	return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
+}
+
+/*
+ * Appends at the end of the talloc'ed buffer,
+ * not the end of the string.
+ */
+char *talloc_strdup_append_buffer(char *s, const char *a)
+{
+	size_t slen;
+
+	if (unlikely(!s)) {
+		return talloc_strdup(NULL, a);
+	}
+
+	if (unlikely(!a)) {
+		return s;
+	}
+
+	slen = talloc_get_size(s);
+	if (likely(slen > 0)) {
+		slen--;
+	}
+
+	return __talloc_strlendup_append(s, slen, a, strlen(a));
+}
+
+/*
+ * Appends at the end of the string.
+ */
+char *talloc_strndup_append(char *s, const char *a, size_t n)
+{
+	if (unlikely(!s)) {
+		return talloc_strdup(NULL, a);
+	}
+
+	if (unlikely(!a)) {
+		return s;
+	}
+
+	return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
+}
+
+/*
+ * Appends at the end of the talloc'ed buffer,
+ * not the end of the string.
+ */
+char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
+{
+	size_t slen;
+
+	if (unlikely(!s)) {
+		return talloc_strdup(NULL, a);
+	}
+
+	if (unlikely(!a)) {
+		return s;
+	}
+
+	slen = talloc_get_size(s);
+	if (likely(slen > 0)) {
+		slen--;
+	}
+
+	return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
+}
+
 #ifndef HAVE_VA_COPY
 #ifdef HAVE___VA_COPY
 #define va_copy(dest, src) __va_copy(dest, src)
-- 
cgit 


From 4a40dd266991b051dbcc4a7eb87123d58b6d5ea5 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 11:56:24 +0000
Subject: r25209: unify logic of talloc_vasprintf_append() and
 talloc_vasprintf_append_buffer()

metze
(This used to be commit 780c1c776e15f7224256a0ba0bda3e9f04702abe)
---
 source4/lib/talloc/talloc.c | 79 +++++++++++++++++----------------------------
 1 file changed, 29 insertions(+), 50 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 0b4d977aa7..033e70d2f9 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1313,30 +1313,18 @@ char *talloc_asprintf(const void *t, const char *fmt, ...)
 	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. Appends at the end
- * of the string.
- **/
-char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
+						 const char *fmt, va_list ap)
 {
-	int len, s_len;
+	ssize_t alen;
 	va_list ap2;
 	char c;
 
-	if (s == NULL) {
-		return talloc_vasprintf(NULL, fmt, ap);
-	}
-
-	s_len = strlen(s);
-
 	va_copy(ap2, ap);
-	len = vsnprintf(&c, 1, fmt, ap2);
+	alen = vsnprintf(&c, 1, fmt, ap2);
 	va_end(ap2);
 
-	if (len <= 0) {
+	if (alen <= 0) {
 		/* Either the vsnprintf failed or the format resulted in
 		 * no characters being formatted. In the former case, we
 		 * ought to return NULL, in the latter we ought to return
@@ -1346,17 +1334,32 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 		return s;
 	}
 
-	s = talloc_realloc(NULL, s, char, s_len + len+1);
+	s = talloc_realloc(NULL, s, char, slen + alen + 1);
 	if (!s) return NULL;
 
 	va_copy(ap2, ap);
-	vsnprintf(s+s_len, len+1, fmt, ap2);
+	vsnprintf(s + slen, alen + 1, fmt, ap2);
 	va_end(ap2);
-	_talloc_set_name_const(s, s);
 
+	_talloc_set_name_const(s, s);
 	return s;
 }
 
+/**
+ * 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. Appends at the end
+ * of the string.
+ **/
+char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+{
+	if (unlikely(!s)) {
+		return talloc_vasprintf(NULL, fmt, ap);
+	}
+
+	return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
+}
+
 /**
  * Realloc @p s to append the formatted result of @p fmt and @p ap,
  * and return @p s, which may have moved. Always appends at the
@@ -1364,42 +1367,18 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
  **/
 char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
 {
-	struct talloc_chunk *tc;
-	int len, s_len;
-	va_list ap2;
-	char c;
+	size_t slen;
 
-	if (s == NULL) {
+	if (unlikely(!s)) {
 		return talloc_vasprintf(NULL, fmt, ap);
 	}
 
-	tc = talloc_chunk_from_ptr(s);
-
-	s_len = tc->size - 1;
-
-	va_copy(ap2, ap);
-	len = vsnprintf(&c, 1, fmt, ap2);
-	va_end(ap2);
-
-	if (len <= 0) {
-		/* Either the vsnprintf failed or the format resulted in
-		 * no characters being formatted. In the former case, we
-		 * ought to return NULL, in the latter we ought to return
-		 * the original string. Most current callers of this
-		 * function expect it to never return NULL.
-		 */
-		return s;
+	slen = talloc_get_size(s);
+	if (likely(slen > 0)) {
+		slen--;
 	}
 
-	s = talloc_realloc(NULL, s, char, s_len + len+1);
-	if (!s) return NULL;
-
-	va_copy(ap2, ap);
-	vsnprintf(s+s_len, len+1, fmt, ap2);
-	va_end(ap2);
-	_talloc_set_name_const(s, s);
-
-	return s;
+	return __talloc_vaslenprintf_append(s, slen, fmt, ap);
 }
 
 /*
-- 
cgit 


From 3864520c9aacafb992f49bd4d3d2cf81f4b6256f Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 13:25:48 +0000
Subject: r25211: fix compiler warning

metze
(This used to be commit c0d095c8c9c1f9a7a96771e20680c105f0cce308)
---
 source4/lib/talloc/talloc.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 033e70d2f9..ea32b3273a 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1313,6 +1313,10 @@ char *talloc_asprintf(const void *t, const char *fmt, ...)
 	return ret;
 }
 
+static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
+						 const char *fmt, va_list ap)
+						 PRINTF_ATTRIBUTE(3,0);
+
 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
 						 const char *fmt, va_list ap)
 {
-- 
cgit 


From bc94aa19f30574dffcc56c98307dfab9772e6057 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 13:45:43 +0000
Subject: r25216: make talloc_append_string() a deprecated macro instead of
 having it as a real function.

metze
(This used to be commit 2b2e8414650f4793e7fd6e7fb368383ee268948f)
---
 source4/lib/talloc/talloc.c | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index ea32b3273a..4d72c0e871 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1132,32 +1132,6 @@ char *talloc_strdup(const void *t, const char *p)
 	return __talloc_strlendup(t, p, strlen(p));
 }
 
-/*
- append to a talloced string 
-*/
-char *talloc_append_string(const void *t, char *orig, const char *append)
-{
-	char *ret;
-	size_t olen = strlen(orig);
-	size_t alenz;
-
-	if (!append)
-		return orig;
-
-	alenz = strlen(append) + 1;
-
-	ret = talloc_realloc(t, orig, char, olen + alenz);
-	if (!ret)
-		return NULL;
-
-	/* append the string with the trailing \0 */
-	memcpy(&ret[olen], append, alenz);
-
-	_talloc_set_name_const(ret, ret);
-
-	return ret;
-}
-
 /*
   strndup with a talloc
 */
-- 
cgit 


From ac4237e9971bd50ef194f2166365ff91af4dbfaa Mon Sep 17 00:00:00 2001
From: Kai Blin <kai@samba.org>
Date: Mon, 17 Dec 2007 18:31:16 +0100
Subject: r26511: Janitorial: Fix a warning for the 'printf' attribute on
 gendb_search_v

While at it, also add a PRINTF_ATTRIBUTE for talloc_vasprintf.
(This used to be commit 5b3a8c8ae195e6a98357a407a0699493f54a8b79)
---
 source4/lib/talloc/talloc.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 4d72c0e871..6661c10bb5 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1245,13 +1245,15 @@ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
 #endif
 #endif
 
+char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+
 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
-{	
+{
 	int len;
 	char *ret;
 	va_list ap2;
 	char c;
-	
+
 	/* this call looks strange, but it makes it work on older solaris boxes */
 	va_copy(ap2, ap);
 	len = vsnprintf(&c, 1, fmt, ap2);
@@ -1276,6 +1278,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
   Perform string formatting, and return a pointer to newly allocated
   memory holding the result, inside a memory pool.
  */
+char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
 char *talloc_asprintf(const void *t, const char *fmt, ...)
 {
 	va_list ap;
-- 
cgit 


From f6c80d0d9cdc24694174c31c51ecaa563f3e6e8c Mon Sep 17 00:00:00 2001
From: Kai Blin <kai@samba.org>
Date: Mon, 17 Dec 2007 20:18:02 +0100
Subject: r26514: Revert the talloc.c part of r26511, as talloc.h already takes
 care of thois.

Thanks to metze for pointing this out
(This used to be commit 4a5e1047fff0620aa534b147ac7e0bd0416a8fe7)
---
 source4/lib/talloc/talloc.c | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 6661c10bb5..f9aefcd6de 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -1245,8 +1245,6 @@ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
 #endif
 #endif
 
-char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
-
 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 {
 	int len;
@@ -1278,7 +1276,6 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
   Perform string formatting, and return a pointer to newly allocated
   memory holding the result, inside a memory pool.
  */
-char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
 char *talloc_asprintf(const void *t, const char *fmt, ...)
 {
 	va_list ap;
-- 
cgit 


From 44cb6a81f26aed44a5bdc383ad59c5fbd2789262 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Tue, 8 Jan 2008 22:42:27 +0100
Subject: Don't shrink a talloc area if we have less than 1k to gain (This used
 to be commit 0c829e6ee6f43299cc5889c2af3d0402256da0d0)

---
 source4/lib/talloc/talloc.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index f9aefcd6de..7aad42ce8c 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -787,6 +787,11 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
 	tc = talloc_chunk_from_ptr(ptr);
 
+	if ((size < tc->size) && ((tc->size - size) < 1024)) {
+		tc->size = size;
+		return ptr;
+	}
+
 	/* don't allow realloc on referenced pointers */
 	if (unlikely(tc->refs)) {
 		return NULL;
-- 
cgit 


From af406133c1aa736d6c2c8327cdc0f39b7592df92 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox@samba.org>
Date: Wed, 9 Jan 2008 01:34:21 +0100
Subject: Fix talloctort: move size check after referenced ptr check.

Michael
(This used to be commit a0caedb94f6f7c62ae706e35a4c0b2876f74978d)
---
 source4/lib/talloc/talloc.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 7aad42ce8c..9e141ab5fd 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -787,16 +787,16 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
 	tc = talloc_chunk_from_ptr(ptr);
 
-	if ((size < tc->size) && ((tc->size - size) < 1024)) {
-		tc->size = size;
-		return ptr;
-	}
-
 	/* don't allow realloc on referenced pointers */
 	if (unlikely(tc->refs)) {
 		return NULL;
 	}
 
+	if ((size < tc->size) && ((tc->size - size) < 1024)) {
+		tc->size = size;
+		return ptr;
+	}
+
 	/* by resetting magic we catch users of the old memory */
 	tc->flags |= TALLOC_FLAG_FREE;
 
-- 
cgit 


From 81abb395e02116eda0f0f3d00843e27fc158e1c0 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox@samba.org>
Date: Wed, 9 Jan 2008 01:35:43 +0100
Subject: Add a comment.

Michael
(This used to be commit 2a2c28584cdb65fcea8563eb3bf21fea497fdff3)
---
 source4/lib/talloc/talloc.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 9e141ab5fd..0df00ed971 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -792,6 +792,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 		return NULL;
 	}
 
+	/* don't shrink if we have less than 1k to gain */
 	if ((size < tc->size) && ((tc->size - size) < 1024)) {
 		tc->size = size;
 		return ptr;
-- 
cgit 


From 7a9033fb2d2057dc8104d9b6f22c94e83e36f8ce Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Sat, 5 Jan 2008 18:26:54 +0100
Subject: Implement talloc_pool()

A talloc pool is a chunk of memory that can be used as a context for further
talloc calls. Allocations with the pool as the parent just chew from that
memory by incrementing a pointer. If the talloc pool is full, then we fall back
to the normal system-level malloc(3) to get memory.

The use case for talloc pools is the transient memory that is used for handling
a single SMB request. Incrementing a pointer will be way faster than any malloc
implementation.

There is a downside of this: If you use talloc_steal() to move something out of
the pool, the whole pool memory is kept around until the last object inside the
pool is freed. So if you talloc_free() the pool, it might happen that the
memory is freed later. So don't hang anything off a talloc pool that should
live long.

Volker
(This used to be commit 60ef9a84f0bd18d48e453c08aa420d17275e0881)
---
 source4/lib/talloc/talloc.c | 176 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 169 insertions(+), 7 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 0df00ed971..e38a4d6275 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -60,6 +60,8 @@
 #define TALLOC_MAGIC 0xe814ec70
 #define TALLOC_FLAG_FREE 0x01
 #define TALLOC_FLAG_LOOP 0x02
+#define TALLOC_FLAG_POOL 0x04		/* This is a talloc pool */
+#define TALLOC_FLAG_POOLMEM 0x08	/* This is allocated in a pool */
 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
 
 /* by default we abort when given a bad pointer (such as when talloc_free() is called 
@@ -109,6 +111,19 @@ struct talloc_chunk {
 	const char *name;
 	size_t size;
 	unsigned flags;
+
+	/*
+	 * "pool" has dual use:
+	 *
+	 * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
+	 * marks the end of the currently allocated area.
+	 *
+	 * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
+	 * is a pointer to the struct talloc_chunk of the pool that it was
+	 * allocated from. This way children can quickly find the pool to chew
+	 * from.
+	 */
+	void *pool;
 };
 
 /* 16 byte alignment seems to keep everyone happy */
@@ -200,12 +215,82 @@ const char *talloc_parent_name(const void *ptr)
 	return tc? tc->name : NULL;
 }
 
+/*
+  A pool carries an in-pool object count count in the first 16 bytes.
+  bytes. This is done to support talloc_steal() to a parent outside of the
+  pool. The count includes the pool itself, so a talloc_free() on a pool will
+  only destroy the pool if the count has dropped to zero. A talloc_free() of a
+  pool member will reduce the count, and eventually also call free(3) on the
+  pool memory.
+
+  The object count is not put into "struct talloc_chunk" because it is only
+  relevant for talloc pools and the alignment to 16 bytes would increase the
+  memory footprint of each talloc chunk by those 16 bytes.
+*/
+
+#define TALLOC_POOL_HDR_SIZE 16
+
+static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc)
+{
+	return (unsigned int *)((char *)tc + sizeof(struct talloc_chunk));
+}
+
+/*
+  Allocate from a pool
+*/
+
+static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
+					      size_t size)
+{
+	struct talloc_chunk *pool_ctx = NULL;
+	size_t space_left;
+	struct talloc_chunk *result;
+
+	if (parent == NULL) {
+		return NULL;
+	}
+
+	if (parent->flags & TALLOC_FLAG_POOL) {
+		pool_ctx = parent;
+	}
+	else if (parent->flags & TALLOC_FLAG_POOLMEM) {
+		pool_ctx = (struct talloc_chunk *)parent->pool;
+	}
+
+	if (pool_ctx == NULL) {
+		return NULL;
+	}
+
+	space_left = ((char *)pool_ctx + TC_HDR_SIZE + pool_ctx->size)
+		- ((char *)pool_ctx->pool);
+
+	/*
+	 * Align size to 16 bytes
+	 */
+	size = ((size + 15) & ~15);
+
+	if (space_left < size) {
+		return NULL;
+	}
+
+	result = (struct talloc_chunk *)pool_ctx->pool;
+
+	pool_ctx->pool = (void *)((char *)result + size);
+
+	result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
+	result->pool = pool_ctx;
+
+	*talloc_pool_objectcount(pool_ctx) += 1;
+
+	return result;
+}
+
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
 static inline void *__talloc(const void *context, size_t size)
 {
-	struct talloc_chunk *tc;
+	struct talloc_chunk *tc = NULL;
 
 	if (unlikely(context == NULL)) {
 		context = null_context;
@@ -215,11 +300,19 @@ static inline void *__talloc(const void *context, size_t size)
 		return NULL;
 	}
 
-	tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
-	if (unlikely(tc == NULL)) return NULL;
+	if (context != NULL) {
+		tc = talloc_alloc_pool(talloc_chunk_from_ptr(context),
+				       TC_HDR_SIZE+size);
+	}
+
+	if (tc == NULL) {
+		tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
+		if (unlikely(tc == NULL)) return NULL;
+		tc->flags = TALLOC_MAGIC;
+		tc->pool  = NULL;
+	}
 
 	tc->size = size;
-	tc->flags = TALLOC_MAGIC;
 	tc->destructor = NULL;
 	tc->child = NULL;
 	tc->name = NULL;
@@ -245,6 +338,29 @@ static inline void *__talloc(const void *context, size_t size)
 	return TC_PTR_FROM_CHUNK(tc);
 }
 
+/*
+ * Create a talloc pool
+ */
+
+void *talloc_pool(const void *context, size_t size)
+{
+	void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
+	struct talloc_chunk *tc;
+
+	if (unlikely(result == NULL)) {
+		return NULL;
+	}
+
+	tc = talloc_chunk_from_ptr(result);
+
+	tc->flags |= TALLOC_FLAG_POOL;
+	tc->pool = (char *)result + TALLOC_POOL_HDR_SIZE;
+
+	*talloc_pool_objectcount(tc) = 1;
+
+	return result;
+}
+
 /*
   setup a destructor to be called on free of a pointer
   the destructor should return 0 on success, or -1 on failure.
@@ -420,7 +536,29 @@ static inline int _talloc_free(void *ptr)
 	}
 
 	tc->flags |= TALLOC_FLAG_FREE;
-	free(tc);
+
+	if (tc->flags & (TALLOC_FLAG_POOL|TALLOC_FLAG_POOLMEM)) {
+		struct talloc_chunk *pool;
+		unsigned int *pool_object_count;
+
+		pool = (tc->flags & TALLOC_FLAG_POOL)
+			? tc : (struct talloc_chunk *)tc->pool;
+
+		pool_object_count = talloc_pool_objectcount(pool);
+
+		if (*pool_object_count == 0) {
+			TALLOC_ABORT("Pool object count zero!");
+		}
+
+		*pool_object_count -= 1;
+
+		if (*pool_object_count == 0) {
+			free(pool);
+		}
+	}
+	else {
+		free(tc);
+	}
 	return 0;
 }
 
@@ -718,6 +856,10 @@ void talloc_free_children(void *ptr)
 			talloc_steal(new_parent, child);
 		}
 	}
+
+	if (tc->flags & TALLOC_FLAG_POOL) {
+		tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
+	}
 }
 
 /* 
@@ -769,6 +911,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 {
 	struct talloc_chunk *tc;
 	void *new_ptr;
+	bool malloced = false;
 
 	/* size zero is equivalent to free() */
 	if (unlikely(size == 0)) {
@@ -808,7 +951,23 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 		free(tc);
 	}
 #else
-	new_ptr = realloc(tc, size + TC_HDR_SIZE);
+	if (tc->flags & TALLOC_FLAG_POOLMEM) {
+
+		new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
+		*talloc_pool_objectcount(tc->pool) -= 1;
+
+		if (new_ptr == NULL) {
+			new_ptr = malloc(TC_HDR_SIZE+size);
+			malloced = true;
+		}
+
+		if (new_ptr) {
+			memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
+		}
+	}
+	else {
+		new_ptr = realloc(tc, size + TC_HDR_SIZE);
+	}
 #endif
 	if (unlikely(!new_ptr)) {	
 		tc->flags &= ~TALLOC_FLAG_FREE; 
@@ -816,7 +975,10 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	}
 
 	tc = (struct talloc_chunk *)new_ptr;
-	tc->flags &= ~TALLOC_FLAG_FREE; 
+	tc->flags &= ~TALLOC_FLAG_FREE;
+	if (malloced) {
+		tc->flags &= ~TALLOC_FLAG_POOLMEM;
+	}
 	if (tc->parent) {
 		tc->parent->child = tc;
 	}
-- 
cgit 


From bdb52e4d58e3e4ce8797050d8e0c2c0ddc1e8e0e Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Thu, 10 Jan 2008 11:34:07 +0100
Subject: Mark talloc_pool memory for valgrind (This used to be commit
 6deca23b6c66616fbf5ba004e9b778aa68790df6)

---
 source4/lib/talloc/talloc.c | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index e38a4d6275..9e935b892c 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -245,6 +245,7 @@ static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
 	struct talloc_chunk *pool_ctx = NULL;
 	size_t space_left;
 	struct talloc_chunk *result;
+	size_t chunk_size;
 
 	if (parent == NULL) {
 		return NULL;
@@ -267,15 +268,19 @@ static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
 	/*
 	 * Align size to 16 bytes
 	 */
-	size = ((size + 15) & ~15);
+	chunk_size = ((size + 15) & ~15);
 
-	if (space_left < size) {
+	if (space_left < chunk_size) {
 		return NULL;
 	}
 
 	result = (struct talloc_chunk *)pool_ctx->pool;
 
-	pool_ctx->pool = (void *)((char *)result + size);
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
+	VALGRIND_MAKE_MEM_UNDEFINED(result, size);
+#endif
+
+	pool_ctx->pool = (void *)((char *)result + chunk_size);
 
 	result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
 	result->pool = pool_ctx;
@@ -358,6 +363,10 @@ void *talloc_pool(const void *context, size_t size)
 
 	*talloc_pool_objectcount(tc) = 1;
 
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+	VALGRIND_MAKE_MEM_NOACCESS(tc->pool, size);
+#endif
+
 	return result;
 }
 
@@ -859,6 +868,10 @@ void talloc_free_children(void *ptr)
 
 	if (tc->flags & TALLOC_FLAG_POOL) {
 		tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+		VALGRIND_MAKE_MEM_NOACCESS(
+			tc->pool, tc->size - TALLOC_POOL_HDR_SIZE);
+#endif
 	}
 }
 
-- 
cgit 


From 59820dcb43bcb2cbb5aad9d2a4dbeed90cc61d98 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Thu, 10 Jan 2008 11:35:17 +0100
Subject: talloc_free_children can only reset pool if it's empty (This used to
 be commit 5cc7a638e93e5f3540755b441a99d4fd3c9c7134)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 9e935b892c..35ed447e45 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -866,7 +866,8 @@ void talloc_free_children(void *ptr)
 		}
 	}
 
-	if (tc->flags & TALLOC_FLAG_POOL) {
+	if ((tc->flags & TALLOC_FLAG_POOL)
+	    && (*talloc_pool_objectcount(tc) == 1)) {
 		tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
 		VALGRIND_MAKE_MEM_NOACCESS(
-- 
cgit 


From a275310bcba62343a759ee7578929eca866fc759 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Thu, 10 Jan 2008 11:35:40 +0100
Subject: Fix a c++ warning (This used to be commit
 9f402c607f44663cab91cc7d2139f62b84c99cc0)

---
 source4/lib/talloc/talloc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 35ed447e45..12b85f5a65 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -968,7 +968,8 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 	if (tc->flags & TALLOC_FLAG_POOLMEM) {
 
 		new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
-		*talloc_pool_objectcount(tc->pool) -= 1;
+		*talloc_pool_objectcount((struct talloc_chunk *)
+					 (tc->pool)) -= 1;
 
 		if (new_ptr == NULL) {
 			new_ptr = malloc(TC_HDR_SIZE+size);
-- 
cgit 


From f5d90683596e02023d0a81d7d7e4a1458dd28278 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Sat, 19 Apr 2008 16:56:44 +0200
Subject: Fix bug 5400

Thanks to Jason Mader!

Volker
(cherry picked from commit 87d8a63ce4e6dd91ea3193d0a2574520a5857be2)
(This used to be commit 34ab9e5a23458c9f9845d1ff808c142cb2f1f2a4)
---
 source4/lib/talloc/talloc.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index 12b85f5a65..baf88fe754 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -85,8 +85,8 @@
 #define likely(x)   __builtin_expect(!!(x), 1)
 #define unlikely(x) __builtin_expect(!!(x), 0)
 #else
-#define likely(x) x
-#define unlikely(x) x
+#define likely(x) (x)
+#define unlikely(x) (x)
 #endif
 
 /* this null_context is only used if talloc_enable_leak_report() or
-- 
cgit 


From 9d6e473c22baba10e8ad5f9423c6798e1d070d23 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sun, 14 Sep 2008 18:50:13 +0200
Subject: Fix warnings on SuSE 9.0.

The macros "[un]likely" are already defined on SuSE 9.0.
Patch from Volker.

(partialy cherry-picked 30d181c92463aecd6e649330d3645d86d5a17e43)
metze
(This used to be commit ad7ed33f786124e4afbba4330201a3a6463c6f73)
---
 source4/lib/talloc/talloc.c | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'source4/lib/talloc/talloc.c')

diff --git a/source4/lib/talloc/talloc.c b/source4/lib/talloc/talloc.c
index baf88fe754..1f7e52439f 100644
--- a/source4/lib/talloc/talloc.c
+++ b/source4/lib/talloc/talloc.c
@@ -82,12 +82,20 @@
 #if (__GNUC__ >= 3)
 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
    as its first argument */
+#ifndef likely
 #define likely(x)   __builtin_expect(!!(x), 1)
+#endif
+#ifndef unlikely
 #define unlikely(x) __builtin_expect(!!(x), 0)
+#endif
 #else
+#ifndef likely
 #define likely(x) (x)
+#endif
+#ifndef unlikely
 #define unlikely(x) (x)
 #endif
+#endif
 
 /* this null_context is only used if talloc_enable_leak_report() or
    talloc_enable_leak_report_full() is called, otherwise it remains
-- 
cgit