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