release/src/router/libxml2/xmlmemory.c

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