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 /*
 772    internal talloc_free call
 773 */
 774 static inline int _talloc_free_internal(void *ptr, const char *location)
 775 {
 776         struct talloc_chunk *tc;
 777
 778         if (unlikely(ptr == NULL)) {
 779                 return -1;
 780         }
 781
 782         /* possibly initialised the talloc fill value */
 783         if (unlikely(!talloc_fill.initialised)) {
 784                 const char *fill = getenv(TALLOC_FILL_ENV);
 785                 if (fill != NULL) {
 786                         talloc_fill.enabled = true;
 787                         talloc_fill.fill_value = strtoul(fill, NULL, 0);
 788                 }
 789                 talloc_fill.initialised = true;
 790         }
 791
 792         tc = talloc_chunk_from_ptr(ptr);
 793
 794         if (unlikely(tc->refs)) {
 795                 int is_child;
 796                 /* check if this is a reference from a child or
 797                  * grandchild back to it's parent or grandparent
 798                  *
 799                  * in that case we need to remove the reference and
 800                  * call another instance of talloc_free() on the current
 801                  * pointer.
 802                  */
 803                 is_child = talloc_is_parent(tc->refs, ptr);
 804                 _talloc_free_internal(tc->refs, location);
 805                 if (is_child) {
 806                         return _talloc_free_internal(ptr, location);
 807                 }
 808                 return -1;
 809         }
 810
 811         if (unlikely(tc->flags & TALLOC_FLAG_LOOP)) {
 812                 /* we have a free loop - stop looping */
 813                 return 0;
 814         }
 815
 816         if (unlikely(tc->destructor)) {
 817                 talloc_destructor_t d = tc->destructor;
 818                 if (d == (talloc_destructor_t)-1) {
 819                         return -1;
 820                 }
 821                 tc->destructor = (talloc_destructor_t)-1;
 822                 if (d(ptr) == -1) {
 823                         tc->destructor = d;
 824                         return -1;
 825                 }
 826                 tc->destructor = NULL;
 827         }
 828
 829         if (tc->parent) {
 830                 _TLIST_REMOVE(tc->parent->child, tc);
 831                 if (tc->parent->child) {
 832                         tc->parent->child->parent = tc->parent;
 833                 }
 834         } else {
 835                 if (tc->prev) tc->prev->next = tc->next;
 836                 if (tc->next) tc->next->prev = tc->prev;
 837         }
 838
 839         tc->flags |= TALLOC_FLAG_LOOP;
 840
 841         while (tc->child) {
 842                 /* we need to work out who will own an abandoned child
 843                    if it cannot be freed. In priority order, the first
 844                    choice is owner of any remaining reference to this
 845                    pointer, the second choice is our parent, and the
 846                    final choice is the null context. */
 847                 void *child = TC_PTR_FROM_CHUNK(tc->child);
 848                 const void *new_parent = null_context;
 849                 struct talloc_chunk *old_parent = NULL;
 850                 if (unlikely(tc->child->refs)) {
 851                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
 852                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 853                 }
 854                 /* finding the parent here is potentially quite
 855                    expensive, but the alternative, which is to change
 856                    talloc to always have a valid tc->parent pointer,
 857                    makes realloc more expensive where there are a
 858                    large number of children.
 859
 860                    The reason we need the parent pointer here is that
 861                    if _talloc_free_internal() fails due to references
 862                    or a failing destructor we need to re-parent, but
 863                    the free call can invalidate the prev pointer.
 864                 */
 865                 if (new_parent == null_context && (tc->child->refs || tc->child->destructor)) {
 866                         old_parent = talloc_parent_chunk(ptr);
 867                 }
 868                 if (unlikely(_talloc_free_internal(child, location) == -1)) {
 869                         if (new_parent == null_context) {
 870                                 struct talloc_chunk *p = old_parent;
 871                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
 872                         }
 873                         _talloc_steal_internal(new_parent, child);
 874                 }
 875         }
 876
 877         tc->flags |= TALLOC_FLAG_FREE;
 878
 879         /* we mark the freed memory with where we called the free
 880          * from. This means on a double free error we can report where
 881          * the first free came from
 882          */
 883         tc->name = location;
 884
 885         if (tc->flags & TALLOC_FLAG_POOL) {
 886                 unsigned int *pool_object_count;
 887
 888                 pool_object_count = talloc_pool_objectcount(tc);
 889
 890                 if (unlikely(*pool_object_count == 0)) {
 891                         talloc_abort("Pool object count zero!");
 892                         return 0;
 893                 }
 894
 895                 *pool_object_count -= 1;
 896
 897                 if (unlikely(*pool_object_count == 0)) {
 898                         TC_INVALIDATE_FULL_CHUNK(tc);
 899                         free(tc);
 900                 }
 901         } else if (tc->flags & TALLOC_FLAG_POOLMEM) {
 902                 _talloc_free_poolmem(tc, location);
 903         } else {
 904                 TC_INVALIDATE_FULL_CHUNK(tc);
 905                 free(tc);
 906         }
 907         return 0;
 908 }
 909
 910 /*
 911    move a lump of memory from one talloc context to another return the
 912    ptr on success, or NULL if it could not be transferred.
 913    passing NULL as ptr will always return NULL with no side effects.
 914 */
 915 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
 916 {
 917         struct talloc_chunk *tc, *new_tc;
 918
 919         if (unlikely(!ptr)) {
 920                 return NULL;
 921         }
 922
 923         if (unlikely(new_ctx == NULL)) {
 924                 new_ctx = null_context;
 925         }
 926
 927         tc = talloc_chunk_from_ptr(ptr);
 928
 929         if (unlikely(new_ctx == NULL)) {
 930                 if (tc->parent) {
 931                         _TLIST_REMOVE(tc->parent->child, tc);
 932                         if (tc->parent->child) {
 933                                 tc->parent->child->parent = tc->parent;
 934                         }
 935                 } else {
 936                         if (tc->prev) tc->prev->next = tc->next;
 937                         if (tc->next) tc->next->prev = tc->prev;
 938                 }
 939
 940                 tc->parent = tc->next = tc->prev = NULL;
 941                 return discard_const_p(void, ptr);
 942         }
 943
 944         new_tc = talloc_chunk_from_ptr(new_ctx);
 945
 946         if (unlikely(tc == new_tc || tc->parent == new_tc)) {
 947                 return discard_const_p(void, ptr);
 948         }
 949
 950         if (tc->parent) {
 951                 _TLIST_REMOVE(tc->parent->child, tc);
 952                 if (tc->parent->child) {
 953                         tc->parent->child->parent = tc->parent;
 954                 }
 955         } else {
 956                 if (tc->prev) tc->prev->next = tc->next;
 957                 if (tc->next) tc->next->prev = tc->prev;
 958         }
 959
 960         tc->parent = new_tc;
 961         if (new_tc->child) new_tc->child->parent = NULL;
 962         _TLIST_ADD(new_tc->child, tc);
 963
 964         return discard_const_p(void, ptr);
 965 }
 966
 967 /*
 968    move a lump of memory from one talloc context to another return the
 969    ptr on success, or NULL if it could not be transferred.
 970    passing NULL as ptr will always return NULL with no side effects.
 971 */
 972 _PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
 973 {
 974         struct talloc_chunk *tc;
 975
 976         if (unlikely(ptr == NULL)) {
 977                 return NULL;
 978         }
 979
 980         tc = talloc_chunk_from_ptr(ptr);
 981
 982         if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
 983                 struct talloc_reference_handle *h;
 984
 985                 talloc_log("WARNING: talloc_steal with references at %s\n",
 986                            location);
 987
 988                 for (h=tc->refs; h; h=h->next) {
 989                         talloc_log("\treference at %s\n",
 990                                    h->location);
 991                 }
 992         }
 993
 994 #if 0
 995         /* this test is probably too expensive to have on in the
 996            normal build, but it useful for debugging */
 997         if (talloc_is_parent(new_ctx, ptr)) {
 998                 talloc_log("WARNING: stealing into talloc child at %s\n", location);
 999         }
