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