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