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.c756
1 files changed, 0 insertions, 756 deletions
diff --git a/src/lib/libcrypto/mem_dbg.c b/src/lib/libcrypto/mem_dbg.c
deleted file mode 100644
index ef19d8f844..0000000000
--- a/src/lib/libcrypto/mem_dbg.c
+++ /dev/null
@@ -1,756 +0,0 @@
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
238static int mem_cmp(MEM *a, MEM *b)
239 {
240 return((char *)a->addr - (char *)b->addr);
241 }
242
243static unsigned long mem_hash(MEM *a)
244 {
245 unsigned long ret;
246
247 ret=(unsigned long)a->addr;
248
249 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
250 return(ret);
251 }
252
253static int app_info_cmp(APP_INFO *a, APP_INFO *b)
254 {
255 return(a->thread != b->thread);
256 }
257
258static unsigned long app_info_hash(APP_INFO *a)
259 {
260 unsigned long ret;
261
262 ret=(unsigned long)a->thread;
263
264 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
265 return(ret);
266 }
267
268static APP_INFO *pop_info()
269 {
270 APP_INFO tmp;
271 APP_INFO *ret = NULL;
272
273 if (amih != NULL)
274 {
275 tmp.thread=CRYPTO_thread_id();
276 if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL)
277 {
278 APP_INFO *next=ret->next;
279
280 if (next != NULL)
281 {
282 next->references++;
283 lh_insert(amih,(char *)next);
284 }
285#ifdef LEVITTE_DEBUG
286 if (ret->thread != tmp.thread)
287 {
288 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
289 ret->thread, tmp.thread);
290 abort();
291 }
292#endif
293 if (--(ret->references) <= 0)
294 {
295 ret->next = NULL;
296 if (next != NULL)
297 next->references--;
298 OPENSSL_free(ret);
299 }
300 }
301 }
302 return(ret);
303 }
304
305int CRYPTO_push_info_(const char *info, const char *file, int line)
306 {
307 APP_INFO *ami, *amim;
308 int ret=0;
309
310 if (is_MemCheck_on())
311 {
312 MemCheck_off(); /* obtain MALLOC2 lock */
313
314 if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
315 {
316 ret=0;
317 goto err;
318 }
319 if (amih == NULL)
320 {
321 if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
322 {
323 OPENSSL_free(ami);
324 ret=0;
325 goto err;
326 }
327 }
328
329 ami->thread=CRYPTO_thread_id();
330 ami->file=file;
331 ami->line=line;
332 ami->info=info;
333 ami->references=1;
334 ami->next=NULL;
335
336 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
337 {
338#ifdef LEVITTE_DEBUG
339 if (ami->thread != amim->thread)
340 {
341 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
342 amim->thread, ami->thread);
343 abort();
344 }
345#endif
346 ami->next=amim;
347 }
348 err:
349 MemCheck_on(); /* release MALLOC2 lock */
350 }
351
352 return(ret);
353 }
354
355int CRYPTO_pop_info(void)
356 {
357 int ret=0;
358
359 if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
360 {
361 MemCheck_off(); /* obtain MALLOC2 lock */
362
363 ret=(pop_info() != NULL);
364
365 MemCheck_on(); /* release MALLOC2 lock */
366 }
367 return(ret);
368 }
369
370int CRYPTO_remove_all_info(void)
371 {
372 int ret=0;
373
374 if (is_MemCheck_on()) /* _must_ be true */
375 {
376 MemCheck_off(); /* obtain MALLOC2 lock */
377
378 while(pop_info() != NULL)
379 ret++;
380
381 MemCheck_on(); /* release MALLOC2 lock */
382 }
383 return(ret);
384 }
385
386
387static unsigned long break_order_num=0;
388void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
389 int before_p)
390 {
391 MEM *m,*mm;
392 APP_INFO tmp,*amim;
393
394 switch(before_p & 127)
395 {
396 case 0:
397 break;
398 case 1:
399 if (addr == NULL)
400 break;
401
402 if (is_MemCheck_on())
403 {
404 MemCheck_off(); /* make sure we hold MALLOC2 lock */
405 if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
406 {
407 OPENSSL_free(addr);
408 MemCheck_on(); /* release MALLOC2 lock
409 * if num_disabled drops to 0 */
410 return;
411 }
412 if (mh == NULL)
413 {
414 if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
415 {
416 OPENSSL_free(addr);
417 OPENSSL_free(m);
418 addr=NULL;
419 goto err;
420 }
421 }
422
423 m->addr=addr;
424 m->file=file;
425 m->line=line;
426 m->num=num;
427 if (options & V_CRYPTO_MDEBUG_THREAD)
428 m->thread=CRYPTO_thread_id();
429 else
430 m->thread=0;
431
432 if (order == break_order_num)
433 {
434 /* BREAK HERE */
435 m->order=order;
436 }
437 m->order=order++;
438#ifdef LEVITTE_DEBUG
439 fprintf(stderr, "LEVITTE_DEBUG: [%5d] %c 0x%p (%d)\n",
440 m->order,
441 (before_p & 128) ? '*' : '+',
442 m->addr, m->num);
443#endif
444 if (options & V_CRYPTO_MDEBUG_TIME)
445 m->time=time(NULL);
446 else
447 m->time=0;
448
449 tmp.thread=CRYPTO_thread_id();
450 m->app_info=NULL;
451 if (amih != NULL
452 && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
453 {
454 m->app_info = amim;
455 amim->references++;
456 }
457
458 if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
459 {
460 /* Not good, but don't sweat it */
461 if (mm->app_info != NULL)
462 {
463 mm->app_info->references--;
464 }
465 OPENSSL_free(mm);
466 }
467 err:
468 MemCheck_on(); /* release MALLOC2 lock
469 * if num_disabled drops to 0 */
470 }
471 break;
472 }
473 return;
474 }
475
476void CRYPTO_dbg_free(void *addr, int before_p)
477 {
478 MEM m,*mp;
479
480 switch(before_p)
481 {
482 case 0:
483 if (addr == NULL)
484 break;
485
486 if (is_MemCheck_on() && (mh != NULL))
487 {
488 MemCheck_off(); /* make sure we hold MALLOC2 lock */
489
490 m.addr=addr;
491 mp=(MEM *)lh_delete(mh,(char *)&m);
492 if (mp != NULL)
493 {
494#ifdef LEVITTE_DEBUG
495 fprintf(stderr, "LEVITTE_DEBUG: [%5d] - 0x%p (%d)\n",
496 mp->order, mp->addr, mp->num);
497#endif
498 if (mp->app_info != NULL)
499 {
500 mp->app_info->references--;
501 }
502 OPENSSL_free(mp);
503 }
504
505 MemCheck_on(); /* release MALLOC2 lock
506 * if num_disabled drops to 0 */
507 }
508 break;
509 case 1:
510 break;
511 }
512 }
513
514void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
515 const char *file, int line, int before_p)
516 {
517 MEM m,*mp;
518
519#ifdef LEVITTE_DEBUG
520 fprintf(stderr, "LEVITTE_DEBUG: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
521 addr1, addr2, num, file, line, before_p);
522#endif
523
524 switch(before_p)
525 {
526 case 0:
527 break;
528 case 1:
529 if (addr2 == NULL)
530 break;
531
532 if (addr1 == NULL)
533 {
534 CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
535 break;
536 }
537
538 if (is_MemCheck_on())
539 {
540 MemCheck_off(); /* make sure we hold MALLOC2 lock */
541
542 m.addr=addr1;
543 mp=(MEM *)lh_delete(mh,(char *)&m);
544 if (mp != NULL)
545 {
546#ifdef LEVITTE_DEBUG
547 fprintf(stderr, "LEVITTE_DEBUG: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
548 mp->order,
549 mp->addr, mp->num,
550 addr2, num);
551#endif
552 mp->addr=addr2;
553 mp->num=num;
554 lh_insert(mh,(char *)mp);
555 }
556
557 MemCheck_on(); /* release MALLOC2 lock
558 * if num_disabled drops to 0 */
559 }
560 break;
561 }
562 return;
563 }
564
565
566typedef struct mem_leak_st
567 {
568 BIO *bio;
569 int chunks;
570 long bytes;
571 } MEM_LEAK;
572
573static void print_leak(MEM *m, MEM_LEAK *l)
574 {
575 char buf[1024];
576 char *bufp = buf;
577 APP_INFO *amip;
578 int ami_cnt;
579 struct tm *lcl = NULL;
580 unsigned long ti;
581
582 if(m->addr == (char *)l->bio)
583 return;
584
585 if (options & V_CRYPTO_MDEBUG_TIME)
586 {
587 lcl = localtime(&m->time);
588
589 sprintf(bufp, "[%02d:%02d:%02d] ",
590 lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
591 bufp += strlen(bufp);
592 }
593
594 sprintf(bufp, "%5lu file=%s, line=%d, ",
595 m->order,m->file,m->line);
596 bufp += strlen(bufp);
597
598 if (options & V_CRYPTO_MDEBUG_THREAD)
599 {
600 sprintf(bufp, "thread=%lu, ", m->thread);
601 bufp += strlen(bufp);
602 }
603
604 sprintf(bufp, "number=%d, address=%08lX\n",
605 m->num,(unsigned long)m->addr);
606 bufp += strlen(bufp);
607
608 BIO_puts(l->bio,buf);
609
610 l->chunks++;
611 l->bytes+=m->num;
612
613 amip=m->app_info;
614 ami_cnt=0;
615 if (!amip)
616 return;
617 ti=amip->thread;
618
619 do
620 {
621 int buf_len;
622 int info_len;
623
624 ami_cnt++;
625 memset(buf,'>',ami_cnt);
626 sprintf(buf + ami_cnt,
627 " thread=%lu, file=%s, line=%d, info=\"",
628 amip->thread, amip->file, amip->line);
629 buf_len=strlen(buf);
630 info_len=strlen(amip->info);
631 if (128 - buf_len - 3 < info_len)
632 {
633 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
634 buf_len = 128 - 3;
635 }
636 else
637 {
638 strcpy(buf + buf_len, amip->info);
639 buf_len = strlen(buf);
640 }
641 sprintf(buf + buf_len, "\"\n");
642
643 BIO_puts(l->bio,buf);
644
645 amip = amip->next;
646 }
647 while(amip && amip->thread == ti);
648
649#ifdef LEVITTE_DEBUG
650 if (amip)
651 {
652 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
653 abort();
654 }
655#endif
656 }
657
658void CRYPTO_mem_leaks(BIO *b)
659 {
660 MEM_LEAK ml;
661 char buf[80];
662
663 if (mh == NULL && amih == NULL)
664 return;
665
666 MemCheck_off(); /* obtain MALLOC2 lock */
667
668 ml.bio=b;
669 ml.bytes=0;
670 ml.chunks=0;
671 if (mh != NULL)
672 lh_doall_arg(mh,(void (*)())print_leak,(char *)&ml);
673 if (ml.chunks != 0)
674 {
675 sprintf(buf,"%ld bytes leaked in %d chunks\n",
676 ml.bytes,ml.chunks);
677 BIO_puts(b,buf);
678 }
679 else
680 {
681 /* Make sure that, if we found no leaks, memory-leak debugging itself
682 * does not introduce memory leaks (which might irritate
683 * external debugging tools).
684 * (When someone enables leak checking, but does not call
685 * this function, we declare it to be their fault.)
686 *
687 * XXX This should be in CRYPTO_mem_leaks_cb,
688 * and CRYPTO_mem_leaks should be implemented by
689 * using CRYPTO_mem_leaks_cb.
690 * (Also their should be a variant of lh_doall_arg
691 * that takes a function pointer instead of a void *;
692 * this would obviate the ugly and illegal
693 * void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
694 * Otherwise the code police will come and get us.)
695 */
696 int old_mh_mode;
697
698 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
699
700 /* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
701 * which uses CRYPTO_is_mem_check_on */
702 old_mh_mode = mh_mode;
703 mh_mode = CRYPTO_MEM_CHECK_OFF;
704
705 if (mh != NULL)
706 {
707 lh_free(mh);
708 mh = NULL;
709 }
710 if (amih != NULL)
711 {
712 if (lh_num_items(amih) == 0)
713 {
714 lh_free(amih);
715 amih = NULL;
716 }
717 }
718
719 mh_mode = old_mh_mode;
720 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
721 }
722 MemCheck_on(); /* release MALLOC2 lock */
723 }
724
725#ifndef NO_FP_API
726void CRYPTO_mem_leaks_fp(FILE *fp)
727 {
728 BIO *b;
729
730 if (mh == NULL) return;
731 if ((b=BIO_new(BIO_s_file())) == NULL)
732 return;
733 BIO_set_fp(b,fp,BIO_NOCLOSE);
734 CRYPTO_mem_leaks(b);
735 BIO_free(b);
736 }
737#endif
738
739
740
741/* FIXME: We really don't allow much to the callback. For example, it has
742 no chance of reaching the info stack for the item it processes. Should
743 it really be this way? -- Richard Levitte */
744static void cb_leak(MEM *m,
745 void (**cb)(unsigned long, const char *, int, int, void *))
746 {
747 (**cb)(m->order,m->file,m->line,m->num,m->addr);
748 }
749
750void CRYPTO_mem_leaks_cb(void (*cb)(unsigned long, const char *, int, int, void *))
751 {
752 if (mh == NULL) return;
753 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
754 lh_doall_arg(mh,(void (*)())cb_leak,(void *)&cb);
755 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
756 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-20 22:45:14 +0000