xref: /reactos/sdk/lib/3rdparty/libxml2/xmlmemory.c (revision fb5d5ecd) 
1 /*
2  * xmlmemory.c:  libxml memory allocator wrapper.
3  *
4  * daniel@veillard.com
5  */
6 
7 #define IN_LIBXML
8 #include "libxml.h"
9 
10 #include <string.h>
11 
12 #ifdef HAVE_SYS_TYPES_H
13 #include <sys/types.h>
14 #endif
15 
16 #ifdef HAVE_TIME_H
17 #include <time.h>
18 #endif
19 
20 #ifdef HAVE_STDLIB_H
21 #include <stdlib.h>
22 #else
23 #ifdef HAVE_MALLOC_H
24 #include <malloc.h>
25 #endif
26 #endif
27 
28 #ifdef HAVE_CTYPE_H
29 #include <ctype.h>
30 #endif
31 
32 /* #define DEBUG_MEMORY */
33 
34 /**
35  * MEM_LIST:
36  *
37  * keep track of all allocated blocks for error reporting
38  * Always build the memory list !
39  */
40 #ifdef DEBUG_MEMORY_LOCATION
41 #ifndef MEM_LIST
42 #define MEM_LIST /* keep a list of all the allocated memory blocks */
43 #endif
44 #endif
45 
46 #include <libxml/globals.h>	/* must come before xmlmemory.h */
47 #include <libxml/xmlmemory.h>
48 #include <libxml/xmlerror.h>
49 #include <libxml/threads.h>
50 
51 static int xmlMemInitialized = 0;
52 static unsigned long  debugMemSize = 0;
53 static unsigned long  debugMemBlocks = 0;
54 static unsigned long  debugMaxMemSize = 0;
55 static xmlMutexPtr xmlMemMutex = NULL;
56 
57 void xmlMallocBreakpoint(void);
58 
59 /************************************************************************
60  *									*
61  *		Macros, variables and associated types			*
62  *									*
63  ************************************************************************/
64 
65 #if !defined(LIBXML_THREAD_ENABLED) && !defined(LIBXML_THREAD_ALLOC_ENABLED)
66 #ifdef xmlMalloc
67 #undef xmlMalloc
68 #endif
69 #ifdef xmlRealloc
70 #undef xmlRealloc
71 #endif
72 #ifdef xmlMemStrdup
73 #undef xmlMemStrdup
74 #endif
75 #endif
76 
77 /*
78  * Each of the blocks allocated begin with a header containing informations
79  */
80 
81 #define MEMTAG 0x5aa5
82 
83 #define MALLOC_TYPE 1
84 #define REALLOC_TYPE 2
85 #define STRDUP_TYPE 3
86 #define MALLOC_ATOMIC_TYPE 4
87 #define REALLOC_ATOMIC_TYPE 5
88 
89 typedef struct memnod {
90     unsigned int   mh_tag;
91     unsigned int   mh_type;
92     unsigned long  mh_number;
93     size_t         mh_size;
94 #ifdef MEM_LIST
95    struct memnod *mh_next;
96    struct memnod *mh_prev;
97 #endif
98    const char    *mh_file;
99    unsigned int   mh_line;
100 }  MEMHDR;
101 
102 
103 #ifdef SUN4
104 #define ALIGN_SIZE  16
105 #else
106 #define ALIGN_SIZE  sizeof(double)
107 #endif
108 #define HDR_SIZE    sizeof(MEMHDR)
109 #define RESERVE_SIZE (((HDR_SIZE + (ALIGN_SIZE-1)) \
110 		      / ALIGN_SIZE ) * ALIGN_SIZE)
111 
112 #define MAX_SIZE_T ((size_t)-1)
113 
114 #define CLIENT_2_HDR(a) ((void *) (((char *) (a)) - RESERVE_SIZE))
115 #define HDR_2_CLIENT(a)    ((void *) (((char *) (a)) + RESERVE_SIZE))
116 
117 
118 static unsigned int block=0;
119 static unsigned int xmlMemStopAtBlock = 0;
120 static void *xmlMemTraceBlockAt = NULL;
121 #ifdef MEM_LIST
122 static MEMHDR *memlist = NULL;
123 #endif
124 
125 static void debugmem_tag_error(void *addr);
126 #ifdef MEM_LIST
127 static void  debugmem_list_add(MEMHDR *);
128 static void debugmem_list_delete(MEMHDR *);
129 #endif
130 #define Mem_Tag_Err(a) debugmem_tag_error(a);
131 
132 #ifndef TEST_POINT
133 #define TEST_POINT
134 #endif
135 
136 /**
137  * xmlMallocBreakpoint:
138  *
139  * Breakpoint to use in conjunction with xmlMemStopAtBlock. When the block
140  * number reaches the specified value this function is called. One need to add a breakpoint
141  * to it to get the context in which the given block is allocated.
142  */
143 
144 void
145 xmlMallocBreakpoint(void) {
146     xmlGenericError(xmlGenericErrorContext,
147 	    "xmlMallocBreakpoint reached on block %d\n", xmlMemStopAtBlock);
148 }
149 
150 /**
151  * xmlMallocLoc:
152  * @size:  an int specifying the size in byte to allocate.
153  * @file:  the file name or NULL
154  * @line:  the line number
155  *
156  * a malloc() equivalent, with logging of the allocation info.
157  *
158  * Returns a pointer to the allocated area or NULL in case of lack of memory.
159  */
160 
161 void *
162 xmlMallocLoc(size_t size, const char * file, int line)
163 {
164     MEMHDR *p;
165     void *ret;
166 
167     if (!xmlMemInitialized) xmlInitMemory();
168 #ifdef DEBUG_MEMORY
169     xmlGenericError(xmlGenericErrorContext,
170 	    "Malloc(%d)\n",size);
171 #endif
172 
173     TEST_POINT
174 
175     if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
176 	xmlGenericError(xmlGenericErrorContext,
177 		"xmlMallocLoc : Unsigned overflow\n");
178 	xmlMemoryDump();
179 	return(NULL);
180     }
181 
182     p = (MEMHDR *) malloc(RESERVE_SIZE+size);
183 
184     if (!p) {
185 	xmlGenericError(xmlGenericErrorContext,
186 		"xmlMallocLoc : Out of free space\n");
187 	xmlMemoryDump();
188 	return(NULL);
189     }
190     p->mh_tag = MEMTAG;
191     p->mh_size = size;
192     p->mh_type = MALLOC_TYPE;
193     p->mh_file = file;
194     p->mh_line = line;
195     xmlMutexLock(xmlMemMutex);
196     p->mh_number = ++block;
197     debugMemSize += size;
198     debugMemBlocks++;
199     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
200 #ifdef MEM_LIST
201     debugmem_list_add(p);
202 #endif
203     xmlMutexUnlock(xmlMemMutex);
204 
205 #ifdef DEBUG_MEMORY
206     xmlGenericError(xmlGenericErrorContext,
207 	    "Malloc(%d) Ok\n",size);
208 #endif
209 
210     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
211 
212     ret = HDR_2_CLIENT(p);
213 
214     if (xmlMemTraceBlockAt == ret) {
215 	xmlGenericError(xmlGenericErrorContext,
216 			"%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
217 			(long unsigned)size);
218 	xmlMallocBreakpoint();
219     }
220 
221     TEST_POINT
222 
223     return(ret);
224 }
225 
226 /**
227  * xmlMallocAtomicLoc:
228  * @size:  an unsigned int specifying the size in byte to allocate.
229  * @file:  the file name or NULL
230  * @line:  the line number
231  *
232  * a malloc() equivalent, with logging of the allocation info.
233  *
234  * Returns a pointer to the allocated area or NULL in case of lack of memory.
235  */
236 
237 void *
238 xmlMallocAtomicLoc(size_t size, const char * file, int line)
239 {
240     MEMHDR *p;
241     void *ret;
242 
243     if (!xmlMemInitialized) xmlInitMemory();
244 #ifdef DEBUG_MEMORY
245     xmlGenericError(xmlGenericErrorContext,
246 	    "Malloc(%d)\n",size);
247 #endif
248 
249     TEST_POINT
250 
251     if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
252 	xmlGenericError(xmlGenericErrorContext,
253 		"xmlMallocAtomicLoc : Unsigned overflow\n");
254 	xmlMemoryDump();
255 	return(NULL);
256     }
257 
258     p = (MEMHDR *) malloc(RESERVE_SIZE+size);
259 
260     if (!p) {
261 	xmlGenericError(xmlGenericErrorContext,
262 		"xmlMallocAtomicLoc : Out of free space\n");
263 	xmlMemoryDump();
264 	return(NULL);
265     }
266     p->mh_tag = MEMTAG;
267     p->mh_size = size;
268     p->mh_type = MALLOC_ATOMIC_TYPE;
269     p->mh_file = file;
270     p->mh_line = line;
271     xmlMutexLock(xmlMemMutex);
272     p->mh_number = ++block;
273     debugMemSize += size;
274     debugMemBlocks++;
275     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
276 #ifdef MEM_LIST
277     debugmem_list_add(p);
278 #endif
279     xmlMutexUnlock(xmlMemMutex);
280 
281 #ifdef DEBUG_MEMORY
282     xmlGenericError(xmlGenericErrorContext,
283 	    "Malloc(%d) Ok\n",size);
284 #endif
285 
286     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
287 
288     ret = HDR_2_CLIENT(p);
289 
290     if (xmlMemTraceBlockAt == ret) {
291 	xmlGenericError(xmlGenericErrorContext,
292 			"%p : Malloc(%lu) Ok\n", xmlMemTraceBlockAt,
293 			(long unsigned)size);
294 	xmlMallocBreakpoint();
295     }
296 
297     TEST_POINT
298 
299     return(ret);
300 }
301 /**
302  * xmlMemMalloc:
303  * @size:  an int specifying the size in byte to allocate.
304  *
305  * a malloc() equivalent, with logging of the allocation info.
306  *
307  * Returns a pointer to the allocated area or NULL in case of lack of memory.
308  */
309 
310 void *
311 xmlMemMalloc(size_t size)
312 {
313     return(xmlMallocLoc(size, "none", 0));
314 }
315 
316 /**
317  * xmlReallocLoc:
318  * @ptr:  the initial memory block pointer
319  * @size:  an int specifying the size in byte to allocate.
320  * @file:  the file name or NULL
321  * @line:  the line number
322  *
323  * a realloc() equivalent, with logging of the allocation info.
324  *
325  * Returns a pointer to the allocated area or NULL in case of lack of memory.
326  */
327 
328 void *
329 xmlReallocLoc(void *ptr,size_t size, const char * file, int line)
330 {
331     MEMHDR *p, *tmp;
332     unsigned long number;
333 #ifdef DEBUG_MEMORY
334     size_t oldsize;
335 #endif
336 
337     if (ptr == NULL)
338         return(xmlMallocLoc(size, file, line));
339 
340     if (!xmlMemInitialized) xmlInitMemory();
341     TEST_POINT
342 
343     p = CLIENT_2_HDR(ptr);
344     number = p->mh_number;
345     if (xmlMemStopAtBlock == number) xmlMallocBreakpoint();
346     if (p->mh_tag != MEMTAG) {
347        Mem_Tag_Err(p);
348 	 goto error;
349     }
350     p->mh_tag = ~MEMTAG;
351     xmlMutexLock(xmlMemMutex);
352     debugMemSize -= p->mh_size;
353     debugMemBlocks--;
354 #ifdef DEBUG_MEMORY
355     oldsize = p->mh_size;
356 #endif
357 #ifdef MEM_LIST
358     debugmem_list_delete(p);
359 #endif
360     xmlMutexUnlock(xmlMemMutex);
361 
362     if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
363 	xmlGenericError(xmlGenericErrorContext,
364 		"xmlReallocLoc : Unsigned overflow\n");
365 	xmlMemoryDump();
366 	return(NULL);
367     }
368 
369     tmp = (MEMHDR *) realloc(p,RESERVE_SIZE+size);
370     if (!tmp) {
371 	 free(p);
372 	 goto error;
373     }
374     p = tmp;
375     if (xmlMemTraceBlockAt == ptr) {
376 	xmlGenericError(xmlGenericErrorContext,
377 			"%p : Realloced(%lu -> %lu) Ok\n",
378 			xmlMemTraceBlockAt, (long unsigned)p->mh_size,
379 			(long unsigned)size);
380 	xmlMallocBreakpoint();
381     }
382     p->mh_tag = MEMTAG;
383     p->mh_number = number;
384     p->mh_type = REALLOC_TYPE;
385     p->mh_size = size;
386     p->mh_file = file;
387     p->mh_line = line;
388     xmlMutexLock(xmlMemMutex);
389     debugMemSize += size;
390     debugMemBlocks++;
391     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
392 #ifdef MEM_LIST
393     debugmem_list_add(p);
394 #endif
395     xmlMutexUnlock(xmlMemMutex);
396 
397     TEST_POINT
398 
399 #ifdef DEBUG_MEMORY
400     xmlGenericError(xmlGenericErrorContext,
401 	    "Realloced(%d to %d) Ok\n", oldsize, size);
402 #endif
403     return(HDR_2_CLIENT(p));
404 
405 error:
406     return(NULL);
407 }
408 
409 /**
410  * xmlMemRealloc:
411  * @ptr:  the initial memory block pointer
412  * @size:  an int specifying the size in byte to allocate.
413  *
414  * a realloc() equivalent, with logging of the allocation info.
415  *
416  * Returns a pointer to the allocated area or NULL in case of lack of memory.
417  */
418 
419 void *
420 xmlMemRealloc(void *ptr,size_t size) {
421     return(xmlReallocLoc(ptr, size, "none", 0));
422 }
423 
424 /**
425  * xmlMemFree:
426  * @ptr:  the memory block pointer
427  *
428  * a free() equivalent, with error checking.
429  */
430 void
431 xmlMemFree(void *ptr)
432 {
433     MEMHDR *p;
434     char *target;
435 #ifdef DEBUG_MEMORY
436     size_t size;
437 #endif
438 
439     if (ptr == NULL)
440 	return;
441 
442     if (ptr == (void *) -1) {
443 	xmlGenericError(xmlGenericErrorContext,
444 	    "trying to free pointer from freed area\n");
445         goto error;
446     }
447 
448     if (xmlMemTraceBlockAt == ptr) {
449 	xmlGenericError(xmlGenericErrorContext,
450 			"%p : Freed()\n", xmlMemTraceBlockAt);
451 	xmlMallocBreakpoint();
452     }
453 
454     TEST_POINT
455 
456     target = (char *) ptr;
457 
458     p = CLIENT_2_HDR(ptr);
459     if (p->mh_tag != MEMTAG) {
460         Mem_Tag_Err(p);
461         goto error;
462     }
463     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
464     p->mh_tag = ~MEMTAG;
465     memset(target, -1, p->mh_size);
466     xmlMutexLock(xmlMemMutex);
467     debugMemSize -= p->mh_size;
468     debugMemBlocks--;
469 #ifdef DEBUG_MEMORY
470     size = p->mh_size;
471 #endif
472 #ifdef MEM_LIST
473     debugmem_list_delete(p);
474 #endif
475     xmlMutexUnlock(xmlMemMutex);
476 
477     free(p);
478 
479     TEST_POINT
480 
481 #ifdef DEBUG_MEMORY
482     xmlGenericError(xmlGenericErrorContext,
483 	    "Freed(%d) Ok\n", size);
484 #endif
485 
486     return;
487 
488 error:
489     xmlGenericError(xmlGenericErrorContext,
490 	    "xmlMemFree(%p) error\n", ptr);
491     xmlMallocBreakpoint();
492     return;
493 }
494 
495 /**
496  * xmlMemStrdupLoc:
497  * @str:  the initial string pointer
498  * @file:  the file name or NULL
499  * @line:  the line number
500  *
501  * a strdup() equivalent, with logging of the allocation info.
502  *
503  * Returns a pointer to the new string or NULL if allocation error occurred.
504  */
505 
506 char *
507 xmlMemStrdupLoc(const char *str, const char *file, int line)
508 {
509     char *s;
510     size_t size = strlen(str) + 1;
511     MEMHDR *p;
512 
513     if (!xmlMemInitialized) xmlInitMemory();
514     TEST_POINT
515 
516     if (size > (MAX_SIZE_T - RESERVE_SIZE)) {
517 	xmlGenericError(xmlGenericErrorContext,
518 		"xmlMemStrdupLoc : Unsigned overflow\n");
519 	xmlMemoryDump();
520 	return(NULL);
521     }
522 
523     p = (MEMHDR *) malloc(RESERVE_SIZE+size);
524     if (!p) {
525       goto error;
526     }
527     p->mh_tag = MEMTAG;
528     p->mh_size = size;
529     p->mh_type = STRDUP_TYPE;
530     p->mh_file = file;
531     p->mh_line = line;
532     xmlMutexLock(xmlMemMutex);
533     p->mh_number = ++block;
534     debugMemSize += size;
535     debugMemBlocks++;
536     if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize;
537 #ifdef MEM_LIST
538     debugmem_list_add(p);
539 #endif
540     xmlMutexUnlock(xmlMemMutex);
541 
542     s = (char *) HDR_2_CLIENT(p);
543 
544     if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint();
545 
546     strcpy(s,str);
547 
548     TEST_POINT
549 
550     if (xmlMemTraceBlockAt == s) {
551 	xmlGenericError(xmlGenericErrorContext,
552 			"%p : Strdup() Ok\n", xmlMemTraceBlockAt);
553 	xmlMallocBreakpoint();
554     }
555 
556     return(s);
557 
558 error:
559     return(NULL);
560 }
561 
562 /**
563  * xmlMemoryStrdup:
564  * @str:  the initial string pointer
565  *
566  * a strdup() equivalent, with logging of the allocation info.
567  *
568  * Returns a pointer to the new string or NULL if allocation error occurred.
569  */
570 
571 char *
572 xmlMemoryStrdup(const char *str) {
573     return(xmlMemStrdupLoc(str, "none", 0));
574 }
575 
576 /**
577  * xmlMemUsed:
578  *
579  * Provides the amount of memory currently allocated
580  *
581  * Returns an int representing the amount of memory allocated.
582  */
583 
584 int
585 xmlMemUsed(void) {
586     int res;
587 
588     xmlMutexLock(xmlMemMutex);
589     res = debugMemSize;
590     xmlMutexUnlock(xmlMemMutex);
591     return(res);
592 }
593 
594 /**
595  * xmlMemBlocks:
596  *
597  * Provides the number of memory areas currently allocated
598  *
599  * Returns an int representing the number of blocks
600  */
601 
602 int
603 xmlMemBlocks(void) {
604     int res;
605 
606     xmlMutexLock(xmlMemMutex);
607     res = debugMemBlocks;
608     xmlMutexUnlock(xmlMemMutex);
609     return(res);
610 }
611 
612 #ifdef MEM_LIST
613 /**
614  * xmlMemContentShow:
615  * @fp:  a FILE descriptor used as the output file
616  * @p:  a memory block header
617  *
618  * tries to show some content from the memory block
619  */
620 
621 static void
622 xmlMemContentShow(FILE *fp, MEMHDR *p)
623 {
624     int i,j,k,len;
625     const char *buf;
626 
627     if (p == NULL) {
628 	fprintf(fp, " NULL");
629 	return;
630     }
631     len = p->mh_size;
632     buf = (const char *) HDR_2_CLIENT(p);
633 
634     for (i = 0;i < len;i++) {
635         if (buf[i] == 0) break;
636 	if (!isprint((unsigned char) buf[i])) break;
637     }
638     if ((i < 4) && ((buf[i] != 0) || (i == 0))) {
639         if (len >= 4) {
640 	    MEMHDR *q;
641 	    void *cur;
642 
643             for (j = 0;(j < len -3) && (j < 40);j += 4) {
644 		cur = *((void **) &buf[j]);
645 		q = CLIENT_2_HDR(cur);
646 		p = memlist;
647 		k = 0;
648 		while (p != NULL) {
649 		    if (p == q) break;
650 		    p = p->mh_next;
651 		    if (k++ > 100) break;
652 		}
653 		if ((p != NULL) && (p == q)) {
654 		    fprintf(fp, " pointer to #%lu at index %d",
655 		            p->mh_number, j);
656 		    return;
657 		}
658 	    }
659 	}
660     } else if ((i == 0) && (buf[i] == 0)) {
661         fprintf(fp," null");
662     } else {
663         if (buf[i] == 0) fprintf(fp," \"%.25s\"", buf);
664 	else {
665             fprintf(fp," [");
666 	    for (j = 0;j < i;j++)
667                 fprintf(fp,"%c", buf[j]);
668             fprintf(fp,"]");
669 	}
670     }
671 }
672 #endif
673 
674 /**
675  * xmlMemDisplayLast:
676  * @fp:  a FILE descriptor used as the output file, if NULL, the result is
677  *       written to the file .memorylist
678  * @nbBytes: the amount of memory to dump
679  *
680  * the last nbBytes of memory allocated and not freed, useful for dumping
681  * the memory left allocated between two places at runtime.
682  */
683 
684 void
685 xmlMemDisplayLast(FILE *fp, long nbBytes)
686 {
687 #ifdef MEM_LIST
688     MEMHDR *p;
689     unsigned idx;
690     int     nb = 0;
691 #endif
692     FILE *old_fp = fp;
693 
694     if (nbBytes <= 0)
695         return;
696 
697     if (fp == NULL) {
698 	fp = fopen(".memorylist", "w");
699 	if (fp == NULL)
700 	    return;
701     }
702 
703 #ifdef MEM_LIST
704     fprintf(fp,"   Last %li MEMORY ALLOCATED : %lu, MAX was %lu\n",
705             nbBytes, debugMemSize, debugMaxMemSize);
706     fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
707     idx = 0;
708     xmlMutexLock(xmlMemMutex);
709     p = memlist;
710     while ((p) && (nbBytes > 0)) {
711 	  fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
712 		  (unsigned long)p->mh_size);
713         switch (p->mh_type) {
714            case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
715            case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
716            case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
717            case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
718            case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
719            default:
720 	        fprintf(fp,"Unknown memory block, may be corrupted");
721 		xmlMutexUnlock(xmlMemMutex);
722 		if (old_fp == NULL)
723 		    fclose(fp);
724 		return;
725         }
726 	if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
727         if (p->mh_tag != MEMTAG)
728 	      fprintf(fp,"  INVALID");
729         nb++;
730 	if (nb < 100)
731 	    xmlMemContentShow(fp, p);
732 	else
733 	    fprintf(fp," skip");
734 
735         fprintf(fp,"\n");
736 	nbBytes -= (unsigned long)p->mh_size;
737         p = p->mh_next;
738     }
739     xmlMutexUnlock(xmlMemMutex);
740 #else
741     fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
742 #endif
743     if (old_fp == NULL)
744 	fclose(fp);
745 }
746 
747 /**
748  * xmlMemDisplay:
749  * @fp:  a FILE descriptor used as the output file, if NULL, the result is
750  *       written to the file .memorylist
751  *
752  * show in-extenso the memory blocks allocated
753  */
754 
755 void
756 xmlMemDisplay(FILE *fp)
757 {
758 #ifdef MEM_LIST
759     MEMHDR *p;
760     unsigned idx;
761     int     nb = 0;
762 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
763     time_t currentTime;
764     char buf[500];
765     struct tm * tstruct;
766 #endif
767 #endif
768     FILE *old_fp = fp;
769 
770     if (fp == NULL) {
771 	fp = fopen(".memorylist", "w");
772 	if (fp == NULL)
773 	    return;
774     }
775 
776 #ifdef MEM_LIST
777 #if defined(HAVE_LOCALTIME) && defined(HAVE_STRFTIME)
778     currentTime = time(NULL);
779     tstruct = localtime(&currentTime);
780     strftime(buf, sizeof(buf) - 1, "%I:%M:%S %p", tstruct);
781     fprintf(fp,"      %s\n\n", buf);
782 #endif
783 
784 
785     fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
786             debugMemSize, debugMaxMemSize);
787     fprintf(fp,"BLOCK  NUMBER   SIZE  TYPE\n");
788     idx = 0;
789     xmlMutexLock(xmlMemMutex);
790     p = memlist;
791     while (p) {
792 	  fprintf(fp,"%-5u  %6lu %6lu ",idx++,p->mh_number,
793 		  (unsigned long)p->mh_size);
794         switch (p->mh_type) {
795            case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
796            case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
797            case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
798            case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
799            case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
800            default:
801 	        fprintf(fp,"Unknown memory block, may be corrupted");
802 		xmlMutexUnlock(xmlMemMutex);
803 		if (old_fp == NULL)
804 		    fclose(fp);
805 		return;
806         }
807 	if (p->mh_file != NULL) fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
808         if (p->mh_tag != MEMTAG)
809 	      fprintf(fp,"  INVALID");
810         nb++;
811 	if (nb < 100)
812 	    xmlMemContentShow(fp, p);
813 	else
814 	    fprintf(fp," skip");
815 
816         fprintf(fp,"\n");
817         p = p->mh_next;
818     }
819     xmlMutexUnlock(xmlMemMutex);
820 #else
821     fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n");
822 #endif
823     if (old_fp == NULL)
824 	fclose(fp);
825 }
826 
827 #ifdef MEM_LIST
828 
829 static void debugmem_list_add(MEMHDR *p)
830 {
831      p->mh_next = memlist;
832      p->mh_prev = NULL;
833      if (memlist) memlist->mh_prev = p;
834      memlist = p;
835 #ifdef MEM_LIST_DEBUG
836      if (stderr)
837      Mem_Display(stderr);
838 #endif
839 }
840 
841 static void debugmem_list_delete(MEMHDR *p)
842 {
843      if (p->mh_next)
844      p->mh_next->mh_prev = p->mh_prev;
845      if (p->mh_prev)
846      p->mh_prev->mh_next = p->mh_next;
847      else memlist = p->mh_next;
848 #ifdef MEM_LIST_DEBUG
849      if (stderr)
850      Mem_Display(stderr);
851 #endif
852 }
853 
854 #endif
855 
856 /*
857  * debugmem_tag_error:
858  *
859  * internal error function.
860  */
861 
862 static void debugmem_tag_error(void *p)
863 {
864      xmlGenericError(xmlGenericErrorContext,
865 	     "Memory tag error occurs :%p \n\t bye\n", p);
866 #ifdef MEM_LIST
867      if (stderr)
868      xmlMemDisplay(stderr);
869 #endif
870 }
871 
872 #ifdef MEM_LIST
873 static FILE *xmlMemoryDumpFile = NULL;
874 #endif
875 
876 /**
877  * xmlMemShow:
878  * @fp:  a FILE descriptor used as the output file
879  * @nr:  number of entries to dump
880  *
881  * show a show display of the memory allocated, and dump
882  * the @nr last allocated areas which were not freed
883  */
884 
885 void
886 xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED)
887 {
888 #ifdef MEM_LIST
889     MEMHDR *p;
890 #endif
891 
892     if (fp != NULL)
893 	fprintf(fp,"      MEMORY ALLOCATED : %lu, MAX was %lu\n",
894 		debugMemSize, debugMaxMemSize);
895 #ifdef MEM_LIST
896     xmlMutexLock(xmlMemMutex);
897     if (nr > 0) {
898 	fprintf(fp,"NUMBER   SIZE  TYPE   WHERE\n");
899 	p = memlist;
900 	while ((p) && nr > 0) {
901 	      fprintf(fp,"%6lu %6lu ",p->mh_number,(unsigned long)p->mh_size);
902 	    switch (p->mh_type) {
903 	       case STRDUP_TYPE:fprintf(fp,"strdup()  in ");break;
904 	       case MALLOC_TYPE:fprintf(fp,"malloc()  in ");break;
905 	       case MALLOC_ATOMIC_TYPE:fprintf(fp,"atomicmalloc()  in ");break;
906 	      case REALLOC_TYPE:fprintf(fp,"realloc() in ");break;
907 	      case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break;
908 		default:fprintf(fp,"   ???    in ");break;
909 	    }
910 	    if (p->mh_file != NULL)
911 	        fprintf(fp,"%s(%u)", p->mh_file, p->mh_line);
912 	    if (p->mh_tag != MEMTAG)
913 		fprintf(fp,"  INVALID");
914 	    xmlMemContentShow(fp, p);
915 	    fprintf(fp,"\n");
916 	    nr--;
917 	    p = p->mh_next;
918 	}
919     }
920     xmlMutexUnlock(xmlMemMutex);
921 #endif /* MEM_LIST */
922 }
923 
924 /**
925  * xmlMemoryDump:
926  *
927  * Dump in-extenso the memory blocks allocated to the file .memorylist
928  */
929 
930 void
931 xmlMemoryDump(void)
932 {
933 #ifdef MEM_LIST
934     FILE *dump;
935 
936     if (debugMaxMemSize == 0)
937 	return;
938     dump = fopen(".memdump", "w");
939     if (dump == NULL)
940 	xmlMemoryDumpFile = stderr;
941     else xmlMemoryDumpFile = dump;
942 
943     xmlMemDisplay(xmlMemoryDumpFile);
944 
945     if (dump != NULL) fclose(dump);
946 #endif /* MEM_LIST */
947 }
948 
949 
950 /****************************************************************
951  *								*
952  *		Initialization Routines				*
953  *								*
954  ****************************************************************/
955 
956 /**
957  * xmlInitMemory:
958  *
959  * Initialize the memory layer.
960  *
961  * Returns 0 on success
962  */
963 int
964 xmlInitMemory(void)
965 {
966 #ifdef HAVE_STDLIB_H
967      char *breakpoint;
968 #endif
969 #ifdef DEBUG_MEMORY
970      xmlGenericError(xmlGenericErrorContext,
971 	     "xmlInitMemory()\n");
972 #endif
973     /*
974      This is really not good code (see Bug 130419).  Suggestions for
975      improvement will be welcome!
976     */
977      if (xmlMemInitialized) return(-1);
978      xmlMemInitialized = 1;
979      xmlMemMutex = xmlNewMutex();
980 
981 #ifdef HAVE_STDLIB_H
982      breakpoint = getenv("XML_MEM_BREAKPOINT");
983      if (breakpoint != NULL) {
984          sscanf(breakpoint, "%ud", &xmlMemStopAtBlock);
985      }
986 #endif
987 #ifdef HAVE_STDLIB_H
988      breakpoint = getenv("XML_MEM_TRACE");
989      if (breakpoint != NULL) {
990          sscanf(breakpoint, "%p", &xmlMemTraceBlockAt);
991      }
992 #endif
993 
994 #ifdef DEBUG_MEMORY
995      xmlGenericError(xmlGenericErrorContext,
996 	     "xmlInitMemory() Ok\n");
997 #endif
998      return(0);
999 }
1000 
1001 /**
1002  * xmlCleanupMemory:
1003  *
1004  * Free up all the memory allocated by the library for its own
1005  * use. This should not be called by user level code.
1006  */
1007 void
1008 xmlCleanupMemory(void) {
1009 #ifdef DEBUG_MEMORY
1010      xmlGenericError(xmlGenericErrorContext,
1011 	     "xmlCleanupMemory()\n");
1012 #endif
1013     if (xmlMemInitialized == 0)
1014         return;
1015 
1016     xmlFreeMutex(xmlMemMutex);
1017     xmlMemMutex = NULL;
1018     xmlMemInitialized = 0;
1019 #ifdef DEBUG_MEMORY
1020      xmlGenericError(xmlGenericErrorContext,
1021 	     "xmlCleanupMemory() Ok\n");
1022 #endif
1023 }
1024 
1025 /**
1026  * xmlMemSetup:
1027  * @freeFunc: the free() function to use
1028  * @mallocFunc: the malloc() function to use
1029  * @reallocFunc: the realloc() function to use
1030  * @strdupFunc: the strdup() function to use
1031  *
1032  * Override the default memory access functions with a new set
1033  * This has to be called before any other libxml routines !
1034  *
1035  * Should this be blocked if there was already some allocations
1036  * done ?
1037  *
1038  * Returns 0 on success
1039  */
1040 int
1041 xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1042             xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc) {
1043 #ifdef DEBUG_MEMORY
1044      xmlGenericError(xmlGenericErrorContext,
1045 	     "xmlMemSetup()\n");
1046 #endif
1047     if (freeFunc == NULL)
1048 	return(-1);
1049     if (mallocFunc == NULL)
1050 	return(-1);
1051     if (reallocFunc == NULL)
1052 	return(-1);
1053     if (strdupFunc == NULL)
1054 	return(-1);
1055     xmlFree = freeFunc;
1056     xmlMalloc = mallocFunc;
1057     xmlMallocAtomic = mallocFunc;
1058     xmlRealloc = reallocFunc;
1059     xmlMemStrdup = strdupFunc;
1060 #ifdef DEBUG_MEMORY
1061      xmlGenericError(xmlGenericErrorContext,
1062 	     "xmlMemSetup() Ok\n");
1063 #endif
1064     return(0);
1065 }
1066 
1067 /**
1068  * xmlMemGet:
1069  * @freeFunc: place to save the free() function in use
1070  * @mallocFunc: place to save the malloc() function in use
1071  * @reallocFunc: place to save the realloc() function in use
1072  * @strdupFunc: place to save the strdup() function in use
1073  *
1074  * Provides the memory access functions set currently in use
1075  *
1076  * Returns 0 on success
1077  */
1078 int
1079 xmlMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1080 	  xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) {
1081     if (freeFunc != NULL) *freeFunc = xmlFree;
1082     if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1083     if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1084     if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1085     return(0);
1086 }
1087 
1088 /**
1089  * xmlGcMemSetup:
1090  * @freeFunc: the free() function to use
1091  * @mallocFunc: the malloc() function to use
1092  * @mallocAtomicFunc: the malloc() function to use for atomic allocations
1093  * @reallocFunc: the realloc() function to use
1094  * @strdupFunc: the strdup() function to use
1095  *
1096  * Override the default memory access functions with a new set
1097  * This has to be called before any other libxml routines !
1098  * The mallocAtomicFunc is specialized for atomic block
1099  * allocations (i.e. of areas  useful for garbage collected memory allocators
1100  *
1101  * Should this be blocked if there was already some allocations
1102  * done ?
1103  *
1104  * Returns 0 on success
1105  */
1106 int
1107 xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
1108               xmlMallocFunc mallocAtomicFunc, xmlReallocFunc reallocFunc,
1109 	      xmlStrdupFunc strdupFunc) {
1110 #ifdef DEBUG_MEMORY
1111      xmlGenericError(xmlGenericErrorContext,
1112 	     "xmlGcMemSetup()\n");
1113 #endif
1114     if (freeFunc == NULL)
1115 	return(-1);
1116     if (mallocFunc == NULL)
1117 	return(-1);
1118     if (mallocAtomicFunc == NULL)
1119 	return(-1);
1120     if (reallocFunc == NULL)
1121 	return(-1);
1122     if (strdupFunc == NULL)
1123 	return(-1);
1124     xmlFree = freeFunc;
1125     xmlMalloc = mallocFunc;
1126     xmlMallocAtomic = mallocAtomicFunc;
1127     xmlRealloc = reallocFunc;
1128     xmlMemStrdup = strdupFunc;
1129 #ifdef DEBUG_MEMORY
1130      xmlGenericError(xmlGenericErrorContext,
1131 	     "xmlGcMemSetup() Ok\n");
1132 #endif
1133     return(0);
1134 }
1135 
1136 /**
1137  * xmlGcMemGet:
1138  * @freeFunc: place to save the free() function in use
1139  * @mallocFunc: place to save the malloc() function in use
1140  * @mallocAtomicFunc: place to save the atomic malloc() function in use
1141  * @reallocFunc: place to save the realloc() function in use
1142  * @strdupFunc: place to save the strdup() function in use
1143  *
1144  * Provides the memory access functions set currently in use
1145  * The mallocAtomicFunc is specialized for atomic block
1146  * allocations (i.e. of areas  useful for garbage collected memory allocators
1147  *
1148  * Returns 0 on success
1149  */
1150 int
1151 xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc,
1152             xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc,
1153 	    xmlStrdupFunc *strdupFunc) {
1154     if (freeFunc != NULL) *freeFunc = xmlFree;
1155     if (mallocFunc != NULL) *mallocFunc = xmlMalloc;
1156     if (mallocAtomicFunc != NULL) *mallocAtomicFunc = xmlMallocAtomic;
1157     if (reallocFunc != NULL) *reallocFunc = xmlRealloc;
1158     if (strdupFunc != NULL) *strdupFunc = xmlMemStrdup;
1159     return(0);
1160 }
1161 
1162 #define bottom_xmlmemory
1163 #include "elfgcchack.h"
1164