lib/talloc/talloc.c

   1 /*
   2    Samba Unix SMB/CIFS implementation.
   3
   4    Samba trivial allocation library - new interface
   5
   6    NOTE: Please read talloc_guide.txt for full documentation
   7
   8    Copyright (C) Andrew Tridgell 2004
   9    Copyright (C) Stefan Metzmacher 2006
  10
  11      ** NOTE! The following LGPL license applies to the talloc
  12      ** library. This does NOT imply that all of Samba is released
  13      ** under the LGPL
  14
  15    This library is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU Lesser General Public
  17    License as published by the Free Software Foundation; either
  18    version 3 of the License, or (at your option) any later version.
  19
  20    This library is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    Lesser General Public License for more details.
  24
  25    You should have received a copy of the GNU Lesser General Public
  26    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  27 */
  28
  29 /*
  30   inspired by http://swapped.cc/halloc/
  31 */
  32
  33 #include "replace.h"
  34 #include "talloc.h"
  35
  36 #ifdef TALLOC_BUILD_VERSION_MAJOR
  37 #if (TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR)
  38 #error "TALLOC_VERSION_MAJOR != TALLOC_BUILD_VERSION_MAJOR"
  39 #endif
  40 #endif
  41
  42 #ifdef TALLOC_BUILD_VERSION_MINOR
  43 #if (TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR)
  44 #error "TALLOC_VERSION_MINOR != TALLOC_BUILD_VERSION_MINOR"
  45 #endif
  46 #endif
  47
  48 /* use this to force every realloc to change the pointer, to stress test
  49    code that might not cope */
  50 #define ALWAYS_REALLOC 0
  51
  52
  53 #define MAX_TALLOC_SIZE 0x10000000
  54 #define TALLOC_MAGIC_BASE 0xe814ec70
  55 #define TALLOC_MAGIC ( \
  56         TALLOC_MAGIC_BASE + \
  57         (TALLOC_VERSION_MAJOR << 12) + \
  58         (TALLOC_VERSION_MINOR << 4) \
  59 )
  60
  61 #define TALLOC_FLAG_FREE 0x01
  62 #define TALLOC_FLAG_LOOP 0x02
  63 #define TALLOC_FLAG_POOL 0x04           /* This is a talloc pool */
  64 #define TALLOC_FLAG_POOLMEM 0x08        /* This is allocated in a pool */
  65 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
  66
  67 /* by default we abort when given a bad pointer (such as when talloc_free() is called
  68    on a pointer that came from malloc() */
  69 #ifndef TALLOC_ABORT
  70 #define TALLOC_ABORT(reason) abort()
  71 #endif
  72
  73 #ifndef discard_const_p
  74 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
  75 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
  76 #else
  77 # define discard_const_p(type, ptr) ((type *)(ptr))
  78 #endif
  79 #endif
  80
  81 /* these macros gain us a few percent of speed on gcc */
  82 #if (__GNUC__ >= 3)
  83 /* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
  84    as its first argument */
  85 #ifndef likely
  86 #define likely(x)   __builtin_expect(!!(x), 1)
  87 #endif
  88 #ifndef unlikely
  89 #define unlikely(x) __builtin_expect(!!(x), 0)
  90 #endif
  91 #else
  92 #ifndef likely
  93 #define likely(x) (x)
  94 #endif
  95 #ifndef unlikely
  96 #define unlikely(x) (x)
  97 #endif
  98 #endif
  99
 100 /* this null_context is only used if talloc_enable_leak_report() or
 101    talloc_enable_leak_report_full() is called, otherwise it remains
 102    NULL
 103 */
 104 static void *null_context;
 105 static void *autofree_context;
 106
 107 struct talloc_reference_handle {
 108         struct talloc_reference_handle *next, *prev;
 109         void *ptr;
 110         const char *location;
 111 };
 112
 113 typedef int (*talloc_destructor_t)(void *);
 114
 115 struct talloc_chunk {
 116         struct talloc_chunk *next, *prev;
 117         struct talloc_chunk *parent, *child;
 118         struct talloc_reference_handle *refs;
 119         talloc_destructor_t destructor;
 120         const char *name;
 121         size_t size;
 122         unsigned flags;
 123
 124         /*
 125          * "pool" has dual use:
 126          *
 127          * For the talloc pool itself (i.e. TALLOC_FLAG_POOL is set), "pool"
 128          * marks the end of the currently allocated area.
 129          *
 130          * For members of the pool (i.e. TALLOC_FLAG_POOLMEM is set), "pool"
 131          * is a pointer to the struct talloc_chunk of the pool that it was
 132          * allocated from. This way children can quickly find the pool to chew
 133          * from.
 134          */
 135         void *pool;
 136 };
 137
 138 /* 16 byte alignment seems to keep everyone happy */
 139 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
 140 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 141
 142 _PUBLIC_ int talloc_version_major(void)
 143 {
 144         return TALLOC_VERSION_MAJOR;
 145 }
 146
 147 _PUBLIC_ int talloc_version_minor(void)
 148 {
 149         return TALLOC_VERSION_MINOR;
 150 }
 151
 152 static void (*talloc_log_fn)(const char *message);
 153
 154 _PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
 155 {
 156         talloc_log_fn = log_fn;
 157 }
 158
 159 static void talloc_log(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
 160 static void talloc_log(const char *fmt, ...)
 161 {
 162         va_list ap;
 163         char *message;
 164
 165         if (!talloc_log_fn) {
 166                 return;
 167         }
 168
 169         va_start(ap, fmt);
 170         message = talloc_vasprintf(NULL, fmt, ap);
 171         va_end(ap);
 172
 173         talloc_log_fn(message);
 174         talloc_free(message);
 175 }
 176
 177 static void talloc_log_stderr(const char *message)
 178 {
 179         fprintf(stderr, "%s", message);
 180 }
 181
 182 _PUBLIC_ void talloc_set_log_stderr(void)
 183 {
 184         talloc_set_log_fn(talloc_log_stderr);
 185 }
 186
 187 static void (*talloc_abort_fn)(const char *reason);
 188
 189 _PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
 190 {
 191         talloc_abort_fn = abort_fn;
 192 }
 193
 194 static void talloc_abort(const char *reason)
 195 {
 196         talloc_log("%s\n", reason);
 197
 198         if (!talloc_abort_fn) {
 199                 TALLOC_ABORT(reason);
 200         }
 201
 202         talloc_abort_fn(reason);
 203 }
 204
 205 static void talloc_abort_magic(unsigned magic)
 206 {
 207         unsigned striped = magic - TALLOC_MAGIC_BASE;
 208         unsigned major = (striped & 0xFFFFF000) >> 12;
 209         unsigned minor = (striped & 0x00000FF0) >> 4;
 210         talloc_log("Bad talloc magic[0x%08X/%u/%u] expected[0x%08X/%u/%u]\n",
 211                    magic, major, minor,
 212                    TALLOC_MAGIC, TALLOC_VERSION_MAJOR, TALLOC_VERSION_MINOR);
 213         talloc_abort("Bad talloc magic value - wrong talloc version used/mixed");
 214 }
 215
 216 static void talloc_abort_double_free(void)
 217 {
 218         talloc_abort("Bad talloc magic value - double free");
 219 }
 220
 221 static void talloc_abort_unknown_value(void)
 222 {
 223         talloc_abort("Bad talloc magic value - unknown value");
 224 }
 225
 226 /* panic if we get a bad magic value */
 227 static inline struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
 228 {
 229         const char *pp = (const char *)ptr;
 230         struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, pp - TC_HDR_SIZE);
 231         if (unlikely((tc->flags & (TALLOC_FLAG_FREE | ~0xF)) != TALLOC_MAGIC)) {
 232                 if ((tc->flags & (~0xFFF)) == TALLOC_MAGIC_BASE) {
 233                         talloc_abort_magic(tc->flags & (~0xF));
 234                         return NULL;
 235                 }
 236
 237                 if (tc->flags & TALLOC_FLAG_FREE) {
 238                         talloc_log("talloc: double free error - first free may be at %s\n", tc->name);
 239                         talloc_abort_double_free();
 240                         return NULL;
 241                 } else {
 242                         talloc_abort_unknown_value();
 243                         return NULL;
 244                 }
 245         }
 246         return tc;
 247 }
 248
 249 /* hook into the front of the list */
 250 #define _TLIST_ADD(list, p) \
 251 do { \
 252         if (!(list)) { \
 253                 (list) = (p); \
 254                 (p)->next = (p)->prev = NULL; \
 255         } else { \
 256                 (list)->prev = (p); \
 257                 (p)->next = (list); \
 258                 (p)->prev = NULL; \
 259                 (list) = (p); \
 260         }\
 261 } while (0)
 262
 263 /* remove an element from a list - element doesn't have to be in list. */
 264 #define _TLIST_REMOVE(list, p) \
 265 do { \
 266         if ((p) == (list)) { \
 267                 (list) = (p)->next; \
 268                 if (list) (list)->prev = NULL; \
 269         } else { \
 270                 if ((p)->prev) (p)->prev->next = (p)->next; \
 271                 if ((p)->next) (p)->next->prev = (p)->prev; \
 272         } \
 273         if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
 274 } while (0)
 275
 276
 277 /*
 278   return the parent chunk of a pointer
 279 */
 280 static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 281 {
 282         struct talloc_chunk *tc;
 283
 284         if (unlikely(ptr == NULL)) {
 285                 return NULL;
 286         }
 287
 288         tc = talloc_chunk_from_ptr(ptr);
 289         while (tc->prev) tc=tc->prev;
 290
 291         return tc->parent;
 292 }
 293
 294 _PUBLIC_ void *talloc_parent(const void *ptr)
 295 {
 296         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 297         return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
 298 }
 299
 300 /*
 301   find parents name
 302 */
 303 _PUBLIC_ const char *talloc_parent_name(const void *ptr)
 304 {
 305         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 306         return tc? tc->name : NULL;
 307 }
 308
 309 /*
 310   A pool carries an in-pool object count count in the first 16 bytes.
 311   bytes. This is done to support talloc_steal() to a parent outside of the
 312   pool. The count includes the pool itself, so a talloc_free() on a pool will
 313   only destroy the pool if the count has dropped to zero. A talloc_free() of a
 314   pool member will reduce the count, and eventually also call free(3) on the
 315   pool memory.
 316
 317   The object count is not put into "struct talloc_chunk" because it is only
 318   relevant for talloc pools and the alignment to 16 bytes would increase the
 319   memory footprint of each talloc chunk by those 16 bytes.
 320 */
 321
 322 #define TALLOC_POOL_HDR_SIZE 16
 323
 324 static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc)
 325 {
 326         return (unsigned int *)((char *)tc + sizeof(struct talloc_chunk));
 327 }
 328
 329 /*
 330   Allocate from a pool
 331 */
 332
 333 static struct talloc_chunk *talloc_alloc_pool(struct talloc_chunk *parent,
 334                                               size_t size)
 335 {
 336         struct talloc_chunk *pool_ctx = NULL;
 337         size_t space_left;
 338         struct talloc_chunk *result;
 339         size_t chunk_size;
 340
 341         if (parent == NULL) {
 342                 return NULL;
 343         }
 344
 345         if (parent->flags & TALLOC_FLAG_POOL) {
 346                 pool_ctx = parent;
 347         }
 348         else if (parent->flags & TALLOC_FLAG_POOLMEM) {
 349                 pool_ctx = (struct talloc_chunk *)parent->pool;
 350         }
 351
 352         if (pool_ctx == NULL) {
 353                 return NULL;
 354         }
 355
 356         space_left = ((char *)pool_ctx + TC_HDR_SIZE + pool_ctx->size)
 357                 - ((char *)pool_ctx->pool);
 358
 359         /*
 360          * Align size to 16 bytes
 361          */
 362         chunk_size = ((size + 15) & ~15);
 363
 364         if (space_left < chunk_size) {
 365                 return NULL;
 366         }
 367
 368         result = (struct talloc_chunk *)pool_ctx->pool;
 369
 370 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
 371         VALGRIND_MAKE_MEM_UNDEFINED(result, size);
 372 #endif
 373
 374         pool_ctx->pool = (void *)((char *)result + chunk_size);
 375
 376         result->flags = TALLOC_MAGIC | TALLOC_FLAG_POOLMEM;
 377         result->pool = pool_ctx;
 378
 379         *talloc_pool_objectcount(pool_ctx) += 1;
 380
 381         return result;
 382 }
 383
 384 /*
 385    Allocate a bit of memory as a child of an existing pointer
 386 */
 387 static inline void *__talloc(const void *context, size_t size)
 388 {
 389         struct talloc_chunk *tc = NULL;
 390
 391         if (unlikely(context == NULL)) {
 392                 context = null_context;
 393         }
 394
 395         if (unlikely(size >= MAX_TALLOC_SIZE)) {
 396                 return NULL;
 397         }
 398
 399         if (context != NULL) {
 400                 tc = talloc_alloc_pool(talloc_chunk_from_ptr(context),
 401                                        TC_HDR_SIZE+size);
 402         }
 403
 404         if (tc == NULL) {
 405                 tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
 406                 if (unlikely(tc == NULL)) return NULL;
 407                 tc->flags = TALLOC_MAGIC;
 408                 tc->pool  = NULL;
 409         }
 410
 411         tc->size = size;
 412         tc->destructor = NULL;
 413         tc->child = NULL;
 414         tc->name = NULL;
 415         tc->refs = NULL;
 416
 417         if (likely(context)) {
 418                 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
 419
 420                 if (parent->child) {
 421                         parent->child->parent = NULL;
 422                         tc->next = parent->child;
 423                         tc->next->prev = tc;
 424                 } else {
 425                         tc->next = NULL;
 426                 }
 427                 tc->parent = parent;
 428                 tc->prev = NULL;
 429                 parent->child = tc;
 430         } else {
 431                 tc->next = tc->prev = tc->parent = NULL;
 432         }
 433
 434         return TC_PTR_FROM_CHUNK(tc);
 435 }
 436
 437 /*
 438  * Create a talloc pool
 439  */
 440
 441 _PUBLIC_ void *talloc_pool(const void *context, size_t size)
 442 {
 443         void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
 444         struct talloc_chunk *tc;
 445
 446         if (unlikely(result == NULL)) {
 447                 return NULL;
 448         }
 449
 450         tc = talloc_chunk_from_ptr(result);
 451
 452         tc->flags |= TALLOC_FLAG_POOL;
 453         tc->pool = (char *)result + TALLOC_POOL_HDR_SIZE;
 454
 455         *talloc_pool_objectcount(tc) = 1;
 456
 457 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
 458         VALGRIND_MAKE_MEM_NOACCESS(tc->pool, size);
 459 #endif
 460
 461         return result;
 462 }
 463
 464 /*
 465   setup a destructor to be called on free of a pointer
 466   the destructor should return 0 on success, or -1 on failure.
 467   if the destructor fails then the free is failed, and the memory can
 468   be continued to be used
 469 */
 470 _PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 471 {
 472         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 473         tc->destructor = destructor;
 474 }
 475
 476 /*
 477   increase the reference count on a piece of memory.
 478 */
 479 _PUBLIC_ int talloc_increase_ref_count(const void *ptr)
 480 {
 481         if (unlikely(!talloc_reference(null_context, ptr))) {
 482                 return -1;
 483         }
 484         return 0;
 485 }
 486
 487 /*
 488   helper for talloc_reference()
 489
 490   this is referenced by a function pointer and should not be inline
 491 */
 492 static int talloc_reference_destructor(struct talloc_reference_handle *handle)
 493 {
 494         struct talloc_chunk *ptr_tc = talloc_chunk_from_ptr(handle->ptr);
 495         _TLIST_REMOVE(ptr_tc->refs, handle);
 496         return 0;
 497 }
 498
 499 /*
 500    more efficient way to add a name to a pointer - the name must point to a
 501    true string constant
 502 */
 503 static inline void _talloc_set_name_const(const void *ptr, const char *name)
 504 {
 505         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 506         tc->name = name;
 507 }
 508
 509 /*
 510   internal talloc_named_const()
 511 */
 512 static inline void *_talloc_named_const(const void *context, size_t size, const char *name)
 513 {
 514         void *ptr;
 515
 516         ptr = __talloc(context, size);
 517         if (unlikely(ptr == NULL)) {
 518                 return NULL;
 519         }
 520
 521         _talloc_set_name_const(ptr, name);
 522
 523         return ptr;
 524 }
 525
 526 /*
 527   make a secondary reference to a pointer, hanging off the given context.
 528   the pointer remains valid until both the original caller and this given
 529   context are freed.
 530
 531   the major use for this is when two different structures need to reference the
 532   same underlying data, and you want to be able to free the two instances separately,
 533   and in either order
 534 */
 535 _PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
 536 {
 537         struct talloc_chunk *tc;
 538         struct talloc_reference_handle *handle;
 539         if (unlikely(ptr == NULL)) return NULL;
 540
 541         tc = talloc_chunk_from_ptr(ptr);
 542         handle = (struct talloc_reference_handle *)_talloc_named_const(context,
 543                                                    sizeof(struct talloc_reference_handle),
 544                                                    TALLOC_MAGIC_REFERENCE);
 545         if (unlikely(handle == NULL)) return NULL;
 546
 547         /* note that we hang the destructor off the handle, not the
 548            main context as that allows the caller to still setup their
 549            own destructor on the context if they want to */
 550         talloc_set_destructor(handle, talloc_reference_destructor);
 551         handle->ptr = discard_const_p(void, ptr);
 552         handle->location = location;
 553         _TLIST_ADD(tc->refs, handle);
 554         return handle->ptr;
 555 }
 556
 557 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
 558
 559 /*
 560    internal talloc_free call
 561 */
 562 static inline int _talloc_free_internal(void *ptr, const char *location)
 563 {
 564         struct talloc_chunk *tc;
 565
 566         if (unlikely(ptr == NULL)) {
 567                 return -1;
 568         }
 569
 570         tc = talloc_chunk_from_ptr(ptr);
 571
 572         if (unlikely(tc->refs)) {
 573                 int is_child;
 574                 /* check this is a reference from a child or grantchild
 575                  * back to it's parent or grantparent
 576                  *
 577                  * in that case we need to remove the reference and
 578                  * call another instance of talloc_free() on the current
 579                  * pointer.
 580                  */
 581                 is_child = talloc_is_parent(tc->refs, ptr);
 582                 _talloc_free_internal(tc->refs, location);
 583                 if (is_child) {
 584                         return _talloc_free_internal(ptr, location);
 585                 }
 586                 return -1;
 587         }
 588
 589         if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
 590                 /* we have a free loop - stop looping */
 591                 return 0;
 592         }
 593
 594         if (unlikely(tc->destructor)) {
 595                 talloc_destructor_t d = tc->destructor;
 596                 if (d == (talloc_destructor_t)-1) {
 597                         return -1;
 598                 }
 599                 tc->destructor = (talloc_destructor_t)-1;
 600                 if (d(ptr) == -1) {
 601                         tc->destructor = d;
 602                         return -1;
 603                 }
 604                 tc->destructor = NULL;
 605         }
 606
 607         if (tc->parent) {
 608                 _TLIST_REMOVE(tc->parent->child, tc);
 609                 if (tc->parent->child) {
 610                         tc->parent->child->parent = tc->parent;
 611                 }
 612         } else {
 613                 if (tc->prev) tc->prev->next = tc->next;
 614                 if (tc->next) tc->next->prev = tc->prev;
 615         }
 616
 617         tc->flags |= TALLOC_FLAG_LOOP;
 618
 619         while (tc->child) {
 620                 /* we need to work out who will own an abandoned child
 621                    if it cannot be freed. In priority order, the first
 622                    choice is owner of any remaining reference to this
 623                    pointer, the second choice is our parent, and the
 624                    final choice is the null context. */
 625                 void *child = TC_PTR_FROM_CHUNK(tc->child);
 626                 const void *new_parent = null_context;
 627                 if (unlikely(tc->child->refs)) {
 628                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
 629                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 630                 }
 631                 if (unlikely(_talloc_free_internal(child, location) == -1)) {
 632                         if (new_parent == null_context) {
 633                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
 634                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 635                         }
 636                         _talloc_steal_internal(new_parent, child);
 637                 }
 638         }
 639
 640         tc->flags |= TALLOC_FLAG_FREE;
 641
 642         /* we mark the freed memory with where we called the free
 643          * from. This means on a double free error we can report where
 644          * the first free came from
 645          */
 646         tc->name = location;
 647
 648         if (tc->flags & (TALLOC_FLAG_POOL|TALLOC_FLAG_POOLMEM)) {
 649                 struct talloc_chunk *pool;
 650                 unsigned int *pool_object_count;
 651
 652                 pool = (tc->flags & TALLOC_FLAG_POOL)
 653                         ? tc : (struct talloc_chunk *)tc->pool;
 654
 655                 pool_object_count = talloc_pool_objectcount(pool);
 656
 657                 if (*pool_object_count == 0) {
 658                         talloc_abort("Pool object count zero!");
 659                         return 0;
 660                 }
 661
 662                 *pool_object_count -= 1;
 663
 664                 if (*pool_object_count == 0) {
 665                         free(pool);
 666                 }
 667         }
 668         else {
 669                 free(tc);
 670         }
 671         return 0;
 672 }
 673
 674 /*
 675    move a lump of memory from one talloc context to another return the
 676    ptr on success, or NULL if it could not be transferred.
 677    passing NULL as ptr will always return NULL with no side effects.
 678 */
 679 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
 680 {
 681         struct talloc_chunk *tc, *new_tc;
 682
 683         if (unlikely(!ptr)) {
 684                 return NULL;
 685         }
 686
 687         if (unlikely(new_ctx == NULL)) {
 688                 new_ctx = null_context;
 689         }
 690
 691         tc = talloc_chunk_from_ptr(ptr);
 692
 693         if (unlikely(new_ctx == NULL)) {
 694                 if (tc->parent) {
 695                         _TLIST_REMOVE(tc->parent->child, tc);
 696                         if (tc->parent->child) {
 697                                 tc->parent->child->parent = tc->parent;
 698                         }
 699                 } else {
 700                         if (tc->prev) tc->prev->next = tc->next;
 701                         if (tc->next) tc->next->prev = tc->prev;
 702                 }
 703
 704                 tc->parent = tc->next = tc->prev = NULL;
 705                 return discard_const_p(void, ptr);
 706         }
 707
 708         new_tc = talloc_chunk_from_ptr(new_ctx);
 709
 710         if (unlikely(tc == new_tc || tc->parent == new_tc)) {
 711                 return discard_const_p(void, ptr);
 712         }
 713
 714         if (tc->parent) {
 715                 _TLIST_REMOVE(tc->parent->child, tc);
 716                 if (tc->parent->child) {
 717                         tc->parent->child->parent = tc->parent;
 718                 }
 719         } else {
 720                 if (tc->prev) tc->prev->next = tc->next;
 721                 if (tc->next) tc->next->prev = tc->prev;
 722         }
 723
 724         tc->parent = new_tc;
 725         if (new_tc->child) new_tc->child->parent = NULL;
 726         _TLIST_ADD(new_tc->child, tc);
 727
 728         return discard_const_p(void, ptr);
 729 }
 730
 731 /*
 732    move a lump of memory from one talloc context to another return the
 733    ptr on success, or NULL if it could not be transferred.
 734    passing NULL as ptr will always return NULL with no side effects.
 735 */
 736 _PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
 737 {
 738         struct talloc_chunk *tc;
 739
 740         if (unlikely(ptr == NULL)) {
 741                 return NULL;
 742         }
 743
 744         tc = talloc_chunk_from_ptr(ptr);
 745
 746         if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
 747                 struct talloc_reference_handle *h;
 748
 749                 talloc_log("WARNING: talloc_steal with references at %s\n",
 750                            location);
 751
 752                 for (h=tc->refs; h; h=h->next) {
 753                         talloc_log("\treference at %s\n",
 754                                    h->location);
 755                 }
 756         }
 757
 758 #if 0
 759         /* this test is probably too expensive to have on in the
 760            normal build, but it useful for debugging */
 761         if (talloc_is_parent(new_ctx, ptr)) {
 762                 talloc_log("WARNING: stealing into talloc child at %s\n", location);
 763         }
 764 #endif
 765
 766         return _talloc_steal_internal(new_ctx, ptr);
 767 }
 768
 769 /*
 770    this is like a talloc_steal(), but you must supply the old
 771    parent. This resolves the ambiguity in a talloc_steal() which is
 772    called on a context that has more than one parent (via references)
 773
 774    The old parent can be either a reference or a parent
 775 */
 776 _PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
 777 {
 778         struct talloc_chunk *tc;
 779         struct talloc_reference_handle *h;
 780
 781         if (unlikely(ptr == NULL)) {
 782                 return NULL;
 783         }
 784
 785         if (old_parent == talloc_parent(ptr)) {
 786                 return _talloc_steal_internal(new_parent, ptr);
 787         }
 788
 789         tc = talloc_chunk_from_ptr(ptr);
 790         for (h=tc->refs;h;h=h->next) {
 791                 if (talloc_parent(h) == old_parent) {
 792                         if (_talloc_steal_internal(new_parent, h) != h) {
 793                                 return NULL;
 794                         }
 795                         return discard_const_p(void, ptr);
 796                 }
 797         }
 798
 799         /* it wasn't a parent */
 800         return NULL;
 801 }
 802
 803 /*
 804   remove a secondary reference to a pointer. This undo's what
 805   talloc_reference() has done. The context and pointer arguments
 806   must match those given to a talloc_reference()
 807 */
 808 static inline int talloc_unreference(const void *context, const void *ptr)
 809 {
 810         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 811         struct talloc_reference_handle *h;
 812
 813         if (unlikely(context == NULL)) {
 814                 context = null_context;
 815         }
 816
 817         for (h=tc->refs;h;h=h->next) {
 818                 struct talloc_chunk *p = talloc_parent_chunk(h);
 819                 if (p == NULL) {
 820                         if (context == NULL) break;
 821                 } else if (TC_PTR_FROM_CHUNK(p) == context) {
 822                         break;
 823                 }
 824         }
 825         if (h == NULL) {
 826                 return -1;
 827         }
 828
 829         return _talloc_free_internal(h, __location__);
 830 }
 831
 832 /*
 833   remove a specific parent context from a pointer. This is a more
 834   controlled varient of talloc_free()
 835 */
 836 _PUBLIC_ int talloc_unlink(const void *context, void *ptr)
 837 {
 838         struct talloc_chunk *tc_p, *new_p;
 839         void *new_parent;
 840
 841         if (ptr == NULL) {
 842                 return -1;
 843         }
 844
 845         if (context == NULL) {
 846                 context = null_context;
 847         }
 848
 849         if (talloc_unreference(context, ptr) == 0) {
 850                 return 0;
 851         }
 852
 853         if (context == NULL) {
 854                 if (talloc_parent_chunk(ptr) != NULL) {
 855                         return -1;
 856                 }
 857         } else {
 858                 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
 859                         return -1;
 860                 }
 861         }
 862
 863         tc_p = talloc_chunk_from_ptr(ptr);
 864
 865         if (tc_p->refs == NULL) {
 866                 return _talloc_free_internal(ptr, __location__);
 867         }
 868
 869         new_p = talloc_parent_chunk(tc_p->refs);
 870         if (new_p) {
 871                 new_parent = TC_PTR_FROM_CHUNK(new_p);
 872         } else {
 873                 new_parent = NULL;
 874         }
 875
 876         if (talloc_unreference(new_parent, ptr) != 0) {
 877                 return -1;
 878         }
 879
 880         _talloc_steal_internal(new_parent, ptr);
 881
 882         return 0;
 883 }
 884
 885 /*
 886   add a name to an existing pointer - va_list version
 887 */
 888 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
 889
 890 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
 891 {
 892         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 893         tc->name = talloc_vasprintf(ptr, fmt, ap);
 894         if (likely(tc->name)) {
 895                 _talloc_set_name_const(tc->name, ".name");
 896         }
 897         return tc->name;
 898 }
 899
 900 /*
 901   add a name to an existing pointer
 902 */
 903 _PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
 904 {
 905         const char *name;
 906         va_list ap;
 907         va_start(ap, fmt);
 908         name = talloc_set_name_v(ptr, fmt, ap);
 909         va_end(ap);
 910         return name;
 911 }
 912
 913
 914 /*
 915   create a named talloc pointer. Any talloc pointer can be named, and
 916   talloc_named() operates just like talloc() except that it allows you
 917   to name the pointer.
 918 */
 919 _PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 920 {
 921         va_list ap;
 922         void *ptr;
 923         const char *name;
 924
 925         ptr = __talloc(context, size);
 926         if (unlikely(ptr == NULL)) return NULL;
 927
 928         va_start(ap, fmt);
 929         name = talloc_set_name_v(ptr, fmt, ap);
 930         va_end(ap);
 931
 932         if (unlikely(name == NULL)) {
 933                 _talloc_free_internal(ptr, __location__);
 934                 return NULL;
 935         }
 936
 937         return ptr;
 938 }
 939
 940 /*
 941   return the name of a talloc ptr, or "UNNAMED"
 942 */
 943 _PUBLIC_ const char *talloc_get_name(const void *ptr)
 944 {
 945         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 946         if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
 947                 return ".reference";
 948         }
 949         if (likely(tc->name)) {
 950                 return tc->name;
 951         }
 952         return "UNNAMED";
 953 }
 954
 955
 956 /*
 957   check if a pointer has the given name. If it does, return the pointer,
 958   otherwise return NULL
 959 */
 960 _PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
 961 {
 962         const char *pname;
 963         if (unlikely(ptr == NULL)) return NULL;
 964         pname = talloc_get_name(ptr);
 965         if (likely(pname == name || strcmp(pname, name) == 0)) {
 966                 return discard_const_p(void, ptr);
 967         }
 968         return NULL;
 969 }
 970
 971 static void talloc_abort_type_missmatch(const char *location,
 972                                         const char *name,
 973                                         const char *expected)
 974 {
 975         const char *reason;
 976
 977         reason = talloc_asprintf(NULL,
 978                                  "%s: Type mismatch: name[%s] expected[%s]",
 979                                  location,
 980                                  name?name:"NULL",
 981                                  expected);
 982         if (!reason) {
 983                 reason = "Type mismatch";
 984         }
 985
 986         talloc_abort(reason);
 987 }
 988
 989 _PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
 990 {
 991         const char *pname;
 992
 993         if (unlikely(ptr == NULL)) {
 994                 talloc_abort_type_missmatch(location, NULL, name);
 995                 return NULL;
 996         }
 997
 998         pname = talloc_get_name(ptr);
 999         if (likely(pname == name || strcmp(pname, name) == 0)) {
1000                 return discard_const_p(void, ptr);
1001         }
1002
1003         talloc_abort_type_missmatch(location, pname, name);
1004         return NULL;
1005 }
1006
1007 /*
1008   this is for compatibility with older versions of talloc
1009 */
1010 _PUBLIC_ void *talloc_init(const char *fmt, ...)
1011 {
1012         va_list ap;
1013         void *ptr;
1014         const char *name;
1015
1016         /*
1017          * samba3 expects talloc_report_depth_cb(NULL, ...)
1018          * reports all talloc'ed memory, so we need to enable
1019          * null_tracking
1020          */
1021         talloc_enable_null_tracking();
1022
1023         ptr = __talloc(NULL, 0);
1024         if (unlikely(ptr == NULL)) return NULL;
1025
1026         va_start(ap, fmt);
1027         name = talloc_set_name_v(ptr, fmt, ap);
1028         va_end(ap);
1029
1030         if (unlikely(name == NULL)) {
1031                 _talloc_free_internal(ptr, __location__);
1032                 return NULL;
1033         }
1034
1035         return ptr;
1036 }
1037
1038 /*
1039   this is a replacement for the Samba3 talloc_destroy_pool functionality. It
1040   should probably not be used in new code. It's in here to keep the talloc
1041   code consistent across Samba 3 and 4.
1042 */
1043 _PUBLIC_ void talloc_free_children(void *ptr)
1044 {
1045         struct talloc_chunk *tc;
1046
1047         if (unlikely(ptr == NULL)) {
1048                 return;
1049         }
1050
1051         tc = talloc_chunk_from_ptr(ptr);
1052
1053         while (tc->child) {
1054                 /* we need to work out who will own an abandoned child
1055                    if it cannot be freed. In priority order, the first
1056                    choice is owner of any remaining reference to this
1057                    pointer, the second choice is our parent, and the
1058                    final choice is the null context. */
1059                 void *child = TC_PTR_FROM_CHUNK(tc->child);
1060                 const void *new_parent = null_context;
1061                 if (unlikely(tc->child->refs)) {
1062                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
1063                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1064                 }
1065                 if (unlikely(talloc_free(child) == -1)) {
1066                         if (new_parent == null_context) {
1067                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
1068                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1069                         }
1070                         _talloc_steal_internal(new_parent, child);
1071                 }
1072         }
1073
1074         if ((tc->flags & TALLOC_FLAG_POOL)
1075             && (*talloc_pool_objectcount(tc) == 1)) {
1076                 tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
1077 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
1078                 VALGRIND_MAKE_MEM_NOACCESS(
1079                         tc->pool, tc->size - TALLOC_POOL_HDR_SIZE);
1080 #endif
1081         }
1082 }
1083
1084 /*
1085    Allocate a bit of memory as a child of an existing pointer
1086 */
1087 _PUBLIC_ void *_talloc(const void *context, size_t size)
1088 {
1089         return __talloc(context, size);
1090 }
1091
1092 /*
1093   externally callable talloc_set_name_const()
1094 */
1095 _PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
1096 {
1097         _talloc_set_name_const(ptr, name);
1098 }
1099
1100 /*
1101   create a named talloc pointer. Any talloc pointer can be named, and
1102   talloc_named() operates just like talloc() except that it allows you
1103   to name the pointer.
1104 */
1105 _PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
1106 {
1107         return _talloc_named_const(context, size, name);
1108 }
1109
1110 /*
1111    free a talloc pointer. This also frees all child pointers of this
1112    pointer recursively
1113
1114    return 0 if the memory is actually freed, otherwise -1. The memory
1115    will not be freed if the ref_count is > 1 or the destructor (if
1116    any) returns non-zero
1117 */
1118 _PUBLIC_ int _talloc_free(void *ptr, const char *location)
1119 {
1120         struct talloc_chunk *tc;
1121
1122         if (unlikely(ptr == NULL)) {
1123                 return -1;
1124         }
1125
1126         tc = talloc_chunk_from_ptr(ptr);
1127
1128         if (unlikely(tc->refs != NULL)) {
1129                 struct talloc_reference_handle *h;
1130
1131                 talloc_log("ERROR: talloc_free with references at %s\n",
1132                            location);
1133
1134                 for (h=tc->refs; h; h=h->next) {
1135                         talloc_log("\treference at %s\n",
1136                                    h->location);
1137                 }
1138                 return -1;
1139         }
1140
1141         return _talloc_free_internal(ptr, location);
1142 }
1143
1144
1145
1146 /*
1147   A talloc version of realloc. The context argument is only used if
1148   ptr is NULL
1149 */
1150 _PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1151 {
1152         struct talloc_chunk *tc;
1153         void *new_ptr;
1154         bool malloced = false;
1155
1156         /* size zero is equivalent to free() */
1157         if (unlikely(size == 0)) {
1158                 talloc_unlink(context, ptr);
1159                 return NULL;
1160         }
1161
1162         if (unlikely(size >= MAX_TALLOC_SIZE)) {
1163                 return NULL;
1164         }
1165
1166         /* realloc(NULL) is equivalent to malloc() */
1167         if (ptr == NULL) {
1168                 return _talloc_named_const(context, size, name);
1169         }
1170
1171         tc = talloc_chunk_from_ptr(ptr);
1172
1173         /* don't allow realloc on referenced pointers */
1174         if (unlikely(tc->refs)) {
1175                 return NULL;
1176         }
1177
1178         /* don't let anybody try to realloc a talloc_pool */
1179         if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1180                 return NULL;
1181         }
1182
1183         /* don't shrink if we have less than 1k to gain */
1184         if ((size < tc->size) && ((tc->size - size) < 1024)) {
1185                 tc->size = size;
1186                 return ptr;
1187         }
1188
1189         /* by resetting magic we catch users of the old memory */
1190         tc->flags |= TALLOC_FLAG_FREE;
1191
1192 #if ALWAYS_REALLOC
1193         new_ptr = malloc(size + TC_HDR_SIZE);
1194         if (new_ptr) {
1195                 memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
1196                 free(tc);
1197         }
1198 #else
1199         if (tc->flags & TALLOC_FLAG_POOLMEM) {
1200
1201                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1202                 *talloc_pool_objectcount((struct talloc_chunk *)
1203                                          (tc->pool)) -= 1;
1204
1205                 if (new_ptr == NULL) {
1206                         new_ptr = malloc(TC_HDR_SIZE+size);
1207                         malloced = true;
1208                 }
1209
1210                 if (new_ptr) {
1211                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1212                 }
1213         }
1214         else {
1215                 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1216         }
1217 #endif
1218         if (unlikely(!new_ptr)) {
1219                 tc->flags &= ~TALLOC_FLAG_FREE;
1220                 return NULL;
1221         }
1222
1223         tc = (struct talloc_chunk *)new_ptr;
1224         tc->flags &= ~TALLOC_FLAG_FREE;
1225         if (malloced) {
1226                 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1227         }
1228         if (tc->parent) {
1229                 tc->parent->child = tc;
1230         }
1231         if (tc->child) {
1232                 tc->child->parent = tc;
1233         }
1234
1235         if (tc->prev) {
1236                 tc->prev->next = tc;
1237         }
1238         if (tc->next) {
1239                 tc->next->prev = tc;
1240         }
1241
1242         tc->size = size;
1243         _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1244
1245         return TC_PTR_FROM_CHUNK(tc);
1246 }
1247
1248 /*
1249   a wrapper around talloc_steal() for situations where you are moving a pointer
1250   between two structures, and want the old pointer to be set to NULL
1251 */
1252 _PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
1253 {
1254         const void **pptr = discard_const_p(const void *,_pptr);
1255         void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
1256         (*pptr) = NULL;
1257         return ret;
1258 }
1259
1260 /*
1261   return the total size of a talloc pool (subtree)
1262 */
1263 _PUBLIC_ size_t talloc_total_size(const void *ptr)
1264 {
1265         size_t total = 0;
1266         struct talloc_chunk *c, *tc;
1267
1268         if (ptr == NULL) {
1269                 ptr = null_context;
1270         }
1271         if (ptr == NULL) {
1272                 return 0;
1273         }
1274
1275         tc = talloc_chunk_from_ptr(ptr);
1276
1277         if (tc->flags & TALLOC_FLAG_LOOP) {
1278                 return 0;
1279         }
1280
1281         tc->flags |= TALLOC_FLAG_LOOP;
1282
1283         if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1284                 total = tc->size;
1285         }
1286         for (c=tc->child;c;c=c->next) {
1287                 total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
1288         }
1289
1290         tc->flags &= ~TALLOC_FLAG_LOOP;
1291
1292         return total;
1293 }
1294
1295 /*
1296   return the total number of blocks in a talloc pool (subtree)
1297 */
1298 _PUBLIC_ size_t talloc_total_blocks(const void *ptr)
1299 {
1300         size_t total = 0;
1301         struct talloc_chunk *c, *tc;
1302
1303         if (ptr == NULL) {
1304                 ptr = null_context;
1305         }
1306         if (ptr == NULL) {
1307                 return 0;
1308         }
1309
1310         tc = talloc_chunk_from_ptr(ptr);
1311
1312         if (tc->flags & TALLOC_FLAG_LOOP) {
1313                 return 0;
1314         }
1315
1316         tc->flags |= TALLOC_FLAG_LOOP;
1317
1318         total++;
1319         for (c=tc->child;c;c=c->next) {
1320                 total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
1321         }
1322
1323         tc->flags &= ~TALLOC_FLAG_LOOP;
1324
1325         return total;
1326 }
1327
1328 /*
1329   return the number of external references to a pointer
1330 */
1331 _PUBLIC_ size_t talloc_reference_count(const void *ptr)
1332 {
1333         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1334         struct talloc_reference_handle *h;
1335         size_t ret = 0;
1336
1337         for (h=tc->refs;h;h=h->next) {
1338                 ret++;
1339         }
1340         return ret;
1341 }
1342
1343 /*
1344   report on memory usage by all children of a pointer, giving a full tree view
1345 */
1346 _PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
1347                             void (*callback)(const void *ptr,
1348                                              int depth, int max_depth,
1349                                              int is_ref,
1350                                              void *private_data),
1351                             void *private_data)
1352 {
1353         struct talloc_chunk *c, *tc;
1354
1355         if (ptr == NULL) {
1356                 ptr = null_context;
1357         }
1358         if (ptr == NULL) return;
1359
1360         tc = talloc_chunk_from_ptr(ptr);
1361
1362         if (tc->flags & TALLOC_FLAG_LOOP) {
1363                 return;
1364         }
1365
1366         callback(ptr, depth, max_depth, 0, private_data);
1367
1368         if (max_depth >= 0 && depth >= max_depth) {
1369                 return;
1370         }
1371
1372         tc->flags |= TALLOC_FLAG_LOOP;
1373         for (c=tc->child;c;c=c->next) {
1374                 if (c->name == TALLOC_MAGIC_REFERENCE) {
1375                         struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
1376                         callback(h->ptr, depth + 1, max_depth, 1, private_data);
1377                 } else {
1378                         talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
1379                 }
1380         }
1381         tc->flags &= ~TALLOC_FLAG_LOOP;
1382 }
1383
1384 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
1385 {
1386         const char *name = talloc_get_name(ptr);
1387         FILE *f = (FILE *)_f;
1388
1389         if (is_ref) {
1390                 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
1391                 return;
1392         }
1393
1394         if (depth == 0) {
1395                 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1396                         (max_depth < 0 ? "full " :""), name,
1397                         (unsigned long)talloc_total_size(ptr),
1398                         (unsigned long)talloc_total_blocks(ptr));
1399                 return;
1400         }
1401
1402         fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1403                 depth*4, "",
1404                 name,
1405                 (unsigned long)talloc_total_size(ptr),
1406                 (unsigned long)talloc_total_blocks(ptr),
1407                 (int)talloc_reference_count(ptr), ptr);
1408
1409 #if 0
1410         fprintf(f, "content: ");
1411         if (talloc_total_size(ptr)) {
1412                 int tot = talloc_total_size(ptr);
1413                 int i;
1414
1415                 for (i = 0; i < tot; i++) {
1416                         if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
1417                                 fprintf(f, "%c", ((char *)ptr)[i]);
1418                         } else {
1419                                 fprintf(f, "~%02x", ((char *)ptr)[i]);
1420                         }
1421                 }
1422         }
1423         fprintf(f, "\n");
1424 #endif
1425 }
1426
1427 /*
1428   report on memory usage by all children of a pointer, giving a full tree view
1429 */
1430 _PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
1431 {
1432         if (f) {
1433                 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
1434                 fflush(f);
1435         }
1436 }
1437
1438 /*
1439   report on memory usage by all children of a pointer, giving a full tree view
1440 */
1441 _PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
1442 {
1443         talloc_report_depth_file(ptr, 0, -1, f);
1444 }
1445
1446 /*
1447   report on memory usage by all children of a pointer
1448 */
1449 _PUBLIC_ void talloc_report(const void *ptr, FILE *f)
1450 {
1451         talloc_report_depth_file(ptr, 0, 1, f);
1452 }
1453
1454 /*
1455   report on any memory hanging off the null context
1456 */
1457 static void talloc_report_null(void)
1458 {
1459         if (talloc_total_size(null_context) != 0) {
1460                 talloc_report(null_context, stderr);
1461         }
1462 }
1463
1464 /*
1465   report on any memory hanging off the null context
1466 */
1467 static void talloc_report_null_full(void)
1468 {
1469         if (talloc_total_size(null_context) != 0) {
1470                 talloc_report_full(null_context, stderr);
1471         }
1472 }
1473
1474 /*
1475   enable tracking of the NULL context
1476 */
1477 _PUBLIC_ void talloc_enable_null_tracking(void)
1478 {
1479         if (null_context == NULL) {
1480                 null_context = _talloc_named_const(NULL, 0, "null_context");
1481                 if (autofree_context != NULL) {
1482                         talloc_reparent(NULL, null_context, autofree_context);
1483                 }
1484         }
1485 }
1486
1487 /*
1488   enable tracking of the NULL context, not moving the autofree context
1489   into the NULL context. This is needed for the talloc testsuite
1490 */
1491 _PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
1492 {
1493         if (null_context == NULL) {
1494                 null_context = _talloc_named_const(NULL, 0, "null_context");
1495         }
1496 }
1497
1498 /*
1499   disable tracking of the NULL context
1500 */
1501 _PUBLIC_ void talloc_disable_null_tracking(void)
1502 {
1503         if (null_context != NULL) {
1504                 /* we have to move any children onto the real NULL
1505                    context */
1506                 struct talloc_chunk *tc, *tc2;
1507                 tc = talloc_chunk_from_ptr(null_context);
1508                 for (tc2 = tc->child; tc2; tc2=tc2->next) {
1509                         if (tc2->parent == tc) tc2->parent = NULL;
1510                         if (tc2->prev == tc) tc2->prev = NULL;
1511                 }
1512                 for (tc2 = tc->next; tc2; tc2=tc2->next) {
1513                         if (tc2->parent == tc) tc2->parent = NULL;
1514                         if (tc2->prev == tc) tc2->prev = NULL;
1515                 }
1516                 tc->child = NULL;
1517                 tc->next = NULL;
1518         }
1519         talloc_free(null_context);
1520         null_context = NULL;
1521 }
1522
1523 /*
1524   enable leak reporting on exit
1525 */
1526 _PUBLIC_ void talloc_enable_leak_report(void)
1527 {
1528         talloc_enable_null_tracking();
1529         atexit(talloc_report_null);
1530 }
1531
1532 /*
1533   enable full leak reporting on exit
1534 */
1535 _PUBLIC_ void talloc_enable_leak_report_full(void)
1536 {
1537         talloc_enable_null_tracking();
1538         atexit(talloc_report_null_full);
1539 }
1540
1541 /*
1542    talloc and zero memory.
1543 */
1544 _PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
1545 {
1546         void *p = _talloc_named_const(ctx, size, name);
1547
1548         if (p) {
1549                 memset(p, '\0', size);
1550         }
1551
1552         return p;
1553 }
1554
1555 /*
1556   memdup with a talloc.
1557 */
1558 _PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
1559 {
1560         void *newp = _talloc_named_const(t, size, name);
1561
1562         if (likely(newp)) {
1563                 memcpy(newp, p, size);
1564         }
1565
1566         return newp;
1567 }
1568
1569 static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
1570 {
1571         char *ret;
1572
1573         ret = (char *)__talloc(t, len + 1);
1574         if (unlikely(!ret)) return NULL;
1575
1576         memcpy(ret, p, len);
1577         ret[len] = 0;
1578
1579         _talloc_set_name_const(ret, ret);
1580         return ret;
1581 }
1582
1583 /*
1584   strdup with a talloc
1585 */
1586 _PUBLIC_ char *talloc_strdup(const void *t, const char *p)
1587 {
1588         if (unlikely(!p)) return NULL;
1589         return __talloc_strlendup(t, p, strlen(p));
1590 }
1591
1592 /*
1593   strndup with a talloc
1594 */
1595 _PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
1596 {
1597         if (unlikely(!p)) return NULL;
1598         return __talloc_strlendup(t, p, strnlen(p, n));
1599 }
1600
1601 static inline char *__talloc_strlendup_append(char *s, size_t slen,
1602                                               const char *a, size_t alen)
1603 {
1604         char *ret;
1605
1606         ret = talloc_realloc(NULL, s, char, slen + alen + 1);
1607         if (unlikely(!ret)) return NULL;
1608
1609         /* append the string and the trailing \0 */
1610         memcpy(&ret[slen], a, alen);
1611         ret[slen+alen] = 0;
1612
1613         _talloc_set_name_const(ret, ret);
1614         return ret;
1615 }
1616
1617 /*
1618  * Appends at the end of the string.
1619  */
1620 _PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
1621 {
1622         if (unlikely(!s)) {
1623                 return talloc_strdup(NULL, a);
1624         }
1625
1626         if (unlikely(!a)) {
1627                 return s;
1628         }
1629
1630         return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
1631 }
1632
1633 /*
1634  * Appends at the end of the talloc'ed buffer,
1635  * not the end of the string.
1636  */
1637 _PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
1638 {
1639         size_t slen;
1640
1641         if (unlikely(!s)) {
1642                 return talloc_strdup(NULL, a);
1643         }
1644
1645         if (unlikely(!a)) {
1646                 return s;
1647         }
1648
1649         slen = talloc_get_size(s);
1650         if (likely(slen > 0)) {
1651                 slen--;
1652         }
1653
1654         return __talloc_strlendup_append(s, slen, a, strlen(a));
1655 }
1656
1657 /*
1658  * Appends at the end of the string.
1659  */
1660 _PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
1661 {
1662         if (unlikely(!s)) {
1663                 return talloc_strdup(NULL, a);
1664         }
1665
1666         if (unlikely(!a)) {
1667                 return s;
1668         }
1669
1670         return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
1671 }
1672
1673 /*
1674  * Appends at the end of the talloc'ed buffer,
1675  * not the end of the string.
1676  */
1677 _PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
1678 {
1679         size_t slen;
1680
1681         if (unlikely(!s)) {
1682                 return talloc_strdup(NULL, a);
1683         }
1684
1685         if (unlikely(!a)) {
1686                 return s;
1687         }
1688
1689         slen = talloc_get_size(s);
1690         if (likely(slen > 0)) {
1691                 slen--;
1692         }
1693
1694         return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
1695 }
1696
1697 #ifndef HAVE_VA_COPY
1698 #ifdef HAVE___VA_COPY
1699 #define va_copy(dest, src) __va_copy(dest, src)
1700 #else
1701 #define va_copy(dest, src) (dest) = (src)
1702 #endif
1703 #endif
1704
1705 _PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
1706 {
1707         int len;
1708         char *ret;
1709         va_list ap2;
1710         char c;
1711
1712         /* this call looks strange, but it makes it work on older solaris boxes */
1713         va_copy(ap2, ap);
1714         len = vsnprintf(&c, 1, fmt, ap2);
1715         va_end(ap2);
1716         if (unlikely(len < 0)) {
1717                 return NULL;
1718         }
1719
1720         ret = (char *)__talloc(t, len+1);
1721         if (unlikely(!ret)) return NULL;
1722
1723         va_copy(ap2, ap);
1724         vsnprintf(ret, len+1, fmt, ap2);
1725         va_end(ap2);
1726
1727         _talloc_set_name_const(ret, ret);
1728         return ret;
1729 }
1730
1731
1732 /*
1733   Perform string formatting, and return a pointer to newly allocated
1734   memory holding the result, inside a memory pool.
1735  */
1736 _PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
1737 {
1738         va_list ap;
1739         char *ret;
1740
1741         va_start(ap, fmt);
1742         ret = talloc_vasprintf(t, fmt, ap);
1743         va_end(ap);
1744         return ret;
1745 }
1746
1747 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
1748                                                  const char *fmt, va_list ap)
1749                                                  PRINTF_ATTRIBUTE(3,0);
1750
1751 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
1752                                                  const char *fmt, va_list ap)
1753 {
1754         ssize_t alen;
1755         va_list ap2;
1756         char c;
1757
1758         va_copy(ap2, ap);
1759         alen = vsnprintf(&c, 1, fmt, ap2);
1760         va_end(ap2);
1761
1762         if (alen <= 0) {
1763                 /* Either the vsnprintf failed or the format resulted in
1764                  * no characters being formatted. In the former case, we
1765                  * ought to return NULL, in the latter we ought to return
1766                  * the original string. Most current callers of this
1767                  * function expect it to never return NULL.
1768                  */
1769                 return s;
1770         }
1771
1772         s = talloc_realloc(NULL, s, char, slen + alen + 1);
1773         if (!s) return NULL;
1774
1775         va_copy(ap2, ap);
1776         vsnprintf(s + slen, alen + 1, fmt, ap2);
1777         va_end(ap2);
1778
1779         _talloc_set_name_const(s, s);
1780         return s;
1781 }
1782
1783 /**
1784  * Realloc @p s to append the formatted result of @p fmt and @p ap,
1785  * and return @p s, which may have moved.  Good for gradually
1786  * accumulating output into a string buffer. Appends at the end
1787  * of the string.
1788  **/
1789 _PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
1790 {
1791         if (unlikely(!s)) {
1792                 return talloc_vasprintf(NULL, fmt, ap);
1793         }
1794
1795         return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
1796 }
1797
1798 /**
1799  * Realloc @p s to append the formatted result of @p fmt and @p ap,
1800  * and return @p s, which may have moved. Always appends at the
1801  * end of the talloc'ed buffer, not the end of the string.
1802  **/
1803 _PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
1804 {
1805         size_t slen;
1806
1807         if (unlikely(!s)) {
1808                 return talloc_vasprintf(NULL, fmt, ap);
1809         }
1810
1811         slen = talloc_get_size(s);
1812         if (likely(slen > 0)) {
1813                 slen--;
1814         }
1815
1816         return __talloc_vaslenprintf_append(s, slen, fmt, ap);
1817 }
1818
1819 /*
1820   Realloc @p s to append the formatted result of @p fmt and return @p
1821   s, which may have moved.  Good for gradually accumulating output
1822   into a string buffer.
1823  */
1824 _PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
1825 {
1826         va_list ap;
1827
1828         va_start(ap, fmt);
1829         s = talloc_vasprintf_append(s, fmt, ap);
1830         va_end(ap);
1831         return s;
1832 }
1833
1834 /*
1835   Realloc @p s to append the formatted result of @p fmt and return @p
1836   s, which may have moved.  Good for gradually accumulating output
1837   into a buffer.
1838  */
1839 _PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
1840 {
1841         va_list ap;
1842
1843         va_start(ap, fmt);
1844         s = talloc_vasprintf_append_buffer(s, fmt, ap);
1845         va_end(ap);
1846         return s;
1847 }
1848
1849 /*
1850   alloc an array, checking for integer overflow in the array size
1851 */
1852 _PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1853 {
1854         if (count >= MAX_TALLOC_SIZE/el_size) {
1855                 return NULL;
1856         }
1857         return _talloc_named_const(ctx, el_size * count, name);
1858 }
1859
1860 /*
1861   alloc an zero array, checking for integer overflow in the array size
1862 */
1863 _PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1864 {
1865         if (count >= MAX_TALLOC_SIZE/el_size) {
1866                 return NULL;
1867         }
1868         return _talloc_zero(ctx, el_size * count, name);
1869 }
1870
1871 /*
1872   realloc an array, checking for integer overflow in the array size
1873 */
1874 _PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
1875 {
1876         if (count >= MAX_TALLOC_SIZE/el_size) {
1877                 return NULL;
1878         }
1879         return _talloc_realloc(ctx, ptr, el_size * count, name);
1880 }
1881
1882 /*
1883   a function version of talloc_realloc(), so it can be passed as a function pointer
1884   to libraries that want a realloc function (a realloc function encapsulates
1885   all the basic capabilities of an allocation library, which is why this is useful)
1886 */
1887 _PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
1888 {
1889         return _talloc_realloc(context, ptr, size, NULL);
1890 }
1891
1892
1893 static int talloc_autofree_destructor(void *ptr)
1894 {
1895         autofree_context = NULL;
1896         return 0;
1897 }
1898
1899 static void talloc_autofree(void)
1900 {
1901         talloc_free(autofree_context);
1902 }
1903
1904 /*
1905   return a context which will be auto-freed on exit
1906   this is useful for reducing the noise in leak reports
1907 */
1908 _PUBLIC_ void *talloc_autofree_context(void)
1909 {
1910         if (autofree_context == NULL) {
1911                 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
1912                 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
1913                 atexit(talloc_autofree);
1914         }
1915         return autofree_context;
1916 }
1917
1918 _PUBLIC_ size_t talloc_get_size(const void *context)
1919 {
1920         struct talloc_chunk *tc;
1921
1922         if (context == NULL) {
1923                 context = null_context;
1924         }
1925         if (context == NULL) {
1926                 return 0;
1927         }
1928
1929         tc = talloc_chunk_from_ptr(context);
1930
1931         return tc->size;
1932 }
1933
1934 /*
1935   find a parent of this context that has the given name, if any
1936 */
1937 _PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
1938 {
1939         struct talloc_chunk *tc;
1940
1941         if (context == NULL) {
1942                 return NULL;
1943         }
1944
1945         tc = talloc_chunk_from_ptr(context);
1946         while (tc) {
1947                 if (tc->name && strcmp(tc->name, name) == 0) {
1948                         return TC_PTR_FROM_CHUNK(tc);
1949                 }
1950                 while (tc && tc->prev) tc = tc->prev;
1951                 if (tc) {
1952                         tc = tc->parent;
1953                 }
1954         }
1955         return NULL;
1956 }
1957
1958 /*
1959   show the parentage of a context
1960 */
1961 _PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
1962 {
1963         struct talloc_chunk *tc;
1964
1965         if (context == NULL) {
1966                 fprintf(file, "talloc no parents for NULL\n");
1967                 return;
1968         }
1969
1970         tc = talloc_chunk_from_ptr(context);
1971         fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
1972         while (tc) {
1973                 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
1974                 while (tc && tc->prev) tc = tc->prev;
1975                 if (tc) {
1976                         tc = tc->parent;
1977                 }
1978         }
1979         fflush(file);
1980 }
1981
1982 /*
1983   return 1 if ptr is a parent of context
1984 */
1985 static int _talloc_is_parent(const void *context, const void *ptr, int depth)
1986 {
1987         struct talloc_chunk *tc;
1988
1989         if (context == NULL) {
1990                 return 0;
1991         }
1992
1993         tc = talloc_chunk_from_ptr(context);
1994         while (tc && depth > 0) {
1995                 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
1996                 while (tc && tc->prev) tc = tc->prev;
1997                 if (tc) {
1998                         tc = tc->parent;
1999                         depth--;
2000                 }
2001         }
2002         return 0;
2003 }
2004
2005 /*
2006   return 1 if ptr is a parent of context
2007 */
2008 _PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
2009 {
2010         return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
2011 }