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