mem.c revision 306195 
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
64static int allow_customize = 1; /* we provide flexible functions for */
65static 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
76static void *(*malloc_func) (size_t) = malloc;
77static void *default_malloc_ex(size_t num, const char *file, int line)
78{
79    return malloc_func(num);
80}
81
82static 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
93static void *(*realloc_func) (void *, size_t) = realloc;
94static void *default_realloc_ex(void *str, size_t num,
95                                const char *file, int line)
96{
97    return realloc_func(str, num);
98}
99
100static 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
109static void *(*malloc_locked_func) (size_t) = malloc;
110static void *default_malloc_locked_ex(size_t num, const char *file, int line)
111{
112    return malloc_locked_func(num);
113}
114
115static 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 */
128static void (*malloc_debug_func) (void *, int, const char *, int, int)
129    = CRYPTO_dbg_malloc;
130static void (*realloc_debug_func) (void *, void *, int, const char *, int,
131                                   int)
132    = CRYPTO_dbg_realloc;
133static void (*free_debug_func) (void *, int) = CRYPTO_dbg_free;
134static void (*set_debug_options_func) (long) = CRYPTO_dbg_set_options;
135static 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 */
141static void (*malloc_debug_func) (void *, int, const char *, int, int) = NULL;
142static void (*realloc_debug_func) (void *, void *, int, const char *, int,
143                                   int)
144    = NULL;
145static void (*free_debug_func) (void *, int) = NULL;
146static void (*set_debug_options_func) (long) = NULL;
147static long (*get_debug_options_func) (void) = NULL;
148#endif
149
150int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t),
151                             void (*f) (void *))
152{
153    /* Dummy call just to ensure OPENSSL_init() gets linked in */
154    OPENSSL_init();
155    if (!allow_customize)
156        return 0;
157    if ((m == 0) || (r == 0) || (f == 0))
158        return 0;
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
170int 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
189int 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
201int 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
214int 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
232void 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
244void 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
256void 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
266void 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
277void 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
296void *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
320void 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
332void *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
356char *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
367void *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
390void *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
427void 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
439void *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
447void CRYPTO_set_mem_debug_options(long bits)
448{
449    if (set_debug_options_func != NULL)
450        set_debug_options_func(bits);
451}
452
453long CRYPTO_get_mem_debug_options(void)
454{
455    if (get_debug_options_func != NULL)
456        return get_debug_options_func();
457    return 0;
458}
459