| /* memory.c |
| * |
| * Copyright (C) 2006-2015 wolfSSL Inc. |
| * |
| * This file is part of wolfSSL. (formerly known as CyaSSL) |
| * |
| * wolfSSL is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * wolfSSL is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <wolfssl/wolfcrypt/settings.h> |
| |
| /* check old macros @wc_fips */ |
| #if defined(USE_CYASSL_MEMORY) && !defined(USE_WOLFSSL_MEMORY) |
| #define USE_WOLFSSL_MEMORY |
| #endif |
| #if defined(CYASSL_MALLOC_CHECK) && !defined(WOLFSSL_MALLOC_CHECK) |
| #define WOLFSSL_MALLOC_CHECK |
| #endif |
| |
| #ifdef USE_WOLFSSL_MEMORY |
| |
| #include <wolfssl/wolfcrypt/memory.h> |
| #include <wolfssl/wolfcrypt/error-crypt.h> |
| |
| #ifdef WOLFSSL_MALLOC_CHECK |
| #include <stdio.h> |
| #endif |
| |
| /* Set these to default values initially. */ |
| static wolfSSL_Malloc_cb malloc_function = 0; |
| static wolfSSL_Free_cb free_function = 0; |
| static wolfSSL_Realloc_cb realloc_function = 0; |
| |
| int wolfSSL_SetAllocators(wolfSSL_Malloc_cb mf, |
| wolfSSL_Free_cb ff, |
| wolfSSL_Realloc_cb rf) |
| { |
| int res = 0; |
| |
| if (mf) |
| malloc_function = mf; |
| else |
| res = BAD_FUNC_ARG; |
| |
| if (ff) |
| free_function = ff; |
| else |
| res = BAD_FUNC_ARG; |
| |
| if (rf) |
| realloc_function = rf; |
| else |
| res = BAD_FUNC_ARG; |
| |
| return res; |
| } |
| |
| |
| void* wolfSSL_Malloc(size_t size) |
| { |
| void* res = 0; |
| |
| if (malloc_function) |
| res = malloc_function(size); |
| else |
| res = malloc(size); |
| |
| #ifdef WOLFSSL_MALLOC_CHECK |
| if (res == NULL) |
| puts("wolfSSL_malloc failed"); |
| #endif |
| |
| return res; |
| } |
| |
| void wolfSSL_Free(void *ptr) |
| { |
| if (free_function) |
| free_function(ptr); |
| else |
| free(ptr); |
| } |
| |
| void* wolfSSL_Realloc(void *ptr, size_t size) |
| { |
| void* res = 0; |
| |
| if (realloc_function) |
| res = realloc_function(ptr, size); |
| else |
| res = realloc(ptr, size); |
| |
| return res; |
| } |
| |
| #endif /* USE_WOLFSSL_MEMORY */ |
| |
| |
| #ifdef HAVE_IO_POOL |
| |
| /* Example for user io pool, shared build may need definitions in lib proper */ |
| |
| #include <wolfssl/wolfcrypt/types.h> |
| #include <stdlib.h> |
| |
| #ifndef HAVE_THREAD_LS |
| #error "Oops, simple I/O pool example needs thread local storage" |
| #endif |
| |
| |
| /* allow simple per thread in and out pools */ |
| /* use 17k size sense max record size is 16k plus overhead */ |
| static THREAD_LS_T byte pool_in[17*1024]; |
| static THREAD_LS_T byte pool_out[17*1024]; |
| |
| |
| void* XMALLOC(size_t n, void* heap, int type) |
| { |
| (void)heap; |
| |
| if (type == DYNAMIC_TYPE_IN_BUFFER) { |
| if (n < sizeof(pool_in)) |
| return pool_in; |
| else |
| return NULL; |
| } |
| |
| if (type == DYNAMIC_TYPE_OUT_BUFFER) { |
| if (n < sizeof(pool_out)) |
| return pool_out; |
| else |
| return NULL; |
| } |
| |
| return malloc(n); |
| } |
| |
| void* XREALLOC(void *p, size_t n, void* heap, int type) |
| { |
| (void)heap; |
| |
| if (type == DYNAMIC_TYPE_IN_BUFFER) { |
| if (n < sizeof(pool_in)) |
| return pool_in; |
| else |
| return NULL; |
| } |
| |
| if (type == DYNAMIC_TYPE_OUT_BUFFER) { |
| if (n < sizeof(pool_out)) |
| return pool_out; |
| else |
| return NULL; |
| } |
| |
| return realloc(p, n); |
| } |
| |
| |
| /* unit api calls, let's make sure visible with WOLFSSL_API */ |
| WOLFSSL_API void XFREE(void *p, void* heap, int type) |
| { |
| (void)heap; |
| |
| if (type == DYNAMIC_TYPE_IN_BUFFER) |
| return; /* do nothing, static pool */ |
| |
| if (type == DYNAMIC_TYPE_OUT_BUFFER) |
| return; /* do nothing, static pool */ |
| |
| free(p); |
| } |
| |
| #endif /* HAVE_IO_POOL */ |
| |