r4466: rather than defining "STANDALONE" for building tdb, ldb and talloc
authorAndrew Tridgell <tridge@samba.org>
Sat, 1 Jan 2005 05:06:22 +0000 (05:06 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:07:54 +0000 (13:07 -0500)
outside the tree, instead defined _SAMBA_BUILD_ inside the Samba
build. This makes it easier to pull code out of Samba for external
use.
(This used to be commit 09e98c8745cca7ccb1ad7134c0c09b8e4c0f4f06)

13 files changed:
source4/build/smb_build/makefile.pm
source4/lib/ldb/Makefile.ldb
source4/lib/ldb/common/talloc.c [new file with mode: 0644]
source4/lib/ldb/include/talloc.h [new file with mode: 0644]
source4/lib/ldb/ldb_tdb/ldb_tdb.h
source4/lib/talloc.c
source4/lib/tdb/common/spinlock.c
source4/lib/tdb/common/tdb.c
source4/lib/tdb/tools/tdbbackup.c
source4/lib/tdb/tools/tdbdump.c
source4/lib/tdb/tools/tdbtest.c
source4/lib/tdb/tools/tdbtorture.c
source4/torture/local/talloc.c

index c6065985682cdcff43d04885423be45e3450ff75..0855beed081233e18efa3fe543d10cf3479ce497 100644 (file)
@@ -83,7 +83,7 @@ sub _prepare_compiler_linker($)
 
        $output = "
 CC=\@CC\@
-CC_FLAGS=-Iinclude -I. -I\$(srcdir)/include -I\$(srcdir) -Ilib \@CFLAGS\@ \@CPPFLAGS\@
+CC_FLAGS=-Iinclude -I. -I\$(srcdir)/include -I\$(srcdir) -D_SAMBA_BUILD_ -Ilib \@CFLAGS\@ \@CPPFLAGS\@
 
 LD=\@CC\@
 LD_FLAGS=\@LDFLAGS\@ \@CFLAGS\@
index a7c86b4e825f2424968fe6452eee298250986029..721ba5f407d1965ecff97ef69d828b1139b76ef2 100644 (file)
@@ -11,7 +11,7 @@ endif
 
 TDBDIR=../tdb
 
-CFLAGS=-Wall -Wall -Wshadow -Wstrict-prototypes -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -g -Iinclude -I. -I.. -I$(TDBDIR)/include -DSTANDALONE=1 -DUSE_MMAP=1 $(LDAP_FLAGS)
+CFLAGS=-Wall -Wall -Wshadow -Wstrict-prototypes -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -g -Iinclude -I. -I.. -I$(TDBDIR)/include -DUSE_MMAP=1 $(LDAP_FLAGS)
 LIB_FLAGS=-Llib -lldb $(LDAP_LIBS)
 
 TDB_OBJ=$(TDBDIR)/common/tdb.o $(TDBDIR)/common/spinlock.o
@@ -21,7 +21,7 @@ LDB_TDB_OBJ=ldb_tdb/ldb_match.o ldb_tdb/ldb_tdb.o \
        ldb_tdb/ldb_cache.o
 
 
-COMMON_OBJ=common/ldb.o common/ldb_ldif.o common/util.o \
+COMMON_OBJ=common/ldb.o common/ldb_ldif.o common/util.o  common/talloc.o \
           common/ldb_parse.o common/ldb_msg.o common/ldb_utf8.o \
           common/ldb_alloc.o common/ldb_debug.o common/ldb_modules.o
 
diff --git a/source4/lib/ldb/common/talloc.c b/source4/lib/ldb/common/talloc.c
new file mode 100644 (file)
index 0000000..7f50264
--- /dev/null
@@ -0,0 +1,997 @@
+/* 
+   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 "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
+#define discard_const_p(type, ptr) ((type *)(ptr))
+#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->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;
+       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);
+}
diff --git a/source4/lib/ldb/include/talloc.h b/source4/lib/ldb/include/talloc.h
new file mode 100644 (file)
index 0000000..ffb4c9f
--- /dev/null
@@ -0,0 +1,96 @@
+#ifndef _TALLOC_H_
+#define _TALLOC_H_
+/* 
+   Unix SMB/CIFS implementation.
+   Samba temporary memory allocation functions
+
+   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.
+*/
+
+/* this is only needed for compatibility with the old talloc */
+typedef void TALLOC_CTX;
+
+/*
+  this uses a little trick to allow __LINE__ to be stringified
+*/
+#define _STRING_LINE_(s)    #s
+#define _STRING_LINE2_(s)   _STRING_LINE_(s)
+#define __LINESTR__       _STRING_LINE2_(__LINE__)
+#define __location__ __FILE__ ":" __LINESTR__
+
+/* useful macros for creating type checked pointers */
+#define talloc(ctx, size) talloc_named_const(ctx, size, __location__)
+#define talloc_zero(ctx, size) _talloc_zero(ctx, size, __location__)
+#define talloc_realloc(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
+#define talloc_p(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
+#define talloc_zero_p(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
+#define talloc_zero_array_p(ctx, type, count) (type *)talloc_zero_array(ctx, sizeof(type), count, __location__)
+#define talloc_array_p(ctx, type, count) (type *)talloc_array(ctx, sizeof(type), count, __location__)
+#define talloc_realloc_p(ctx, p, type, count) (type *)talloc_realloc_array(ctx, p, sizeof(type), count, __location__)
+#define talloc_memdup(t, p, size) _talloc_memdup(t, p, size, __location__)
+
+#define talloc_destroy(ctx) talloc_free(ctx)
+
+#define malloc_p(type) (type *)malloc(sizeof(type))
+#define malloc_array_p(type, count) (type *)realloc_array(NULL, sizeof(type), count)
+#define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count)
+
+#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__)
+#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__)
+
+#ifndef PRINTF_ATTRIBUTE
+#define PRINTF_ATTRIBUTE(a1, a2)
+#endif
+
+
+/* The following definitions come from lib/talloc.c  */
+void *_talloc(const void *context, size_t size);
+void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
+void talloc_increase_ref_count(const void *ptr);
+void *talloc_reference(const void *context, const void *ptr);
+int talloc_unlink(const void *context, void *ptr);
+void talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+void talloc_set_name_const(const void *ptr, const char *name);
+void *talloc_named(const void *context, size_t size, 
+                  const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
+void *talloc_named_const(const void *context, size_t size, const char *name);
+const char *talloc_get_name(const void *ptr);
+void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
+int talloc_free(void *ptr);
+void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
+void *talloc_steal(const void *new_ctx, const void *ptr);
+off_t talloc_total_size(const void *ptr);
+off_t talloc_total_blocks(const void *ptr);
+void talloc_report_full(const void *ptr, FILE *f);
+void talloc_report(const void *ptr, FILE *f);
+void talloc_enable_leak_report(void);
+void talloc_enable_leak_report_full(void);
+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);
+char *talloc_strdup(const void *t, const char *p);
+char *talloc_strndup(const void *t, const char *p, size_t n);
+char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+char *talloc_asprintf_append(char *s,
+                            const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+void *talloc_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);
+void *talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
+void *talloc_ldb_alloc(void *context, void *ptr, size_t size);
+
+#endif
+
index 05311346f4e659f2ec38ee9020b03304521788c0..7d6f35dc79d6acd24333d344145311485aa77867 100644 (file)
@@ -1,5 +1,5 @@
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #include "tdb.h"
 #endif
 
index 0b1f5b7cb55148813c5e1f036a810a26cd1eb302..7f502648011e55b59069ef9e245e3fec5ad47e79 100644 (file)
 */
 
 
-/*
-  if you need to build this outside of the Samba source tree then please define _STANDALONE_
-*/
-#ifdef _STANDALONE_
+#ifdef _SAMBA_BUILD_
+#include "includes.h"
+#else
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include "talloc.h"
-#else
-#include "includes.h"
 #endif
 
 /* use this to force every realloc to change the pointer, to stress test
index 27481e221c1f7cc6ccd8e75ce01e8c99b20ac0d7..30bfd77962f56a9c92276e318a9f2bea38baffce 100644 (file)
@@ -27,7 +27,7 @@
 #include <config.h>
 #endif
 
-#if STANDALONE
+#ifndef _SAMBA_BUILD_
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -157,12 +157,12 @@ static inline int __spin_is_locked(spinlock_t *lock)
  * "sgi" and "_COMPILER_VERSION" are always defined by MIPSPro.
  */
 
-#if defined(STANDALONE)
+#ifndef _SAMBA_BUILD_
 
 /* MIPSPro 7.3 has "__inline" as an extension, but not "inline. */
 #define inline __inline
 
-#endif /* STANDALONE */
+#endif /* _SAMBA_BUILD_ */
 
 /* Returns 0 if the lock is acquired, EBUSY otherwise. */
 static inline int __spin_trylock(spinlock_t *lock)
index afe2ca1621d2a1f8089c77647ab429039b11fd2a..46b24991794aceb74f7eb85da586b5c655eb0460 100644 (file)
@@ -46,7 +46,7 @@
  * right time.  Probably too hard -- the process just doesn't know.
  */ 
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
index 1a0e1c1588fdc4affd532ae7c699c6f1e6a35d91..4cb6a8cfddcd228f6363cafc86a269a78c7dd6a5 100644 (file)
@@ -41,7 +41,7 @@
 
  */
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
index dbb647cbbf56ccc176c54ff7a5729ba9736a74f0..dd018af6f54c7dde7dfd3d613bb9db550a43140f 100644 (file)
@@ -18,7 +18,7 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
index 6c20a5dc77dba69ad502e0f44de82a90471b0eb2..f4854b59313410f14212869dce5c77a4beebd664 100644 (file)
@@ -1,6 +1,6 @@
 /* a test program for tdb - the trivial database */
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
index e90a967138b84a27e525a938a55e232b1bb17c57..890e25af50fc6c4d4ac22b894464b89886e069f0 100644 (file)
@@ -2,7 +2,7 @@
    writers - that stresses the locking code. Build with TDB_DEBUG=1
    for best effect */
 
-#ifdef STANDALONE
+#ifndef _SAMBA_BUILD_
 #include <stdlib.h>
 #include <time.h>
 #include <stdio.h>
index 2eedb2b9b08fea813d556aedceda2667b6cfd4d8..69becf67ccd3663bf6a2b0773bf2bfcba63aa13a 100644 (file)
@@ -20,7 +20,9 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#ifdef _STANDALONE_
+#ifdef _SAMBA_BUILD_
+#include "includes.h"
+#else
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
 #include <time.h>
 #include "talloc.h"
-#else
-#include "includes.h"
 #endif
 
 /* the test suite can be built standalone, or as part of Samba */
-#ifdef _STANDALONE_
+#ifndef _SAMBA_BUILD_
 typedef enum {False=0,True=1} BOOL;
 
 static struct timeval current_time(void)
@@ -49,7 +49,7 @@ static double elapsed_time(struct timeval *tv)
        return (tv2.tv_sec - tv->tv_sec) + 
               (tv2.tv_usec - tv->tv_usec)*1.0e-6;
 }
-#endif /* _STANDALONE_ */
+#endif /* _SAMBA_BUILD_ */
 
 
 #define CHECK_SIZE(ptr, tsize) do { \
@@ -712,7 +712,7 @@ BOOL torture_local_talloc(void)
 
 
 
-#ifdef _STANDALONE_
+#ifndef _SAMBA_BUILD_
 int main(void)
 {
        if (!torture_local_talloc(0)) {
@@ -722,4 +722,3 @@ int main(void)
        return 0;
 }
 #endif
-