crypto/mem_dbg.c

   1 /* crypto/mem_dbg.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <time.h>
  62 #include <openssl/crypto.h>
  63 #include <openssl/buffer.h>
  64 #include <openssl/bio.h>
  65 #include <openssl/lhash.h>
  66 #include "cryptlib.h"
  67
  68 static int mh_mode=CRYPTO_MEM_CHECK_OFF;
  69 /* The state changes to CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE
  70  * when the application asks for it (usually after library initialisation
  71  * for which no book-keeping is desired).
  72  *
  73  * State CRYPTO_MEM_CHECK_ON exists only temporarily when the library
  74  * thinks that certain allocations should not be checked (e.g. the data
  75  * structures used for memory checking).  It is not suitable as an initial
  76  * state: the library will unexpectedly enable memory checking when it
  77  * executes one of those sections that want to disable checking
  78  * temporarily.
  79  *
  80  * State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes no sense whatsoever.
  81  */
  82
  83 static unsigned long order = 0; /* number of memory requests */
  84 static LHASH *mh=NULL; /* hash-table of memory requests (address as key) */
  85
  86
  87 typedef struct app_mem_info_st
  88 /* For application-defined information (static C-string `info')
  89  * to be displayed in memory leak list.
  90  * Each thread has its own stack.  For applications, there is
  91  *   CRYPTO_add_info("...")     to push an entry,
  92  *   CRYPTO_remove_info()       to pop an entry,
  93  *   CRYPTO_remove_all_info()   to pop all entries.
  94  */
  95         {
  96         unsigned long thread;
  97         const char *file;
  98         int line;
  99         const char *info;
 100         struct app_mem_info_st *next; /* tail of thread's stack */
 101         int references;
 102         } APP_INFO;
 103
 104 static LHASH *amih=NULL; /* hash-table with those app_mem_info_st's
 105                           * that are at the top of their thread's stack
 106                           * (with `thread' as key) */
 107
 108 typedef struct mem_st
 109 /* memory-block description */
 110         {
 111         char *addr;
 112         int num;
 113         const char *file;
 114         int line;
 115         unsigned long thread;
 116         unsigned long order;
 117         time_t time;
 118         APP_INFO *app_info;
 119         } MEM;
 120
 121 static long options =             /* extra information to be recorded */
 122 #if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
 123         V_CRYPTO_MDEBUG_TIME |
 124 #endif
 125 #if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
 126         V_CRYPTO_MDEBUG_THREAD |
 127 #endif
 128         0;
 129
 130
 131 static unsigned long disabling_thread = 0;
 132
 133 int CRYPTO_mem_ctrl(int mode)
 134         {
 135         int ret=mh_mode;
 136
 137         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 138         switch (mode)
 139                 {
 140         /* for applications: */
 141         case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
 142                 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
 143                 disabling_thread = 0;
 144                 break;
 145         case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
 146                 mh_mode = 0;
 147                 disabling_thread = 0;
 148                 break;
 149
 150         /* switch off temporarily (for library-internal use): */
 151         case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
 152                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
 153                         {
 154                         mh_mode&= ~CRYPTO_MEM_CHECK_ENABLE;
 155                         if (disabling_thread != CRYPTO_thread_id()) /* otherwise we already have the MALLOC2 lock */
 156                                 {
 157                                 /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
 158                                  * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
 159                                  * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
 160                                  * it because we block entry to this function).
 161                                  * Give them a chance, first, and then claim the locks in
 162                                  * appropriate order (long-time lock first).
 163                                  */
 164                                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 165                                 /* Note that after we have waited for CRYPTO_LOCK_MALLOC2
 166                                  * and CRYPTO_LOCK_MALLOC, we'll still be in the right
 167                                  * "case" and "if" branch because MemCheck_start and
 168                                  * MemCheck_stop may never be used while there are multiple
 169                                  * OpenSSL threads. */
 170                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 171                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 172                                 disabling_thread=CRYPTO_thread_id();
 173                                 }
 174                         }
 175                 break;
 176         case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
 177                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
 178                         {
 179                         mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
 180                         if (disabling_thread != 0)
 181                                 {
 182                                 disabling_thread=0;
 183                                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 184                                 }
 185                         }
 186                 break;
 187
 188         default:
 189                 break;
 190                 }
 191         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 192         return(ret);
 193         }
 194
 195 int CRYPTO_is_mem_check_on(void)
 196         {
 197         int ret = 0;
 198
 199         if (mh_mode & CRYPTO_MEM_CHECK_ON)
 200                 {
 201                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 202
 203                 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
 204                         && disabling_thread != CRYPTO_thread_id();
 205
 206                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 207                 }
 208         return(ret);
 209         }
 210
 211
 212 void CRYPTO_dbg_set_options(long bits)
 213         {
 214         options = bits;
 215         }
 216
 217 long CRYPTO_dbg_get_options()
 218         {
 219         return options;
 220         }
 221
 222 static int mem_cmp(MEM *a, MEM *b)
 223         {
 224         return(a->addr - b->addr);
 225         }
 226
 227 static unsigned long mem_hash(MEM *a)
 228         {
 229         unsigned long ret;
 230
 231         ret=(unsigned long)a->addr;
 232
 233         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
 234         return(ret);
 235         }
 236
 237 static int app_info_cmp(APP_INFO *a, APP_INFO *b)
 238         {
 239         return(a->thread != b->thread);
 240         }
 241
 242 static unsigned long app_info_hash(APP_INFO *a)
 243         {
 244         unsigned long ret;
 245
 246         ret=(unsigned long)a->thread;
 247
 248         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
 249         return(ret);
 250         }
 251
 252 static APP_INFO *remove_info()
 253         {
 254         APP_INFO tmp;
 255         APP_INFO *ret = NULL;
 256
 257         if (amih != NULL)
 258                 {
 259                 tmp.thread=CRYPTO_thread_id();
 260                 if ((ret=(APP_INFO *)lh_delete(amih,(char *)&tmp)) != NULL)
 261                         {
 262                         APP_INFO *next=ret->next;
 263
 264                         if (next != NULL)
 265                                 {
 266                                 next->references++;
 267                                 lh_insert(amih,(char *)next);
 268                                 }
 269 #ifdef LEVITTE_DEBUG
 270                         if (ret->thread != tmp.thread)
 271                                 {
 272                                 fprintf(stderr, "remove_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
 273                                         ret->thread, tmp.thread);
 274                                 abort();
 275                                 }
 276 #endif
 277                         if (--(ret->references) <= 0)
 278                                 {
 279                                 ret->next = NULL;
 280                                 if (next != NULL)
 281                                         next->references--;
 282                                 Free(ret);
 283                                 }
 284                         }
 285                 }
 286         return(ret);
 287         }
 288
 289 int CRYPTO_add_info_(const char *file, int line, const char *info)
 290         {
 291         APP_INFO *ami, *amim;
 292         int ret=0;
 293
 294         if (is_MemCheck_on())
 295                 {
 296                 MemCheck_off();
 297
 298                 if ((ami = (APP_INFO *)Malloc(sizeof(APP_INFO))) == NULL)
 299                         {
 300                         ret=0;
 301                         goto err;
 302                         }
 303                 if (amih == NULL)
 304                         {
 305                         if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
 306                                 {
 307                                 Free(ami);
 308                                 ret=0;
 309                                 goto err;
 310                                 }
 311                         }
 312
 313                 ami->thread=CRYPTO_thread_id();
 314                 ami->file=file;
 315                 ami->line=line;
 316                 ami->info=info;
 317                 ami->references=1;
 318                 ami->next=NULL;
 319
 320                 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
 321                         {
 322 #ifdef LEVITTE_DEBUG
 323                         if (ami->thread != amim->thread)
 324                                 {
 325                                 fprintf(stderr, "CRYPTO_add_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
 326                                         amim->thread, ami->thread);
 327                                 abort();
 328                                 }
 329 #endif
 330                         ami->next=amim;
 331                         }
 332  err:
 333                 MemCheck_on();
 334                 }
 335
 336         return(ret);
 337         }
 338
 339 int CRYPTO_remove_info(void)
 340         {
 341         int ret=0;
 342
 343         if (is_MemCheck_on()) /* _must_ be true, or something went severly wrong */
 344                 {
 345                 MemCheck_off();
 346                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 347
 348                 ret=(remove_info() != NULL);
 349
 350                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 351                 MemCheck_on();
 352                 }
 353         return(ret);
 354         }
 355
 356 int CRYPTO_remove_all_info(void)
 357         {
 358         int ret=0;
 359
 360         if (is_MemCheck_on()) /* _must_ be true */
 361                 {
 362                 MemCheck_off();
 363                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 364
 365                 while(remove_info() != NULL)
 366                         ret++;
 367
 368                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 369                 MemCheck_on();
 370                 }
 371         return(ret);
 372         }
 373
 374
 375 static unsigned long break_order_num=0;
 376 void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
 377         int before_p)
 378         {
 379         MEM *m,*mm;
 380         APP_INFO tmp,*amim;
 381
 382         switch(before_p & 127)
 383                 {
 384         case 0:
 385                 break;
 386         case 1:
 387                 if (addr == NULL)
 388                         break;
 389
 390                 if (is_MemCheck_on())
 391                         {
 392                         MemCheck_off();
 393                         if ((m=(MEM *)Malloc(sizeof(MEM))) == NULL)
 394                                 {
 395                                 Free(addr);
 396                                 MemCheck_on();
 397                                 return;
 398                                 }
 399                         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 400                         if (mh == NULL)
 401                                 {
 402                                 if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
 403                                         {
 404                                         Free(addr);
 405                                         Free(m);
 406                                         addr=NULL;
 407                                         goto err;
 408                                         }
 409                                 }
 410
 411                         m->addr=addr;
 412                         m->file=file;
 413                         m->line=line;
 414                         m->num=num;
 415                         if (options & V_CRYPTO_MDEBUG_THREAD)
 416                                 m->thread=CRYPTO_thread_id();
 417                         else
 418                                 m->thread=0;
 419
 420                         if (order == break_order_num)
 421                                 {
 422                                 /* BREAK HERE */
 423                                 m->order=order;
 424                                 }
 425                         m->order=order++;
 426 #ifdef LEVITTE_DEBUG
 427                         fprintf(stderr, "LEVITTE_DEBUG: [%5d] %c 0x%p (%d)\n",
 428                                 m->order,
 429                                 (before_p & 128) ? '*' : '+',
 430                                 m->addr, m->num);
 431 #endif
 432                         if (options & V_CRYPTO_MDEBUG_TIME)
 433                                 m->time=time(NULL);
 434                         else
 435                                 m->time=0;
 436
 437                         tmp.thread=CRYPTO_thread_id();
 438                         m->app_info=NULL;
 439                         if (amih != NULL
 440                                 && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
 441                                 {
 442                                 m->app_info = amim;
 443                                 amim->references++;
 444                                 }
 445
 446                         if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
 447                                 {
 448                                 /* Not good, but don't sweat it */
 449                                 if (mm->app_info != NULL)
 450                                         {
 451                                         mm->app_info->references--;
 452                                         }
 453                                 Free(mm);
 454                                 }
 455                 err:
 456                         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 457                         MemCheck_on();
 458                         }
 459                 break;
 460                 }
 461         return;
 462         }
 463
 464 void CRYPTO_dbg_free(void *addr, int before_p)
 465         {
 466         MEM m,*mp;
 467
 468         switch(before_p)
 469                 {
 470         case 0:
 471                 if (addr == NULL)
 472                         break;
 473
 474                 if (is_MemCheck_on() && (mh != NULL))
 475                         {
 476                         MemCheck_off();
 477
 478                         m.addr=addr;
 479                         mp=(MEM *)lh_delete(mh,(char *)&m);
 480                         if (mp != NULL)
 481                                 {
 482 #ifdef LEVITTE_DEBUG
 483                         fprintf(stderr, "LEVITTE_DEBUG: [%5d] - 0x%p (%d)\n",
 484                                 mp->order, mp->addr, mp->num);
 485 #endif
 486                                 if (mp->app_info != NULL)
 487                                         {
 488                                         mp->app_info->references--;
 489                                         }
 490                                 Free(mp);
 491                                 }
 492
 493                         MemCheck_on();
 494                         }
 495                 break;
 496         case 1:
 497                 break;
 498                 }
 499         }
 500
 501 void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
 502         const char *file, int line, int before_p)
 503         {
 504         MEM m,*mp;
 505
 506 #ifdef LEVITTE_DEBUG
 507         fprintf(stderr, "LEVITTE_DEBUG: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
 508                 addr1, addr2, num, file, line, before_p);
 509 #endif
 510
 511         switch(before_p)
 512                 {
 513         case 0:
 514                 break;
 515         case 1:
 516                 if (addr2 == NULL)
 517                         break;
 518
 519                 if (addr1 == NULL)
 520                         {
 521                         CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
 522                         break;
 523                         }
 524
 525                 if (is_MemCheck_on())
 526                         {
 527                         MemCheck_off();
 528                         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 529
 530                         m.addr=addr1;
 531                         mp=(MEM *)lh_delete(mh,(char *)&m);
 532                         if (mp != NULL)
 533                                 {
 534 #ifdef LEVITTE_DEBUG
 535                                 fprintf(stderr, "LEVITTE_DEBUG: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
 536                                         mp->order,
 537                                         mp->addr, mp->num,
 538                                         addr2, num);
 539 #endif
 540                                 mp->addr=addr2;
 541                                 mp->num=num;
 542                                 lh_insert(mh,(char *)mp);
 543                                 }
 544
 545                         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 546                         MemCheck_on();
 547                         }
 548                 break;
 549                 }
 550         return;
 551         }
 552
 553
 554 typedef struct mem_leak_st
 555         {
 556         BIO *bio;
 557         int chunks;
 558         long bytes;
 559         } MEM_LEAK;
 560
 561 static void print_leak(MEM *m, MEM_LEAK *l)
 562         {
 563         char buf[1024];
 564         char *bufp = buf;
 565         APP_INFO *amip;
 566         int ami_cnt;
 567         struct tm *lcl = NULL;
 568         unsigned long ti;
 569
 570         if(m->addr == (char *)l->bio)
 571             return;
 572
 573         if (options & V_CRYPTO_MDEBUG_TIME)
 574                 {
 575                 lcl = localtime(&m->time);
 576
 577                 sprintf(bufp, "[%02d:%02d:%02d] ",
 578                         lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
 579                 bufp += strlen(bufp);
 580                 }
 581
 582         sprintf(bufp, "%5lu file=%s, line=%d, ",
 583                 m->order,m->file,m->line);
 584         bufp += strlen(bufp);
 585
 586         if (options & V_CRYPTO_MDEBUG_THREAD)
 587                 {
 588                 sprintf(bufp, "thread=%lu, ", m->thread);
 589                 bufp += strlen(bufp);
 590                 }
 591
 592         sprintf(bufp, "number=%d, address=%08lX\n",
 593                 m->num,(unsigned long)m->addr);
 594         bufp += strlen(bufp);
 595
 596         BIO_puts(l->bio,buf);
 597
 598         l->chunks++;
 599         l->bytes+=m->num;
 600
 601         amip=m->app_info;
 602         ami_cnt=0;
 603         if (amip)
 604                 ti=amip->thread;
 605         while(amip && amip->thread == ti)
 606                 {
 607                 int buf_len;
 608                 int info_len;
 609
 610                 ami_cnt++;
 611                 memset(buf,'>',ami_cnt);
 612                 sprintf(buf + ami_cnt,
 613                         "thread=%lu, file=%s, line=%d, info=\"",
 614                         amip->thread, amip->file, amip->line);
 615                 buf_len=strlen(buf);
 616                 info_len=strlen(amip->info);
 617                 if (128 - buf_len - 3 < info_len)
 618                         {
 619                         memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
 620                         buf_len = 128 - 3;
 621                         }
 622                 else
 623                         {
 624                         strcpy(buf + buf_len, amip->info);
 625                         buf_len = strlen(buf);
 626                         }
 627                 sprintf(buf + buf_len, "\"\n");
 628
 629                 BIO_puts(l->bio,buf);
 630
 631                 amip = amip->next;
 632                 }
 633 #ifdef LEVITTE_DEBUG
 634         if (amip)
 635                 {
 636                 fprintf(stderr, "Thread switch detected i backtrace!!!!\n");
 637                 abort();
 638                 }
 639 #endif
 640         }
 641
 642 void CRYPTO_mem_leaks(BIO *b)
 643         {
 644         MEM_LEAK ml;
 645         char buf[80];
 646
 647         if (mh == NULL) return;
 648         ml.bio=b;
 649         ml.bytes=0;
 650         ml.chunks=0;
 651         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 652         lh_doall_arg(mh,(void (*)())print_leak,(char *)&ml);
 653         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 654         if (ml.chunks != 0)
 655                 {
 656                 sprintf(buf,"%ld bytes leaked in %d chunks\n",
 657                         ml.bytes,ml.chunks);
 658                 BIO_puts(b,buf);
 659                 }
 660
 661 #if 0
 662         lh_stats_bio(mh,b);
 663         lh_node_stats_bio(mh,b);
 664         lh_node_usage_stats_bio(mh,b);
 665 #endif
 666         }
 667
 668 static void (*mem_cb)()=NULL;
 669
 670 static void cb_leak(MEM *m, char *cb)
 671         {
 672         void (*mem_callback)()=(void (*)())cb;
 673         mem_callback(m->order,m->file,m->line,m->num,m->addr);
 674         }
 675
 676 void CRYPTO_mem_leaks_cb(void (*cb)())
 677         {
 678         if (mh == NULL) return;
 679         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 680         mem_cb=cb;
 681         lh_doall_arg(mh,(void (*)())cb_leak,(char *)mem_cb);
 682         mem_cb=NULL;
 683         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 684         }
 685
 686 #ifndef NO_FP_API
 687 void CRYPTO_mem_leaks_fp(FILE *fp)
 688         {
 689         BIO *b;
 690
 691         if (mh == NULL) return;
 692         if ((b=BIO_new(BIO_s_file())) == NULL)
 693                 return;
 694         BIO_set_fp(b,fp,BIO_NOCLOSE);
 695         CRYPTO_mem_leaks(b);
 696         BIO_free(b);
 697         }
 698 #endif
 699