crypto/mem.c

   1 /* crypto/mem.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <openssl/crypto.h>
  62 #ifdef CRYPTO_MDEBUG_TIME
  63 # include <time.h>
  64 #endif
  65 #include <openssl/buffer.h>
  66 #include <openssl/bio.h>
  67 #include <openssl/lhash.h>
  68 #include "cryptlib.h"
  69
  70 /* #ifdef CRYPTO_MDEBUG */
  71 /* static int mh_mode=CRYPTO_MEM_CHECK_ON; */
  72 /* #else */
  73 static int mh_mode=CRYPTO_MEM_CHECK_OFF;
  74 static unsigned long disabling_thread = 0;
  75 /* #endif */
  76 /* State CRYPTO_MEM_CHECK_ON exists only temporarily when the library
  77  * thinks that certain allocations should not be checked (e.g. the data
  78  * structures used for memory checking).  It is not suitable as an initial
  79  * state: the library will unexpectedly enable memory checking when it
  80  * executes one of those sections that want to disable checking
  81  * temporarily.
  82  *
  83  * State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes no sense whatsoever.
  84  */
  85
  86 static unsigned long order=0;
  87
  88 static LHASH *amih=NULL;
  89
  90 typedef struct app_mem_info_st
  91         {
  92         unsigned long thread;
  93         const char *file;
  94         int line;
  95         const char *info;
  96         struct app_mem_info_st *next;
  97         int references;
  98         } APP_INFO;
  99
 100 static LHASH *mh=NULL;
 101
 102 typedef struct mem_st
 103         {
 104         char *addr;
 105         int num;
 106         const char *file;
 107         int line;
 108 #ifdef CRYPTO_MDEBUG_THREAD
 109         unsigned long thread;
 110 #endif
 111         unsigned long order;
 112 #ifdef CRYPTO_MDEBUG_TIME
 113         time_t time;
 114 #endif
 115         APP_INFO *app_info;
 116         } MEM;
 117
 118 int CRYPTO_mem_ctrl(int mode)
 119         {
 120         int ret=mh_mode;
 121
 122         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 123         switch (mode)
 124                 {
 125         /* for applications: */
 126         case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
 127                 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
 128                 disabling_thread = 0;
 129                 break;
 130         case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
 131                 mh_mode = 0;
 132                 disabling_thread = 0;
 133                 break;
 134
 135         /* switch off temporarily (for library-internal use): */
 136         case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
 137                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
 138                         {
 139                         mh_mode&= ~CRYPTO_MEM_CHECK_ENABLE;
 140                         if (disabling_thread != CRYPTO_thread_id())
 141                                 {
 142                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 143                                 disabling_thread=CRYPTO_thread_id();
 144                                 }
 145                         }
 146                 break;
 147         case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
 148                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
 149                         {
 150                         mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
 151                         if (disabling_thread != 0)
 152                                 {
 153                                 disabling_thread=0;
 154                                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 155                                 }
 156                         }
 157                 break;
 158
 159         default:
 160                 break;
 161                 }
 162         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 163         return(ret);
 164         }
 165
 166 static int is_MemCheck_On()
 167         {
 168         int ret = 0;
 169
 170         if (mh_mode & CRYPTO_MEM_CHECK_ON)
 171                 {
 172                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 173
 174                 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
 175                         && disabling_thread != CRYPTO_thread_id();
 176
 177                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
 178                 }
 179         return(ret);
 180         }
 181
 182 static int mem_cmp(MEM *a, MEM *b)
 183         {
 184         return(a->addr - b->addr);
 185         }
 186
 187 static unsigned long mem_hash(MEM *a)
 188         {
 189         unsigned long ret;
 190
 191         ret=(unsigned long)a->addr;
 192
 193         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
 194         return(ret);
 195         }
 196
 197 static int app_info_cmp(APP_INFO *a, APP_INFO *b)
 198         {
 199         return(a->thread - b->thread);
 200         }
 201
 202 static unsigned long app_info_hash(APP_INFO *a)
 203         {
 204         unsigned long ret;
 205
 206         ret=(unsigned long)a->thread;
 207
 208         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
 209         return(ret);
 210         }
 211
 212 static APP_INFO *free_info(APP_INFO *app_info)
 213         {
 214         APP_INFO *next;
 215
 216         if (app_info == NULL)
 217                 return NULL;
 218
 219         if (--(app_info->references) > 0)
 220                 return app_info;
 221
 222         app_info->references = 0;
 223
 224         next = app_info->next;
 225         app_info->next = NULL;  /* Just to make sure */
 226
 227         Free(app_info);
 228         if (next != app_info)
 229                 return free_info(next);
 230         return NULL;
 231         }
 232
 233 static APP_INFO *remove_info()
 234         {
 235         APP_INFO tmp;
 236         APP_INFO *ret = NULL;
 237
 238         if (amih != NULL)
 239                 {
 240                 tmp.thread=CRYPTO_thread_id();
 241                 if ((ret=(APP_INFO *)lh_delete(amih,(char *)&tmp)) != NULL)
 242                         {
 243                         APP_INFO *next=ret->next;
 244 #ifdef LEVITTE_DEBUG
 245                         if (ret->thread != tmp.thread)
 246                                 {
 247                                 fprintf(stderr, "remove_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
 248                                         ret->thread, tmp.thread);
 249                                 abort();
 250                                 }
 251 #endif
 252                         if (next != NULL)
 253                                 {
 254                                 lh_insert(amih,(char *)next);
 255                                 }
 256                         free_info(ret);
 257                         }
 258                 }
 259         return(ret);
 260         }
 261
 262 int CRYPTO_add_info(const char *file, int line, const char *info)
 263         {
 264         APP_INFO *ami, *amim;
 265         int ret=0;
 266
 267         if (is_MemCheck_On())
 268                 {
 269                 MemCheck_off();
 270
 271                 if ((ami = (APP_INFO *)Malloc(sizeof(APP_INFO))) == NULL)
 272                         {
 273                         ret=0;
 274                         goto err;
 275                         }
 276                 if (amih == NULL)
 277                         {
 278                         if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
 279                                 {
 280                                 Free(ami);
 281                                 ret=0;
 282                                 goto err;
 283                                 }
 284                         }
 285
 286                 ami->thread=CRYPTO_thread_id();
 287                 ami->file=file;
 288                 ami->line=line;
 289                 ami->info=info;
 290                 ami->references=1;
 291                 ami->next=NULL;
 292
 293                 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
 294                         {
 295 #ifdef LEVITTE_DEBUG
 296                         if (ami->thread != amim->thread)
 297                                 {
 298                                 fprintf(stderr, "CRYPTO_add_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
 299                                         amim->thread, ami->thread);
 300                                 abort();
 301                                 }
 302 #endif
 303                         ami->next=amim;
 304                         }
 305  err:
 306                 MemCheck_on();
 307                 }
 308
 309         return(ret);
 310         }
 311
 312 int CRYPTO_remove_info()
 313         {
 314         int ret=0;
 315
 316         if (is_MemCheck_On())
 317                 {
 318                 MemCheck_off();
 319
 320                 ret=(remove_info() != NULL);
 321
 322                 MemCheck_on();
 323                 }
 324         return(ret);
 325         }
 326
 327 static char *(*malloc_locked_func)()=(char *(*)())malloc;
 328 static void (*free_locked_func)()=(void (*)())free;
 329 static char *(*malloc_func)()=  (char *(*)())malloc;
 330 static char *(*realloc_func)()= (char *(*)())realloc;
 331 static void (*free_func)()=     (void (*)())free;
 332
 333 void CRYPTO_set_mem_functions(char *(*m)(), char *(*r)(), void (*f)())
 334         {
 335         if ((m == NULL) || (r == NULL) || (f == NULL)) return;
 336         malloc_func=m;
 337         realloc_func=r;
 338         free_func=f;
 339         malloc_locked_func=m;
 340         free_locked_func=f;
 341         }
 342
 343 void CRYPTO_set_locked_mem_functions(char *(*m)(), void (*f)())
 344         {
 345         if ((m == NULL) || (f == NULL)) return;
 346         malloc_locked_func=m;
 347         free_locked_func=f;
 348         }
 349
 350 void CRYPTO_get_mem_functions(char *(**m)(), char *(**r)(), void (**f)())
 351         {
 352         if (m != NULL) *m=malloc_func;
 353         if (r != NULL) *r=realloc_func;
 354         if (f != NULL) *f=free_func;
 355         }
 356
 357 void CRYPTO_get_locked_mem_functions(char *(**m)(), void (**f)())
 358         {
 359         if (m != NULL) *m=malloc_locked_func;
 360         if (f != NULL) *f=free_locked_func;
 361         }
 362
 363 void *CRYPTO_malloc_locked(int num)
 364         {
 365         return(malloc_locked_func(num));
 366         }
 367
 368 void CRYPTO_free_locked(void *str)
 369         {
 370         free_locked_func(str);
 371         }
 372
 373 void *CRYPTO_malloc(int num)
 374         {
 375         return(malloc_func(num));
 376         }
 377
 378 void *CRYPTO_realloc(void *str, int num)
 379         {
 380         return(realloc_func(str,num));
 381         }
 382
 383 void CRYPTO_free(void *str)
 384         {
 385         free_func(str);
 386         }
 387
 388 static unsigned long break_order_num=0;
 389 void *CRYPTO_dbg_malloc(int num, const char *file, int line)
 390         {
 391         char *ret;
 392         MEM *m,*mm;
 393         APP_INFO tmp,*amim;
 394
 395         if ((ret=malloc_func(num)) == NULL)
 396                 return(NULL);
 397
 398         if (is_MemCheck_On())
 399                 {
 400                 MemCheck_off();
 401                 if ((m=(MEM *)Malloc(sizeof(MEM))) == NULL)
 402                         {
 403                         Free(ret);
 404                         MemCheck_on();
 405                         return(NULL);
 406                         }
 407                 if (mh == NULL)
 408                         {
 409                         if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
 410                                 {
 411                                 Free(ret);
 412                                 Free(m);
 413                                 ret=NULL;
 414                                 goto err;
 415                                 }
 416                         }
 417
 418                 m->addr=ret;
 419                 m->file=file;
 420                 m->line=line;
 421                 m->num=num;
 422 #ifdef CRYPTO_MDEBUG_THREAD
 423                 m->thread=CRYPTO_thread_id();
 424 #endif
 425                 if (order == break_order_num)
 426                         {
 427                         /* BREAK HERE */
 428                         m->order=order;
 429                         }
 430                 m->order=order++;
 431 #ifdef CRYPTO_MDEBUG_TIME
 432                 m->time=time(NULL);
 433 #endif
 434
 435                 tmp.thread=CRYPTO_thread_id();
 436                 m->app_info=NULL;
 437                 if (amih != NULL
 438                     && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
 439                         {
 440                         m->app_info = amim;
 441                         amim->references++;
 442                         }
 443
 444                 if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
 445                         {
 446                         /* Not good, but don't sweat it */
 447                         if (mm->app_info != NULL)
 448                                 {
 449                                 mm->app_info->references--;
 450                                 }
 451                         Free(mm);
 452                         }
 453 err:
 454                 MemCheck_on();
 455                 }
 456         return(ret);
 457         }
 458
 459 void CRYPTO_dbg_free(void *addr)
 460         {
 461         MEM m,*mp;
 462
 463         if (is_MemCheck_On() && (mh != NULL))
 464                 {
 465                 MemCheck_off();
 466
 467                 m.addr=addr;
 468                 mp=(MEM *)lh_delete(mh,(char *)&m);
 469                 if (mp != NULL)
 470                         {
 471                         if (mp->app_info != NULL)
 472                                 {
 473                                 mp->app_info->references--;
 474                                 }
 475                         Free(mp);
 476                         }
 477
 478                 MemCheck_on();
 479                 }
 480         free_func(addr);
 481         }
 482
 483 void *CRYPTO_dbg_realloc(void *addr, int num, const char *file, int line)
 484         {
 485         char *ret;
 486         MEM m,*mp;
 487
 488         ret=realloc_func(addr,num);
 489         if (ret == addr) return(ret);
 490
 491         if (is_MemCheck_On())
 492                 {
 493                 if (ret == NULL) return(NULL);
 494
 495                 MemCheck_off();
 496
 497                 m.addr=addr;
 498                 mp=(MEM *)lh_delete(mh,(char *)&m);
 499                 if (mp != NULL)
 500                         {
 501                         mp->addr=ret;
 502                         lh_insert(mh,(char *)mp);
 503                         }
 504
 505                 MemCheck_on();
 506                 }
 507         return(ret);
 508         }
 509
 510 void *CRYPTO_remalloc(void *a, int n)
 511         {
 512         if (a != NULL) Free(a);
 513         a=(char *)Malloc(n);
 514         return(a);
 515         }
 516
 517 void *CRYPTO_dbg_remalloc(void *a, int n, const char *file, int line)
 518         {
 519         if (a != NULL) CRYPTO_dbg_free(a);
 520         a=(char *)CRYPTO_dbg_malloc(n,file,line);
 521         return(a);
 522         }
 523
 524
 525 typedef struct mem_leak_st
 526         {
 527         BIO *bio;
 528         int chunks;
 529         long bytes;
 530         } MEM_LEAK;
 531
 532 static void print_leak(MEM *m, MEM_LEAK *l)
 533         {
 534         char buf[128];
 535         APP_INFO *amip;
 536         int ami_cnt;
 537 #ifdef CRYPTO_MDEBUG_TIME
 538         struct tm *lcl;
 539 #endif
 540         unsigned long ti;
 541
 542         if(m->addr == (char *)l->bio)
 543             return;
 544
 545 #ifdef CRYPTO_MDEBUG_TIME
 546         lcl = localtime(&m->time);
 547 #endif
 548
 549         sprintf(buf,
 550 #ifdef CRYPTO_MDEBUG_TIME
 551                 "[%02d:%02d:%02d] "
 552 #endif
 553                 "%5lu file=%s, line=%d, "
 554 #ifdef CRYPTO_MDEBUG_THREAD
 555                 "thread=%lu, "
 556 #endif
 557                 "number=%d, address=%08lX\n",
 558 #ifdef CRYPTO_MDEBUG_TIME
 559                 lcl->tm_hour,lcl->tm_min,lcl->tm_sec,
 560 #endif
 561                 m->order,m->file,m->line,
 562 #ifdef CRYPTO_MDEBUG_THREAD
 563                 m->thread,
 564 #endif
 565                 m->num,(unsigned long)m->addr);
 566
 567         BIO_puts(l->bio,buf);
 568
 569         l->chunks++;
 570         l->bytes+=m->num;
 571
 572         amip=m->app_info;
 573         ami_cnt=0;
 574         if (amip)
 575                 ti=amip->thread;
 576         while(amip && amip->thread == ti)
 577                 {
 578                 int buf_len;
 579                 int info_len;
 580
 581                 ami_cnt++;
 582                 memset(buf,'>',ami_cnt);
 583                 sprintf(buf + ami_cnt,
 584                         "thread=%lu, file=%s, line=%d, info=\"",
 585                         amip->thread, amip->file, amip->line);
 586                 buf_len=strlen(buf);
 587                 info_len=strlen(amip->info);
 588                 if (128 - buf_len - 3 < info_len)
 589                         {
 590                         memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
 591                         buf_len = 128 - 3;
 592                         }
 593                 else
 594                         {
 595                         strcpy(buf + buf_len, amip->info);
 596                         buf_len = strlen(buf);
 597                         }
 598                 sprintf(buf + buf_len, "\"\n");
 599
 600                 BIO_puts(l->bio,buf);
 601
 602                 amip = amip->next;
 603                 }
 604 #ifdef LEVITTE_DEBUG
 605         if (amip)
 606                 {
 607                 fprintf(stderr, "Thread switch detected i backtrace!!!!\n");
 608                 abort();
 609                 }
 610 #endif
 611         }
 612
 613 void CRYPTO_mem_leaks(BIO *b)
 614         {
 615         MEM_LEAK ml;
 616         char buf[80];
 617
 618         if (mh == NULL) return;
 619         ml.bio=b;
 620         ml.bytes=0;
 621         ml.chunks=0;
 622         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 623         lh_doall_arg(mh,(void (*)())print_leak,(char *)&ml);
 624         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 625         if (ml.chunks != 0)
 626                 {
 627                 sprintf(buf,"%ld bytes leaked in %d chunks\n",
 628                         ml.bytes,ml.chunks);
 629                 BIO_puts(b,buf);
 630                 }
 631
 632 #if 0
 633         lh_stats_bio(mh,b);
 634         lh_node_stats_bio(mh,b);
 635         lh_node_usage_stats_bio(mh,b);
 636 #endif
 637         }
 638
 639 static void (*mem_cb)()=NULL;
 640
 641 static void cb_leak(MEM *m, char *cb)
 642         {
 643         void (*mem_callback)()=(void (*)())cb;
 644         mem_callback(m->order,m->file,m->line,m->num,m->addr);
 645         }
 646
 647 void CRYPTO_mem_leaks_cb(void (*cb)())
 648         {
 649         if (mh == NULL) return;
 650         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
 651         mem_cb=cb;
 652         lh_doall_arg(mh,(void (*)())cb_leak,(char *)mem_cb);
 653         mem_cb=NULL;
 654         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
 655         }
 656
 657 #ifndef NO_FP_API
 658 void CRYPTO_mem_leaks_fp(FILE *fp)
 659         {
 660         BIO *b;
 661
 662         if (mh == NULL) return;
 663         if ((b=BIO_new(BIO_s_file())) == NULL)
 664                 return;
 665         BIO_set_fp(b,fp,BIO_NOCLOSE);
 666         CRYPTO_mem_leaks(b);
 667         BIO_free(b);
 668         }
 669 #endif
 670