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