Typo which prevents mult valued RDNs being created.
[openssl.git] / 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 "cryptlib.h"
63 #include <openssl/crypto.h>
64 #include <openssl/buffer.h>
65 #include <openssl/bio.h>
66 #include <openssl/lhash.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                         * access requires MALLOC2 lock */
86
87
88 typedef struct app_mem_info_st
89 /* For application-defined information (static C-string `info')
90  * to be displayed in memory leak list.
91  * Each thread has its own stack.  For applications, there is
92  *   CRYPTO_push_info("...")     to push an entry,
93  *   CRYPTO_pop_info()           to pop an entry,
94  *   CRYPTO_remove_all_info()    to pop all entries.
95  */
96         {       
97         unsigned long thread;
98         const char *file;
99         int line;
100         const char *info;
101         struct app_mem_info_st *next; /* tail of thread's stack */
102         int references;
103         } APP_INFO;
104
105 static void app_info_free(APP_INFO *);
106
107 static LHASH *amih=NULL; /* hash-table with those app_mem_info_st's
108                           * that are at the top of their thread's stack
109                           * (with `thread' as key);
110                           * access requires MALLOC2 lock */
111
112 typedef struct mem_st
113 /* memory-block description */
114         {
115         void *addr;
116         int num;
117         const char *file;
118         int line;
119         unsigned long thread;
120         unsigned long order;
121         time_t time;
122         APP_INFO *app_info;
123         } MEM;
124
125 static long options =             /* extra information to be recorded */
126 #if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
127         V_CRYPTO_MDEBUG_TIME |
128 #endif
129 #if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
130         V_CRYPTO_MDEBUG_THREAD |
131 #endif
132         0;
133
134
135 static unsigned int num_disable = 0; /* num_disable > 0
136                                       *     iff
137                                       * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
138                                       */
139 static unsigned long disabling_thread = 0; /* Valid iff num_disable > 0.
140                                             * CRYPTO_LOCK_MALLOC2 is locked
141                                             * exactly in this case (by the
142                                             * thread named in disabling_thread).
143                                             */
144
145 static void app_info_free(APP_INFO *inf)
146         {
147         if (--(inf->references) <= 0)
148                 {
149                 if (inf->next != NULL)
150                         {
151                         app_info_free(inf->next);
152                         }
153                 OPENSSL_free(inf);
154                 }
155         }
156
157 int CRYPTO_mem_ctrl(int mode)
158         {
159         int ret=mh_mode;
160
161         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
162         switch (mode)
163                 {
164         /* for applications (not to be called while multiple threads
165          * use the library): */
166         case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
167                 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
168                 num_disable = 0;
169                 break;
170         case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
171                 mh_mode = 0;
172                 num_disable = 0; /* should be true *before* MemCheck_stop is used,
173                                     or there'll be a lot of confusion */
174                 break;
175
176         /* switch off temporarily (for library-internal use): */
177         case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
178                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
179                         {
180                         if (!num_disable || (disabling_thread != CRYPTO_thread_id())) /* otherwise we already have the MALLOC2 lock */
181                                 {
182                                 /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
183                                  * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
184                                  * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
185                                  * it because we block entry to this function).
186                                  * Give them a chance, first, and then claim the locks in
187                                  * appropriate order (long-time lock first).
188                                  */
189                                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
190                                 /* Note that after we have waited for CRYPTO_LOCK_MALLOC2
191                                  * and CRYPTO_LOCK_MALLOC, we'll still be in the right
192                                  * "case" and "if" branch because MemCheck_start and
193                                  * MemCheck_stop may never be used while there are multiple
194                                  * OpenSSL threads. */
195                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
196                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
197                                 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
198                                 disabling_thread=CRYPTO_thread_id();
199                                 }
200                         num_disable++;
201                         }
202                 break;
203         case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
204                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
205                         {
206                         if (num_disable) /* always true, or something is going wrong */
207                                 {
208                                 num_disable--;
209                                 if (num_disable == 0)
210                                         {
211                                         mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
212                                         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
213                                         }
214                                 }
215                         }
216                 break;
217
218         default:
219                 break;
220                 }
221         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
222         return(ret);
223         }
224
225 int CRYPTO_is_mem_check_on(void)
226         {
227         int ret = 0;
228
229         if (mh_mode & CRYPTO_MEM_CHECK_ON)
230                 {
231                 CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
232
233                 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
234                         || (disabling_thread != CRYPTO_thread_id());
235
236                 CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
237                 }
238         return(ret);
239         }       
240
241
242 void CRYPTO_dbg_set_options(long bits)
243         {
244         options = bits;
245         }
246
247 long CRYPTO_dbg_get_options(void)
248         {
249         return options;
250         }
251
252 /* static int mem_cmp(MEM *a, MEM *b) */
253 static int mem_cmp(const void *a_void, const void *b_void)
254         {
255 #ifdef _WIN64
256         const char *a=(const char *)((const MEM *)a_void)->addr,
257                    *b=(const char *)((const MEM *)b_void)->addr;
258         if (a==b)       return 0;
259         else if (a>b)   return 1;
260         else            return -1;
261 #else
262         return((const char *)((const MEM *)a_void)->addr
263                 - (const char *)((const MEM *)b_void)->addr);
264 #endif
265         }
266
267 /* static unsigned long mem_hash(MEM *a) */
268 static unsigned long mem_hash(const void *a_void)
269         {
270         unsigned long ret;
271
272         ret=(unsigned long)((const MEM *)a_void)->addr;
273
274         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
275         return(ret);
276         }
277
278 /* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
279 static int app_info_cmp(const void *a_void, const void *b_void)
280         {
281         return(((const APP_INFO *)a_void)->thread
282                 != ((const APP_INFO *)b_void)->thread);
283         }
284
285 /* static unsigned long app_info_hash(APP_INFO *a) */
286 static unsigned long app_info_hash(const void *a_void)
287         {
288         unsigned long ret;
289
290         ret=(unsigned long)((const APP_INFO *)a_void)->thread;
291
292         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
293         return(ret);
294         }
295
296 static APP_INFO *pop_info(void)
297         {
298         APP_INFO tmp;
299         APP_INFO *ret = NULL;
300
301         if (amih != NULL)
302                 {
303                 tmp.thread=CRYPTO_thread_id();
304                 if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL)
305                         {
306                         APP_INFO *next=ret->next;
307
308                         if (next != NULL)
309                                 {
310                                 next->references++;
311                                 lh_insert(amih,(char *)next);
312                                 }
313 #ifdef LEVITTE_DEBUG_MEM
314                         if (ret->thread != tmp.thread)
315                                 {
316                                 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
317                                         ret->thread, tmp.thread);
318                                 abort();
319                                 }
320 #endif
321                         if (--(ret->references) <= 0)
322                                 {
323                                 ret->next = NULL;
324                                 if (next != NULL)
325                                         next->references--;
326                                 OPENSSL_free(ret);
327                                 }
328                         }
329                 }
330         return(ret);
331         }
332
333 int CRYPTO_push_info_(const char *info, const char *file, int line)
334         {
335         APP_INFO *ami, *amim;
336         int ret=0;
337
338         if (is_MemCheck_on())
339                 {
340                 MemCheck_off(); /* obtain MALLOC2 lock */
341
342                 if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
343                         {
344                         ret=0;
345                         goto err;
346                         }
347                 if (amih == NULL)
348                         {
349                         if ((amih=lh_new(app_info_hash, app_info_cmp)) == NULL)
350                                 {
351                                 OPENSSL_free(ami);
352                                 ret=0;
353                                 goto err;
354                                 }
355                         }
356
357                 ami->thread=CRYPTO_thread_id();
358                 ami->file=file;
359                 ami->line=line;
360                 ami->info=info;
361                 ami->references=1;
362                 ami->next=NULL;
363
364                 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
365                         {
366 #ifdef LEVITTE_DEBUG_MEM
367                         if (ami->thread != amim->thread)
368                                 {
369                                 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
370                                         amim->thread, ami->thread);
371                                 abort();
372                                 }
373 #endif
374                         ami->next=amim;
375                         }
376  err:
377                 MemCheck_on(); /* release MALLOC2 lock */
378                 }
379
380         return(ret);
381         }
382
383 int CRYPTO_pop_info(void)
384         {
385         int ret=0;
386
387         if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
388                 {
389                 MemCheck_off(); /* obtain MALLOC2 lock */
390
391                 ret=(pop_info() != NULL);
392
393                 MemCheck_on(); /* release MALLOC2 lock */
394                 }
395         return(ret);
396         }
397
398 int CRYPTO_remove_all_info(void)
399         {
400         int ret=0;
401
402         if (is_MemCheck_on()) /* _must_ be true */
403                 {
404                 MemCheck_off(); /* obtain MALLOC2 lock */
405
406                 while(pop_info() != NULL)
407                         ret++;
408
409                 MemCheck_on(); /* release MALLOC2 lock */
410                 }
411         return(ret);
412         }
413
414
415 static unsigned long break_order_num=0;
416 void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
417         int before_p)
418         {
419         MEM *m,*mm;
420         APP_INFO tmp,*amim;
421
422         switch(before_p & 127)
423                 {
424         case 0:
425                 break;
426         case 1:
427                 if (addr == NULL)
428                         break;
429
430                 if (is_MemCheck_on())
431                         {
432                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
433                         if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
434                                 {
435                                 OPENSSL_free(addr);
436                                 MemCheck_on(); /* release MALLOC2 lock
437                                                 * if num_disabled drops to 0 */
438                                 return;
439                                 }
440                         if (mh == NULL)
441                                 {
442                                 if ((mh=lh_new(mem_hash, mem_cmp)) == NULL)
443                                         {
444                                         OPENSSL_free(addr);
445                                         OPENSSL_free(m);
446                                         addr=NULL;
447                                         goto err;
448                                         }
449                                 }
450
451                         m->addr=addr;
452                         m->file=file;
453                         m->line=line;
454                         m->num=num;
455                         if (options & V_CRYPTO_MDEBUG_THREAD)
456                                 m->thread=CRYPTO_thread_id();
457                         else
458                                 m->thread=0;
459
460                         if (order == break_order_num)
461                                 {
462                                 /* BREAK HERE */
463                                 m->order=order;
464                                 }
465                         m->order=order++;
466 #ifdef LEVITTE_DEBUG_MEM
467                         fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] %c 0x%p (%d)\n",
468                                 m->order,
469                                 (before_p & 128) ? '*' : '+',
470                                 m->addr, m->num);
471 #endif
472                         if (options & V_CRYPTO_MDEBUG_TIME)
473                                 m->time=time(NULL);
474                         else
475                                 m->time=0;
476
477                         tmp.thread=CRYPTO_thread_id();
478                         m->app_info=NULL;
479                         if (amih != NULL
480                                 && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
481                                 {
482                                 m->app_info = amim;
483                                 amim->references++;
484                                 }
485
486                         if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
487                                 {
488                                 /* Not good, but don't sweat it */
489                                 if (mm->app_info != NULL)
490                                         {
491                                         mm->app_info->references--;
492                                         }
493                                 OPENSSL_free(mm);
494                                 }
495                 err:
496                         MemCheck_on(); /* release MALLOC2 lock
497                                         * if num_disabled drops to 0 */
498                         }
499                 break;
500                 }
501         return;
502         }
503
504 void CRYPTO_dbg_free(void *addr, int before_p)
505         {
506         MEM m,*mp;
507
508         switch(before_p)
509                 {
510         case 0:
511                 if (addr == NULL)
512                         break;
513
514                 if (is_MemCheck_on() && (mh != NULL))
515                         {
516                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
517
518                         m.addr=addr;
519                         mp=(MEM *)lh_delete(mh,(char *)&m);
520                         if (mp != NULL)
521                                 {
522 #ifdef LEVITTE_DEBUG_MEM
523                         fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] - 0x%p (%d)\n",
524                                 mp->order, mp->addr, mp->num);
525 #endif
526                                 if (mp->app_info != NULL)
527                                         app_info_free(mp->app_info);
528                                 OPENSSL_free(mp);
529                                 }
530
531                         MemCheck_on(); /* release MALLOC2 lock
532                                         * if num_disabled drops to 0 */
533                         }
534                 break;
535         case 1:
536                 break;
537                 }
538         }
539
540 void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
541         const char *file, int line, int before_p)
542         {
543         MEM m,*mp;
544
545 #ifdef LEVITTE_DEBUG_MEM
546         fprintf(stderr, "LEVITTE_DEBUG_MEM: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
547                 addr1, addr2, num, file, line, before_p);
548 #endif
549
550         switch(before_p)
551                 {
552         case 0:
553                 break;
554         case 1:
555                 if (addr2 == NULL)
556                         break;
557
558                 if (addr1 == NULL)
559                         {
560                         CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
561                         break;
562                         }
563
564                 if (is_MemCheck_on())
565                         {
566                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
567
568                         m.addr=addr1;
569                         mp=(MEM *)lh_delete(mh,(char *)&m);
570                         if (mp != NULL)
571                                 {
572 #ifdef LEVITTE_DEBUG_MEM
573                                 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
574                                         mp->order,
575                                         mp->addr, mp->num,
576                                         addr2, num);
577 #endif
578                                 mp->addr=addr2;
579                                 mp->num=num;
580                                 lh_insert(mh,(char *)mp);
581                                 }
582
583                         MemCheck_on(); /* release MALLOC2 lock
584                                         * if num_disabled drops to 0 */
585                         }
586                 break;
587                 }
588         return;
589         }
590
591
592 typedef struct mem_leak_st
593         {
594         BIO *bio;
595         int chunks;
596         long bytes;
597         } MEM_LEAK;
598
599 static void print_leak(const MEM *m, MEM_LEAK *l)
600         {
601         char buf[1024];
602         char *bufp = buf;
603         APP_INFO *amip;
604         int ami_cnt;
605         struct tm *lcl = NULL;
606         unsigned long ti;
607
608 #define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
609
610         if(m->addr == (char *)l->bio)
611             return;
612
613         if (options & V_CRYPTO_MDEBUG_TIME)
614                 {
615                 lcl = localtime(&m->time);
616         
617                 BIO_snprintf(bufp, BUF_REMAIN, "[%02d:%02d:%02d] ",
618                         lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
619                 bufp += strlen(bufp);
620                 }
621
622         BIO_snprintf(bufp, BUF_REMAIN, "%5lu file=%s, line=%d, ",
623                 m->order,m->file,m->line);
624         bufp += strlen(bufp);
625
626         if (options & V_CRYPTO_MDEBUG_THREAD)
627                 {
628                 BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ", m->thread);
629                 bufp += strlen(bufp);
630                 }
631
632         BIO_snprintf(bufp, BUF_REMAIN, "number=%d, address=%08lX\n",
633                 m->num,(unsigned long)m->addr);
634         bufp += strlen(bufp);
635
636         BIO_puts(l->bio,buf);
637         
638         l->chunks++;
639         l->bytes+=m->num;
640
641         amip=m->app_info;
642         ami_cnt=0;
643         if (!amip)
644                 return;
645         ti=amip->thread;
646         
647         do
648                 {
649                 int buf_len;
650                 int info_len;
651
652                 ami_cnt++;
653                 memset(buf,'>',ami_cnt);
654                 BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
655                         " thread=%lu, file=%s, line=%d, info=\"",
656                         amip->thread, amip->file, amip->line);
657                 buf_len=strlen(buf);
658                 info_len=strlen(amip->info);
659                 if (128 - buf_len - 3 < info_len)
660                         {
661                         memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
662                         buf_len = 128 - 3;
663                         }
664                 else
665                         {
666                         BUF_strlcpy(buf + buf_len, amip->info,
667                                     sizeof buf - buf_len);
668                         buf_len = strlen(buf);
669                         }
670                 BIO_snprintf(buf + buf_len, sizeof buf - buf_len, "\"\n");
671                 
672                 BIO_puts(l->bio,buf);
673
674                 amip = amip->next;
675                 }
676         while(amip && amip->thread == ti);
677                 
678 #ifdef LEVITTE_DEBUG_MEM
679         if (amip)
680                 {
681                 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
682                 abort();
683                 }
684 #endif
685         }
686
687 static IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM *, MEM_LEAK *)
688
689 void CRYPTO_mem_leaks(BIO *b)
690         {
691         MEM_LEAK ml;
692
693         if (mh == NULL && amih == NULL)
694                 return;
695
696         MemCheck_off(); /* obtain MALLOC2 lock */
697
698         ml.bio=b;
699         ml.bytes=0;
700         ml.chunks=0;
701         if (mh != NULL)
702                 lh_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak),
703                                 (char *)&ml);
704         if (ml.chunks != 0)
705                 {
706                 BIO_printf(b,"%ld bytes leaked in %d chunks\n",
707                            ml.bytes,ml.chunks);
708                 }
709         else
710                 {
711                 /* Make sure that, if we found no leaks, memory-leak debugging itself
712                  * does not introduce memory leaks (which might irritate
713                  * external debugging tools).
714                  * (When someone enables leak checking, but does not call
715                  * this function, we declare it to be their fault.)
716                  *
717                  * XXX    This should be in CRYPTO_mem_leaks_cb,
718                  * and CRYPTO_mem_leaks should be implemented by
719                  * using CRYPTO_mem_leaks_cb.
720                  * (Also their should be a variant of lh_doall_arg
721                  * that takes a function pointer instead of a void *;
722                  * this would obviate the ugly and illegal
723                  * void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
724                  * Otherwise the code police will come and get us.)
725                  */
726                 int old_mh_mode;
727
728                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
729
730                 /* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
731                  * which uses CRYPTO_is_mem_check_on */
732                 old_mh_mode = mh_mode;
733                 mh_mode = CRYPTO_MEM_CHECK_OFF;
734
735                 if (mh != NULL)
736                         {
737                         lh_free(mh);
738                         mh = NULL;
739                         }
740                 if (amih != NULL)
741                         {
742                         if (lh_num_items(amih) == 0) 
743                                 {
744                                 lh_free(amih);
745                                 amih = NULL;
746                                 }
747                         }
748
749                 mh_mode = old_mh_mode;
750                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
751                 }
752         MemCheck_on(); /* release MALLOC2 lock */
753         }
754
755 #ifndef OPENSSL_NO_FP_API
756 void CRYPTO_mem_leaks_fp(FILE *fp)
757         {
758         BIO *b;
759
760         if (mh == NULL) return;
761         /* Need to turn off memory checking when allocated BIOs ... especially
762          * as we're creating them at a time when we're trying to check we've not
763          * left anything un-free()'d!! */
764         MemCheck_off();
765         b = BIO_new(BIO_s_file());
766         MemCheck_on();
767         if(!b) return;
768         BIO_set_fp(b,fp,BIO_NOCLOSE);
769         CRYPTO_mem_leaks(b);
770         BIO_free(b);
771         }
772 #endif
773
774
775
776 /* FIXME: We really don't allow much to the callback.  For example, it has
777    no chance of reaching the info stack for the item it processes.  Should
778    it really be this way?  -- Richard Levitte */
779 /* NB: The prototypes have been typedef'd to CRYPTO_MEM_LEAK_CB inside crypto.h
780  * If this code is restructured, remove the callback type if it is no longer
781  * needed. -- Geoff Thorpe */
782 static void cb_leak(const MEM *m, CRYPTO_MEM_LEAK_CB **cb)
783         {
784         (**cb)(m->order,m->file,m->line,m->num,m->addr);
785         }
786
787 static IMPLEMENT_LHASH_DOALL_ARG_FN(cb_leak, const MEM *, CRYPTO_MEM_LEAK_CB **)
788
789 void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
790         {
791         if (mh == NULL) return;
792         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
793         lh_doall_arg(mh, LHASH_DOALL_ARG_FN(cb_leak), &cb);
794         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
795         }