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