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 */
137 static LHASH *mh=NULL; /* hash-table of memory requests (address as key);
138 * access requires MALLOC2 lock */
141 typedef struct app_mem_info_st
142 /* For application-defined information (static C-string `info')
143 * to be displayed in memory leak list.
144 * Each thread has its own stack. For applications, there is
145 * CRYPTO_push_info("...") to push an entry,
146 * CRYPTO_pop_info() to pop an entry,
147 * CRYPTO_remove_all_info() to pop all entries.
150 unsigned long thread_id;
155 struct app_mem_info_st *next; /* tail of thread's stack */
159 static void app_info_free(APP_INFO *);
161 static LHASH *amih=NULL; /* hash-table with those app_mem_info_st's
162 * that are at the top of their thread's stack
163 * (with `thread' as key);
164 * access requires MALLOC2 lock */
166 typedef struct mem_st
167 /* memory-block description */
173 unsigned long thread_id;
180 static long options = /* extra information to be recorded */
181 #if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
182 V_CRYPTO_MDEBUG_TIME |
184 #if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
185 V_CRYPTO_MDEBUG_THREAD |
190 static unsigned int num_disable = 0; /* num_disable > 0
192 * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
195 /* The following two variables, disabling_thread_id and disabling_thread_idptr,
196 * are valid iff num_disable > 0. CRYPTO_LOCK_MALLOC2 is locked exactly in
197 * this case (by the thread named in disabling_thread_id / disabling_thread_idptr).
199 static unsigned long disabling_thread_id = 0;
200 static void *disabling_thread_idptr = NULL;
202 static void app_info_free(APP_INFO *inf)
204 if (--(inf->references) <= 0)
206 if (inf->next != NULL)
208 app_info_free(inf->next);
214 int CRYPTO_mem_ctrl(int mode)
218 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
221 /* for applications (not to be called while multiple threads
222 * use the library): */
223 case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
224 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
227 case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
229 num_disable = 0; /* should be true *before* MemCheck_stop is used,
230 or there'll be a lot of confusion */
233 /* switch off temporarily (for library-internal use): */
234 case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
235 if (mh_mode & CRYPTO_MEM_CHECK_ON)
238 || (disabling_thread_id != CRYPTO_thread_id())
239 || (disabling_thread_idptr != CRYPTO_thread_idptr())) /* otherwise we already have the MALLOC2 lock */
241 /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
242 * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
243 * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
244 * it because we block entry to this function).
245 * Give them a chance, first, and then claim the locks in
246 * appropriate order (long-time lock first).
248 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
249 /* Note that after we have waited for CRYPTO_LOCK_MALLOC2
250 * and CRYPTO_LOCK_MALLOC, we'll still be in the right
251 * "case" and "if" branch because MemCheck_start and
252 * MemCheck_stop may never be used while there are multiple
253 * OpenSSL threads. */
254 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
255 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
256 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
257 disabling_thread_id=CRYPTO_thread_id();
258 disabling_thread_idptr=CRYPTO_thread_idptr();
263 case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
264 if (mh_mode & CRYPTO_MEM_CHECK_ON)
266 if (num_disable) /* always true, or something is going wrong */
269 if (num_disable == 0)
271 mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
272 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
281 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
285 int CRYPTO_is_mem_check_on(void)
289 if (mh_mode & CRYPTO_MEM_CHECK_ON)
291 CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
293 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
294 || (disabling_thread_id != CRYPTO_thread_id())
295 || (disabling_thread_idptr != CRYPTO_thread_idptr());
297 CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
303 void CRYPTO_dbg_set_options(long bits)
308 long CRYPTO_dbg_get_options(void)
313 /* static int mem_cmp(MEM *a, MEM *b) */
314 static int mem_cmp(const void *a_void, const void *b_void)
317 const char *a=(const char *)((const MEM *)a_void)->addr,
318 *b=(const char *)((const MEM *)b_void)->addr;
320 else if (a>b) return 1;
323 return((const char *)((const MEM *)a_void)->addr
324 - (const char *)((const MEM *)b_void)->addr);
328 /* static unsigned long mem_hash(MEM *a) */
329 static unsigned long mem_hash(const void *a_void)
333 ret=(unsigned long)((const MEM *)a_void)->addr;
335 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
339 /* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
340 static int app_info_cmp(const void *a_void, const void *b_void)
342 return (((const APP_INFO *)a_void)->thread_id != ((const APP_INFO *)b_void)->thread_id)
343 || (((const APP_INFO *)a_void)->thread_idptr != ((const APP_INFO *)b_void)->thread_idptr);
346 /* static unsigned long app_info_hash(APP_INFO *a) */
347 static unsigned long app_info_hash(const void *a_void)
349 unsigned long id1, id2;
352 id1=(unsigned long)((const APP_INFO *)a_void)->thread_id;
353 id2=(unsigned long)((const APP_INFO *)a_void)->thread_idptr;
356 ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
360 static APP_INFO *pop_info(void)
363 APP_INFO *ret = NULL;
367 tmp.thread_id=CRYPTO_thread_id();
368 tmp.thread_idptr=CRYPTO_thread_idptr();
369 if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL)
371 APP_INFO *next=ret->next;
376 lh_insert(amih,(char *)next);
378 #ifdef LEVITTE_DEBUG_MEM
379 if (ret->thread_id != tmp.thread_id || ret->thread_idptr != tmp.thread_idptr)
381 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu/%p) than the current thread (%lu/%p)!!!!\n",
382 ret->thread_id, ret->thread_idptr, tmp.thread_id, tmp.thread_idptr);
386 if (--(ret->references) <= 0)
398 int CRYPTO_push_info_(const char *info, const char *file, int line)
400 APP_INFO *ami, *amim;
403 if (is_MemCheck_on())
405 MemCheck_off(); /* obtain MALLOC2 lock */
407 if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
414 if ((amih=lh_new(app_info_hash, app_info_cmp)) == NULL)
422 ami->thread_id=CRYPTO_thread_id();
423 ami->thread_idptr=CRYPTO_thread_idptr();
430 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
432 #ifdef LEVITTE_DEBUG_MEM
433 if (ami->thread_id != amim->thread_id || ami->thread_idptr != amim->thread_idptr)
435 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu/%p) than the current thread (%lu/%p)!!!!\n",
436 amim->thread_id, amim->thread_idptr, ami->thread_id, ami->thread_idptr);
443 MemCheck_on(); /* release MALLOC2 lock */
449 int CRYPTO_pop_info(void)
453 if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
455 MemCheck_off(); /* obtain MALLOC2 lock */
457 ret=(pop_info() != NULL);
459 MemCheck_on(); /* release MALLOC2 lock */
464 int CRYPTO_remove_all_info(void)
468 if (is_MemCheck_on()) /* _must_ be true */
470 MemCheck_off(); /* obtain MALLOC2 lock */
472 while(pop_info() != NULL)
475 MemCheck_on(); /* release MALLOC2 lock */
481 static unsigned long break_order_num=0;
482 void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
488 switch(before_p & 127)
496 if (is_MemCheck_on())
498 MemCheck_off(); /* make sure we hold MALLOC2 lock */
499 if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
502 MemCheck_on(); /* release MALLOC2 lock
503 * if num_disabled drops to 0 */
508 if ((mh=lh_new(mem_hash, mem_cmp)) == NULL)
521 if (options & V_CRYPTO_MDEBUG_THREAD)
523 m->thread_id=CRYPTO_thread_id();
524 m->thread_idptr=CRYPTO_thread_idptr();
529 m->thread_idptr=NULL;
532 if (order == break_order_num)
538 #ifdef LEVITTE_DEBUG_MEM
539 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] %c 0x%p (%d)\n",
541 (before_p & 128) ? '*' : '+',
544 if (options & V_CRYPTO_MDEBUG_TIME)
549 tmp.thread_id=CRYPTO_thread_id();
550 tmp.thread_idptr=CRYPTO_thread_idptr();
553 && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
559 if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
561 /* Not good, but don't sweat it */
562 if (mm->app_info != NULL)
564 mm->app_info->references--;
569 MemCheck_on(); /* release MALLOC2 lock
570 * if num_disabled drops to 0 */
577 void CRYPTO_dbg_free(void *addr, int before_p)
587 if (is_MemCheck_on() && (mh != NULL))
589 MemCheck_off(); /* make sure we hold MALLOC2 lock */
592 mp=(MEM *)lh_delete(mh,(char *)&m);
595 #ifdef LEVITTE_DEBUG_MEM
596 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] - 0x%p (%d)\n",
597 mp->order, mp->addr, mp->num);
599 if (mp->app_info != NULL)
600 app_info_free(mp->app_info);
604 MemCheck_on(); /* release MALLOC2 lock
605 * if num_disabled drops to 0 */
613 void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
614 const char *file, int line, int before_p)
618 #ifdef LEVITTE_DEBUG_MEM
619 fprintf(stderr, "LEVITTE_DEBUG_MEM: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
620 addr1, addr2, num, file, line, before_p);
633 CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
637 if (is_MemCheck_on())
639 MemCheck_off(); /* make sure we hold MALLOC2 lock */
642 mp=(MEM *)lh_delete(mh,(char *)&m);
645 #ifdef LEVITTE_DEBUG_MEM
646 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] * 0x%p (%d) -> 0x%p (%d)\n",
653 lh_insert(mh,(char *)mp);
656 MemCheck_on(); /* release MALLOC2 lock
657 * if num_disabled drops to 0 */
665 typedef struct mem_leak_st
672 static void print_leak(const MEM *m, MEM_LEAK *l)
678 struct tm *lcl = NULL;
682 #define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
684 if(m->addr == (char *)l->bio)
687 if (options & V_CRYPTO_MDEBUG_TIME)
689 lcl = localtime(&m->time);
691 BIO_snprintf(bufp, BUF_REMAIN, "[%02d:%02d:%02d] ",
692 lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
693 bufp += strlen(bufp);
696 BIO_snprintf(bufp, BUF_REMAIN, "%5lu file=%s, line=%d, ",
697 m->order,m->file,m->line);
698 bufp += strlen(bufp);
700 if (options & V_CRYPTO_MDEBUG_THREAD)
702 BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu/%p, ", m->thread_id, m->thread_idptr);
703 bufp += strlen(bufp);
706 BIO_snprintf(bufp, BUF_REMAIN, "number=%d, address=%08lX\n",
707 m->num,(unsigned long)m->addr);
708 bufp += strlen(bufp);
710 BIO_puts(l->bio,buf);
720 tip=amip->thread_idptr;
728 memset(buf,'>',ami_cnt);
729 BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
730 " thread=%lu/%p, file=%s, line=%d, info=\"",
731 amip->thread_id, amip->thread_idptr, amip->file, amip->line);
733 info_len=strlen(amip->info);
734 if (128 - buf_len - 3 < info_len)
736 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
741 BUF_strlcpy(buf + buf_len, amip->info,
742 sizeof buf - buf_len);
743 buf_len = strlen(buf);
745 BIO_snprintf(buf + buf_len, sizeof buf - buf_len, "\"\n");
747 BIO_puts(l->bio,buf);
751 while(amip && amip->thread_id == ti && amip->thread_idptr == tip);
753 #ifdef LEVITTE_DEBUG_MEM
756 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
762 static IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM *, MEM_LEAK *)
764 void CRYPTO_mem_leaks(BIO *b)
768 if (mh == NULL && amih == NULL)
771 MemCheck_off(); /* obtain MALLOC2 lock */
777 lh_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak),
781 BIO_printf(b,"%ld bytes leaked in %d chunks\n",
786 /* Make sure that, if we found no leaks, memory-leak debugging itself
787 * does not introduce memory leaks (which might irritate
788 * external debugging tools).
789 * (When someone enables leak checking, but does not call
790 * this function, we declare it to be their fault.)
792 * XXX This should be in CRYPTO_mem_leaks_cb,
793 * and CRYPTO_mem_leaks should be implemented by
794 * using CRYPTO_mem_leaks_cb.
795 * (Also their should be a variant of lh_doall_arg
796 * that takes a function pointer instead of a void *;
797 * this would obviate the ugly and illegal
798 * void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
799 * Otherwise the code police will come and get us.)
803 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
805 /* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
806 * which uses CRYPTO_is_mem_check_on */
807 old_mh_mode = mh_mode;
808 mh_mode = CRYPTO_MEM_CHECK_OFF;
817 if (lh_num_items(amih) == 0)
824 mh_mode = old_mh_mode;
825 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
827 MemCheck_on(); /* release MALLOC2 lock */
830 #ifndef OPENSSL_NO_FP_API
831 void CRYPTO_mem_leaks_fp(FILE *fp)
835 if (mh == NULL) return;
836 /* Need to turn off memory checking when allocated BIOs ... especially
837 * as we're creating them at a time when we're trying to check we've not
838 * left anything un-free()'d!! */
840 b = BIO_new(BIO_s_file());
843 BIO_set_fp(b,fp,BIO_NOCLOSE);
851 /* FIXME: We really don't allow much to the callback. For example, it has
852 no chance of reaching the info stack for the item it processes. Should
853 it really be this way? -- Richard Levitte */
854 /* NB: The prototypes have been typedef'd to CRYPTO_MEM_LEAK_CB inside crypto.h
855 * If this code is restructured, remove the callback type if it is no longer
856 * needed. -- Geoff Thorpe */
857 static void cb_leak(const MEM *m, CRYPTO_MEM_LEAK_CB **cb)
859 (**cb)(m->order,m->file,m->line,m->num,m->addr);
862 static IMPLEMENT_LHASH_DOALL_ARG_FN(cb_leak, const MEM *, CRYPTO_MEM_LEAK_CB **)
864 void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
866 if (mh == NULL) return;
867 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
868 lh_doall_arg(mh, LHASH_DOALL_ARG_FN(cb_leak), &cb);
869 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);