Return an error if no recipient type matches.
[openssl.git] / crypto / mem_dbg.c
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         }