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