X509_cmp_time: only return 1, 0, -1.
[openssl.git] / 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 }