r6845: make the talloc header align to 40 bytes, which costs us an extra 4
[samba.git] / source / lib / talloc / talloc.c
1 /* 
2    Samba Unix SMB/CIFS implementation.
3
4    Samba trivial allocation library - new interface
5
6    NOTE: Please read talloc_guide.txt for full documentation
7
8    Copyright (C) Andrew Tridgell 2004
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 /*
26   inspired by http://swapped.cc/halloc/
27 */
28
29
30 #include "config.h"
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #ifdef HAVE_SYS_TYPES_H
37 #include <sys/types.h>
38 #endif
39
40 #ifdef HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43
44 #ifdef HAVE_STDARG_H
45 #include <stdarg.h>
46 #else
47 #include <varargs.h>
48 #endif
49
50 #ifdef HAVE_STDINT_H
51 #include <stdint.h>
52 #endif
53
54 #include "talloc.h"
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
61 #define MAX_TALLOC_SIZE 0x10000000
62 #define TALLOC_MAGIC 0xe814ec4f
63 #define TALLOC_MAGIC_FREE 0x7faebef3
64 #define TALLOC_MAGIC_REFERENCE ((const char *)1)
65
66 /* by default we abort when given a bad pointer (such as when talloc_free() is called 
67    on a pointer that came from malloc() */
68 #ifndef TALLOC_ABORT
69 #define TALLOC_ABORT(reason) abort()
70 #endif
71
72 #ifndef discard_const_p
73 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
74 # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
75 #else
76 # define discard_const_p(type, ptr) ((type *)(ptr))
77 #endif
78 #endif
79
80 /* this null_context is only used if talloc_enable_leak_report() or
81    talloc_enable_leak_report_full() is called, otherwise it remains
82    NULL
83 */
84 static const void *null_context;
85 static void *cleanup_context;
86
87
88 struct talloc_reference_handle {
89         struct talloc_reference_handle *next, *prev;
90         void *ptr;
91 };
92
93 typedef int (*talloc_destructor_t)(void *);
94
95 struct talloc_chunk {
96         struct talloc_chunk *next, *prev;
97         struct talloc_chunk *parent, *child;
98         struct talloc_reference_handle *refs;
99         size_t size;
100         talloc_destructor_t destructor;
101         const char *name;
102         union {
103                 unsigned magic;
104                 double align_dummy;
105         } u;
106 };
107
108 /* panic if we get a bad magic value */
109 static struct talloc_chunk *talloc_chunk_from_ptr(const void *ptr)
110 {
111         struct talloc_chunk *tc = discard_const_p(struct talloc_chunk, ptr)-1;
112         if (tc->u.magic != TALLOC_MAGIC) { 
113                 if (tc->u.magic == TALLOC_MAGIC_FREE) {
114                         TALLOC_ABORT("Bad talloc magic value - double free"); 
115                 } else {
116                         TALLOC_ABORT("Bad talloc magic value - unknown value"); 
117                 }
118         }
119
120         return tc;
121 }
122
123 /* hook into the front of the list */
124 #define _TLIST_ADD(list, p) \
125 do { \
126         if (!(list)) { \
127                 (list) = (p); \
128                 (p)->next = (p)->prev = NULL; \
129         } else { \
130                 (list)->prev = (p); \
131                 (p)->next = (list); \
132                 (p)->prev = NULL; \
133                 (list) = (p); \
134         }\
135 } while (0)
136
137 /* remove an element from a list - element doesn't have to be in list. */
138 #define _TLIST_REMOVE(list, p) \
139 do { \
140         if ((p) == (list)) { \
141                 (list) = (p)->next; \
142                 if (list) (list)->prev = NULL; \
143         } else { \
144                 if ((p)->prev) (p)->prev->next = (p)->next; \
145                 if ((p)->next) (p)->next->prev = (p)->prev; \
146         } \
147         if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
148 } while (0)
149
150
151 /*
152   return the parent chunk of a pointer
153 */
154 static struct talloc_chunk *talloc_parent_chunk(const void *ptr)
155 {
156         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
157         while (tc->prev) tc=tc->prev;
158         return tc->parent;
159 }
160
161 void *talloc_parent(const void *ptr)
162 {
163         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
164         return (void *)(tc+1);
165 }
166
167 /* 
168    Allocate a bit of memory as a child of an existing pointer
169 */
170 void *_talloc(const void *context, size_t size)
171 {
172         struct talloc_chunk *tc;
173
174         if (context == NULL) {
175                 context = null_context;
176         }
177
178         if (size >= MAX_TALLOC_SIZE) {
179                 return NULL;
180         }
181
182         tc = malloc(sizeof(*tc)+size);
183         if (tc == NULL) return NULL;
184
185         tc->size = size;
186         tc->u.magic = TALLOC_MAGIC;
187         tc->destructor = NULL;
188         tc->child = NULL;
189         tc->name = NULL;
190         tc->refs = NULL;
191
192         if (context) {
193                 struct talloc_chunk *parent = talloc_chunk_from_ptr(context);
194
195                 tc->parent = parent;
196
197                 if (parent->child) {
198                         parent->child->parent = NULL;
199                 }
200
201                 _TLIST_ADD(parent->child, tc);
202         } else {
203                 tc->next = tc->prev = tc->parent = NULL;
204         }
205
206         return (void *)(tc+1);
207 }
208
209
210 /*
211   setup a destructor to be called on free of a pointer
212   the destructor should return 0 on success, or -1 on failure.
213   if the destructor fails then the free is failed, and the memory can
214   be continued to be used
215 */
216 void talloc_set_destructor(const void *ptr, int (*destructor)(void *))
217 {
218         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
219         tc->destructor = destructor;
220 }
221
222 /*
223   increase the reference count on a piece of memory. 
224 */
225 void talloc_increase_ref_count(const void *ptr)
226 {
227         talloc_reference(null_context, ptr);
228 }
229
230 /*
231   helper for talloc_reference()
232 */
233 static int talloc_reference_destructor(void *ptr)
234 {
235         struct talloc_reference_handle *handle = ptr;
236         struct talloc_chunk *tc1 = talloc_chunk_from_ptr(ptr);
237         struct talloc_chunk *tc2 = talloc_chunk_from_ptr(handle->ptr);
238         if (tc1->destructor != (talloc_destructor_t)-1) {
239                 tc1->destructor = NULL;
240         }
241         _TLIST_REMOVE(tc2->refs, handle);
242         talloc_free(handle);
243         return 0;
244 }
245
246 /*
247   make a secondary reference to a pointer, hanging off the given context.
248   the pointer remains valid until both the original caller and this given
249   context are freed.
250   
251   the major use for this is when two different structures need to reference the 
252   same underlying data, and you want to be able to free the two instances separately,
253   and in either order
254 */
255 void *talloc_reference(const void *context, const void *ptr)
256 {
257         struct talloc_chunk *tc;
258         struct talloc_reference_handle *handle;
259         if (ptr == NULL) return NULL;
260
261         tc = talloc_chunk_from_ptr(ptr);
262         handle = talloc_named_const(context, sizeof(*handle), TALLOC_MAGIC_REFERENCE);
263
264         if (handle == NULL) return NULL;
265
266         /* note that we hang the destructor off the handle, not the
267            main context as that allows the caller to still setup their
268            own destructor on the context if they want to */
269         talloc_set_destructor(handle, talloc_reference_destructor);
270         handle->ptr = discard_const_p(void, ptr);
271         _TLIST_ADD(tc->refs, handle);
272         return handle->ptr;
273 }
274
275 /*
276   remove a secondary reference to a pointer. This undo's what
277   talloc_reference() has done. The context and pointer arguments
278   must match those given to a talloc_reference()
279 */
280 static int talloc_unreference(const void *context, const void *ptr)
281 {
282         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
283         struct talloc_reference_handle *h;
284
285         if (context == NULL) {
286                 context = null_context;
287         }
288
289         for (h=tc->refs;h;h=h->next) {
290                 struct talloc_chunk *p = talloc_parent_chunk(h);
291                 if ((p==NULL && context==NULL) || p+1 == context) break;
292         }
293         if (h == NULL) {
294                 return -1;
295         }
296
297         talloc_set_destructor(h, NULL);
298         _TLIST_REMOVE(tc->refs, h);
299         talloc_free(h);
300         return 0;
301 }
302
303 /*
304   remove a specific parent context from a pointer. This is a more
305   controlled varient of talloc_free()
306 */
307 int talloc_unlink(const void *context, void *ptr)
308 {
309         struct talloc_chunk *tc_p, *new_p;
310         void *new_parent;
311
312         if (ptr == NULL) {
313                 return -1;
314         }
315
316         if (context == NULL) {
317                 context = null_context;
318         }
319
320         if (talloc_unreference(context, ptr) == 0) {
321                 return 0;
322         }
323
324         if (context == NULL) {
325                 if (talloc_parent_chunk(ptr) != NULL) {
326                         return -1;
327                 }
328         } else {
329                 if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
330                         return -1;
331                 }
332         }
333         
334         tc_p = talloc_chunk_from_ptr(ptr);
335
336         if (tc_p->refs == NULL) {
337                 return talloc_free(ptr);
338         }
339
340         new_p = talloc_parent_chunk(tc_p->refs);
341         if (new_p) {
342                 new_parent = new_p+1;
343         } else {
344                 new_parent = NULL;
345         }
346
347         if (talloc_unreference(new_parent, ptr) != 0) {
348                 return -1;
349         }
350
351         talloc_steal(new_parent, ptr);
352
353         return 0;
354 }
355
356 /*
357   add a name to an existing pointer - va_list version
358 */
359 static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
360
361 static void talloc_set_name_v(const void *ptr, const char *fmt, va_list ap)
362 {
363         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
364         tc->name = talloc_vasprintf(ptr, fmt, ap);
365         if (tc->name) {
366                 talloc_set_name_const(tc->name, ".name");
367         }
368 }
369
370 /*
371   add a name to an existing pointer
372 */
373 void talloc_set_name(const void *ptr, const char *fmt, ...)
374 {
375         va_list ap;
376         va_start(ap, fmt);
377         talloc_set_name_v(ptr, fmt, ap);
378         va_end(ap);
379 }
380
381 /*
382    more efficient way to add a name to a pointer - the name must point to a 
383    true string constant
384 */
385 void talloc_set_name_const(const void *ptr, const char *name)
386 {
387         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
388         tc->name = name;
389 }
390
391 /*
392   create a named talloc pointer. Any talloc pointer can be named, and
393   talloc_named() operates just like talloc() except that it allows you
394   to name the pointer.
395 */
396 void *talloc_named(const void *context, size_t size, const char *fmt, ...)
397 {
398         va_list ap;
399         void *ptr;
400
401         ptr = _talloc(context, size);
402         if (ptr == NULL) return NULL;
403
404         va_start(ap, fmt);
405         talloc_set_name_v(ptr, fmt, ap);
406         va_end(ap);
407
408         return ptr;
409 }
410
411 /*
412   create a named talloc pointer. Any talloc pointer can be named, and
413   talloc_named() operates just like talloc() except that it allows you
414   to name the pointer.
415 */
416 void *talloc_named_const(const void *context, size_t size, const char *name)
417 {
418         void *ptr;
419
420         ptr = _talloc(context, size);
421         if (ptr == NULL) {
422                 return NULL;
423         }
424
425         talloc_set_name_const(ptr, name);
426
427         return ptr;
428 }
429
430 /*
431   return the name of a talloc ptr, or "UNNAMED"
432 */
433 const char *talloc_get_name(const void *ptr)
434 {
435         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
436         if (tc->name == TALLOC_MAGIC_REFERENCE) {
437                 return ".reference";
438         }
439         if (tc->name) {
440                 return tc->name;
441         }
442         return "UNNAMED";
443 }
444
445
446 /*
447   check if a pointer has the given name. If it does, return the pointer,
448   otherwise return NULL
449 */
450 void *talloc_check_name(const void *ptr, const char *name)
451 {
452         const char *pname;
453         if (ptr == NULL) return NULL;
454         pname = talloc_get_name(ptr);
455         if (pname == name || strcmp(pname, name) == 0) {
456                 return discard_const_p(void, ptr);
457         }
458         return NULL;
459 }
460
461
462 /*
463   this is for compatibility with older versions of talloc
464 */
465 void *talloc_init(const char *fmt, ...)
466 {
467         va_list ap;
468         void *ptr;
469
470         ptr = _talloc(NULL, 0);
471         if (ptr == NULL) return NULL;
472
473         va_start(ap, fmt);
474         talloc_set_name_v(ptr, fmt, ap);
475         va_end(ap);
476
477         return ptr;
478 }
479
480 /*
481   this is a replacement for the Samba3 talloc_destroy_pool functionality. It
482   should probably not be used in new code. It's in here to keep the talloc
483   code consistent across Samba 3 and 4.
484 */
485 void talloc_free_children(void *ptr)
486 {
487         struct talloc_chunk *tc;
488
489         if (ptr == NULL) {
490                 return;
491         }
492
493         tc = talloc_chunk_from_ptr(ptr);
494
495         while (tc->child) {
496                 /* we need to work out who will own an abandoned child
497                    if it cannot be freed. In priority order, the first
498                    choice is owner of any remaining reference to this
499                    pointer, the second choice is our parent, and the
500                    final choice is the null context. */
501                 void *child = tc->child+1;
502                 const void *new_parent = null_context;
503                 if (tc->child->refs) {
504                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
505                         if (p) new_parent = p+1;
506                 }
507                 if (talloc_free(child) == -1) {
508                         if (new_parent == null_context) {
509                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
510                                 if (p) new_parent = p+1;
511                         }
512                         talloc_steal(new_parent, child);
513                 }
514         }
515 }
516
517 /* 
518    free a talloc pointer. This also frees all child pointers of this 
519    pointer recursively
520
521    return 0 if the memory is actually freed, otherwise -1. The memory
522    will not be freed if the ref_count is > 1 or the destructor (if
523    any) returns non-zero
524 */
525 int talloc_free(void *ptr)
526 {
527         struct talloc_chunk *tc;
528
529         if (ptr == NULL) {
530                 return -1;
531         }
532
533         tc = talloc_chunk_from_ptr(ptr);
534
535         if (tc->refs) {
536                 talloc_reference_destructor(tc->refs);
537                 return -1;
538         }
539
540         if (tc->destructor) {
541                 talloc_destructor_t d = tc->destructor;
542                 if (d == (talloc_destructor_t)-1) {
543                         return -1;
544                 }
545                 tc->destructor = (talloc_destructor_t)-1;
546                 if (d(ptr) == -1) {
547                         tc->destructor = d;
548                         return -1;
549                 }
550                 tc->destructor = NULL;
551         }
552
553         talloc_free_children(ptr);
554
555         if (tc->parent) {
556                 _TLIST_REMOVE(tc->parent->child, tc);
557                 if (tc->parent->child) {
558                         tc->parent->child->parent = tc->parent;
559                 }
560         } else {
561                 if (tc->prev) tc->prev->next = tc->next;
562                 if (tc->next) tc->next->prev = tc->prev;
563         }
564
565         tc->u.magic = TALLOC_MAGIC_FREE;
566
567         free(tc);
568         return 0;
569 }
570
571
572
573 /*
574   A talloc version of realloc. The context argument is only used if
575   ptr is NULL
576 */
577 void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
578 {
579         struct talloc_chunk *tc;
580         void *new_ptr;
581
582         /* size zero is equivalent to free() */
583         if (size == 0) {
584                 talloc_free(ptr);
585                 return NULL;
586         }
587
588         if (size >= MAX_TALLOC_SIZE) {
589                 return NULL;
590         }
591
592         /* realloc(NULL) is equavalent to malloc() */
593         if (ptr == NULL) {
594                 return talloc_named_const(context, size, name);
595         }
596
597         tc = talloc_chunk_from_ptr(ptr);
598
599         /* don't allow realloc on referenced pointers */
600         if (tc->refs) {
601                 return NULL;
602         }
603
604         /* by resetting magic we catch users of the old memory */
605         tc->u.magic = TALLOC_MAGIC_FREE;
606
607 #if ALWAYS_REALLOC
608         new_ptr = malloc(size + sizeof(*tc));
609         if (new_ptr) {
610                 memcpy(new_ptr, tc, tc->size + sizeof(*tc));
611                 free(tc);
612         }
613 #else
614         new_ptr = realloc(tc, size + sizeof(*tc));
615 #endif
616         if (!new_ptr) { 
617                 tc->u.magic = TALLOC_MAGIC; 
618                 return NULL; 
619         }
620
621         tc = new_ptr;
622         tc->u.magic = TALLOC_MAGIC;
623         if (tc->parent) {
624                 tc->parent->child = new_ptr;
625         }
626         if (tc->child) {
627                 tc->child->parent = new_ptr;
628         }
629
630         if (tc->prev) {
631                 tc->prev->next = tc;
632         }
633         if (tc->next) {
634                 tc->next->prev = tc;
635         }
636
637         tc->size = size;
638         talloc_set_name_const(tc+1, name);
639
640         return (void *)(tc+1);
641 }
642
643 /* 
644    move a lump of memory from one talloc context to another return the
645    ptr on success, or NULL if it could not be transferred.
646    passing NULL as ptr will always return NULL with no side effects.
647 */
648 void *talloc_steal(const void *new_ctx, const void *ptr)
649 {
650         struct talloc_chunk *tc, *new_tc;
651
652         if (!ptr) {
653                 return NULL;
654         }
655
656         if (new_ctx == NULL) {
657                 new_ctx = null_context;
658         }
659
660         tc = talloc_chunk_from_ptr(ptr);
661
662         if (new_ctx == NULL) {
663                 if (tc->parent) {
664                         _TLIST_REMOVE(tc->parent->child, tc);
665                         if (tc->parent->child) {
666                                 tc->parent->child->parent = tc->parent;
667                         }
668                 } else {
669                         if (tc->prev) tc->prev->next = tc->next;
670                         if (tc->next) tc->next->prev = tc->prev;
671                 }
672                 
673                 tc->parent = tc->next = tc->prev = NULL;
674                 return discard_const_p(void, ptr);
675         }
676
677         new_tc = talloc_chunk_from_ptr(new_ctx);
678
679         if (tc == new_tc) {
680                 return discard_const_p(void, ptr);
681         }
682
683         if (tc->parent) {
684                 _TLIST_REMOVE(tc->parent->child, tc);
685                 if (tc->parent->child) {
686                         tc->parent->child->parent = tc->parent;
687                 }
688         } else {
689                 if (tc->prev) tc->prev->next = tc->next;
690                 if (tc->next) tc->next->prev = tc->prev;
691         }
692
693         tc->parent = new_tc;
694         if (new_tc->child) new_tc->child->parent = NULL;
695         _TLIST_ADD(new_tc->child, tc);
696
697         return discard_const_p(void, ptr);
698 }
699
700 /*
701   return the total size of a talloc pool (subtree)
702 */
703 off_t talloc_total_size(const void *ptr)
704 {
705         off_t total = 0;
706         struct talloc_chunk *c, *tc;
707         
708         if (ptr == NULL) {
709                 ptr = null_context;
710         }
711         if (ptr == NULL) {
712                 return 0;
713         }
714
715         tc = talloc_chunk_from_ptr(ptr);
716
717         total = tc->size;
718         for (c=tc->child;c;c=c->next) {
719                 total += talloc_total_size(c+1);
720         }
721         return total;
722 }
723
724 /*
725   return the total number of blocks in a talloc pool (subtree)
726 */
727 off_t talloc_total_blocks(const void *ptr)
728 {
729         off_t total = 0;
730         struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
731
732         total++;
733         for (c=tc->child;c;c=c->next) {
734                 total += talloc_total_blocks(c+1);
735         }
736         return total;
737 }
738
739 /*
740   return the number of external references to a pointer
741 */
742 static int talloc_reference_count(const void *ptr)
743 {
744         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
745         struct talloc_reference_handle *h;
746         int ret = 0;
747
748         for (h=tc->refs;h;h=h->next) {
749                 ret++;
750         }
751         return ret;
752 }
753
754 /*
755   report on memory usage by all children of a pointer, giving a full tree view
756 */
757 void talloc_report_depth(const void *ptr, FILE *f, int depth)
758 {
759         struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
760
761         for (c=tc->child;c;c=c->next) {
762                 if (c->name == TALLOC_MAGIC_REFERENCE) {
763                         struct talloc_reference_handle *handle = (void *)(c+1);
764                         const char *name2 = talloc_get_name(handle->ptr);
765                         fprintf(f, "%*sreference to: %s\n", depth*4, "", name2);
766                 } else {
767                         const char *name = talloc_get_name(c+1);
768                         fprintf(f, "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n", 
769                                 depth*4, "",
770                                 name,
771                                 (unsigned long)talloc_total_size(c+1),
772                                 (unsigned long)talloc_total_blocks(c+1),
773                                 talloc_reference_count(c+1));
774                         talloc_report_depth(c+1, f, depth+1);
775                 }
776         }
777
778 }
779
780 /*
781   report on memory usage by all children of a pointer, giving a full tree view
782 */
783 void talloc_report_full(const void *ptr, FILE *f)
784 {
785         if (ptr == NULL) {
786                 ptr = null_context;
787         }
788         if (ptr == NULL) return;
789
790         fprintf(f,"full talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
791                 talloc_get_name(ptr), 
792                 (unsigned long)talloc_total_size(ptr),
793                 (unsigned long)talloc_total_blocks(ptr));
794
795         talloc_report_depth(ptr, f, 1);
796         fflush(f);
797 }
798
799 /*
800   report on memory usage by all children of a pointer
801 */
802 void talloc_report(const void *ptr, FILE *f)
803 {
804         struct talloc_chunk *c, *tc;
805
806         if (ptr == NULL) {
807                 ptr = null_context;
808         }
809         if (ptr == NULL) return;
810        
811         fprintf(f,"talloc report on '%s' (total %lu bytes in %lu blocks)\n", 
812                 talloc_get_name(ptr), 
813                 (unsigned long)talloc_total_size(ptr),
814                 (unsigned long)talloc_total_blocks(ptr));
815
816         tc = talloc_chunk_from_ptr(ptr);
817
818         for (c=tc->child;c;c=c->next) {
819                 fprintf(f, "\t%-30s contains %6lu bytes in %3lu blocks\n", 
820                         talloc_get_name(c+1),
821                         (unsigned long)talloc_total_size(c+1),
822                         (unsigned long)talloc_total_blocks(c+1));
823         }
824         fflush(f);
825 }
826
827 /*
828   report on any memory hanging off the null context
829 */
830 static void talloc_report_null(void)
831 {
832         if (talloc_total_size(null_context) != 0) {
833                 talloc_report(null_context, stderr);
834         }
835 }
836
837 /*
838   report on any memory hanging off the null context
839 */
840 static void talloc_report_null_full(void)
841 {
842         if (talloc_total_size(null_context) != 0) {
843                 talloc_report_full(null_context, stderr);
844         }
845 }
846
847 /*
848   enable tracking of the NULL context
849 */
850 void talloc_enable_null_tracking(void)
851 {
852         if (null_context == NULL) {
853                 null_context = talloc_named_const(NULL, 0, "null_context");
854         }
855 }
856
857 /*
858   enable leak reporting on exit
859 */
860 void talloc_enable_leak_report(void)
861 {
862         talloc_enable_null_tracking();
863         atexit(talloc_report_null);
864 }
865
866 /*
867   enable full leak reporting on exit
868 */
869 void talloc_enable_leak_report_full(void)
870 {
871         talloc_enable_null_tracking();
872         atexit(talloc_report_null_full);
873 }
874
875 /* 
876    talloc and zero memory. 
877 */
878 void *_talloc_zero(const void *ctx, size_t size, const char *name)
879 {
880         void *p = talloc_named_const(ctx, size, name);
881
882         if (p) {
883                 memset(p, '\0', size);
884         }
885
886         return p;
887 }
888
889
890 /*
891   memdup with a talloc. 
892 */
893 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
894 {
895         void *newp = talloc_named_const(t, size, name);
896
897         if (newp) {
898                 memcpy(newp, p, size);
899         }
900
901         return newp;
902 }
903
904 /*
905   strdup with a talloc 
906 */
907 char *talloc_strdup(const void *t, const char *p)
908 {
909         char *ret;
910         if (!p) {
911                 return NULL;
912         }
913         ret = talloc_memdup(t, p, strlen(p) + 1);
914         if (ret) {
915                 talloc_set_name_const(ret, ret);
916         }
917         return ret;
918 }
919
920 /*
921   strndup with a talloc 
922 */
923 char *talloc_strndup(const void *t, const char *p, size_t n)
924 {
925         size_t len;
926         char *ret;
927
928         for (len=0; len<n && p[len]; len++) ;
929
930         ret = _talloc(t, len + 1);
931         if (!ret) { return NULL; }
932         memcpy(ret, p, len);
933         ret[len] = 0;
934         talloc_set_name_const(ret, ret);
935         return ret;
936 }
937
938 #ifndef VA_COPY
939 #ifdef HAVE_VA_COPY
940 #define VA_COPY(dest, src) va_copy(dest, src)
941 #elif defined(HAVE___VA_COPY)
942 #define VA_COPY(dest, src) __va_copy(dest, src)
943 #else
944 #define VA_COPY(dest, src) (dest) = (src)
945 #endif
946 #endif
947
948 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
949 {       
950         int len;
951         char *ret;
952         va_list ap2;
953         
954         VA_COPY(ap2, ap);
955
956         len = vsnprintf(NULL, 0, fmt, ap2);
957
958         ret = _talloc(t, len+1);
959         if (ret) {
960                 VA_COPY(ap2, ap);
961                 vsnprintf(ret, len+1, fmt, ap2);
962                 talloc_set_name_const(ret, ret);
963         }
964
965         return ret;
966 }
967
968
969 /*
970   Perform string formatting, and return a pointer to newly allocated
971   memory holding the result, inside a memory pool.
972  */
973 char *talloc_asprintf(const void *t, const char *fmt, ...)
974 {
975         va_list ap;
976         char *ret;
977
978         va_start(ap, fmt);
979         ret = talloc_vasprintf(t, fmt, ap);
980         va_end(ap);
981         return ret;
982 }
983
984
985 /**
986  * Realloc @p s to append the formatted result of @p fmt and @p ap,
987  * and return @p s, which may have moved.  Good for gradually
988  * accumulating output into a string buffer.
989  **/
990
991 static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
992
993 static char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
994 {       
995         struct talloc_chunk *tc;
996         int len, s_len;
997         va_list ap2;
998
999         if (s == NULL) {
1000                 return talloc_vasprintf(NULL, fmt, ap);
1001         }
1002
1003         tc = talloc_chunk_from_ptr(s);
1004
1005         VA_COPY(ap2, ap);
1006
1007         s_len = tc->size - 1;
1008         len = vsnprintf(NULL, 0, fmt, ap2);
1009
1010         s = talloc_realloc(NULL, s, char, s_len + len+1);
1011         if (!s) return NULL;
1012
1013         VA_COPY(ap2, ap);
1014
1015         vsnprintf(s+s_len, len+1, fmt, ap2);
1016         talloc_set_name_const(s, s);
1017
1018         return s;
1019 }
1020
1021 /*
1022   Realloc @p s to append the formatted result of @p fmt and return @p
1023   s, which may have moved.  Good for gradually accumulating output
1024   into a string buffer.
1025  */
1026 char *talloc_asprintf_append(char *s, const char *fmt, ...)
1027 {
1028         va_list ap;
1029
1030         va_start(ap, fmt);
1031         s = talloc_vasprintf_append(s, fmt, ap);
1032         va_end(ap);
1033         return s;
1034 }
1035
1036 /*
1037   alloc an array, checking for integer overflow in the array size
1038 */
1039 void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1040 {
1041         if (count >= MAX_TALLOC_SIZE/el_size) {
1042                 return NULL;
1043         }
1044         return talloc_named_const(ctx, el_size * count, name);
1045 }
1046
1047 /*
1048   alloc an zero array, checking for integer overflow in the array size
1049 */
1050 void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
1051 {
1052         if (count >= MAX_TALLOC_SIZE/el_size) {
1053                 return NULL;
1054         }
1055         return _talloc_zero(ctx, el_size * count, name);
1056 }
1057
1058
1059 /*
1060   realloc an array, checking for integer overflow in the array size
1061 */
1062 void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
1063 {
1064         if (count >= MAX_TALLOC_SIZE/el_size) {
1065                 return NULL;
1066         }
1067         return _talloc_realloc(ctx, ptr, el_size * count, name);
1068 }
1069
1070 /*
1071   a function version of talloc_realloc(), so it can be passed as a function pointer
1072   to libraries that want a realloc function (a realloc function encapsulates
1073   all the basic capabilities of an allocation library, which is why this is useful)
1074 */
1075 void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
1076 {
1077         return _talloc_realloc(context, ptr, size, NULL);
1078 }
1079
1080
1081 static void talloc_autofree(void)
1082 {
1083         talloc_free(cleanup_context);
1084         cleanup_context = NULL;
1085 }
1086
1087 /*
1088   return a context which will be auto-freed on exit
1089   this is useful for reducing the noise in leak reports
1090 */
1091 void *talloc_autofree_context(void)
1092 {
1093         if (cleanup_context == NULL) {
1094                 cleanup_context = talloc_named_const(NULL, 0, "autofree_context");
1095                 atexit(talloc_autofree);
1096         }
1097         return cleanup_context;
1098 }
1099
1100 size_t talloc_get_size(const void *context)
1101 {
1102         struct talloc_chunk *tc;
1103
1104         if (context == NULL)
1105                 return 0;
1106
1107         tc = talloc_chunk_from_ptr(context);
1108
1109         return tc->size;
1110 }