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