1000 #endif
1001
1002         return _talloc_steal_internal(new_ctx, ptr);
1003 }
1004
1005 /*
1006    this is like a talloc_steal(), but you must supply the old
1007    parent. This resolves the ambiguity in a talloc_steal() which is
1008    called on a context that has more than one parent (via references)
1009
1010    The old parent can be either a reference or a parent
1011 */
1012 _PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
1013 {
1014         struct talloc_chunk *tc;
1015         struct talloc_reference_handle *h;
1016
1017         if (unlikely(ptr == NULL)) {
1018                 return NULL;
1019         }
1020
1021         if (old_parent == talloc_parent(ptr)) {
1022                 return _talloc_steal_internal(new_parent, ptr);
1023         }
1024
1025         tc = talloc_chunk_from_ptr(ptr);
1026         for (h=tc->refs;h;h=h->next) {
1027                 if (talloc_parent(h) == old_parent) {
1028                         if (_talloc_steal_internal(new_parent, h) != h) {
1029                                 return NULL;
1030                         }
1031                         return discard_const_p(void, ptr);
1032                 }
1033         }
1034
1035         /* it wasn't a parent */
1036         return NULL;
1037 }
1038
1039 /*
1040   remove a secondary reference to a pointer. This undo's what
1041   talloc_reference() has done. The context and pointer arguments
1042   must match those given to a talloc_reference()
1043 */
1044 static inline int talloc_unreference(const void *context, const void *ptr)
1045 {
1046         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1047         struct talloc_reference_handle *h;
1048
1049         if (unlikely(context == NULL)) {
1050                 context = null_context;
1051         }
1052
1053         for (h=tc->refs;h;h=h->next) {
1054                 struct talloc_chunk *p = talloc_parent_chunk(h);
1055                 if (p == NULL) {
1056                         if (context == NULL) break;
1057                 } else if (TC_PTR_FROM_CHUNK(p) == context) {
1058                         break;
1059                 }
1060         }
1061         if (h == NULL) {
1062                 return -1;
1063         }
1064
1065         return _talloc_free_internal(h, __location__);
1066 }
1067
1068 /*
1069   remove a specific parent context from a pointer. This is a more
1070   controlled varient of talloc_free()
1071 */
1072 _PUBLIC_ int talloc_unlink(const void *context, void *ptr)
1073 {
1074         struct talloc_chunk *tc_p, *new_p;
1075         void *new_parent;
1076
1077         if (ptr == NULL) {
1078                 return -1;
1079         }
1080
1081         if (context == NULL) {
1082                 context = null_context;
1083         }
1084
1085         if (talloc_unreference(context, ptr) == 0) {
1086                 return 0;
1087         }
1088
1089         if (context == NULL) {
1090                 if (talloc_parent_chunk(ptr) != NULL) {
1091                         return -1;
1092                 }
1093         } else {
1094                 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
1095                         return -1;
1096                 }
1097         }
1098
1099         tc_p = talloc_chunk_from_ptr(ptr);
1100
1101         if (tc_p->refs == NULL) {
1102                 return _talloc_free_internal(ptr, __location__);
1103         }
1104
1105         new_p = talloc_parent_chunk(tc_p->refs);
1106         if (new_p) {
1107                 new_parent = TC_PTR_FROM_CHUNK(new_p);
1108         } else {
1109                 new_parent = NULL;
1110         }
1111
1112         if (talloc_unreference(new_parent, ptr) != 0) {
1113                 return -1;
1114         }
1115
1116         _talloc_steal_internal(new_parent, ptr);
1117
1118         return 0;
1119 }
1120
1121 /*
1122   add a name to an existing pointer - va_list version
1123 */
1124 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
1125
1126 static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
1127 {
1128         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1129         tc->name = talloc_vasprintf(ptr, fmt, ap);
1130         if (likely(tc->name)) {
1131                 _talloc_set_name_const(tc->name, ".name");
1132         }
1133         return tc->name;
1134 }
1135
1136 /*
1137   add a name to an existing pointer
1138 */
1139 _PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
1140 {
1141         const char *name;
1142         va_list ap;
1143         va_start(ap, fmt);
1144         name = talloc_set_name_v(ptr, fmt, ap);
1145         va_end(ap);
1146         return name;
1147 }
1148
1149
1150 /*
1151   create a named talloc pointer. Any talloc pointer can be named, and
1152   talloc_named() operates just like talloc() except that it allows you
1153   to name the pointer.
1154 */
1155 _PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
1156 {
1157         va_list ap;
1158         void *ptr;
1159         const char *name;
1160
1161         ptr = __talloc(context, size);
1162         if (unlikely(ptr == NULL)) return NULL;
1163
1164         va_start(ap, fmt);
1165         name = talloc_set_name_v(ptr, fmt, ap);
1166         va_end(ap);
1167
1168         if (unlikely(name == NULL)) {
1169                 _talloc_free_internal(ptr, __location__);
1170                 return NULL;
1171         }
1172
1173         return ptr;
1174 }
1175
1176 /*
1177   return the name of a talloc ptr, or "UNNAMED"
1178 */
1179 _PUBLIC_ const char *talloc_get_name(const void *ptr)
1180 {
1181         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1182         if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
1183                 return ".reference";
1184         }
1185         if (likely(tc->name)) {
1186                 return tc->name;
1187         }
1188         return "UNNAMED";
1189 }
1190
1191
1192 /*
1193   check if a pointer has the given name. If it does, return the pointer,
1194   otherwise return NULL
1195 */
1196 _PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
1197 {
1198         const char *pname;
1199         if (unlikely(ptr == NULL)) return NULL;
1200         pname = talloc_get_name(ptr);
1201         if (likely(pname == name || strcmp(pname, name) == 0)) {
1202                 return discard_const_p(void, ptr);
1203         }
1204         return NULL;
1205 }
1206
1207 static void talloc_abort_type_missmatch(const char *location,
1208                                         const char *name,
1209                                         const char *expected)
1210 {
1211         const char *reason;
1212
1213         reason = talloc_asprintf(NULL,
1214                                  "%s: Type mismatch: name[%s] expected[%s]",
1215                                  location,
1216                                  name?name:"NULL",
1217                                  expected);
1218         if (!reason) {
1219                 reason = "Type mismatch";
1220         }
1221
1222         talloc_abort(reason);
1223 }
1224
1225 _PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
1226 {
1227         const char *pname;
1228
1229         if (unlikely(ptr == NULL)) {
1230                 talloc_abort_type_missmatch(location, NULL, name);
1231                 return NULL;
1232         }
1233
1234         pname = talloc_get_name(ptr);
1235         if (likely(pname == name || strcmp(pname, name) == 0)) {
1236                 return discard_const_p(void, ptr);
1237         }
1238
1239         talloc_abort_type_missmatch(location, pname, name);
1240         return NULL;
1241 }
1242
1243 /*
1244   this is for compatibility with older versions of talloc
1245 */
1246 _PUBLIC_ void *talloc_init(const char *fmt, ...)
1247 {
1248         va_list ap;
1249         void *ptr;
1250         const char *name;
1251
1252         ptr = __talloc(NULL, 0);
1253         if (unlikely(ptr == NULL)) return NULL;
1254
1255         va_start(ap, fmt);
1256         name = talloc_set_name_v(ptr, fmt, ap);
1257         va_end(ap);
1258
1259         if (unlikely(name == NULL)) {
1260                 _talloc_free_internal(ptr, __location__);
1261                 return NULL;
1262         }
1263
1264         return ptr;
1265 }
1266
1267 /*
1268   this is a replacement for the Samba3 talloc_destroy_pool functionality. It
1269   should probably not be used in new code. It's in here to keep the talloc
1270   code consistent across Samba 3 and 4.
1271 */
1272 _PUBLIC_ void talloc_free_children(void *ptr)
1273 {
1274         struct talloc_chunk *tc;
1275
1276         if (unlikely(ptr == NULL)) {
1277                 return;
1278         }
1279
1280         tc = talloc_chunk_from_ptr(ptr);
1281
1282         while (tc->child) {
1283                 /* we need to work out who will own an abandoned child
1284                    if it cannot be freed. In priority order, the first
1285                    choice is owner of any remaining reference to this
1286                    pointer, the second choice is our parent, and the
1287                    final choice is the null context. */
1288                 void *child = TC_PTR_FROM_CHUNK(tc->child);
1289                 const void *new_parent = null_context;
1290                 if (unlikely(tc->child->refs)) {
1291                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
1292                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1293                 }
1294                 if (unlikely(talloc_free(child) == -1)) {
1295                         if (new_parent == null_context) {
1296                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
1297                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
1298                         }
1299                         _talloc_steal_internal(new_parent, child);
1300                 }
1301         }
1302 }
1303
1304 /*
1305    Allocate a bit of memory as a child of an existing pointer
1306 */
1307 _PUBLIC_ void *_talloc(const void *context, size_t size)
1308 {
1309         return __talloc(context, size);
1310 }
1311
1312 /*
1313   externally callable talloc_set_name_const()
1314 */
1315 _PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
1316 {
1317         _talloc_set_name_const(ptr, name);
1318 }
1319
1320 /*
1321   create a named talloc pointer. Any talloc pointer can be named, and
1322   talloc_named() operates just like talloc() except that it allows you
1323   to name the pointer.
1324 */
1325 _PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
1326 {
1327         return _talloc_named_const(context, size, name);
1328 }
1329
1330 /*
1331    free a talloc pointer. This also frees all child pointers of this
1332    pointer recursively
1333
1334    return 0 if the memory is actually freed, otherwise -1. The memory
1335    will not be freed if the ref_count is > 1 or the destructor (if
1336    any) returns non-zero
1337 */
1338 _PUBLIC_ int _talloc_free(void *ptr, const char *location)
1339 {
1340         struct talloc_chunk *tc;
1341
1342         if (unlikely(ptr == NULL)) {
1343                 return -1;
1344         }
1345
1346         tc = talloc_chunk_from_ptr(ptr);
1347
1348         if (unlikely(tc->refs != NULL)) {
1349                 struct talloc_reference_handle *h;
1350
1351                 if (talloc_parent(ptr) == null_context && tc->refs->next == NULL) {
1352                         /* in this case we do know which parent should
1353                            get this pointer, as there is really only
1354                            one parent */
1355                         return talloc_unlink(null_context, ptr);
1356                 }
1357
1358                 talloc_log("ERROR: talloc_free with references at %s\n",
1359                            location);
1360
1361                 for (h=tc->refs; h; h=h->next) {
1362                         talloc_log("\treference at %s\n",
1363                                    h->location);
1364                 }
1365                 return -1;
1366         }
1367
1368         return _talloc_free_internal(ptr, location);
1369 }
1370
1371
1372
1373 /*
1374   A talloc version of realloc. The context argument is only used if
1375   ptr is NULL
1376 */
1377 _PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
1378 {
1379         struct talloc_chunk *tc;
1380         void *new_ptr;
1381         bool malloced = false;
1382         struct talloc_chunk *pool_tc = NULL;
1383
1384         /* size zero is equivalent to free() */
1385         if (unlikely(size == 0)) {
1386                 talloc_unlink(context, ptr);
1387                 return NULL;
1388         }
1389
1390         if (unlikely(size >= MAX_TALLOC_SIZE)) {
1391                 return NULL;
1392         }
1393
1394         /* realloc(NULL) is equivalent to malloc() */
1395         if (ptr == NULL) {
1396                 return _talloc_named_const(context, size, name);
1397         }
1398
1399         tc = talloc_chunk_from_ptr(ptr);
1400
1401         /* don't allow realloc on referenced pointers */
1402         if (unlikely(tc->refs)) {
1403                 return NULL;
1404         }
1405
1406         /* don't let anybody try to realloc a talloc_pool */
1407         if (unlikely(tc->flags & TALLOC_FLAG_POOL)) {
1408                 return NULL;
1409         }
1410
1411         /* don't let anybody try to realloc a talloc_pool */
1412         if (unlikely(tc->flags & TALLOC_FLAG_POOLMEM)) {
1413                 pool_tc = (struct talloc_chunk *)tc->pool;
1414         }
1415
1416 #if (ALWAYS_REALLOC == 0)
1417         /* don't shrink if we have less than 1k to gain */
1418         if (size < tc->size) {
1419                 if (pool_tc) {
1420                         void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
1421                         TC_INVALIDATE_SHRINK_CHUNK(tc, size);
1422                         tc->size = size;
1423                         if (next_tc == pool_tc->pool) {
1424                                 pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
1425                         }
1426                         return ptr;
1427                 } else if ((tc->size - size) < 1024) {
1428                         /*
1429                          * if we call TC_INVALIDATE_SHRINK_CHUNK() here
1430                          * we would need to call TC_UNDEFINE_GROW_CHUNK()
1431                          * after each realloc call, which slows down
1432                          * testing a lot :-(.
1433                          *
1434                          * That is why we only mark memory as undefined here.
1435                          */
1436                         TC_UNDEFINE_SHRINK_CHUNK(tc, size);
1437
1438                         /* do not shrink if we have less than 1k to gain */
1439                         tc->size = size;
1440                         return ptr;
1441                 }
1442         } else if (tc->size == size) {
1443                 /*
1444                  * do not change the pointer if it is exactly
1445                  * the same size.
1446                  */
1447                 return ptr;
1448         }
1449 #endif
1450
1451         /* by resetting magic we catch users of the old memory */
1452         tc->flags |= TALLOC_FLAG_FREE;
1453
1454 #if ALWAYS_REALLOC
1455         if (pool_tc) {
1456                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1457                 *talloc_pool_objectcount(pool_tc) -= 1;
1458
1459                 if (new_ptr == NULL) {
1460                         new_ptr = malloc(TC_HDR_SIZE+size);
1461                         malloced = true;
1462                 }
1463
1464                 if (new_ptr) {
1465                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1466                         TC_INVALIDATE_FULL_CHUNK(tc);
1467                 }
1468         } else {
1469                 new_ptr = malloc(size + TC_HDR_SIZE);
1470                 if (new_ptr) {
1471                         memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
1472                         free(tc);
1473                 }
1474         }
1475 #else
1476         if (pool_tc) {
1477                 void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
1478                 size_t old_chunk_size = TC_POOLMEM_CHUNK_SIZE(tc);
1479                 size_t new_chunk_size = TC_ALIGN16(TC_HDR_SIZE + size);
1480                 size_t space_needed;
1481                 size_t space_left;
1482                 unsigned int chunk_count = *talloc_pool_objectcount(pool_tc);
1483
1484                 if (!(pool_tc->flags & TALLOC_FLAG_FREE)) {
1485                         chunk_count -= 1;
1486                 }
1487
1488                 if (chunk_count == 1) {
1489                         /*
1490                          * optimize for the case where 'tc' is the only
1491                          * chunk in the pool.
1492                          */
1493                         space_needed = new_chunk_size;
1494                         space_left = pool_tc->size - TALLOC_POOL_HDR_SIZE;
1495
1496                         if (space_left >= space_needed) {
1497                                 size_t old_used = TC_HDR_SIZE + tc->size;
1498                                 size_t new_used = TC_HDR_SIZE + size;
1499                                 pool_tc->pool = TC_POOL_FIRST_CHUNK(pool_tc);
1500 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
1501                                 /*
1502                                  * we need to prepare the memmove into
1503                                  * the unaccessable area.
1504                                  */
1505                                 {
1506                                         size_t diff = PTR_DIFF(tc, pool_tc->pool);
1507                                         size_t flen = MIN(diff, old_used);
1508                                         char *fptr = (char *)pool_tc->pool;
1509                                         VALGRIND_MAKE_MEM_UNDEFINED(fptr, flen);
1510                                 }
1511 #endif
1512                                 memmove(pool_tc->pool, tc, old_used);
1513                                 new_ptr = pool_tc->pool;
1514
1515                                 tc = (struct talloc_chunk *)new_ptr;
1516                                 TC_UNDEFINE_GROW_CHUNK(tc, size);
1517
1518                                 /*
1519                                  * first we do not align the pool pointer
1520                                  * because we want to invalidate the padding
1521                                  * too.
1522                                  */
1523                                 pool_tc->pool = new_used + (char *)new_ptr;
1524                                 TC_INVALIDATE_POOL(pool_tc);
1525
1526                                 /* now the aligned pointer */
1527                                 pool_tc->pool = new_chunk_size + (char *)new_ptr;
1528                                 goto got_new_ptr;
1529                         }
1530
1531                         next_tc = NULL;
1532                 }
1533
1534                 if (new_chunk_size == old_chunk_size) {
1535                         TC_UNDEFINE_GROW_CHUNK(tc, size);
1536                         tc->flags &= ~TALLOC_FLAG_FREE;
1537                         tc->size = size;
1538                         return ptr;
1539                 }
1540
1541                 if (next_tc == pool_tc->pool) {
1542                         /*
1543                          * optimize for the case where 'tc' is the last
1544                          * chunk in the pool.
1545                          */
1546                         space_needed = new_chunk_size - old_chunk_size;
1547                         space_left = TC_POOL_SPACE_LEFT(pool_tc);
1548
1549                         if (space_left >= space_needed) {
1550                                 TC_UNDEFINE_GROW_CHUNK(tc, size);
1551                                 tc->flags &= ~TALLOC_FLAG_FREE;
1552                                 tc->size = size;
1553                                 pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
1554                                 return ptr;
1555                         }
1556                 }
1557
1558                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
1559
1560                 if (new_ptr == NULL) {
1561                         new_ptr = malloc(TC_HDR_SIZE+size);
1562                         malloced = true;
1563                 }
1564
1565                 if (new_ptr) {
1566                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
1567
1568                         _talloc_free_poolmem(tc, __location__ "_talloc_realloc");
1569                 }
1570         }
1571         else {
1572                 new_ptr = realloc(tc, size + TC_HDR_SIZE);
1573         }
1574 got_new_ptr:
1575 #endif
1576         if (unlikely(!new_ptr)) {
1577                 tc->flags &= ~TALLOC_FLAG_FREE;
1578                 return NULL;
1579         }
1580
1581         tc = (struct talloc_chunk *)new_ptr;
1582         tc->flags &= ~TALLOC_FLAG_FREE;
1583         if (malloced) {
1584                 tc->flags &= ~TALLOC_FLAG_POOLMEM;
1585         }
1586         if (tc->parent) {
1587                 tc->parent->child = tc;
1588         }
1589         if (tc->child) {
1590                 tc->child->parent = tc;
1591         }
1592
1593         if (tc->prev) {
1594                 tc->prev->next = tc;
1595         }
1596         if (tc->next) {
1597                 tc->next->prev = tc;
1598         }
1599
1600         tc->size = size;
1601         _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
1602
1603         return TC_PTR_FROM_CHUNK(tc);
1604 }
1605
1606 /*
1607   a wrapper around talloc_steal() for situations where you are moving a pointer
1608   between two structures, and want the old pointer to be set to NULL
1609 */
1610 _PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
1611 {
1612         const void **pptr = discard_const_p(const void *,_pptr);
1613         void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
1614         (*pptr) = NULL;
1615         return ret;
1616 }
1617
1618 /*
1619   return the total size of a talloc pool (subtree)
1620 */
1621 _PUBLIC_ size_t talloc_total_size(const void *ptr)
1622 {
1623         size_t total = 0;
1624         struct talloc_chunk *c, *tc;
1625
1626         if (ptr == NULL) {
1627                 ptr = null_context;
1628         }
1629         if (ptr == NULL) {
1630                 return 0;
1631         }
1632
1633         tc = talloc_chunk_from_ptr(ptr);
1634
1635         if (tc->flags & TALLOC_FLAG_LOOP) {
1636                 return 0;
1637         }
1638
1639         tc->flags |= TALLOC_FLAG_LOOP;
1640
1641         if (likely(tc->name != TALLOC_MAGIC_REFERENCE)) {
1642                 total = tc->size;
1643         }
1644         for (c=tc->child;c;c=c->next) {
1645                 total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
1646         }
1647
1648         tc->flags &= ~TALLOC_FLAG_LOOP;
1649
1650         return total;
1651 }
1652
1653 /*
1654   return the total number of blocks in a talloc pool (subtree)
1655 */
1656 _PUBLIC_ size_t talloc_total_blocks(const void *ptr)
1657 {
1658         size_t total = 0;
1659         struct talloc_chunk *c, *tc;
1660
1661         if (ptr == NULL) {
1662                 ptr = null_context;
1663         }
1664         if (ptr == NULL) {
1665                 return 0;
1666         }
1667
1668         tc = talloc_chunk_from_ptr(ptr);
1669
1670         if (tc->flags & TALLOC_FLAG_LOOP) {
1671                 return 0;
1672         }
1673
1674         tc->flags |= TALLOC_FLAG_LOOP;
1675
1676         total++;
1677         for (c=tc->child;c;c=c->next) {
1678                 total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
1679         }
1680
1681         tc->flags &= ~TALLOC_FLAG_LOOP;
1682
1683         return total;
1684 }
1685
1686 /*
1687   return the number of external references to a pointer
1688 */
1689 _PUBLIC_ size_t talloc_reference_count(const void *ptr)
1690 {
1691         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
1692         struct talloc_reference_handle *h;
1693         size_t ret = 0;
1694
1695         for (h=tc->refs;h;h=h->next) {
1696                 ret++;
1697         }
1698         return ret;
1699 }
1700
1701 /*
1702   report on memory usage by all children of a pointer, giving a full tree view
1703 */
1704 _PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
1705                             void (*callback)(const void *ptr,
1706                                              int depth, int max_depth,
1707                                              int is_ref,
1708                                              void *private_data),
1709                             void *private_data)
1710 {
1711         struct talloc_chunk *c, *tc;
1712
1713         if (ptr == NULL) {
1714                 ptr = null_context;
1715         }
1716         if (ptr == NULL) return;
1717
1718         tc = talloc_chunk_from_ptr(ptr);
1719
1720         if (tc->flags & TALLOC_FLAG_LOOP) {
1721                 return;
1722         }
1723
1724         callback(ptr, depth, max_depth, 0, private_data);
1725
1726         if (max_depth >= 0 && depth >= max_depth) {
1727                 return;
1728         }
1729
1730         tc->flags |= TALLOC_FLAG_LOOP;
1731         for (c=tc->child;c;c=c->next) {
1732                 if (c->name == TALLOC_MAGIC_REFERENCE) {
1733                         struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
1734                         callback(h->ptr, depth + 1, max_depth, 1, private_data);
1735                 } else {
1736                         talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
1737                 }
1738         }
1739         tc->flags &= ~TALLOC_FLAG_LOOP;
1740 }
1741
1742 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
1743 {
1744         const char *name = talloc_get_name(ptr);
1745         FILE *f = (FILE *)_f;
1746
1747         if (is_ref) {
1748                 fprintf(f, "%*sreference to: %s\n", depth*4, "", name);
1749                 return;
1750         }
1751
1752         if (depth == 0) {
1753                 fprintf(f,"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
1754                         (max_depth < 0 ? "full " :""), name,
1755                         (unsigned long)talloc_total_size(ptr),
1756                         (unsigned long)talloc_total_blocks(ptr));
1757                 return;
1758         }
1759
1760         fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d) %p\n",
1761                 depth*4, "",
1762                 name,
1763                 (unsigned long)talloc_total_size(ptr),
1764                 (unsigned long)talloc_total_blocks(ptr),
1765                 (int)talloc_reference_count(ptr), ptr);
1766
1767 #if 0
1768         fprintf(f, "content: ");
1769         if (talloc_total_size(ptr)) {
1770                 int tot = talloc_total_size(ptr);
1771                 int i;
1772
1773                 for (i = 0; i < tot; i++) {
1774                         if ((((char *)ptr)[i] > 31) && (((char *)ptr)[i] < 126)) {
1775                                 fprintf(f, "%c", ((char *)ptr)[i]);
1776                         } else {
1777                                 fprintf(f, "~%02x", ((char *)ptr)[i]);
1778                         }
1779                 }
1780         }
1781         fprintf(f, "\n");
1782 #endif
1783 }
1784
1785 /*
1786   report on memory usage by all children of a pointer, giving a full tree view
1787 */
1788 _PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
1789 {
1790         if (f) {
1791                 talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
1792                 fflush(f);
1793         }
1794 }
1795
1796 /*
1797   report on memory usage by all children of a pointer, giving a full tree view
1798 */
1799 _PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
1800 {
1801         talloc_report_depth_file(ptr, 0, -1, f);
1802 }
1803
1804 /*
1805   report on memory usage by all children of a pointer
1806 */
1807 _PUBLIC_ void talloc_report(const void *ptr, FILE *f)
1808 {
1809         talloc_report_depth_file(ptr, 0, 1, f);
1810 }
1811
1812 /*
1813   report on any memory hanging off the null context
1814 */
1815 static void talloc_report_null(void)
1816 {
1817         if (talloc_total_size(null_context) != 0) {
1818                 talloc_report(null_context, stderr);
1819         }
1820 }
1821
1822 /*
1823   report on any memory hanging off the null context
1824 */
1825 static void talloc_report_null_full(void)
1826 {
1827         if (talloc_total_size(null_context) != 0) {
1828                 talloc_report_full(null_context, stderr);
1829         }
1830 }
1831
1832 /*
1833   enable tracking of the NULL context
1834 */
1835 _PUBLIC_ void talloc_enable_null_tracking(void)
1836 {
1837         if (null_context == NULL) {
1838                 null_context = _talloc_named_const(NULL, 0, "null_context");
1839                 if (autofree_context != NULL) {
1840                         talloc_reparent(NULL, null_context, autofree_context);
1841                 }
1842         }
1843 }
1844
1845 /*
1846   enable tracking of the NULL context, not moving the autofree context
1847   into the NULL context. This is needed for the talloc testsuite
1848 */
1849 _PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
1850 {
1851         if (null_context == NULL) {
1852                 null_context = _talloc_named_const(NULL, 0, "null_context");
1853         }
1854 }
1855
1856 /*
1857   disable tracking of the NULL context
1858 */
1859 _PUBLIC_ void talloc_disable_null_tracking(void)
1860 {
1861         if (null_context != NULL) {
1862                 /* we have to move any children onto the real NULL
1863                    context */
1864                 struct talloc_chunk *tc, *tc2;
1865                 tc = talloc_chunk_from_ptr(null_context);
1866                 for (tc2 = tc->child; tc2; tc2=tc2->next) {
1867                         if (tc2->parent == tc) tc2->parent = NULL;
1868                         if (tc2->prev == tc) tc2->prev = NULL;
1869                 }
1870                 for (tc2 = tc->next; tc2; tc2=tc2->next) {
1871                         if (tc2->parent == tc) tc2->parent = NULL;
1872                         if (tc2->prev == tc) tc2->prev = NULL;
1873                 }
1874                 tc->child = NULL;
1875                 tc->next = NULL;
1876         }
1877         talloc_free(null_context);
1878         null_context = NULL;
1879 }
1880
1881 /*
1882   enable leak reporting on exit
1883 */
1884 _PUBLIC_ void talloc_enable_leak_report(void)
1885 {
1886         talloc_enable_null_tracking();
1887         atexit(talloc_report_null);
1888 }
1889
1890 /*
1891   enable full leak reporting on exit
1892 */
1893 _PUBLIC_ void talloc_enable_leak_report_full(void)
1894 {
1895         talloc_enable_null_tracking();
1896         atexit(talloc_report_null_full);
1897 }
1898
1899 /*
1900    talloc and zero memory.
1901 */
1902 _PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
1903 {
1904         void *p = _talloc_named_const(ctx, size, name);
1905
1906         if (p) {
1907                 memset(p, '\0', size);
1908         }
1909
1910         return p;
1911 }
1912
1913 /*
1914   memdup with a talloc.
1915 */
1916 _PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
1917 {
1918         void *newp = _talloc_named_const(t, size, name);
1919
1920         if (likely(newp)) {
1921                 memcpy(newp, p, size);
1922         }
1923
1924         return newp;
1925 }
1926
1927 static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
1928 {
1929         char *ret;
1930
1931         ret = (char *)__talloc(t, len + 1);
1932         if (unlikely(!ret)) return NULL;
1933
1934         memcpy(ret, p, len);
1935         ret[len] = 0;
1936
1937         _talloc_set_name_const(ret, ret);
1938         return ret;
1939 }
1940
1941 /*
1942   strdup with a talloc
1943 */
1944 _PUBLIC_ char *talloc_strdup(const void *t, const char *p)
1945 {
1946         if (unlikely(!p)) return NULL;
1947         return __talloc_strlendup(t, p, strlen(p));
1948 }
1949
1950 /*
1951   strndup with a talloc
1952 */
1953 _PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
1954 {
1955         if (unlikely(!p)) return NULL;
1956         return __talloc_strlendup(t, p, strnlen(p, n));
1957 }
1958
1959 static inline char *__talloc_strlendup_append(char *s, size_t slen,
1960                                               const char *a, size_t alen)
1961 {
1962         char *ret;
1963
1964         ret = talloc_realloc(NULL, s, char, slen + alen + 1);
1965         if (unlikely(!ret)) return NULL;
1966
1967         /* append the string and the trailing \0 */
1968         memcpy(&ret[slen], a, alen);
1969         ret[slen+alen] = 0;
1970
1971         _talloc_set_name_const(ret, ret);
1972         return ret;
1973 }
1974
1975 /*
1976  * Appends at the end of the string.
1977  */
1978 _PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
1979 {
1980         if (unlikely(!s)) {
1981                 return talloc_strdup(NULL, a);
1982         }
1983
1984         if (unlikely(!a)) {
1985                 return s;
1986         }
1987
1988         return __talloc_strlendup_append(s, strlen(s), a, strlen(a));
1989 }
1990
1991 /*
1992  * Appends at the end of the talloc'ed buffer,
1993  * not the end of the string.
1994  */
1995 _PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
1996 {
1997         size_t slen;
1998
1999         if (unlikely(!s)) {
2000                 return talloc_strdup(NULL, a);
2001         }
2002
2003         if (unlikely(!a)) {
2004                 return s;
2005         }
2006
2007         slen = talloc_get_size(s);
2008         if (likely(slen > 0)) {
2009                 slen--;
2010         }
2011
2012         return __talloc_strlendup_append(s, slen, a, strlen(a));
2013 }
2014
2015 /*
2016  * Appends at the end of the string.
2017  */
2018 _PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
2019 {
2020         if (unlikely(!s)) {
2021                 return talloc_strdup(NULL, a);
2022         }
2023
2024         if (unlikely(!a)) {
2025                 return s;
2026         }
2027
2028         return __talloc_strlendup_append(s, strlen(s), a, strnlen(a, n));
2029 }
2030
2031 /*
2032  * Appends at the end of the talloc'ed buffer,
2033  * not the end of the string.
2034  */
2035 _PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
2036 {
2037         size_t slen;
2038
2039         if (unlikely(!s)) {
2040                 return talloc_strdup(NULL, a);
2041         }
2042
2043         if (unlikely(!a)) {
2044                 return s;
2045         }
2046
2047         slen = talloc_get_size(s);
2048         if (likely(slen > 0)) {
2049                 slen--;
2050         }
2051
2052         return __talloc_strlendup_append(s, slen, a, strnlen(a, n));
2053 }
2054
2055 #ifndef HAVE_VA_COPY
2056 #ifdef HAVE___VA_COPY
2057 #define va_copy(dest, src) __va_copy(dest, src)
2058 #else
2059 #define va_copy(dest, src) (dest) = (src)
2060 #endif
2061 #endif
2062
2063 _PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
2064 {
2065         int len;
2066         char *ret;
2067         va_list ap2;
2068         char c;
2069
2070         /* this call looks strange, but it makes it work on older solaris boxes */
2071         va_copy(ap2, ap);
2072         len = vsnprintf(&c, 1, fmt, ap2);
2073         va_end(ap2);
2074         if (unlikely(len < 0)) {
2075                 return NULL;
2076         }
2077
2078         ret = (char *)__talloc(t, len+1);
2079         if (unlikely(!ret)) return NULL;
2080
2081         va_copy(ap2, ap);
2082         vsnprintf(ret, len+1, fmt, ap2);
2083         va_end(ap2);
2084
2085         _talloc_set_name_const(ret, ret);
2086         return ret;
2087 }
2088
2089
2090 /*
2091   Perform string formatting, and return a pointer to newly allocated
2092   memory holding the result, inside a memory pool.
2093  */
2094 _PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
2095 {
2096         va_list ap;
2097         char *ret;
2098
2099         va_start(ap, fmt);
2100         ret = talloc_vasprintf(t, fmt, ap);
2101         va_end(ap);
2102         return ret;
2103 }
2104
2105 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2106                                                  const char *fmt, va_list ap)
2107                                                  PRINTF_ATTRIBUTE(3,0);
2108
2109 static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
2110                                                  const char *fmt, va_list ap)
2111 {
2112         ssize_t alen;
2113         va_list ap2;
2114         char c;
2115
2116         va_copy(ap2, ap);
2117         alen = vsnprintf(&c, 1, fmt, ap2);
2118         va_end(ap2);
2119
2120         if (alen <= 0) {
2121                 /* Either the vsnprintf failed or the format resulted in
2122                  * no characters being formatted. In the former case, we
2123                  * ought to return NULL, in the latter we ought to return
2124                  * the original string. Most current callers of this
2125                  * function expect it to never return NULL.
2126                  */
2127                 return s;
2128         }
2129
2130         s = talloc_realloc(NULL, s, char, slen + alen + 1);
2131         if (!s) return NULL;
2132
2133         va_copy(ap2, ap);
2134         vsnprintf(s + slen, alen + 1, fmt, ap2);
2135         va_end(ap2);
2136
2137         _talloc_set_name_const(s, s);
2138         return s;
2139 }
2140
2141 /**
2142  * Realloc @p s to append the formatted result of @p fmt and @p ap,
2143  * and return @p s, which may have moved.  Good for gradually
2144  * accumulating output into a string buffer. Appends at the end
2145  * of the string.
2146  **/
2147 _PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
2148 {
2149         if (unlikely(!s)) {
2150                 return talloc_vasprintf(NULL, fmt, ap);
2151         }
2152
2153         return __talloc_vaslenprintf_append(s, strlen(s), fmt, ap);
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. Always appends at the
2159  * end of the talloc'ed buffer, not the end of the string.
2160  **/
2161 _PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
2162 {
2163         size_t slen;
2164
2165         if (unlikely(!s)) {
2166                 return talloc_vasprintf(NULL, fmt, ap);
2167         }
2168
2169         slen = talloc_get_size(s);
2170         if (likely(slen > 0)) {
2171                 slen--;
2172         }
2173
2174         return __talloc_vaslenprintf_append(s, slen, fmt, ap);
2175 }
2176
2177 /*
2178   Realloc @p s to append the formatted result of @p fmt and return @p
2179   s, which may have moved.  Good for gradually accumulating output
2180   into a string buffer.
2181  */
2182 _PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
2183 {
2184         va_list ap;
2185
2186         va_start(ap, fmt);
2187         s = talloc_vasprintf_append(s, fmt, ap);
2188         va_end(ap);
2189         return s;
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 buffer.
2196  */
2197 _PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
2198 {
2199         va_list ap;
2200
2201         va_start(ap, fmt);
2202         s = talloc_vasprintf_append_buffer(s, fmt, ap);
2203         va_end(ap);
2204         return s;
2205 }
2206
2207 /*
2208   alloc an array, checking for integer overflow in the array size
2209 */
2210 _PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2211 {
2212         if (count >= MAX_TALLOC_SIZE/el_size) {
2213                 return NULL;
2214         }
2215         return _talloc_named_const(ctx, el_size * count, name);
2216 }
2217
2218 /*
2219   alloc an zero array, checking for integer overflow in the array size
2220 */
2221 _PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
2222 {
2223         if (count >= MAX_TALLOC_SIZE/el_size) {
2224                 return NULL;
2225         }
2226         return _talloc_zero(ctx, el_size * count, name);
2227 }
2228
2229 /*
2230   realloc an array, checking for integer overflow in the array size
2231 */
2232 _PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
2233 {
2234         if (count >= MAX_TALLOC_SIZE/el_size) {
2235                 return NULL;
2236         }
2237         return _talloc_realloc(ctx, ptr, el_size * count, name);
2238 }
2239
2240 /*
2241   a function version of talloc_realloc(), so it can be passed as a function pointer
2242   to libraries that want a realloc function (a realloc function encapsulates
2243   all the basic capabilities of an allocation library, which is why this is useful)
2244 */
2245 _PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
2246 {
2247         return _talloc_realloc(context, ptr, size, NULL);
2248 }
2249
2250
2251 static int talloc_autofree_destructor(void *ptr)
2252 {
2253         autofree_context = NULL;
2254         return 0;
2255 }
2256
2257 static void talloc_autofree(void)
2258 {
2259         talloc_free(autofree_context);
2260 }
2261
2262 /*
2263   return a context which will be auto-freed on exit
2264   this is useful for reducing the noise in leak reports
2265 */
2266 _PUBLIC_ void *talloc_autofree_context(void)
2267 {
2268         if (autofree_context == NULL) {
2269                 autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
2270                 talloc_set_destructor(autofree_context, talloc_autofree_destructor);
2271                 atexit(talloc_autofree);
2272         }
2273         return autofree_context;
2274 }
2275
2276 _PUBLIC_ size_t talloc_get_size(const void *context)
2277 {
2278         struct talloc_chunk *tc;
2279
2280         if (context == NULL) {
2281                 context = null_context;
2282         }
2283         if (context == NULL) {
2284                 return 0;
2285         }
2286
2287         tc = talloc_chunk_from_ptr(context);
2288
2289         return tc->size;
2290 }
2291
2292 /*
2293   find a parent of this context that has the given name, if any
2294 */
2295 _PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
2296 {
2297         struct talloc_chunk *tc;
2298
2299         if (context == NULL) {
2300                 return NULL;
2301         }
2302
2303         tc = talloc_chunk_from_ptr(context);
2304         while (tc) {
2305                 if (tc->name && strcmp(tc->name, name) == 0) {
2306                         return TC_PTR_FROM_CHUNK(tc);
2307                 }
2308                 while (tc && tc->prev) tc = tc->prev;
2309                 if (tc) {
2310                         tc = tc->parent;
2311                 }
2312         }
2313         return NULL;
2314 }
2315
2316 /*
2317   show the parentage of a context
2318 */
2319 _PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
2320 {
2321         struct talloc_chunk *tc;
2322
2323         if (context == NULL) {
2324                 fprintf(file, "talloc no parents for NULL\n");
2325                 return;
2326         }
2327
2328         tc = talloc_chunk_from_ptr(context);
2329         fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
2330         while (tc) {
2331                 fprintf(file, "\t'%s'\n", talloc_get_name(TC_PTR_FROM_CHUNK(tc)));
2332                 while (tc && tc->prev) tc = tc->prev;
2333                 if (tc) {
2334                         tc = tc->parent;
2335                 }
2336         }
2337         fflush(file);
2338 }
2339
2340 /*
2341   return 1 if ptr is a parent of context
2342 */
2343 static int _talloc_is_parent(const void *context, const void *ptr, int depth)
2344 {
2345         struct talloc_chunk *tc;
2346
2347         if (context == NULL) {
2348                 return 0;
2349         }
2350
2351         tc = talloc_chunk_from_ptr(context);
2352         while (tc && depth > 0) {
2353                 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
2354                 while (tc && tc->prev) tc = tc->prev;
2355                 if (tc) {
2356                         tc = tc->parent;
2357                         depth--;
2358                 }
2359         }
2360         return 0;
2361 }
2362
2363 /*
2364   return 1 if ptr is a parent of context
2365 */
2366 _PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
2367 {
2368         return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
2369 }