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