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 #include "cryptlib.h"
  63
  64 static int allow_customize = 1; /* we provide flexible functions for */
  65 static int allow_customize_debug = 1; /* exchanging memory-related functions
  66                                        * at run-time, but this must be done
  67                                        * before any blocks are actually
  68                                        * allocated; or we'll run into huge
  69                                        * problems when malloc/free pairs
  70                                        * don't match etc. */
  71
  72 /*
  73  * the following pointers may be changed as long as 'allow_customize' is set
  74  */
  75
  76 static void *(*malloc_func) (size_t) = malloc;
  77 static void *default_malloc_ex(size_t num, const char *file, int line)
  78 {
  79     return malloc_func(num);
  80 }
  81
  82 static void *(*malloc_ex_func) (size_t, const char *file, int line)
  83     = default_malloc_ex;
  84
  85 #ifdef OPENSSL_SYS_VMS
  86 # if __INITIAL_POINTER_SIZE == 64
  87 #  define realloc _realloc64
  88 # elif __INITIAL_POINTER_SIZE == 32
  89 #  define realloc _realloc32
  90 # endif
  91 #endif
  92
  93 static void *(*realloc_func) (void *, size_t) = realloc;
  94 static void *default_realloc_ex(void *str, size_t num,
  95                                 const char *file, int line)
  96 {
  97     return realloc_func(str, num);
  98 }
  99
 100 static void *(*realloc_ex_func) (void *, size_t, const char *file, int line)
 101     = default_realloc_ex;
 102
 103 #ifdef OPENSSL_SYS_VMS
 104    static void (*free_func) (__void_ptr64) = free;
 105 #else
 106    static void (*free_func) (void *) = free;
 107 #endif
 108
 109 static void *(*malloc_locked_func) (size_t) = malloc;
 110 static void *default_malloc_locked_ex(size_t num, const char *file, int line)
 111 {
 112     return malloc_locked_func(num);
 113 }
 114
 115 static void *(*malloc_locked_ex_func) (size_t, const char *file, int line)
 116     = default_malloc_locked_ex;
 117
 118 #ifdef OPENSSL_SYS_VMS
 119    static void (*free_locked_func) (__void_ptr64) = free;
 120 #else
 121    static void (*free_locked_func) (void *) = free;
 122 #endif
 123
 124 /* may be changed as long as 'allow_customize_debug' is set */
 125 /* XXX use correct function pointer types */
 126 #ifdef CRYPTO_MDEBUG
 127 /* use default functions from mem_dbg.c */
 128 static void (*malloc_debug_func) (void *, int, const char *, int, int)
 129     = CRYPTO_dbg_malloc;
 130 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
 131                                    int)
 132     = CRYPTO_dbg_realloc;
 133 static void (*free_debug_func) (void *, int) = CRYPTO_dbg_free;
 134 static void (*set_debug_options_func) (long) = CRYPTO_dbg_set_options;
 135 static long (*get_debug_options_func) (void) = CRYPTO_dbg_get_options;
 136 #else
 137 /*
 138  * applications can use CRYPTO_malloc_debug_init() to select above case at
 139  * run-time
 140  */
 141 static void (*malloc_debug_func) (void *, int, const char *, int, int) = NULL;
 142 static void (*realloc_debug_func) (void *, void *, int, const char *, int,
 143                                    int)
 144     = NULL;
 145 static void (*free_debug_func) (void *, int) = NULL;
 146 static void (*set_debug_options_func) (long) = NULL;
 147 static long (*get_debug_options_func) (void) = NULL;
 148 #endif
 149
 150 int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t),
 151                              void (*f) (void *))
 152 {
 153     if (!allow_customize)
 154         return 0;
 155     if ((m == 0) || (r == 0) || (f == 0))
 156         return 0;
 157     /* Dummy call just to ensure OPENSSL_init() gets linked in */
 158     OPENSSL_init();
 159     malloc_func = m;
 160     malloc_ex_func = default_malloc_ex;
 161     realloc_func = r;
 162     realloc_ex_func = default_realloc_ex;
 163     free_func = f;
 164     malloc_locked_func = m;
 165     malloc_locked_ex_func = default_malloc_locked_ex;
 166     free_locked_func = f;
 167     return 1;
 168 }
 169
 170 int CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int),
 171                                 void *(*r) (void *, size_t, const char *,
 172                                             int), void (*f) (void *))
 173 {
 174     if (!allow_customize)
 175         return 0;
 176     if ((m == 0) || (r == 0) || (f == 0))
 177         return 0;
 178     malloc_func = 0;
 179     malloc_ex_func = m;
 180     realloc_func = 0;
 181     realloc_ex_func = r;
 182     free_func = f;
 183     malloc_locked_func = 0;
 184     malloc_locked_ex_func = m;
 185     free_locked_func = f;
 186     return 1;
 187 }
 188
 189 int CRYPTO_set_locked_mem_functions(void *(*m) (size_t), void (*f) (void *))
 190 {
 191     if (!allow_customize)
 192         return 0;
 193     if ((m == NULL) || (f == NULL))
 194         return 0;
 195     malloc_locked_func = m;
 196     malloc_locked_ex_func = default_malloc_locked_ex;
 197     free_locked_func = f;
 198     return 1;
 199 }
 200
 201 int CRYPTO_set_locked_mem_ex_functions(void *(*m) (size_t, const char *, int),
 202                                        void (*f) (void *))
 203 {
 204     if (!allow_customize)
 205         return 0;
 206     if ((m == NULL) || (f == NULL))
 207         return 0;
 208     malloc_locked_func = 0;
 209     malloc_locked_ex_func = m;
 210     free_func = f;
 211     return 1;
 212 }
 213
 214 int CRYPTO_set_mem_debug_functions(void (*m)
 215                                     (void *, int, const char *, int, int),
 216                                    void (*r) (void *, void *, int,
 217                                               const char *, int, int),
 218                                    void (*f) (void *, int), void (*so) (long),
 219                                    long (*go) (void))
 220 {
 221     if (!allow_customize_debug)
 222         return 0;
 223     OPENSSL_init();
 224     malloc_debug_func = m;
 225     realloc_debug_func = r;
 226     free_debug_func = f;
 227     set_debug_options_func = so;
 228     get_debug_options_func = go;
 229     return 1;
 230 }
 231
 232 void CRYPTO_get_mem_functions(void *(**m) (size_t),
 233                               void *(**r) (void *, size_t),
 234                               void (**f) (void *))
 235 {
 236     if (m != NULL)
 237         *m = (malloc_ex_func == default_malloc_ex) ? malloc_func : 0;
 238     if (r != NULL)
 239         *r = (realloc_ex_func == default_realloc_ex) ? realloc_func : 0;
 240     if (f != NULL)
 241         *f = free_func;
 242 }
 243
 244 void CRYPTO_get_mem_ex_functions(void *(**m) (size_t, const char *, int),
 245                                  void *(**r) (void *, size_t, const char *,
 246                                               int), void (**f) (void *))
 247 {
 248     if (m != NULL)
 249         *m = (malloc_ex_func != default_malloc_ex) ? malloc_ex_func : 0;
 250     if (r != NULL)
 251         *r = (realloc_ex_func != default_realloc_ex) ? realloc_ex_func : 0;
 252     if (f != NULL)
 253         *f = free_func;
 254 }
 255
 256 void CRYPTO_get_locked_mem_functions(void *(**m) (size_t),
 257                                      void (**f) (void *))
 258 {
 259     if (m != NULL)
 260         *m = (malloc_locked_ex_func == default_malloc_locked_ex) ?
 261             malloc_locked_func : 0;
 262     if (f != NULL)
 263         *f = free_locked_func;
 264 }
 265
 266 void CRYPTO_get_locked_mem_ex_functions(void
 267                                         *(**m) (size_t, const char *, int),
 268                                         void (**f) (void *))
 269 {
 270     if (m != NULL)
 271         *m = (malloc_locked_ex_func != default_malloc_locked_ex) ?
 272             malloc_locked_ex_func : 0;
 273     if (f != NULL)
 274         *f = free_locked_func;
 275 }
 276
 277 void CRYPTO_get_mem_debug_functions(void (**m)
 278                                      (void *, int, const char *, int, int),
 279                                     void (**r) (void *, void *, int,
 280                                                 const char *, int, int),
 281                                     void (**f) (void *, int),
 282                                     void (**so) (long), long (**go) (void))
 283 {
 284     if (m != NULL)
 285         *m = malloc_debug_func;
 286     if (r != NULL)
 287         *r = realloc_debug_func;
 288     if (f != NULL)
 289         *f = free_debug_func;
 290     if (so != NULL)
 291         *so = set_debug_options_func;
 292     if (go != NULL)
 293         *go = get_debug_options_func;
 294 }
 295
 296 void *CRYPTO_malloc_locked(int num, const char *file, int line)
 297 {
 298     void *ret = NULL;
 299
 300     if (num <= 0)
 301         return NULL;
 302
 303     if (allow_customize)
 304         allow_customize = 0;
 305     if (malloc_debug_func != NULL) {
 306         if (allow_customize_debug)
 307             allow_customize_debug = 0;
 308         malloc_debug_func(NULL, num, file, line, 0);
 309     }
 310     ret = malloc_locked_ex_func(num, file, line);
 311 #ifdef LEVITTE_DEBUG_MEM
 312     fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
 313 #endif
 314     if (malloc_debug_func != NULL)
 315         malloc_debug_func(ret, num, file, line, 1);
 316
 317     return ret;
 318 }
 319
 320 void CRYPTO_free_locked(void *str)
 321 {
 322     if (free_debug_func != NULL)
 323         free_debug_func(str, 0);
 324 #ifdef LEVITTE_DEBUG_MEM
 325     fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
 326 #endif
 327     free_locked_func(str);
 328     if (free_debug_func != NULL)
 329         free_debug_func(NULL, 1);
 330 }
 331
 332 void *CRYPTO_malloc(int num, const char *file, int line)
 333 {
 334     void *ret = NULL;
 335
 336     if (num <= 0)
 337         return NULL;
 338
 339     if (allow_customize)
 340         allow_customize = 0;
 341     if (malloc_debug_func != NULL) {
 342         if (allow_customize_debug)
 343             allow_customize_debug = 0;
 344         malloc_debug_func(NULL, num, file, line, 0);
 345     }
 346     ret = malloc_ex_func(num, file, line);
 347 #ifdef LEVITTE_DEBUG_MEM
 348     fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
 349 #endif
 350     if (malloc_debug_func != NULL)
 351         malloc_debug_func(ret, num, file, line, 1);
 352
 353     return ret;
 354 }
 355
 356 char *CRYPTO_strdup(const char *str, const char *file, int line)
 357 {
 358     char *ret = CRYPTO_malloc(strlen(str) + 1, file, line);
 359
 360     if (ret == NULL)
 361         return NULL;
 362
 363     strcpy(ret, str);
 364     return ret;
 365 }
 366
 367 void *CRYPTO_realloc(void *str, int num, const char *file, int line)
 368 {
 369     void *ret = NULL;
 370
 371     if (str == NULL)
 372         return CRYPTO_malloc(num, file, line);
 373
 374     if (num <= 0)
 375         return NULL;
 376
 377     if (realloc_debug_func != NULL)
 378         realloc_debug_func(str, NULL, num, file, line, 0);
 379     ret = realloc_ex_func(str, num, file, line);
 380 #ifdef LEVITTE_DEBUG_MEM
 381     fprintf(stderr, "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n", str,
 382             ret, num);
 383 #endif
 384     if (realloc_debug_func != NULL)
 385         realloc_debug_func(str, ret, num, file, line, 1);
 386
 387     return ret;
 388 }
 389
 390 void *CRYPTO_realloc_clean(void *str, int old_len, int num, const char *file,
 391                            int line)
 392 {
 393     void *ret = NULL;
 394
 395     if (str == NULL)
 396         return CRYPTO_malloc(num, file, line);
 397
 398     if (num <= 0)
 399         return NULL;
 400
 401     /*
 402      * We don't support shrinking the buffer. Note the memcpy that copies
 403      * |old_len| bytes to the new buffer, below.
 404      */
 405     if (num < old_len)
 406         return NULL;
 407
 408     if (realloc_debug_func != NULL)
 409         realloc_debug_func(str, NULL, num, file, line, 0);
 410     ret = malloc_ex_func(num, file, line);
 411     if (ret) {
 412         memcpy(ret, str, old_len);
 413         OPENSSL_cleanse(str, old_len);
 414         free_func(str);
 415     }
 416 #ifdef LEVITTE_DEBUG_MEM
 417     fprintf(stderr,
 418             "LEVITTE_DEBUG_MEM:         | 0x%p -> 0x%p (%d)\n",
 419             str, ret, num);
 420 #endif
 421     if (realloc_debug_func != NULL)
 422         realloc_debug_func(str, ret, num, file, line, 1);
 423
 424     return ret;
 425 }
 426
 427 void CRYPTO_free(void *str)
 428 {
 429     if (free_debug_func != NULL)
 430         free_debug_func(str, 0);
 431 #ifdef LEVITTE_DEBUG_MEM
 432     fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
 433 #endif
 434     free_func(str);
 435     if (free_debug_func != NULL)
 436         free_debug_func(NULL, 1);
 437 }
 438
 439 void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
 440 {
 441     if (a != NULL)
 442         OPENSSL_free(a);
 443     a = (char *)OPENSSL_malloc(num);
 444     return (a);
 445 }
 446
 447 void CRYPTO_set_mem_debug_options(long bits)
 448 {
 449     if (set_debug_options_func != NULL)
 450         set_debug_options_func(bits);
 451 }
 452
 453 long CRYPTO_get_mem_debug_options(void)
 454 {
 455     if (get_debug_options_func != NULL)
 456         return get_debug_options_func();
 457     return 0;
 458 }