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