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