2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
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.
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).
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.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
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)"
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
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.]
58 /* ====================================================================
59 * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
87 * 6. Redistributions of any form whatsoever must retain the following
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
115 #include "cryptlib.h"
116 #include <openssl/crypto.h>
117 #include <openssl/buffer.h>
118 #include <openssl/bio.h>
119 #include <openssl/lhash.h>
121 static int mh_mode=CRYPTO_MEM_CHECK_OFF;
122 /* The state changes to CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE
123 * when the application asks for it (usually after library initialisation
124 * for which no book-keeping is desired).
126 * State CRYPTO_MEM_CHECK_ON exists only temporarily when the library
127 * thinks that certain allocations should not be checked (e.g. the data
128 * structures used for memory checking). It is not suitable as an initial
129 * state: the library will unexpectedly enable memory checking when it
130 * executes one of those sections that want to disable checking
133 * State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes no sense whatsoever.
136 static unsigned long order = 0; /* number of memory requests */
138 DECLARE_LHASH_OF(MEM);
139 static LHASH_OF(MEM) *mh=NULL; /* hash-table of memory requests
140 * (address as key); access requires
144 typedef struct app_mem_info_st
146 * For application-defined information (static C-string `info')
147 * to be displayed in memory leak list.
148 * Each thread has its own stack. For applications, there is
149 * CRYPTO_push_info("...") to push an entry,
150 * CRYPTO_pop_info() to pop an entry,
151 * CRYPTO_remove_all_info() to pop all entries.
154 CRYPTO_THREADID threadid;
158 struct app_mem_info_st *next; /* tail of thread's stack */
162 static void app_info_free(APP_INFO *);
164 DECLARE_LHASH_OF(APP_INFO);
165 static LHASH_OF(APP_INFO) *amih=NULL; /* hash-table with those
166 * app_mem_info_st's that are at
167 * the top of their thread's
168 * stack (with `thread' as key);
169 * access requires MALLOC2
172 typedef struct mem_st
173 /* memory-block description */
179 CRYPTO_THREADID threadid;
185 static long options = /* extra information to be recorded */
186 #if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
187 V_CRYPTO_MDEBUG_TIME |
189 #if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
190 V_CRYPTO_MDEBUG_THREAD |
195 static unsigned int num_disable = 0; /* num_disable > 0
197 * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
200 /* Valid iff num_disable > 0. CRYPTO_LOCK_MALLOC2 is locked exactly in this
201 * case (by the thread named in disabling_thread).
203 static CRYPTO_THREADID disabling_threadid;
205 static void app_info_free(APP_INFO *inf)
207 if (--(inf->references) <= 0)
209 if (inf->next != NULL)
211 app_info_free(inf->next);
217 int CRYPTO_mem_ctrl(int mode)
221 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
224 /* for applications (not to be called while multiple threads
225 * use the library): */
226 case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
227 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
230 case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
232 num_disable = 0; /* should be true *before* MemCheck_stop is
233 used, or there'll be a lot of confusion */
236 /* switch off temporarily (for library-internal use): */
237 case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
238 if (mh_mode & CRYPTO_MEM_CHECK_ON)
241 CRYPTO_THREADID_current(&cur);
242 /* see if we don't have the MALLOC2 lock already */
243 if (!num_disable || CRYPTO_THREADID_cmp(&disabling_threadid, &cur))
245 /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
246 * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
247 * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
248 * it because we block entry to this function).
249 * Give them a chance, first, and then claim the locks in
250 * appropriate order (long-time lock first).
252 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
253 /* Note that after we have waited for CRYPTO_LOCK_MALLOC2
254 * and CRYPTO_LOCK_MALLOC, we'll still be in the right
255 * "case" and "if" branch because MemCheck_start and
256 * MemCheck_stop may never be used while there are multiple
257 * OpenSSL threads. */
258 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
259 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
260 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
261 CRYPTO_THREADID_cpy(&disabling_threadid, &cur);
266 case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
267 if (mh_mode & CRYPTO_MEM_CHECK_ON)
269 if (num_disable) /* always true, or something is going wrong */
272 if (num_disable == 0)
274 mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
275 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
284 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
288 int CRYPTO_is_mem_check_on(void)
292 if (mh_mode & CRYPTO_MEM_CHECK_ON)
295 CRYPTO_THREADID_current(&cur);
296 CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
298 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
299 || CRYPTO_THREADID_cmp(&disabling_threadid, &cur);
301 CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
307 void CRYPTO_dbg_set_options(long bits)
312 long CRYPTO_dbg_get_options(void)
317 static int mem_cmp(const MEM *a, const MEM *b)
320 const char *ap=(const char *)a->addr,
321 *bp=(const char *)b->addr;
322 if (ap==bp) return 0;
323 else if (ap>bp) return 1;
326 return (const char *)a->addr - (const char *)b->addr;
329 static IMPLEMENT_LHASH_COMP_FN(mem, MEM)
331 static unsigned long mem_hash(const MEM *a)
335 ret=(unsigned long)a->addr;
337 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
340 static IMPLEMENT_LHASH_HASH_FN(mem, MEM)
342 /* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
343 static int app_info_cmp(const void *a_void, const void *b_void)
345 return CRYPTO_THREADID_cmp(&((const APP_INFO *)a_void)->threadid,
346 &((const APP_INFO *)b_void)->threadid);
348 static IMPLEMENT_LHASH_COMP_FN(app_info, APP_INFO)
350 static unsigned long app_info_hash(const APP_INFO *a)
354 ret = CRYPTO_THREADID_hash(&a->threadid);
355 /* This is left in as a "who am I to question legacy?" measure */
356 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
359 static IMPLEMENT_LHASH_HASH_FN(app_info, APP_INFO)
361 static APP_INFO *pop_info(void)
364 APP_INFO *ret = NULL;
368 CRYPTO_THREADID_current(&tmp.threadid);
369 if ((ret=lh_APP_INFO_delete(amih,&tmp)) != NULL)
371 APP_INFO *next=ret->next;
376 (void)lh_APP_INFO_insert(amih,next);
378 #ifdef LEVITTE_DEBUG_MEM
379 if (CRYPTO_THREADID_cmp(&ret->threadid, &tmp.threadid))
381 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
382 CRYPTO_THREADID_hash(&ret->threadid),
383 CRYPTO_THREADID_hash(&tmp.threadid));
387 if (--(ret->references) <= 0)
399 int CRYPTO_push_info_(const char *info, const char *file, int line)
401 APP_INFO *ami, *amim;
404 if (is_MemCheck_on())
406 MemCheck_off(); /* obtain MALLOC2 lock */
408 if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
415 if ((amih=lh_APP_INFO_new()) == NULL)
423 CRYPTO_THREADID_current(&ami->threadid);
430 if ((amim=lh_APP_INFO_insert(amih,ami)) != NULL)
432 #ifdef LEVITTE_DEBUG_MEM
433 if (CRYPTO_THREADID_cmp(&ami->threadid, &amim->threadid))
435 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
436 CRYPTO_THREADID_hash(&amim->threadid),
437 CRYPTO_THREADID_hash(&ami->threadid));
444 MemCheck_on(); /* release MALLOC2 lock */
450 int CRYPTO_pop_info(void)
454 if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
456 MemCheck_off(); /* obtain MALLOC2 lock */
458 ret=(pop_info() != NULL);
460 MemCheck_on(); /* release MALLOC2 lock */
465 int CRYPTO_remove_all_info(void)
469 if (is_MemCheck_on()) /* _must_ be true */
471 MemCheck_off(); /* obtain MALLOC2 lock */
473 while(pop_info() != NULL)
476 MemCheck_on(); /* release MALLOC2 lock */
482 static unsigned long break_order_num=0;
483 void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
489 switch(before_p & 127)
497 if (is_MemCheck_on())
499 MemCheck_off(); /* make sure we hold MALLOC2 lock */
500 if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
503 MemCheck_on(); /* release MALLOC2 lock
504 * if num_disabled drops to 0 */
509 if ((mh=lh_MEM_new()) == NULL)
522 if (options & V_CRYPTO_MDEBUG_THREAD)
523 CRYPTO_THREADID_current(&m->threadid);
525 memset(&m->threadid, 0, sizeof(m->threadid));
527 if (order == break_order_num)
533 #ifdef LEVITTE_DEBUG_MEM
534 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] %c 0x%p (%d)\n",
536 (before_p & 128) ? '*' : '+',
539 if (options & V_CRYPTO_MDEBUG_TIME)
544 CRYPTO_THREADID_current(&tmp.threadid);
547 && (amim=lh_APP_INFO_retrieve(amih,&tmp)) != NULL)
553 if ((mm=lh_MEM_insert(mh, m)) != NULL)
555 /* Not good, but don't sweat it */
556 if (mm->app_info != NULL)
558 mm->app_info->references--;
563 MemCheck_on(); /* release MALLOC2 lock
564 * if num_disabled drops to 0 */
571 void CRYPTO_dbg_free(void *addr, int before_p)
581 if (is_MemCheck_on() && (mh != NULL))
583 MemCheck_off(); /* make sure we hold MALLOC2 lock */
586 mp=lh_MEM_delete(mh,&m);
589 #ifdef LEVITTE_DEBUG_MEM
590 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] - 0x%p (%d)\n",
591 mp->order, mp->addr, mp->num);
593 if (mp->app_info != NULL)
594 app_info_free(mp->app_info);
598 MemCheck_on(); /* release MALLOC2 lock
599 * if num_disabled drops to 0 */
607 void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
608 const char *file, int line, int before_p)
612 #ifdef LEVITTE_DEBUG_MEM
613 fprintf(stderr, "LEVITTE_DEBUG_MEM: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
614 addr1, addr2, num, file, line, before_p);
627 CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
631 if (is_MemCheck_on())
633 MemCheck_off(); /* make sure we hold MALLOC2 lock */
636 mp=lh_MEM_delete(mh,&m);
639 #ifdef LEVITTE_DEBUG_MEM
640 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] * 0x%p (%d) -> 0x%p (%d)\n",
647 (void)lh_MEM_insert(mh,mp);
650 MemCheck_on(); /* release MALLOC2 lock
651 * if num_disabled drops to 0 */
659 typedef struct mem_leak_st
666 static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
672 struct tm *lcl = NULL;
675 #define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
677 if(m->addr == (char *)l->bio)
680 if (options & V_CRYPTO_MDEBUG_TIME)
682 lcl = localtime(&m->time);
684 BIO_snprintf(bufp, BUF_REMAIN, "[%02d:%02d:%02d] ",
685 lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
686 bufp += strlen(bufp);
689 BIO_snprintf(bufp, BUF_REMAIN, "%5lu file=%s, line=%d, ",
690 m->order,m->file,m->line);
691 bufp += strlen(bufp);
693 if (options & V_CRYPTO_MDEBUG_THREAD)
695 BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ",
696 CRYPTO_THREADID_hash(&m->threadid));
697 bufp += strlen(bufp);
700 BIO_snprintf(bufp, BUF_REMAIN, "number=%d, address=%08lX\n",
701 m->num,(unsigned long)m->addr);
702 bufp += strlen(bufp);
704 BIO_puts(l->bio,buf);
713 CRYPTO_THREADID_cpy(&ti, &amip->threadid);
721 memset(buf,'>',ami_cnt);
722 BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
723 " thread=%lu, file=%s, line=%d, info=\"",
724 CRYPTO_THREADID_hash(&amip->threadid), amip->file,
727 info_len=strlen(amip->info);
728 if (128 - buf_len - 3 < info_len)
730 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
735 BUF_strlcpy(buf + buf_len, amip->info,
736 sizeof buf - buf_len);
737 buf_len = strlen(buf);
739 BIO_snprintf(buf + buf_len, sizeof buf - buf_len, "\"\n");
741 BIO_puts(l->bio,buf);
745 while(amip && !CRYPTO_THREADID_cmp(&amip->threadid, &ti));
747 #ifdef LEVITTE_DEBUG_MEM
750 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
756 static IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM, MEM_LEAK)
758 void CRYPTO_mem_leaks(BIO *b)
762 if (mh == NULL && amih == NULL)
765 MemCheck_off(); /* obtain MALLOC2 lock */
771 lh_MEM_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak), MEM_LEAK,
775 BIO_printf(b,"%ld bytes leaked in %d chunks\n",
777 #ifdef CRYPTO_MDEBUG_ABORT
783 /* Make sure that, if we found no leaks, memory-leak debugging itself
784 * does not introduce memory leaks (which might irritate
785 * external debugging tools).
786 * (When someone enables leak checking, but does not call
787 * this function, we declare it to be their fault.)
789 * XXX This should be in CRYPTO_mem_leaks_cb,
790 * and CRYPTO_mem_leaks should be implemented by
791 * using CRYPTO_mem_leaks_cb.
792 * (Also there should be a variant of lh_doall_arg
793 * that takes a function pointer instead of a void *;
794 * this would obviate the ugly and illegal
795 * void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
796 * Otherwise the code police will come and get us.)
800 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
802 /* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
803 * which uses CRYPTO_is_mem_check_on */
804 old_mh_mode = mh_mode;
805 mh_mode = CRYPTO_MEM_CHECK_OFF;
814 if (lh_APP_INFO_num_items(amih) == 0)
816 lh_APP_INFO_free(amih);
821 mh_mode = old_mh_mode;
822 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
824 MemCheck_on(); /* release MALLOC2 lock */
827 #ifndef OPENSSL_NO_FP_API
828 void CRYPTO_mem_leaks_fp(FILE *fp)
832 if (mh == NULL) return;
833 /* Need to turn off memory checking when allocated BIOs ... especially
834 * as we're creating them at a time when we're trying to check we've not
835 * left anything un-free()'d!! */
837 b = BIO_new(BIO_s_file());
840 BIO_set_fp(b,fp,BIO_NOCLOSE);
848 /* FIXME: We really don't allow much to the callback. For example, it has
849 no chance of reaching the info stack for the item it processes. Should
850 it really be this way? -- Richard Levitte */
851 /* NB: The prototypes have been typedef'd to CRYPTO_MEM_LEAK_CB inside crypto.h
852 * If this code is restructured, remove the callback type if it is no longer
853 * needed. -- Geoff Thorpe */
855 /* Can't pass CRYPTO_MEM_LEAK_CB directly to lh_MEM_doall_arg because it
856 * is a function pointer and conversion to void * is prohibited. Instead
860 typedef CRYPTO_MEM_LEAK_CB *PCRYPTO_MEM_LEAK_CB;
862 static void cb_leak_doall_arg(const MEM *m, PCRYPTO_MEM_LEAK_CB *cb)
864 (*cb)(m->order,m->file,m->line,m->num,m->addr);
867 static IMPLEMENT_LHASH_DOALL_ARG_FN(cb_leak, const MEM, PCRYPTO_MEM_LEAK_CB)
869 void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
871 if (mh == NULL) return;
872 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
873 lh_MEM_doall_arg(mh, LHASH_DOALL_ARG_FN(cb_leak), PCRYPTO_MEM_LEAK_CB,
875 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);