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