lib/talloc/talloc.c

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