root
/
openssl
mirror of https://github.com/openssl/openssl.git
1
0
Fork 0
Code Issues Actions 7 Packages Projects Releases Wiki Activity
openssl/crypto/mem.c

388 lines
13 KiB
C
Raw Normal View History

Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
/* crypto/mem.c */
Import of old SSLeay release: SSLeay 0.9.0b
1998-12-21 18:56:39 +08:00
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include <stdlib.h>
Have CRYPTO_MDEBUG_TIME automatically set CRYPTO_MDEBUG, and make it the default for some debugging configurations.
1999-07-19 17:25:35 +08:00
#include <openssl/crypto.h>
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
#include "cryptlib.h"
Two changes have been made: 1. Added code to the memory leak detecting code to give the user the possibility to add information, thereby forming a traceback. 2. Make the memory leak detecting code multithread-safe. The idea is that we're actually dealing with two separate critical sections, one containing the hash tables with the information, the other containing the current memory checking mode. Those should not be handled with the same lock, especially since their handling overlap. Hence, the added second lock.
1999-11-12 10:51:24 +08:00
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
static int allow_customize = 1; /* we provide flexible functions for */
static int allow_customize_debug = 1;/* exchanging memory-related functions at
* run-time, but this must be done
* before any blocks are actually
* allocated; or we'll run into huge
* problems when malloc/free pairs
* don't match etc. */
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
/* the following pointers may be changed as long as 'allow_customize' is set */
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
static void *(*malloc_func)(size_t) = malloc;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
static void *default_malloc_ex(size_t num, const char *file, int line)
{ return malloc_func(num); }
static void *(*malloc_ex_func)(size_t, const char *file, int line)
= default_malloc_ex;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
static void *(*realloc_func)(void *, size_t)= realloc;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
static void *default_realloc_ex(void *str, size_t num,
const char *file, int line)
{ return realloc_func(str,num); }
static void *(*realloc_ex_func)(void *, size_t, const char *file, int line)
= default_realloc_ex;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
static void (*free_func)(void *) = free;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
static void *(*malloc_locked_func)(size_t) = malloc;
static void *default_malloc_locked_ex(size_t num, const char *file, int line)
{ return malloc_locked_func(num); }
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
static void *(*malloc_locked_ex_func)(size_t, const char *file, int line)
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
= default_malloc_locked_ex;
static void (*free_locked_func)(void *) = free;
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
/* may be changed as long as 'allow_customize_debug' is set */
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
/* XXX use correct function pointer types */
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
#ifdef CRYPTO_MDEBUG
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
/* use default functions from mem_dbg.c */
static void (*malloc_debug_func)(void *,int,const char *,int,int)
= CRYPTO_dbg_malloc;
static void (*realloc_debug_func)(void *,void *,int,const char *,int,int)
= CRYPTO_dbg_realloc;
static void (*free_debug_func)(void *,int) = CRYPTO_dbg_free;
static void (*set_debug_options_func)(long) = CRYPTO_dbg_set_options;
static long (*get_debug_options_func)(void) = CRYPTO_dbg_get_options;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
#else
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
/* applications can use CRYPTO_malloc_debug_init() to select above case
* at run-time */
static void (*malloc_debug_func)(void *,int,const char *,int,int) = NULL;
static void (*realloc_debug_func)(void *,void *,int,const char *,int,int)
= NULL;
static void (*free_debug_func)(void *,int) = NULL;
static void (*set_debug_options_func)(long) = NULL;
static long (*get_debug_options_func)(void) = NULL;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
#endif
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t),
void (*f)(void *))
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
if (!allow_customize)
return 0;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
if ((m == 0) || (r == 0) || (f == 0))
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
return 0;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
malloc_func=m; malloc_ex_func=default_malloc_ex;
realloc_func=r; realloc_ex_func=default_realloc_ex;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
free_func=f;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
malloc_locked_func=m; malloc_locked_ex_func=default_malloc_locked_ex;
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 19:00:56 +08:00
free_locked_func=f;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
return 1;
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
int CRYPTO_set_mem_ex_functions(
void *(*m)(size_t,const char *,int),
void *(*r)(void *, size_t,const char *,int),
void (*f)(void *))
{
if (!allow_customize)
return 0;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
if ((m == 0) || (r == 0) || (f == 0))
return 0;
malloc_func=0; malloc_ex_func=m;
realloc_func=0; realloc_ex_func=r;
free_func=f;
malloc_locked_func=0; malloc_locked_ex_func=m;
free_locked_func=f;
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
return 1;
}
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*f)(void *))
{
if (!allow_customize)
return 0;
if ((m == NULL) || (f == NULL))
return 0;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
malloc_locked_func=m; malloc_locked_ex_func=default_malloc_locked_ex;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
free_locked_func=f;
return 1;
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 19:00:56 +08:00
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
int CRYPTO_set_locked_mem_ex_functions(
void *(*m)(size_t,const char *,int),
void (*f)(void *))
{
if (!allow_customize)
return 0;
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
if ((m == NULL) || (f == NULL))
return 0;
malloc_locked_func=0; malloc_locked_ex_func=m;
free_func=f;
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
return 1;
}
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int),
void (*r)(void *,void *,int,const char *,int,int),
void (*f)(void *,int),
void (*so)(long),
long (*go)(void))
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
{
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
if (!allow_customize_debug)
return 0;
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
malloc_debug_func=m;
realloc_debug_func=r;
free_debug_func=f;
set_debug_options_func=so;
get_debug_options_func=go;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
return 1;
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
}
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
void (**f)(void *))
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
No functional change, but slightly improved code clarity.
2001-01-11 03:26:34 +08:00
if (m != NULL) *m = (malloc_ex_func == default_malloc_ex) ?
malloc_func : 0;
if (r != NULL) *r = (realloc_ex_func == default_realloc_ex) ?
realloc_func : 0;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
if (f != NULL) *f=free_func;
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
void CRYPTO_get_mem_ex_functions(
void *(**m)(size_t,const char *,int),
void *(**r)(void *, size_t,const char *,int),
void (**f)(void *))
{
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
if (m != NULL) *m = (malloc_ex_func != default_malloc_ex) ?
malloc_ex_func : 0;
if (r != NULL) *r = (realloc_ex_func != default_realloc_ex) ?
realloc_ex_func : 0;
if (f != NULL) *f=free_func;
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
}
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *))
{
No functional change, but slightly improved code clarity.
2001-01-11 03:26:34 +08:00
if (m != NULL) *m = (malloc_locked_ex_func == default_malloc_locked_ex) ?
malloc_locked_func : 0;
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
if (f != NULL) *f=free_locked_func;
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
void CRYPTO_get_locked_mem_ex_functions(
void *(**m)(size_t,const char *,int),
void (**f)(void *))
{
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
if (m != NULL) *m = (malloc_locked_ex_func != default_malloc_locked_ex) ?
malloc_locked_ex_func : 0;
if (f != NULL) *f=free_locked_func;
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
}
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
void (**r)(void *,void *,int,const char *,int,int),
void (**f)(void *,int),
void (**so)(long),
long (**go)(void))
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 19:00:56 +08:00
{
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
if (m != NULL) *m=malloc_debug_func;
if (r != NULL) *r=realloc_debug_func;
if (f != NULL) *f=free_debug_func;
if (so != NULL) *so=set_debug_options_func;
if (go != NULL) *go=get_debug_options_func;
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 19:00:56 +08:00
}
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
Source code cleanups: Use void * rather than char * in lhash, eliminate some of the -Wcast-qual warnings (debug-ben-strict target)
2000-01-31 06:20:28 +08:00
void *CRYPTO_malloc_locked(int num, const char *file, int line)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
void *ret = NULL;
Add OPENSSL_cleanse() to help cleanse memory and avoid certain compiler and linker optimizations. PR: 343
2002-11-27 20:24:05 +08:00
extern unsigned char cleanse_ctr;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
allow_customize = 0;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (malloc_debug_func != NULL)
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
{
allow_customize_debug = 0;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
malloc_debug_func(NULL, num, file, line, 0);
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
ret = malloc_locked_ex_func(num,file,line);
Constification of the data of a hash table. This means the callback functions need to be constified, and therefore meant a number of easy changes a little everywhere. Now, if someone could explain to me why OBJ_dup() cheats...
2000-12-14 01:15:03 +08:00
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num);
Add optional (compile-time configurable) time to CRYPTO_mem_leaks output. This is much more helpful than the counter when doing tests with the library interactively.
1999-07-19 06:39:45 +08:00
#endif
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (malloc_debug_func != NULL)
malloc_debug_func(ret, num, file, line, 1);
Two changes have been made: 1. Added code to the memory leak detecting code to give the user the possibility to add information, thereby forming a traceback. 2. Make the memory leak detecting code multithread-safe. The idea is that we're actually dealing with two separate critical sections, one containing the hash tables with the information, the other containing the current memory checking mode. Those should not be handled with the same lock, especially since their handling overlap. Hence, the added second lock.
1999-11-12 10:51:24 +08:00
Add OPENSSL_cleanse() to help cleanse memory and avoid certain compiler and linker optimizations. PR: 343
2002-11-27 20:24:05 +08:00
/* Create a dependency on the value of 'cleanse_ctr' so our memory
* sanitisation function can't be optimised out. NB: We only do
* this for >2Kb so the overhead doesn't bother us. */
if(ret && (num > 2048))
((unsigned char *)ret)[0] = cleanse_ctr;
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
return ret;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
void CRYPTO_free_locked(void *str)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (free_debug_func != NULL)
free_debug_func(str, 0);
Constification of the data of a hash table. This means the callback functions need to be constified, and therefore meant a number of easy changes a little everywhere. Now, if someone could explain to me why OBJ_dup() cheats...
2000-12-14 01:15:03 +08:00
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str);
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
#endif
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
free_locked_func(str);
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (free_debug_func != NULL)
free_debug_func(NULL, 1);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Source code cleanups: Use void * rather than char * in lhash, eliminate some of the -Wcast-qual warnings (debug-ben-strict target)
2000-01-31 06:20:28 +08:00
void *CRYPTO_malloc(int num, const char *file, int line)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
void *ret = NULL;
Add OPENSSL_cleanse() to help cleanse memory and avoid certain compiler and linker optimizations. PR: 343
2002-11-27 20:24:05 +08:00
extern unsigned char cleanse_ctr;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
allow_customize = 0;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (malloc_debug_func != NULL)
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
{
allow_customize_debug = 0;
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
malloc_debug_func(NULL, num, file, line, 0);
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
}
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
ret = malloc_ex_func(num,file,line);
Constification of the data of a hash table. This means the callback functions need to be constified, and therefore meant a number of easy changes a little everywhere. Now, if someone could explain to me why OBJ_dup() cheats...
2000-12-14 01:15:03 +08:00
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: > 0x%p (%d)\n", ret, num);
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
#endif
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (malloc_debug_func != NULL)
malloc_debug_func(ret, num, file, line, 1);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
Add OPENSSL_cleanse() to help cleanse memory and avoid certain compiler and linker optimizations. PR: 343
2002-11-27 20:24:05 +08:00
/* Create a dependency on the value of 'cleanse_ctr' so our memory
* sanitisation function can't be optimised out. NB: We only do
* this for >2Kb so the overhead doesn't bother us. */
if(ret && (num > 2048))
((unsigned char *)ret)[0] = cleanse_ctr;
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
return ret;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Source code cleanups: Use void * rather than char * in lhash, eliminate some of the -Wcast-qual warnings (debug-ben-strict target)
2000-01-31 06:20:28 +08:00
void *CRYPTO_realloc(void *str, int num, const char *file, int line)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
In Message-ID: <003201bfb332$14a07520$0801a8c0@janm.transactionsite.com>, "Jan Mikkelsen" <janm@transactionsite.com> correctly states that the OpenSSL header files have #include's and extern "C"'s in an incorrect order. Thusly fixed. Also, make the memory debugging routines defined and declared with prototypes, and use void* instead of char* for memory blobs. And last of all, redo the ugly callback construct for elegance and better definition (with prototypes).
2000-05-02 21:36:50 +08:00
void *ret = NULL;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
If CRYPTO_realloc() is called with a NULL pointer, have it call OPENSSL_malloc(). PR: 187
2002-08-01 18:08:37 +08:00
if (str == NULL)
return CRYPTO_malloc(num, file, line);
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (realloc_debug_func != NULL)
realloc_debug_func(str, NULL, num, file, line, 0);
As response to a user request to be able to use external memory handling routines that need file name and line number information, I've added a call level to our memory handling routines to allow that kind of hooking.
2001-01-10 21:14:58 +08:00
ret = realloc_ex_func(str,num,file,line);
Constification of the data of a hash table. This means the callback functions need to be constified, and therefore meant a number of easy changes a little everywhere. Now, if someone could explain to me why OBJ_dup() cheats...
2000-12-14 01:15:03 +08:00
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n", str, ret, num);
Two changes have been made: 1. Added code to the memory leak detecting code to give the user the possibility to add information, thereby forming a traceback. 2. Make the memory leak detecting code multithread-safe. The idea is that we're actually dealing with two separate critical sections, one containing the hash tables with the information, the other containing the current memory checking mode. Those should not be handled with the same lock, especially since their handling overlap. Hence, the added second lock.
1999-11-12 10:51:24 +08:00
#endif
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (realloc_debug_func != NULL)
realloc_debug_func(str, ret, num, file, line, 1);
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
return ret;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Security fixes brought forward from 0.9.7.
2002-11-13 23:43:43 +08:00
void *CRYPTO_realloc_clean(void *str, int old_len, int num, const char *file,
int line)
{
void *ret = NULL;
if (str == NULL)
return CRYPTO_malloc(num, file, line);
if (realloc_debug_func != NULL)
realloc_debug_func(str, NULL, num, file, line, 0);
ret=malloc_ex_func(num,file,line);
if(ret)
memcpy(ret,str,old_len);
Cleanse memory using the new OPENSSL_cleanse() function. I've covered all the memset()s I felt safe modifying, but may have missed some.
2002-11-28 16:04:36 +08:00
OPENSSL_cleanse(str,old_len);
Security fixes brought forward from 0.9.7.
2002-11-13 23:43:43 +08:00
free_func(str);
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: | 0x%p -> 0x%p (%d)\n", str, ret, num);
#endif
if (realloc_debug_func != NULL)
realloc_debug_func(str, ret, num, file, line, 1);
return ret;
}
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
void CRYPTO_free(void *str)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (free_debug_func != NULL)
free_debug_func(str, 0);
Constification of the data of a hash table. This means the callback functions need to be constified, and therefore meant a number of easy changes a little everywhere. Now, if someone could explain to me why OBJ_dup() cheats...
2000-12-14 01:15:03 +08:00
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: < 0x%p\n", str);
Import of old SSLeay release: SSLeay 0.9.1b (unreleased)
1998-12-21 19:00:56 +08:00
#endif
After discussion with Richard, change the new API for extended memory allocation callbacks so that it is no longer visible to applications that these live at a different call level than conventional memory allocation callbacks.
2001-01-11 02:09:57 +08:00
free_func(str);
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (free_debug_func != NULL)
free_debug_func(NULL, 1);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Source code cleanups: Use void * rather than char * in lhash, eliminate some of the -Wcast-qual warnings (debug-ben-strict target)
2000-01-31 06:20:28 +08:00
void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
There have been a number of complaints from a number of sources that names like Malloc, Realloc and especially Free conflict with already existing names on some operating systems or other packages. That is reason enough to change the names of the OpenSSL memory allocation macros to something that has a better chance of being unique, like prepending them with OPENSSL_. This change includes all the name changes needed throughout all C files.
2000-06-02 06:19:21 +08:00
if (a != NULL) OPENSSL_free(a);
a=(char *)OPENSSL_malloc(num);
Rebuild of the OpenSSL memory allocation and deallocation routines. With this change, the following is provided and present at all times (meaning CRYPTO_MDEBUG is no longer required to get this functionality): - hooks to provide your own allocation and deallocation routines. They have to have the same interface as malloc(), realloc() and free(). They are registered by calling CRYPTO_set_mem_functions() with the function pointers. - hooks to provide your own memory debugging routines. The have to have the same interface as as the CRYPTO_dbg_*() routines. They are registered by calling CRYPTO_set_mem_debug_functions() with the function pointers. I moved everything that was already built into OpenSSL and did memory debugging to a separate file (mem_dbg.c), to make it clear what is what. With this, the relevance of the CRYPTO_MDEBUG has changed. The only thing in crypto/crypto.h that it affects is the definition of the MemCheck_start and MemCheck_stop macros.
1999-12-17 20:56:24 +08:00
return(a);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
void CRYPTO_set_mem_debug_options(long bits)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (set_debug_options_func != NULL)
set_debug_options_func(bits);
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}
Make gcc 2.95.2 happy again, even under ``-Wall -Wshadow -Wpointer-arith -Wcast-align -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline''.
2000-02-11 17:47:18 +08:00
long CRYPTO_get_mem_debug_options(void)
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
{
- Added more documentation in CHANGES. - Made CRYPTO_MDEBUG even less used in crypto.h, giving MemCheck_start() and MemCheck_stop() only one possible definition. - Made the values of the debug function pointers in mem.c dependent on the existence of the CRYPTO_MDEBUG macro, and made the rest of the code understand the NULL case. That's it. With this code, the old behvior of the debug functionality is restored, but you can still opt to have it on, even when the library wasn't compiled with a defined CRYPTO_MDEBUG.
1999-12-18 10:34:37 +08:00
if (get_debug_options_func != NULL)
return get_debug_options_func();
- Don't assume that int and size_t have the same representation (and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
1999-12-18 13:22:50 +08:00
return 0;
Import of old SSLeay release: SSLeay 0.8.1b
1998-12-21 18:52:47 +08:00
}