luna - wolfssl/wolfcrypt/src/memory.c

   1/* memory.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22/* inhibit "#undef current" in linuxkm_wc_port.h, included from wc_port.h,
  23 * because needed in linuxkm_memory.c, included below.
  24 */
  25#ifdef WOLFSSL_LINUXKM
  26    #define WOLFSSL_LINUXKM_NEED_LINUX_CURRENT
  27#endif
  28
  29#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  30
  31#ifdef NO_INLINE
  32    #include <wolfssl/wolfcrypt/misc.h>
  33#else
  34    #define WOLFSSL_MISC_INCLUDED
  35    #include <wolfcrypt/src/misc.c>
  36#endif
  37
  38/*
  39Possible memory options:
  40 * NO_WOLFSSL_MEMORY:               Disables wolf memory callback support. When not defined settings.h defines USE_WOLFSSL_MEMORY.
  41 * WOLFSSL_STATIC_MEMORY:           Turns on the use of static memory buffers and functions.
  42                                        This allows for using static memory instead of dynamic.
  43 * WOLFSSL_STATIC_MEMORY_LEAN:      Requires WOLFSSL_STATIC_MEMORY be defined.
  44 *                                  Uses smaller type sizes for structs
  45 *                                  requiring that memory pool sizes be less
  46 *                                  then 65k and limits features available like
  47 *                                  IO buffers to reduce footprint size.
  48 * WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK:
  49 *                                  Enables option to register a debugging
  50 *                                  callback function, useful for
  51 *                                  WOLFSSL_STATIC_MEMORY builds where XMALLOC
  52 *                                  and XFREE are not user defined.
  53 * WOLFSSL_STATIC_ALIGN:            Define defaults to 16 to indicate static memory alignment.
  54 * HAVE_IO_POOL:                    Enables use of static thread safe memory pool for input/output buffers.
  55 * XMALLOC_OVERRIDE:                Allows override of the XMALLOC, XFREE and XREALLOC macros.
  56 * XMALLOC_USER:                    Allows custom XMALLOC, XFREE and XREALLOC functions to be defined.
  57 * WOLFSSL_NO_MALLOC:               Disables the fall-back case to use STDIO malloc/free when no callbacks are set.
  58 * WOLFSSL_TRACK_MEMORY:            Enables memory tracking for total stats and list of allocated memory.
  59 * WOLFSSL_DEBUG_MEMORY:            Enables extra function and line number args for memory callbacks.
  60 * WOLFSSL_DEBUG_MEMORY_PRINT:      Enables printing of each malloc/free.
  61 * WOLFSSL_MALLOC_CHECK:            Reports malloc or alignment failure using WOLFSSL_STATIC_ALIGN
  62 * WOLFSSL_FORCE_MALLOC_FAIL_TEST:  Used for internal testing to induce random malloc failures.
  63 * WOLFSSL_HEAP_TEST:               Used for internal testing of heap hint
  64 * WOLFSSL_MEM_FAIL_COUNT:          Fail memory allocation at a count from
  65 *                                  environment variable: MEM_FAIL_CNT.
  66 */
  67
  68#ifdef WOLFSSL_ZEPHYR
  69#undef realloc
  70void *z_realloc(void *ptr, size_t size)
  71{
  72    if (ptr == NULL)
  73        ptr = malloc(size); /* native heap */
  74    else
  75        ptr = realloc(ptr, size); /* native heap */
  76
  77    return ptr;
  78}
  79#define realloc z_realloc
  80#endif
  81
  82#ifdef USE_WOLFSSL_MEMORY
  83
  84#include <wolfssl/wolfcrypt/memory.h>
  85
  86#if defined(WOLFSSL_DEBUG_MEMORY) && defined(WOLFSSL_DEBUG_MEMORY_PRINT)
  87#include <stdio.h>
  88#endif
  89
  90#ifdef WOLFSSL_FORCE_MALLOC_FAIL_TEST
  91    static int gMemFailCountSeed;
  92    static int gMemFailCount;
  93    void wolfSSL_SetMemFailCount(int memFailCount)
  94    {
  95        if (gMemFailCountSeed == 0) {
  96            gMemFailCountSeed = memFailCount;
  97            gMemFailCount = memFailCount;
  98        }
  99    }
 100#endif
 101#if defined(WOLFSSL_MALLOC_CHECK) || defined(WOLFSSL_TRACK_MEMORY_FULL) || \
 102                                                     defined(WOLFSSL_MEMORY_LOG)
 103    #include <stdio.h>
 104#endif
 105
 106
 107/* Set these to default values initially. */
 108static wolfSSL_Malloc_cb  malloc_function = NULL;
 109static wolfSSL_Free_cb    free_function = NULL;
 110static wolfSSL_Realloc_cb realloc_function = NULL;
 111
 112int wolfSSL_SetAllocators(wolfSSL_Malloc_cb  mf,
 113                          wolfSSL_Free_cb    ff,
 114                          wolfSSL_Realloc_cb rf)
 115{
 116    malloc_function = mf;
 117    free_function = ff;
 118    realloc_function = rf;
 119    return 0;
 120}
 121
 122int wolfSSL_GetAllocators(wolfSSL_Malloc_cb*  mf,
 123                          wolfSSL_Free_cb*    ff,
 124                          wolfSSL_Realloc_cb* rf)
 125{
 126    if (mf) *mf = malloc_function;
 127    if (ff) *ff = free_function;
 128    if (rf) *rf = realloc_function;
 129    return 0;
 130}
 131
 132#ifdef WOLFSSL_MEM_FAIL_COUNT
 133static wolfSSL_Mutex memFailMutex WOLFSSL_MUTEX_INITIALIZER_CLAUSE(memFailMutex);
 134int mem_fail_allocs = 0;
 135int mem_fail_frees = 0;
 136int mem_fail_cnt = 0;
 137
 138void wc_MemFailCount_Init(void)
 139{
 140    char* cnt;
 141#ifndef WOLFSSL_MUTEX_INITIALIZER
 142    wc_InitMutex(&memFailMutex);
 143#endif
 144    cnt = getenv("MEM_FAIL_CNT");
 145    if (cnt != NULL) {
 146        fprintf(stderr, "MemFailCount At: %d\n", mem_fail_cnt);
 147        mem_fail_cnt = atoi(cnt);
 148    }
 149}
 150static int wc_MemFailCount_AllocMem(void)
 151{
 152    int ret = 1;
 153
 154    wc_LockMutex(&memFailMutex);
 155    if ((mem_fail_cnt > 0) && (mem_fail_cnt <= mem_fail_allocs + 1)) {
 156        ret = 0;
 157    }
 158    else {
 159        mem_fail_allocs++;
 160    }
 161    wc_UnLockMutex(&memFailMutex);
 162
 163    return ret;
 164}
 165static void wc_MemFailCount_FreeMem(void)
 166{
 167    wc_LockMutex(&memFailMutex);
 168    mem_fail_frees++;
 169    wc_UnLockMutex(&memFailMutex);
 170}
 171void wc_MemFailCount_Free(void)
 172{
 173#ifndef WOLFSSL_MUTEX_INITIALIZER
 174    wc_FreeMutex(&memFailMutex);
 175#endif
 176    fprintf(stderr, "MemFailCount Total: %d\n", mem_fail_allocs);
 177    fprintf(stderr, "MemFailCount Frees: %d\n", mem_fail_frees);
 178}
 179#endif
 180
 181#ifndef WOLFSSL_STATIC_MEMORY
 182#ifdef WOLFSSL_CHECK_MEM_ZERO
 183
 184#ifndef WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN
 185/* Number of entries in table of addresses to check. */
 186#define WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN    256
 187#endif
 188
 189/* Alignment to maintain when adding length to allocated pointer.
 190 * Intel x64 wants to use aligned loads of XMM registers.
 191 */
 192#define MEM_ALIGN       16
 193
 194/* An address that is meant to be all zeros for its length. */
 195typedef struct MemZero {
 196    /* Name of address to check. */
 197    const char* name;
 198    /* Address to check. */
 199    const void* addr;
 200    /* Length of data that must be zero. */
 201    size_t len;
 202} MemZero;
 203
 204/* List of addresses to check. */
 205static MemZero memZero[WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN];
 206/* Next index to place address at.
 207 * -1 indicates uninitialized.
 208 * If nextIdx is equal to WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN then all entries
 209 * have been used.
 210 */
 211static int nextIdx = -1;
 212/* Mutex to protect modifying list of addresses to check. */
 213static wolfSSL_Mutex zeroMutex WOLFSSL_MUTEX_INITIALIZER_CLAUSE(zeroMutex);
 214
 215/* Initialize the table of addresses and the mutex.
 216 */
 217void wc_MemZero_Init(void)
 218{
 219    /* Clear the table to more easily see what is valid. */
 220    XMEMSET(memZero, 0, sizeof(memZero));
 221    /* Initialize mutex. */
 222#ifndef WOLFSSL_MUTEX_INITIALIZER
 223    wc_InitMutex(&zeroMutex);
 224#endif
 225    /* Next index is first entry. */
 226    nextIdx = 0;
 227}
 228
 229/* Free the mutex and check we have not any uncheck addresses.
 230 */
 231void wc_MemZero_Free(void)
 232{
 233    /* Free mutex. */
 234#ifndef WOLFSSL_MUTEX_INITIALIZER
 235    wc_FreeMutex(&zeroMutex);
 236#endif
 237    /* Make sure we checked all addresses. */
 238    if (nextIdx > 0) {
 239        int i;
 240        fprintf(stderr, "[MEM_ZERO] Unseen: %d\n", nextIdx);
 241        for (i = 0; i < nextIdx; i++) {
 242            fprintf(stderr, "  %s - %p:%ld\n", memZero[i].name, memZero[i].addr,
 243                memZero[i].len);
 244        }
 245    }
 246    /* Uninitialized value in next index. */
 247    nextIdx = -1;
 248}
 249
 250/* Add an address to check.
 251 *
 252 * @param [in] name  Name of address to check.
 253 * @param [in] addr  Address that needs to be checked.
 254 * @param [in] len   Length of data that must be zero.
 255 */
 256void wc_MemZero_Add(const char* name, const void* addr, size_t len)
 257{
 258    /* Initialize if not done. */
 259    if (nextIdx == -1) {
 260        wc_MemZero_Init();
 261    }
 262
 263    /* Add an entry to the table while locked. */
 264    wc_LockMutex(&zeroMutex);
 265    if (nextIdx < WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN) {
 266        /* Fill in the next entry and update next index. */
 267        memZero[nextIdx].name = name;
 268        memZero[nextIdx].addr = addr;
 269        memZero[nextIdx].len  = len;
 270        nextIdx++;
 271    }
 272    else {
 273        /* Abort when too many entries. */
 274        fprintf(stderr, "\n[MEM_ZERO] Too many addresses to check\n");
 275        fprintf(stderr, "[MEM_ZERO] WOLFSSL_MEM_CHECK_ZERO_CACHE_LEN\n");
 276        abort();
 277    }
 278    wc_UnLockMutex(&zeroMutex);
 279}
 280
 281/* Check the memory in the range of the address for memory that must be zero.
 282 *
 283 * @param [in] addr  Start address of memory that is to be checked.
 284 * @param [in] len   Length of data associated with address.
 285 */
 286void wc_MemZero_Check(void* addr, size_t len)
 287{
 288    int i;
 289    size_t j;
 290
 291    wc_LockMutex(&zeroMutex);
 292    /* Look at each address for overlap with address passes in. */
 293    for (i = 0; i < nextIdx; i++) {
 294        if ((memZero[i].addr < addr) ||
 295               ((size_t)memZero[i].addr >= (size_t)addr + len)) {
 296            /* Check address not part of memory to check. */
 297            continue;
 298        }
 299
 300        /* Address is in range of memory being freed - check each byte zero. */
 301        for (j = 0; j < memZero[i].len; j++) {
 302            if (((unsigned char*)memZero[i].addr)[j] != 0) {
 303                /* Byte not zero - abort! */
 304                fprintf(stderr, "\n[MEM_ZERO] %s:%p + %ld is not zero\n",
 305                    memZero[i].name, memZero[i].addr, j);
 306                fprintf(stderr, "[MEM_ZERO] Checking %p:%ld\n", addr, len);
 307            #ifndef TEST_ALWAYS_RUN_TO_END
 308                abort();
 309            #endif
 310            }
 311        }
 312        /* Update next index to write to. */
 313        nextIdx--;
 314        if (nextIdx > 0) {
 315            /* Remove entry. */
 316            XMEMMOVE(memZero + i, memZero + i + 1,
 317                sizeof(MemZero) * (nextIdx - i));
 318            /* Clear out top to make it easier to see what is to be checked. */
 319            XMEMSET(&memZero[nextIdx], 0, sizeof(MemZero));
 320        }
 321        /* Need to check this index again with new data. */
 322        i--;
 323    }
 324    wc_UnLockMutex(&zeroMutex);
 325}
 326#endif /* WOLFSSL_CHECK_MEM_ZERO */
 327
 328#ifdef WOLFSSL_DEBUG_MEMORY
 329void* wolfSSL_Malloc(size_t size, const char* func, unsigned int line)
 330#else
 331void* wolfSSL_Malloc(size_t size)
 332#endif
 333{
 334    void* res = 0;
 335
 336#ifdef WOLFSSL_MEM_FAIL_COUNT
 337    if (!wc_MemFailCount_AllocMem()) {
 338        WOLFSSL_MSG("MemFailCnt: Fail malloc");
 339        return NULL;
 340    }
 341#endif
 342
 343#ifdef WOLFSSL_CHECK_MEM_ZERO
 344    /* Space for requested size. */
 345    size += MEM_ALIGN;
 346#endif
 347
 348    if (malloc_function) {
 349    #ifdef WOLFSSL_DEBUG_MEMORY
 350        res = malloc_function(size, func, line);
 351    #else
 352        res = malloc_function(size);
 353    #endif
 354    }
 355    else {
 356    #ifndef WOLFSSL_NO_MALLOC
 357        #ifdef WOLFSSL_TRAP_MALLOC_SZ
 358        if (size > WOLFSSL_TRAP_MALLOC_SZ) {
 359            WOLFSSL_MSG("Malloc too big!");
 360            return NULL;
 361        }
 362        #endif
 363
 364        res = malloc(size); /* native heap */
 365    #else
 366        WOLFSSL_MSG("No malloc available");
 367    #endif
 368    }
 369
 370#ifdef WOLFSSL_CHECK_MEM_ZERO
 371    /* Restore size to requested value. */
 372    size -= MEM_ALIGN;
 373    if (res != NULL) {
 374        /* Place size at front of allocated data and move pointer passed it. */
 375        *(size_t*)res = size;
 376        res = ((unsigned char*)res) + MEM_ALIGN;
 377    }
 378#endif
 379
 380#ifdef WOLFSSL_DEBUG_MEMORY
 381#if defined(WOLFSSL_DEBUG_MEMORY_PRINT) && !defined(WOLFSSL_TRACK_MEMORY)
 382    fprintf(stderr, "Alloc: %p -> %u at %s:%u\n", res, (word32)size, func, line);
 383#else
 384    (void)func;
 385    (void)line;
 386#endif
 387#endif
 388
 389#ifdef WOLFSSL_MALLOC_CHECK
 390    if (res == NULL)
 391        WOLFSSL_MSG("wolfSSL_malloc failed");
 392#endif
 393
 394#ifdef WOLFSSL_FORCE_MALLOC_FAIL_TEST
 395    if (res && --gMemFailCount == 0) {
 396        fprintf(stderr, "\n---FORCED MEM FAIL TEST---\n");
 397        if (free_function) {
 398        #ifdef WOLFSSL_DEBUG_MEMORY
 399            free_function(res, func, line);
 400        #else
 401            free_function(res);
 402        #endif
 403        }
 404        else {
 405            free(res); /* native heap */
 406        }
 407        gMemFailCount = gMemFailCountSeed; /* reset */
 408        return NULL;
 409    }
 410#endif
 411
 412    return res;
 413}
 414
 415#ifdef WOLFSSL_DEBUG_MEMORY
 416void wolfSSL_Free(void *ptr, const char* func, unsigned int line)
 417#else
 418void wolfSSL_Free(void *ptr)
 419#endif
 420{
 421#ifdef WOLFSSL_DEBUG_MEMORY
 422#if defined(WOLFSSL_DEBUG_MEMORY_PRINT) && !defined(WOLFSSL_TRACK_MEMORY)
 423    fprintf(stderr, "Free: %p at %s:%u\n", ptr, func, line);
 424#else
 425    (void)func;
 426    (void)line;
 427#endif
 428#endif
 429
 430#ifdef WOLFSSL_CHECK_MEM_ZERO
 431    /* Move pointer back to originally allocated pointer. */
 432    ptr = ((unsigned char*)ptr) - MEM_ALIGN;
 433    /* Check that the pointer is zero where required. */
 434    wc_MemZero_Check(((unsigned char*)ptr) + MEM_ALIGN, *(size_t*)ptr);
 435#endif
 436#ifdef WOLFSSL_MEM_FAIL_COUNT
 437    wc_MemFailCount_FreeMem();
 438#endif
 439
 440    if (free_function) {
 441    #ifdef WOLFSSL_DEBUG_MEMORY
 442        free_function(ptr, func, line);
 443    #else
 444        free_function(ptr);
 445    #endif
 446    }
 447    else {
 448    #ifndef WOLFSSL_NO_MALLOC
 449        free(ptr); /* native heap */
 450    #else
 451        WOLFSSL_MSG("No free available");
 452    #endif
 453    }
 454}
 455
 456#ifdef WOLFSSL_DEBUG_MEMORY
 457void* wolfSSL_Realloc(void *ptr, size_t size, const char* func, unsigned int line)
 458#else
 459void* wolfSSL_Realloc(void *ptr, size_t size)
 460#endif
 461{
 462#ifdef WOLFSSL_CHECK_MEM_ZERO
 463    /* Can't check data that has been freed during realloc.
 464     * Manually allocated new memory, copy data and free original pointer.
 465     */
 466#ifdef WOLFSSL_DEBUG_MEMORY
 467    void* res = wolfSSL_Malloc(size, func, line);
 468#else
 469    void* res = wolfSSL_Malloc(size);
 470#endif
 471    if (ptr != NULL) {
 472        /* Copy the minimum of old and new size. */
 473        size_t copySize = *(size_t*)(((unsigned char*)ptr) - MEM_ALIGN);
 474        if (size < copySize) {
 475            copySize = size;
 476        }
 477        XMEMCPY(res, ptr, copySize);
 478        /* Dispose of old pointer. */
 479    #ifdef WOLFSSL_DEBUG_MEMORY
 480        wolfSSL_Free(ptr, func, line);
 481    #else
 482        wolfSSL_Free(ptr);
 483    #endif
 484    }
 485
 486    /* Return new pointer with data copied into it. */
 487    return res;
 488#else
 489    void* res = 0;
 490
 491#ifdef WOLFSSL_MEM_FAIL_COUNT
 492    if (!wc_MemFailCount_AllocMem()) {
 493        WOLFSSL_MSG("MemFailCnt: Fail realloc");
 494        return NULL;
 495    }
 496#endif
 497
 498    if (realloc_function) {
 499    #ifdef WOLFSSL_DEBUG_MEMORY
 500        res = realloc_function(ptr, size, func, line);
 501    #else
 502        res = realloc_function(ptr, size);
 503    #endif
 504    }
 505    else {
 506    #ifndef WOLFSSL_NO_MALLOC
 507        res = realloc(ptr, size); /* native heap */
 508    #else
 509        WOLFSSL_MSG("No realloc available");
 510    #endif
 511    }
 512
 513#ifdef WOLFSSL_MEM_FAIL_COUNT
 514    if (ptr != NULL) {
 515        wc_MemFailCount_FreeMem();
 516    }
 517#endif
 518
 519    return res;
 520#endif
 521}
 522#endif /* WOLFSSL_STATIC_MEMORY */
 523
 524#if defined(WOLFSSL_TRACK_MEMORY) && defined(USE_WOLFSSL_MEMORY) && \
 525    !defined(WOLFSSL_STATIC_MEMORY)
 526#include <wolfssl/wolfcrypt/mem_track.h>
 527WOLFSSL_API memoryStats *wc_MemStats_Ptr;
 528#endif /* WOLFSSL_TRACK_MEMORY && USE_WOLFSSL_MEMORY && !WOLFSSL_STATIC_MEMORY */
 529
 530#ifdef WOLFSSL_STATIC_MEMORY
 531
 532struct wc_Memory {
 533    byte*  buffer;
 534    struct wc_Memory* next;
 535#ifdef WOLFSSL_STATIC_MEMORY_LEAN
 536    /* lean static memory is assumed to be under 65k */
 537    word16 sz;
 538#else
 539    word32 sz;
 540#endif
 541#ifdef WOLFSSL_DEBUG_MEMORY
 542    word16 szUsed;
 543#endif
 544};
 545
 546
 547#ifdef WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK
 548static DebugMemoryCb DebugCb = NULL;
 549
 550/* Used to set a debug memory callback. Helpful in cases where
 551 * printf is not available. */
 552void wolfSSL_SetDebugMemoryCb(DebugMemoryCb cb)
 553{
 554    DebugCb = cb;
 555}
 556#endif
 557
 558/* returns amount of memory used on success. On error returns negative value
 559   wc_Memory** list is the list that new buckets are prepended to
 560 */
 561static int wc_create_memory_buckets(byte* buffer, word32 bufSz,
 562                              word32 buckSz, word32 buckNum, wc_Memory** list) {
 563    byte*  pt  = buffer;
 564    int    ret = 0;
 565    byte memSz   = (byte)sizeof(wc_Memory);
 566    word16 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
 567    word16 i;
 568
 569    /* if not enough space available for bucket size then do not try */
 570    if (buckSz + memSz + padSz > bufSz) {
 571        return ret;
 572    }
 573
 574    for (i = 0; i < buckNum; i++) {
 575        if ((buckSz + memSz + padSz) <= (bufSz - ret)) {
 576            /* create a new struct and set its values */
 577            wc_Memory* mem = (struct wc_Memory*)(pt);
 578            mem->sz = buckSz;
 579            mem->buffer = (byte*)pt + padSz + memSz;
 580            mem->next = NULL;
 581
 582        #ifdef WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK
 583            if (DebugCb) {
 584                DebugCb(buckSz, buckSz, WOLFSSL_DEBUG_MEMORY_INIT, 0);
 585            }
 586        #endif
 587
 588            /* add the newly created struct to front of list */
 589            if (*list == NULL) {
 590                *list = mem;
 591            } else {
 592                mem->next = *list;
 593                *list = mem;
 594            }
 595
 596            /* advance pointer and keep track of memory used */
 597            ret += buckSz + padSz + memSz;
 598            pt  += buckSz + padSz + memSz;
 599        }
 600        else {
 601            break; /* not enough space left for more buckets of this size */
 602        }
 603    }
 604
 605    return ret;
 606}
 607
 608static int wc_partition_static_memory(byte* buffer, word32 sz, int flag,
 609                                                             WOLFSSL_HEAP* heap)
 610{
 611    word32 ava = sz;
 612    byte*  pt  = buffer;
 613    int    ret = 0;
 614    byte   memSz = (word32)sizeof(wc_Memory);
 615    byte   padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
 616
 617    WOLFSSL_ENTER("wc_partition_static_memory");
 618
 619    /* align pt */
 620    while ((wc_ptr_t)pt % WOLFSSL_STATIC_ALIGN && pt < (buffer + sz)) {
 621        *pt = 0x00;
 622        pt++;
 623        ava--;
 624    }
 625
 626#ifdef WOLFSSL_DEBUG_MEMORY
 627    fprintf(stderr, "Allocated %d bytes for static memory @ %p\n", ava, pt);
 628#endif
 629
 630    /* divide into chunks of memory and add them to available list */
 631    while (ava >= (word32)(heap->sizeList[0] + padSz + memSz)) {
 632    #ifndef WOLFSSL_STATIC_MEMORY_LEAN
 633        /* creating only IO buffers from memory passed in, max TLS is 16k */
 634        if (flag & WOLFMEM_IO_POOL || flag & WOLFMEM_IO_POOL_FIXED) {
 635            if ((ret = wc_create_memory_buckets(pt, ava,
 636                            WOLFMEM_IO_SZ, 1, &(heap->io))) < 0) {
 637                WOLFSSL_LEAVE("wc_partition_static_memory", ret);
 638                return ret;
 639            }
 640
 641            /* check if no more room left for creating IO buffers */
 642            if (ret == 0) {
 643                break;
 644            }
 645
 646            /* advance pointer in buffer for next buckets and keep track
 647               of how much memory is left available */
 648            pt  += ret;
 649            ava -= ret;
 650        }
 651        else
 652    #endif
 653        {
 654            int i;
 655            /* start at largest and move to smaller buckets */
 656            for (i = (WOLFMEM_MAX_BUCKETS - 1); i >= 0; i--) {
 657                if ((word32)(heap->sizeList[i] + padSz + memSz) <= ava) {
 658                    if ((ret = wc_create_memory_buckets(pt, ava,
 659                                    heap->sizeList[i], heap->distList[i],
 660                                    &(heap->ava[i]))) < 0) {
 661                        WOLFSSL_LEAVE("wc_partition_static_memory", ret);
 662                        return ret;
 663                    }
 664
 665                    /* advance pointer in buffer for next buckets and keep track
 666                       of how much memory is left available */
 667                    pt  += ret;
 668                    ava -= ret;
 669                }
 670            }
 671        }
 672    }
 673
 674    (void)flag;
 675    return 1;
 676}
 677
 678static int wc_init_memory_heap(WOLFSSL_HEAP* heap, unsigned int listSz,
 679        const word32 *sizeList, const word32 *distList)
 680{
 681    unsigned int i;
 682
 683    XMEMSET(heap, 0, sizeof(WOLFSSL_HEAP));
 684
 685    /* avoid XMEMCPY for LEAN static memory build */
 686    for (i = 0; i < listSz; i++) {
 687        heap->sizeList[i] = sizeList[i];
 688    }
 689
 690    for (i = 0; i < listSz; i++) {
 691        heap->distList[i] = distList[i];
 692    }
 693
 694#ifndef SINGLE_THREADED
 695    if (wc_InitMutex(&(heap->memory_mutex)) != 0) {
 696        WOLFSSL_MSG("Error creating heap memory mutex");
 697        return BAD_MUTEX_E;
 698    }
 699#endif
 700
 701    return 0;
 702}
 703
 704int wc_LoadStaticMemory_ex(WOLFSSL_HEAP_HINT** pHint,
 705        unsigned int listSz, const word32 *sizeList,
 706        const word32 *distList, unsigned char *buf,
 707        unsigned int sz, int flag, int maxSz)
 708{
 709    WOLFSSL_HEAP*      heap = NULL;
 710    WOLFSSL_HEAP_HINT* hint = NULL;
 711    word16 idx = 0;
 712    int ret;
 713
 714    WOLFSSL_ENTER("wc_LoadStaticMemory_ex");
 715
 716    if (pHint == NULL || buf == NULL || sizeList == NULL || distList == NULL) {
 717        return BAD_FUNC_ARG;
 718    }
 719
 720    /* Cap the listSz to the actual number of items allocated in the list. */
 721    if (listSz > WOLFMEM_MAX_BUCKETS) {
 722        WOLFSSL_MSG("Truncating the list of memory buckets");
 723        listSz = WOLFMEM_MAX_BUCKETS;
 724    }
 725
 726    if ((sizeof(WOLFSSL_HEAP) + sizeof(WOLFSSL_HEAP_HINT)) > sz - idx) {
 727        WOLFSSL_MSG("Not enough memory for partition tracking");
 728        return BUFFER_E; /* not enough memory for structures */
 729    }
 730
 731    /* check if hint has already been assigned */
 732    if (*pHint == NULL) {
 733        heap = (WOLFSSL_HEAP*)buf;
 734        idx += sizeof(WOLFSSL_HEAP);
 735        hint = (WOLFSSL_HEAP_HINT*)(buf + idx);
 736        idx += sizeof(WOLFSSL_HEAP_HINT);
 737
 738        ret = wc_init_memory_heap(heap, listSz, sizeList, distList);
 739        if (ret != 0) {
 740            return ret;
 741        }
 742
 743        XMEMSET(hint, 0, sizeof(WOLFSSL_HEAP_HINT));
 744        hint->memory = heap;
 745    }
 746    else {
 747    #ifdef WOLFSSL_HEAP_TEST
 748        /* do not load in memory if test has been set */
 749        if (heap == (void*)WOLFSSL_HEAP_TEST) {
 750            return 0;
 751        }
 752    #endif
 753
 754        hint = (WOLFSSL_HEAP_HINT*)(*pHint);
 755        heap = hint->memory;
 756    }
 757
 758    ret = wc_partition_static_memory(buf + idx, sz - idx, flag, heap);
 759    if (ret != 1) {
 760        WOLFSSL_MSG("Error partitioning memory");
 761        return MEMORY_E;
 762    }
 763
 764#ifndef WOLFSSL_STATIC_MEMORY_LEAN
 765    /* determine what max applies too */
 766    if ((flag & WOLFMEM_IO_POOL) || (flag & WOLFMEM_IO_POOL_FIXED)) {
 767        heap->maxIO = maxSz;
 768    }
 769    else { /* general memory used in handshakes */
 770        heap->maxHa = maxSz;
 771    }
 772    heap->flag |= flag;
 773#endif
 774    *pHint = hint;
 775
 776    (void)maxSz;
 777    return 0;
 778}
 779
 780int wc_LoadStaticMemory(WOLFSSL_HEAP_HINT** pHint,
 781    unsigned char* buf, unsigned int sz, int flag, int maxSz)
 782{
 783    word32 sizeList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_BUCKETS };
 784    word32 distList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_DIST };
 785    int ret = 0;
 786
 787    WOLFSSL_ENTER("wc_LoadStaticMemory");
 788    ret = wc_LoadStaticMemory_ex(pHint,
 789            WOLFMEM_DEF_BUCKETS, sizeList, distList,
 790            buf, sz, flag, maxSz);
 791    WOLFSSL_LEAVE("wc_LoadStaticMemory", ret);
 792    return ret;
 793}
 794
 795
 796void wc_UnloadStaticMemory(WOLFSSL_HEAP_HINT* heap)
 797{
 798    WOLFSSL_ENTER("wc_UnloadStaticMemory");
 799#ifndef SINGLE_THREADED
 800    if (heap != NULL && heap->memory != NULL) {
 801        wc_FreeMutex(&heap->memory->memory_mutex);
 802    }
 803#else
 804    (void)heap;
 805#endif
 806}
 807
 808#ifndef WOLFSSL_STATIC_MEMORY_LEAN
 809/* returns the size of management memory needed for each bucket.
 810 * This is memory that is used to keep track of and align memory buckets. */
 811int wolfSSL_MemoryPaddingSz(void)
 812{
 813    word32 memSz = (word32)sizeof(wc_Memory);
 814    word32 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
 815    return memSz + padSz;
 816}
 817
 818
 819/* Used to calculate memory size for optimum use with buckets.
 820   returns the suggested size rounded down to the nearest bucket. */
 821int wolfSSL_StaticBufferSz_ex(unsigned int listSz,
 822        const word32 *sizeList, const word32 *distList,
 823        byte* buffer, word32 sz, int flag)
 824{
 825    word32 ava = sz;
 826    byte*  pt  = buffer;
 827    word32 memSz = (word32)sizeof(wc_Memory);
 828    word32 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
 829
 830    WOLFSSL_ENTER("wolfSSL_StaticBufferSz_ex");
 831
 832    if (buffer == NULL || sizeList == NULL || distList == NULL) {
 833        return BAD_FUNC_ARG;
 834    }
 835
 836    /* Cap the listSz to the actual number of items allocated in the list. */
 837    if (listSz > WOLFMEM_MAX_BUCKETS) {
 838        WOLFSSL_MSG("Truncating the list of memory buckets");
 839        listSz = WOLFMEM_MAX_BUCKETS;
 840    }
 841
 842    /* align pt */
 843    while ((wc_ptr_t)pt % WOLFSSL_STATIC_ALIGN && pt < (buffer + sz)) {
 844        pt++;
 845        ava--;
 846    }
 847
 848#ifndef WOLFSSL_STATIC_MEMORY_LEAN
 849    /* creating only IO buffers from memory passed in, max TLS is 16k */
 850    if (flag & WOLFMEM_IO_POOL || flag & WOLFMEM_IO_POOL_FIXED) {
 851        if (ava < (memSz + padSz + WOLFMEM_IO_SZ)) {
 852            return 0; /* not enough room for even one bucket */
 853        }
 854
 855        ava = ava % (memSz + padSz + WOLFMEM_IO_SZ);
 856    }
 857    else
 858#endif
 859    {
 860        int i, k;
 861
 862        if (ava < (sizeList[0] + padSz + memSz)) {
 863            return 0; /* not enough room for even one bucket */
 864        }
 865
 866        while ((ava >= (sizeList[0] + padSz + memSz)) && (ava > 0)) {
 867            /* start at largest and move to smaller buckets */
 868            for (i = (listSz - 1); i >= 0; i--) {
 869                for (k = distList[i]; k > 0; k--) {
 870                    if ((sizeList[i] + padSz + memSz) <= ava) {
 871                        ava -= sizeList[i] + padSz + memSz;
 872                    }
 873                }
 874            }
 875        }
 876    }
 877
 878    WOLFSSL_LEAVE("wolfSSL_StaticBufferSz_ex", sz - ava);
 879    return sz - ava; /* round down */
 880}
 881
 882
 883/* Calls wolfSSL_StaticBufferSz_ex with the static memory pool config
 884 * used by wolfSSL by default. */
 885int wolfSSL_StaticBufferSz(byte* buffer, word32 sz, int flag)
 886{
 887    word32 bucketSz[WOLFMEM_DEF_BUCKETS] = {WOLFMEM_BUCKETS};
 888    word32 distList[WOLFMEM_DEF_BUCKETS] = {WOLFMEM_DIST};
 889
 890    return wolfSSL_StaticBufferSz_ex(WOLFMEM_DEF_BUCKETS, bucketSz, distList,
 891        buffer, sz, flag);
 892}
 893
 894
 895int FreeFixedIO(WOLFSSL_HEAP* heap, wc_Memory** io)
 896{
 897    WOLFSSL_MSG("Freeing fixed IO buffer");
 898
 899    /* check if fixed buffer was set */
 900    if (*io == NULL) {
 901        return 1;
 902    }
 903
 904    if (heap == NULL) {
 905        WOLFSSL_MSG("No heap to return fixed IO too");
 906    }
 907    else {
 908        /* put IO buffer back into IO pool */
 909        (*io)->next = heap->io;
 910        heap->io    = *io;
 911        *io         = NULL;
 912    }
 913
 914    return 1;
 915}
 916
 917
 918int SetFixedIO(WOLFSSL_HEAP* heap, wc_Memory** io)
 919{
 920    WOLFSSL_MSG("Setting fixed IO for SSL");
 921    if (heap == NULL) {
 922        return MEMORY_E;
 923    }
 924
 925    *io = heap->io;
 926
 927    if (*io != NULL) {
 928        heap->io = (*io)->next;
 929        (*io)->next = NULL;
 930    }
 931    else { /* failed to grab an IO buffer */
 932        return 0;
 933    }
 934
 935    return 1;
 936}
 937
 938
 939int wolfSSL_GetMemStats(WOLFSSL_HEAP* heap, WOLFSSL_MEM_STATS* stats)
 940{
 941        word32     i;
 942        wc_Memory* pt;
 943
 944        XMEMSET(stats, 0, sizeof(WOLFSSL_MEM_STATS));
 945
 946        stats->totalAlloc = heap->alloc;
 947        stats->totalFr    = heap->frAlc;
 948        stats->curAlloc   = stats->totalAlloc - stats->totalFr;
 949        stats->maxHa      = heap->maxHa;
 950        stats->maxIO      = heap->maxIO;
 951        for (i = 0; i < WOLFMEM_MAX_BUCKETS; i++) {
 952            stats->blockSz[i] = heap->sizeList[i];
 953            for (pt = heap->ava[i]; pt != NULL; pt = pt->next) {
 954                stats->avaBlock[i] += 1;
 955            }
 956        }
 957
 958        for (pt = heap->io; pt != NULL; pt = pt->next) {
 959            stats->avaIO++;
 960        }
 961
 962        stats->flag       = heap->flag; /* flag used */
 963
 964    return 1;
 965}
 966#endif /* !WOLFSSL_STATIC_MEMORY_LEAN */
 967
 968
 969/* global heap hint to fall back on when no heap hint is passed to
 970 * XMALLOC/XFREE
 971 * NOT thread safe, should be set once before any expected XMALLOC XFREE calls
 972 */
 973static void* globalHeapHint = NULL;
 974
 975
 976/* Used to set a new global heap hint. Returns a pointer to the current global
 977 * heap hint before being set. */
 978void* wolfSSL_SetGlobalHeapHint(void* heap)
 979{
 980    void *oldHint = globalHeapHint;
 981
 982    globalHeapHint = heap;
 983    return oldHint;
 984}
 985
 986
 987/* returns a pointer to the current global heap hint */
 988void* wolfSSL_GetGlobalHeapHint(void)
 989{
 990    return globalHeapHint;
 991}
 992
 993
 994#ifdef WOLFSSL_DEBUG_MEMORY
 995void* wolfSSL_Malloc(size_t size, void* heap, int type, const char* func, unsigned int line)
 996#else
 997void* wolfSSL_Malloc(size_t size, void* heap, int type)
 998#endif
 999{
1000    void* res = 0;
1001    wc_Memory* pt = NULL;
1002    int   i;
1003
1004    /* check for testing heap hint was set */
1005#ifdef WOLFSSL_HEAP_TEST
1006    if (heap == (void*)WOLFSSL_HEAP_TEST) {
1007        return malloc(size); /* native heap */
1008    }
1009#endif
1010
1011    /* if no heap hint then use dynamic memory*/
1012    if (heap == NULL && globalHeapHint == NULL) {
1013        #ifdef WOLFSSL_HEAP_TEST
1014            /* allow using malloc for creating ctx and method */
1015            if (type == DYNAMIC_TYPE_CTX || type == DYNAMIC_TYPE_METHOD ||
1016                                            type == DYNAMIC_TYPE_CERT_MANAGER) {
1017                WOLFSSL_MSG("ERROR allowing null heap hint for ctx/method");
1018                res = malloc(size); /* native heap */
1019            }
1020            else {
1021                WOLFSSL_MSG("ERROR null heap hint passed into XMALLOC");
1022                res = NULL;
1023            }
1024        #else
1025        #ifndef WOLFSSL_NO_MALLOC
1026            #ifdef FREERTOS
1027                res = pvPortMalloc(size); /* native heap */
1028            #elif defined(WOLFSSL_EMBOS)
1029                res = OS_HEAP_malloc(size);
1030            #else
1031                res = malloc(size); /* native heap */
1032            #endif
1033
1034            #ifdef WOLFSSL_DEBUG_MEMORY
1035                fprintf(stderr, "[HEAP %p] Alloc: %p -> %u at %s:%u\n", heap,
1036                    res, (word32)size, func, line);
1037            #endif
1038        #else
1039            WOLFSSL_MSG("No heap hint found to use and no malloc");
1040            #ifdef WOLFSSL_DEBUG_MEMORY
1041            fprintf(stderr, "ERROR: at %s:%u\n", func, line);
1042            #endif
1043        #endif /* WOLFSSL_NO_MALLOC */
1044        #endif /* WOLFSSL_HEAP_TEST */
1045    }
1046    else {
1047        WOLFSSL_HEAP_HINT* hint = (WOLFSSL_HEAP_HINT*)heap;
1048        WOLFSSL_HEAP*      mem;
1049
1050        if (hint == NULL) {
1051            hint = (WOLFSSL_HEAP_HINT*)globalHeapHint;
1052        #ifdef WOLFSSL_DEBUG_MEMORY
1053            fprintf(stderr, "(Using global heap hint %p) ", hint);
1054        #endif
1055        }
1056        mem = hint->memory;
1057
1058    #ifndef SINGLE_THREADED
1059        if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
1060            WOLFSSL_MSG("Bad memory_mutex lock");
1061            return NULL;
1062        }
1063    #endif
1064
1065    #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1066        /* case of using fixed IO buffers */
1067        if (mem->flag & WOLFMEM_IO_POOL_FIXED &&
1068                                             (type == DYNAMIC_TYPE_OUT_BUFFER ||
1069                                              type == DYNAMIC_TYPE_IN_BUFFER)) {
1070            if (type == DYNAMIC_TYPE_OUT_BUFFER) {
1071                pt = hint->outBuf;
1072            }
1073            if (type == DYNAMIC_TYPE_IN_BUFFER) {
1074                pt = hint->inBuf;
1075            }
1076        }
1077        else
1078    #endif
1079        {
1080        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1081            /* check if using IO pool flag */
1082            if (mem->flag & WOLFMEM_IO_POOL &&
1083                                             (type == DYNAMIC_TYPE_OUT_BUFFER ||
1084                                              type == DYNAMIC_TYPE_IN_BUFFER)) {
1085                if (mem->io != NULL) {
1086                    pt      = mem->io;
1087                    mem->io = pt->next;
1088                }
1089            }
1090         #endif
1091
1092            /* general static memory */
1093            if (pt == NULL) {
1094                for (i = 0; i < WOLFMEM_MAX_BUCKETS; i++) {
1095                    if ((word32)size <= mem->sizeList[i]) {
1096                        if (mem->ava[i] != NULL) {
1097                            pt = mem->ava[i];
1098                            mem->ava[i] = pt->next;
1099                            break;
1100                        }
1101                    #ifdef WOLFSSL_DEBUG_STATIC_MEMORY
1102                        else {
1103                            fprintf(stderr, "Size: %lu, Empty: %d\n",
1104                                (unsigned long) size, mem->sizeList[i]);
1105                        }
1106                    #endif
1107                    }
1108                }
1109            }
1110        }
1111
1112        if (pt != NULL) {
1113        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1114            mem->alloc += 1;
1115        #endif
1116            res = pt->buffer;
1117
1118        #ifdef WOLFSSL_DEBUG_MEMORY
1119            pt->szUsed = size;
1120            fprintf(stderr, "[HEAP %p] Alloc: %p -> %lu at %s:%u\n", heap,
1121                pt->buffer, size, func, line);
1122        #endif
1123        #ifdef WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK
1124            if (DebugCb) {
1125                DebugCb(size, pt->sz, WOLFSSL_DEBUG_MEMORY_ALLOC, type);
1126            }
1127        #endif
1128        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1129            /* keep track of connection statistics if flag is set */
1130            if (mem->flag & WOLFMEM_TRACK_STATS) {
1131                WOLFSSL_MEM_CONN_STATS* stats = hint->stats;
1132                if (stats != NULL) {
1133                    stats->curMem += pt->sz;
1134                    if (stats->peakMem < stats->curMem) {
1135                        stats->peakMem = stats->curMem;
1136                    }
1137                    stats->curAlloc++;
1138                    if (stats->peakAlloc < stats->curAlloc) {
1139                        stats->peakAlloc = stats->curAlloc;
1140                    }
1141                    stats->totalAlloc++;
1142                }
1143            }
1144        #endif
1145        }
1146        else {
1147            WOLFSSL_MSG("ERROR ran out of static memory");
1148            res = NULL;
1149            #ifdef WOLFSSL_DEBUG_MEMORY
1150                fprintf(stderr, "Looking for %lu bytes at %s:%u\n",
1151                    (unsigned long) size, func, line);
1152            #endif
1153            #ifdef WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK
1154            if (DebugCb) {
1155                DebugCb(size, 0, WOLFSSL_DEBUG_MEMORY_FAIL, type);
1156            }
1157            #endif
1158        }
1159    #ifndef SINGLE_THREADED
1160        wc_UnLockMutex(&(mem->memory_mutex));
1161    #endif
1162    }
1163
1164    #ifdef WOLFSSL_MALLOC_CHECK
1165        if ((wc_ptr_t)res % WOLFSSL_STATIC_ALIGN) {
1166            WOLFSSL_MSG("ERROR memory is not aligned");
1167            res = NULL;
1168        }
1169    #endif
1170
1171
1172    (void)i;
1173    (void)pt;
1174    (void)type;
1175
1176    return res;
1177}
1178
1179
1180#ifdef WOLFSSL_DEBUG_MEMORY
1181void wolfSSL_Free(void *ptr, void* heap, int type, const char* func, unsigned int line)
1182#else
1183void wolfSSL_Free(void *ptr, void* heap, int type)
1184#endif
1185{
1186    int i;
1187    wc_Memory* pt = NULL;
1188
1189    if (ptr) {
1190        /* check for testing heap hint was set */
1191    #ifdef WOLFSSL_HEAP_TEST
1192        if (heap == (void*)WOLFSSL_HEAP_TEST) {
1193        #ifdef WOLFSSL_DEBUG_MEMORY
1194            fprintf(stderr, "[HEAP %p] Free: %p at %s:%u\n", heap, pt, func,
1195                line);
1196        #endif
1197            return free(ptr); /* native heap */
1198        }
1199    #endif
1200
1201        if (heap == NULL && globalHeapHint == NULL) {
1202        #ifdef WOLFSSL_HEAP_TEST
1203            /* allow using malloc for creating ctx and method */
1204            if (type == DYNAMIC_TYPE_CTX || type == DYNAMIC_TYPE_METHOD ||
1205                                            type == DYNAMIC_TYPE_CERT_MANAGER) {
1206                WOLFSSL_MSG("ERROR allowing null heap hint for ctx/method");
1207            }
1208            else {
1209                WOLFSSL_MSG("ERROR null heap hint passed into XFREE");
1210            }
1211        #endif
1212        #ifndef WOLFSSL_NO_MALLOC
1213            #ifdef WOLFSSL_DEBUG_MEMORY
1214            fprintf(stderr, "[HEAP %p] Free: %p at %s:%u\n", heap, pt, func,
1215                line);
1216            #endif
1217            #ifdef FREERTOS
1218                vPortFree(ptr); /* native heap */
1219            #elif defined(WOLFSSL_EMBOS)
1220                OS_HEAP_free(ptr); /* native heap */
1221            #else
1222                free(ptr); /* native heap */
1223            #endif
1224        #else
1225            WOLFSSL_MSG("Error trying to call free when turned off");
1226        #endif /* WOLFSSL_NO_MALLOC */
1227        }
1228        else {
1229            WOLFSSL_HEAP_HINT* hint = (WOLFSSL_HEAP_HINT*)heap;
1230            WOLFSSL_HEAP*      mem;
1231            word32 padSz = -(int)sizeof(wc_Memory) & (WOLFSSL_STATIC_ALIGN - 1);
1232
1233            if (hint == NULL) {
1234                hint = (WOLFSSL_HEAP_HINT*)globalHeapHint;
1235            #ifdef WOLFSSL_DEBUG_MEMORY
1236                fprintf(stderr, "(Using global heap hint %p) ", hint);
1237            #endif
1238            }
1239            mem = hint->memory;
1240            if (mem == NULL) {
1241                WOLFSSL_MSG("Bad hint pointer to memory");
1242                return;
1243            }
1244
1245            /* get memory struct and add it to available list */
1246            pt = (wc_Memory*)((byte*)ptr - sizeof(wc_Memory) - padSz);
1247        #ifndef SINGLE_THREADED
1248            if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
1249                WOLFSSL_MSG("Bad memory_mutex lock");
1250                return;
1251            }
1252        #endif
1253
1254        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1255            /* case of using fixed IO buffers */
1256            if (mem->flag & WOLFMEM_IO_POOL_FIXED &&
1257                                             (type == DYNAMIC_TYPE_OUT_BUFFER ||
1258                                              type == DYNAMIC_TYPE_IN_BUFFER)) {
1259                /* fixed IO pools are free'd at the end of SSL lifetime
1260                   using FreeFixedIO(WOLFSSL_HEAP* heap, wc_Memory** io) */
1261            }
1262            else if (mem->flag & WOLFMEM_IO_POOL && pt->sz == WOLFMEM_IO_SZ &&
1263                                             (type == DYNAMIC_TYPE_OUT_BUFFER ||
1264                                              type == DYNAMIC_TYPE_IN_BUFFER)) {
1265                pt->next = mem->io;
1266                mem->io  = pt;
1267            }
1268            else
1269       #endif
1270            { /* general memory free */
1271                for (i = 0; i < WOLFMEM_MAX_BUCKETS; i++) {
1272                    if (pt->sz == mem->sizeList[i]) {
1273                        pt->next = mem->ava[i];
1274                        mem->ava[i] = pt;
1275
1276                    #ifdef WOLFSSL_STATIC_MEMORY_DEBUG_CALLBACK
1277                        if (DebugCb) {
1278                        #ifdef WOLFSSL_DEBUG_MEMORY
1279                            DebugCb(pt->szUsed, pt->sz, WOLFSSL_DEBUG_MEMORY_FREE, type);
1280                        #else
1281                            DebugCb(pt->sz, pt->sz, WOLFSSL_DEBUG_MEMORY_FREE, type);
1282                        #endif
1283                        }
1284                    #endif
1285                        break;
1286                    }
1287                }
1288            }
1289        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1290            mem->inUse -= pt->sz;
1291            mem->frAlc += 1;
1292        #endif
1293
1294        #ifdef WOLFSSL_DEBUG_MEMORY
1295            fprintf(stderr, "[HEAP %p] Free: %p -> %u at %s:%u\n", heap,
1296                pt->buffer, pt->szUsed, func, line);
1297        #endif
1298
1299        #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1300            /* keep track of connection statistics if flag is set */
1301            if (mem->flag & WOLFMEM_TRACK_STATS) {
1302                WOLFSSL_MEM_CONN_STATS* stats = hint->stats;
1303                if (stats != NULL) {
1304                    /* avoid under flow */
1305                    if (stats->curMem > pt->sz) {
1306                        stats->curMem -= pt->sz;
1307                    }
1308                    else {
1309                        stats->curMem = 0;
1310                    }
1311
1312                    if (stats->curAlloc > 0) {
1313                        stats->curAlloc--;
1314                    }
1315                    stats->totalFr++;
1316                }
1317            }
1318        #endif
1319        #ifndef SINGLE_THREADED
1320            wc_UnLockMutex(&(mem->memory_mutex));
1321        #endif
1322        }
1323    }
1324
1325    (void)i;
1326    (void)pt;
1327    (void)type;
1328}
1329
1330#ifndef WOLFSSL_NO_REALLOC
1331#ifdef WOLFSSL_DEBUG_MEMORY
1332void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type, const char* func, unsigned int line)
1333#else
1334void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type)
1335#endif
1336{
1337    void* res = 0;
1338    wc_Memory* pt = NULL;
1339    int    i;
1340
1341    /* check for testing heap hint was set */
1342#ifdef WOLFSSL_HEAP_TEST
1343    if (heap == (void*)WOLFSSL_HEAP_TEST) {
1344        return realloc(ptr, size); /* native heap */
1345    }
1346#endif
1347
1348    if (heap == NULL && globalHeapHint == NULL) {
1349        #ifdef WOLFSSL_HEAP_TEST
1350            WOLFSSL_MSG("ERROR null heap hint passed in to XREALLOC");
1351        #endif
1352        #ifndef WOLFSSL_NO_MALLOC
1353            res = realloc(ptr, size); /* native heap */
1354        #else
1355            WOLFSSL_MSG("NO heap found to use for realloc");
1356        #endif /* WOLFSSL_NO_MALLOC */
1357    }
1358    else {
1359        WOLFSSL_HEAP_HINT* hint = (WOLFSSL_HEAP_HINT*)heap;
1360        WOLFSSL_HEAP*      mem;
1361        word32 padSz = -(int)sizeof(wc_Memory) & (WOLFSSL_STATIC_ALIGN - 1);
1362
1363        if (hint == NULL) {
1364            hint = (WOLFSSL_HEAP_HINT*)globalHeapHint;
1365        #ifdef WOLFSSL_DEBUG_MEMORY
1366            fprintf(stderr, "(Using global heap hint %p) ", hint);
1367        #endif
1368        }
1369        mem = hint->memory;
1370
1371        if (ptr == NULL) {
1372        #ifdef WOLFSSL_DEBUG_MEMORY
1373            return wolfSSL_Malloc(size, heap, type, func, line);
1374        #else
1375            return wolfSSL_Malloc(size, heap, type);
1376        #endif
1377        }
1378    #ifndef SINGLE_THREADED
1379        if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
1380            WOLFSSL_MSG("Bad memory_mutex lock");
1381            return NULL;
1382        }
1383    #endif
1384
1385    #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1386        /* case of using fixed IO buffers or IO pool */
1387        if (((mem->flag & WOLFMEM_IO_POOL)||(mem->flag & WOLFMEM_IO_POOL_FIXED))
1388                                          && (type == DYNAMIC_TYPE_OUT_BUFFER ||
1389                                              type == DYNAMIC_TYPE_IN_BUFFER)) {
1390            /* no realloc, is fixed size */
1391            pt = (wc_Memory*)((byte*)ptr - padSz - sizeof(wc_Memory));
1392            if (pt->sz < size) {
1393                WOLFSSL_MSG("Error IO memory was not large enough");
1394                res = NULL; /* return NULL in error case */
1395            }
1396            else {
1397                res = pt->buffer;
1398            }
1399        }
1400        else
1401    #endif
1402        {
1403        /* general memory */
1404            for (i = 0; i < WOLFMEM_MAX_BUCKETS; i++) {
1405                if ((word32)size <= mem->sizeList[i]) {
1406                    if (mem->ava[i] != NULL) {
1407                        pt = mem->ava[i];
1408                        mem->ava[i] = pt->next;
1409                        break;
1410                    }
1411                }
1412            }
1413
1414            if (pt != NULL && res == NULL) {
1415                word32 prvSz;
1416
1417                res = pt->buffer;
1418
1419                /* copy over original information and free ptr */
1420                prvSz = ((wc_Memory*)((byte*)ptr - padSz -
1421                                               sizeof(wc_Memory)))->sz;
1422                prvSz = (prvSz > pt->sz)? pt->sz: prvSz;
1423                XMEMCPY(pt->buffer, ptr, prvSz);
1424            #ifndef WOLFSSL_STATIC_MEMORY_LEAN
1425                mem->inUse += pt->sz;
1426                mem->alloc += 1;
1427            #endif
1428
1429                /* free memory that was previously being used */
1430            #ifndef SINGLE_THREADED
1431                wc_UnLockMutex(&(mem->memory_mutex));
1432            #endif
1433                wolfSSL_Free(ptr, heap, type
1434            #ifdef WOLFSSL_DEBUG_MEMORY
1435                    , func, line
1436            #endif
1437                );
1438            #ifndef SINGLE_THREADED
1439                if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
1440                    WOLFSSL_MSG("Bad memory_mutex lock");
1441                    return NULL;
1442                }
1443            #endif
1444            }
1445        }
1446    #ifndef SINGLE_THREADED
1447        wc_UnLockMutex(&(mem->memory_mutex));
1448    #endif
1449    }
1450
1451    #ifdef WOLFSSL_MALLOC_CHECK
1452        if ((wc_ptr_t)res % WOLFSSL_STATIC_ALIGN) {
1453            WOLFSSL_MSG("ERROR memory is not aligned");
1454            res = NULL;
1455        }
1456    #endif
1457
1458    (void)i;
1459    (void)pt;
1460    (void)type;
1461
1462    return res;
1463}
1464#endif /* WOLFSSL_STATIC_MEMORY */
1465#endif /* WOLFSSL_NO_REALLOC */
1466#endif /* USE_WOLFSSL_MEMORY */
1467
1468
1469#ifdef HAVE_IO_POOL
1470
1471/* Example for user io pool, shared build may need definitions in lib proper */
1472
1473#include <stdlib.h>
1474
1475#ifndef HAVE_THREAD_LS
1476    #error "Oops, simple I/O pool example needs thread local storage"
1477#endif
1478
1479
1480/* allow simple per thread in and out pools */
1481/* use 17k size since max record size is 16k plus overhead */
1482static THREAD_LS_T byte pool_in[17*1024];
1483static THREAD_LS_T byte pool_out[17*1024];
1484
1485
1486void* XMALLOC(size_t n, void* heap, int type)
1487{
1488    (void)heap;
1489
1490    if (type == DYNAMIC_TYPE_IN_BUFFER) {
1491        if (n < sizeof(pool_in))
1492            return pool_in;
1493        else
1494            return NULL;
1495    }
1496
1497    if (type == DYNAMIC_TYPE_OUT_BUFFER) {
1498        if (n < sizeof(pool_out))
1499            return pool_out;
1500        else
1501            return NULL;
1502    }
1503
1504    return malloc(n); /* native heap */
1505}
1506
1507void* XREALLOC(void *p, size_t n, void* heap, int type)
1508{
1509    (void)heap;
1510
1511    if (type == DYNAMIC_TYPE_IN_BUFFER) {
1512        if (n < sizeof(pool_in))
1513            return pool_in;
1514        else
1515            return NULL;
1516    }
1517
1518    if (type == DYNAMIC_TYPE_OUT_BUFFER) {
1519        if (n < sizeof(pool_out))
1520            return pool_out;
1521        else
1522            return NULL;
1523    }
1524
1525    return realloc(p, n); /* native heap */
1526}
1527
1528void XFREE(void *p, void* heap, int type)
1529{
1530    (void)heap;
1531
1532    if (type == DYNAMIC_TYPE_IN_BUFFER)
1533        return;  /* do nothing, static pool */
1534
1535    if (type == DYNAMIC_TYPE_OUT_BUFFER)
1536        return;  /* do nothing, static pool */
1537
1538    free(p); /* native heap */
1539}
1540
1541#endif /* HAVE_IO_POOL */
1542
1543#ifdef WOLFSSL_MEMORY_LOG
1544void *xmalloc(size_t n, void* heap, int type, const char* func,
1545              const char* file, unsigned int line)
1546{
1547    void*   p = NULL;
1548    word32* p32;
1549
1550#ifdef WOLFSSL_MEM_FAIL_COUNT
1551    if (!wc_MemFailCount_AllocMem()) {
1552        WOLFSSL_MSG("MemFailCnt: Fail malloc");
1553        return NULL;
1554    }
1555#endif
1556
1557    if (malloc_function) {
1558#if !defined(WOLFSSL_STATIC_MEMORY) && !defined(WOLFSSL_DEBUG_MEMORY)
1559        p32 = malloc_function(n + sizeof(word32) * 4);
1560#else
1561        p32 = malloc_function(n + sizeof(word32) * 4, heap, type);
1562#endif
1563    }
1564    else
1565        p32 = malloc(n + sizeof(word32) * 4); /* native heap */
1566
1567    if (p32 != NULL) {
1568        p32[0] = (word32)n;
1569        p = (void*)(p32 + 4);
1570
1571        fprintf(stderr, "Alloc: %p -> %u (%d) at %s:%s:%u\n", p, (word32)n,
1572                                                        type, func, file, line);
1573    }
1574
1575    (void)heap;
1576
1577    return p;
1578}
1579void *xrealloc(void *p, size_t n, void* heap, int type, const char* func,
1580               const char* file, unsigned int line)
1581{
1582    void*   newp = NULL;
1583    word32* p32;
1584    word32* oldp32 = NULL;
1585    word32  oldLen;
1586
1587#ifdef WOLFSSL_MEM_FAIL_COUNT
1588    if (!wc_MemFailCount_AllocMem()) {
1589        WOLFSSL_MSG("MemFailCnt: Fail malloc");
1590        return NULL;
1591    }
1592#endif
1593
1594    if (p != NULL) {
1595        oldp32 = (word32*)p;
1596        oldp32 -= 4;
1597        oldLen = oldp32[0];
1598    }
1599
1600    if (realloc_function) {
1601#if !defined(WOLFSSL_STATIC_MEMORY) && !defined(WOLFSSL_DEBUG_MEMORY)
1602        p32 = realloc_function(oldp32, n + sizeof(word32) * 4);
1603#else
1604        p32 = realloc_function(oldp32, n + sizeof(word32) * 4, heap, type);
1605#endif
1606    }
1607    else
1608        p32 = realloc(oldp32, n + sizeof(word32) * 4); /* native heap */
1609
1610    if (p32 != NULL) {
1611        p32[0] = (word32)n;
1612        newp = (void*)(p32 + 4);
1613
1614        if (p != NULL) {
1615            fprintf(stderr, "Free: %p -> %u (%d) at %s:%s:%u\n", p, oldLen,
1616                                                        type, func, file, line);
1617        }
1618        fprintf(stderr, "Alloc: %p -> %u (%d) at %s:%s:%u\n", newp, (word32)n,
1619                                                        type, func, file, line);
1620    }
1621
1622#ifdef WOLFSSL_MEM_FAIL_COUNT
1623    if (p != NULL) {
1624        wc_MemFailCount_FreeMem();
1625    }
1626#endif
1627
1628    (void)heap;
1629
1630    return newp;
1631}
1632void xfree(void *p, void* heap, int type, const char* func, const char* file,
1633           unsigned int line)
1634{
1635    word32* p32 = (word32*)p;
1636
1637    if (p != NULL) {
1638    #ifdef WOLFSSL_MEM_FAIL_COUNT
1639        wc_MemFailCount_FreeMem();
1640    #endif
1641        p32 -= 4;
1642
1643        fprintf(stderr, "Free: %p -> %u (%d) at %s:%s:%u\n", p, p32[0], type,
1644                                                              func, file, line);
1645
1646        if (free_function) {
1647#if !defined(WOLFSSL_STATIC_MEMORY) && !defined(WOLFSSL_DEBUG_MEMORY)
1648            free_function(p32);
1649#else
1650            free_function(p32, heap, type);
1651#endif
1652        }
1653        else
1654            free(p32); /* native heap */
1655    }
1656
1657    (void)heap;
1658}
1659#endif /* WOLFSSL_MEMORY_LOG */
1660
1661#ifdef WOLFSSL_STACK_LOG
1662/* Note: this code only works with GCC using -finstrument-functions. */
1663void __attribute__((no_instrument_function))
1664     __cyg_profile_func_enter(void *func,  void *caller)
1665{
1666    register void* sp asm("sp");
1667    fprintf(stderr, "ENTER: %016lx %p\n", (unsigned long)(wc_ptr_t)func, sp);
1668    (void)caller;
1669}
1670
1671void __attribute__((no_instrument_function))
1672     __cyg_profile_func_exit(void *func, void *caller)
1673{
1674    register void* sp asm("sp");
1675    fprintf(stderr, "EXIT: %016lx %p\n", (unsigned long)(wc_ptr_t)func, sp);
1676    (void)caller;
1677}
1678#endif
1679
1680#ifndef WOLFSSL_NO_FORCE_ZERO
1681/* Exported version of ForceZero(). */
1682void wc_ForceZero(void *mem, size_t len)
1683{
1684    ForceZero(mem, len);
1685}
1686#endif
1687
1688#ifdef WC_DEBUG_CIPHER_LIFECYCLE
1689static const byte wc_debug_cipher_lifecycle_tag_value[] =
1690    { 'W', 'o', 'l', 'f' };
1691
1692WOLFSSL_LOCAL int wc_debug_CipherLifecycleInit(
1693    void **CipherLifecycleTag,
1694    void *heap)
1695{
1696    if (CipherLifecycleTag == NULL)
1697        return BAD_FUNC_ARG;
1698    *CipherLifecycleTag = (void *)XMALLOC(
1699        sizeof(wc_debug_cipher_lifecycle_tag_value),
1700        heap,
1701        DYNAMIC_TYPE_DEBUG_TAG);
1702    if (*CipherLifecycleTag == NULL)
1703        return MEMORY_E;
1704    XMEMCPY(*CipherLifecycleTag,
1705            wc_debug_cipher_lifecycle_tag_value,
1706            sizeof(wc_debug_cipher_lifecycle_tag_value));
1707    return 0;
1708}
1709
1710WOLFSSL_LOCAL int wc_debug_CipherLifecycleCheck(
1711    void *CipherLifecycleTag,
1712    int abort_p)
1713{
1714    int ret;
1715    if (CipherLifecycleTag == NULL) {
1716        ret = BAD_STATE_E;
1717        goto out;
1718    }
1719    if (XMEMCMP(CipherLifecycleTag,
1720                wc_debug_cipher_lifecycle_tag_value,
1721                sizeof(wc_debug_cipher_lifecycle_tag_value)) != 0)
1722    {
1723        ret = BAD_STATE_E;
1724        goto out;
1725    }
1726    ret = 0;
1727
1728out:
1729    if ((ret < 0) && abort_p)
1730        abort();
1731
1732    return ret;
1733}
1734
1735WOLFSSL_LOCAL int wc_debug_CipherLifecycleFree(
1736    void **CipherLifecycleTag,
1737    void *heap,
1738    int abort_p)
1739{
1740    int ret;
1741    if (CipherLifecycleTag == NULL)
1742        return BAD_FUNC_ARG;
1743    ret = wc_debug_CipherLifecycleCheck(*CipherLifecycleTag, abort_p);
1744    if (ret != 0)
1745        return ret;
1746    XFREE(*CipherLifecycleTag, heap, DYNAMIC_TYPE_DEBUG_TAG);
1747    *CipherLifecycleTag = NULL;
1748    return 0;
1749}
1750#endif /* WC_DEBUG_CIPHER_LIFECYCLE */
1751
1752#ifdef DEBUG_VECTOR_REGISTER_ACCESS
1753THREAD_LS_T int wc_svr_count = 0;
1754THREAD_LS_T const char *wc_svr_last_file = NULL;
1755THREAD_LS_T int wc_svr_last_line = -1;
1756THREAD_LS_T int wc_debug_vector_registers_retval =
1757    WC_DEBUG_VECTOR_REGISTERS_RETVAL_INITVAL;
1758#endif
1759
1760#ifdef DEBUG_VECTOR_REGISTER_ACCESS_FUZZING
1761
1762#ifdef HAVE_THREAD_LS
1763
1764WOLFSSL_LOCAL int SAVE_VECTOR_REGISTERS2_fuzzer(void) {
1765    static THREAD_LS_T struct drand48_data wc_svr_fuzzing_state;
1766    static THREAD_LS_T int wc_svr_fuzzing_seeded = 0;
1767    long result;
1768
1769#ifdef DEBUG_VECTOR_REGISTER_ACCESS
1770    if (wc_debug_vector_registers_retval)
1771        return wc_debug_vector_registers_retval;
1772#endif
1773
1774    if (wc_svr_fuzzing_seeded == 0) {
1775        long seed = WC_DEBUG_VECTOR_REGISTERS_FUZZING_SEED;
1776        char *seed_envstr = getenv("WC_DEBUG_VECTOR_REGISTERS_FUZZING_SEED");
1777        if (seed_envstr)
1778            seed = strtol(seed_envstr, NULL, 0);
1779        (void)srand48_r(seed, &wc_svr_fuzzing_state);
1780        wc_svr_fuzzing_seeded = 1;
1781    }
1782    (void)lrand48_r(&wc_svr_fuzzing_state, &result);
1783    if (result & 1)
1784        return WC_NO_ERR_TRACE(IO_FAILED_E);
1785    else
1786        return 0;
1787}
1788
1789#else /* !HAVE_THREAD_LS */
1790
1791/* alternate implementation useful for testing in the kernel module build, where
1792 * glibc and thread-local storage are unavailable.
1793 *
1794 * note this is not a well-behaved PRNG, but is adequate for fuzzing purposes.
1795 * the prn sequence is incompressible according to ent and xz, and does not
1796 * cycle within 10M iterations with various seeds including zero, but the Chi
1797 * square distribution is poor, and the unconditioned lsb bit balance is ~54%
1798 * regardless of seed.
1799 *
1800 * deterministic only if access is single-threaded, but never degenerate.
1801 */
1802
1803WOLFSSL_LOCAL int SAVE_VECTOR_REGISTERS2_fuzzer(void) {
1804    static unsigned long prn = WC_DEBUG_VECTOR_REGISTERS_FUZZING_SEED;
1805    static int balance_bit = 0;
1806    unsigned long new_prn = prn ^ 0xba86943da66ee701ul; /* note this magic
1807                                                         * random number is
1808                                                         * bit-balanced.
1809                                                         */
1810
1811#ifdef DEBUG_VECTOR_REGISTER_ACCESS
1812    if (wc_debug_vector_registers_retval)
1813        return wc_debug_vector_registers_retval;
1814#endif
1815
1816    /* barrel-roll using the bottom 6 bits. */
1817    if (new_prn & 0x3f)
1818        new_prn = (new_prn << (new_prn & 0x3f)) |
1819            (new_prn >> (0x40 - (new_prn & 0x3f)));
1820    prn = new_prn;
1821
1822    balance_bit = !balance_bit;
1823
1824    return ((prn & 1) ^ balance_bit) ? WC_NO_ERR_TRACE(IO_FAILED_E) : 0;
1825}
1826
1827#endif /* !HAVE_THREAD_LS */
1828
1829#endif /* DEBUG_VECTOR_REGISTER_ACCESS_FUZZING */
1830
1831#if defined(WOLFSSL_LINUXKM) || defined(WC_SYM_RELOC_TABLES) || \
1832    defined(WC_SYM_RELOC_TABLES_SUPPORT)
1833    #include "linuxkm/linuxkm_memory.c"
1834#endif