luna - wolfssl/wolfcrypt/src/logging.c

   1/* logging.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#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  23
  24#if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY)
  25/* avoid adding WANT_READ and WANT_WRITE to error queue */
  26#include <wolfssl/error-ssl.h>
  27#endif
  28
  29#ifdef WOLFSSL_FUNC_TIME
  30/* WARNING: This code is only to be used for debugging performance.
  31 *          The code is not thread-safe.
  32 *          Do not use WOLFSSL_FUNC_TIME in production code.
  33 */
  34static double wc_func_start[WC_FUNC_COUNT];
  35static double wc_func_time[WC_FUNC_COUNT] = { 0, };
  36static const char* wc_func_name[WC_FUNC_COUNT] = {
  37    "SendHelloRequest",
  38    "DoHelloRequest",
  39    "SendClientHello",
  40    "DoClientHello",
  41    "SendServerHello",
  42    "DoServerHello",
  43    "SendEncryptedExtensions",
  44    "DoEncryptedExtensions",
  45    "SendCertificateRequest",
  46    "DoCertificateRequest",
  47    "SendCertificate",
  48    "DoCertificate",
  49    "SendCertificateVerify",
  50    "DoCertificateVerify",
  51    "SendFinished",
  52    "DoFinished",
  53    "SendKeyUpdate",
  54    "DoKeyUpdate",
  55    "SendEarlyData",
  56    "DoEarlyData",
  57    "SendNewSessionTicket",
  58    "DoNewSessionTicket",
  59    "SendServerHelloDone",
  60    "DoServerHelloDone",
  61    "SendTicket",
  62    "DoTicket",
  63    "SendClientKeyExchange",
  64    "DoClientKeyExchange",
  65    "SendCertificateStatus",
  66    "DoCertificateStatus",
  67    "SendServerKeyExchange",
  68    "DoServerKeyExchange",
  69    "SendEarlyData",
  70    "DoEarlyData",
  71};
  72
  73#include <sys/time.h>
  74
  75/* WARNING: This function is not portable. */
  76static WC_INLINE double current_time(int reset)
  77{
  78    struct timeval tv;
  79    gettimeofday(&tv, 0);
  80    (void)reset;
  81
  82    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
  83}
  84#endif /* WOLFSSL_FUNC_TIME */
  85
  86#ifdef HAVE_WC_INTROSPECTION
  87
  88const char *wolfSSL_configure_args(void) {
  89#ifdef LIBWOLFSSL_CONFIGURE_ARGS
  90  /* the spaces on either side are to make matching simple and efficient. */
  91  return " " LIBWOLFSSL_CONFIGURE_ARGS " ";
  92#else
  93  return NULL;
  94#endif
  95}
  96
  97PEDANTIC_EXTENSION const char *wolfSSL_global_cflags(void) {
  98#ifdef LIBWOLFSSL_GLOBAL_CFLAGS
  99  /* the spaces on either side are to make matching simple and efficient. */
 100  return " " LIBWOLFSSL_GLOBAL_CFLAGS " ";
 101#else
 102  return NULL;
 103#endif
 104}
 105
 106#endif /* HAVE_WC_INTROSPECTION */
 107
 108#ifdef HAVE_STACK_SIZE_VERBOSE
 109
 110THREAD_LS_T unsigned char *StackSizeCheck_myStack = NULL;
 111THREAD_LS_T size_t StackSizeCheck_stackSize = 0;
 112THREAD_LS_T size_t StackSizeCheck_stackSizeHWM = 0;
 113THREAD_LS_T size_t *StackSizeCheck_stackSizeHWM_ptr = 0;
 114THREAD_LS_T void *StackSizeCheck_stackOffsetPointer = 0;
 115
 116#endif /* HAVE_STACK_SIZE_VERBOSE */
 117
 118#if defined(DEBUG_WOLFSSL) || \
 119    (defined(WOLFSSL_DEBUG_CERTS) && !defined(NO_WOLFSSL_DEBUG_CERTS))
 120
 121/* Set these to default values initially. */
 122static wolfSSL_Logging_cb LogFunction = NULL;
 123#ifndef WOLFSSL_LOGGINGENABLED_DEFAULT
 124#define WOLFSSL_LOGGINGENABLED_DEFAULT 0
 125#endif
 126static int loggingEnabled = WOLFSSL_LOGGINGENABLED_DEFAULT;
 127#ifndef WOLFSSL_CERT_LOG_ENABLED_DEFAULT
 128#define WOLFSSL_CERT_LOG_ENABLED_DEFAULT 0
 129#endif
 130#ifndef NO_WOLFSSL_DEBUG_CERTS
 131static int loggingCertEnabled = WOLFSSL_CERT_LOG_ENABLED_DEFAULT;
 132#endif
 133THREAD_LS_T const char* log_prefix = NULL;
 134
 135#if defined(WOLFSSL_APACHE_MYNEWT)
 136#include "log/log.h"
 137static struct log mynewt_log;
 138#define WOLFSSL_APACHE_MYNEWT_NOT_INITALIZED 0
 139#define WOLFSSL_APACHE_MYNEWT_INITALIZED     1
 140static int loggingApacheNewtRegistered = WOLFSSL_APACHE_MYNEWT_NOT_INITALIZED;
 141#endif /* WOLFSSL_APACHE_MYNEWT */
 142#endif /* DEBUG_WOLFSSL || WOLFSSL_DEBUG_CERTS */
 143
 144int wolfSSL_CertDebugging_ON(void)
 145{
 146    /* Certificate debugging is also a subset of full debugging */
 147#if defined(WOLFSSL_DEBUG_CERTS) || defined(DEBUG_WOLFSSL)
 148    #if defined(NO_WOLFSSL_DEBUG_CERTS)
 149        return NOT_COMPILED_IN;
 150    #else
 151        loggingCertEnabled = 1;
 152    #endif
 153    #if defined(WOLFSSL_APACHE_MYNEWT)
 154        if (loggingApacheNewtRegistered != WOLFSSL_APACHE_MYNEWT_INITALIZED) {
 155            log_register("wolfcrypt", &mynewt_log, &log_console_handler,
 156                                      NULL, LOG_SYSLEVEL);
 157            loggingApacheNewtRegistered = WOLFSSL_APACHE_MYNEWT_INITALIZED;
 158        }
 159    #endif /* WOLFSSL_APACHE_MYNEWT */
 160    return 0;
 161#else
 162    return NOT_COMPILED_IN;
 163#endif
 164}
 165
 166int wolfSSL_CertDebugging_OFF(void)
 167{
 168#if defined(WOLFSSL_DEBUG_CERTS) || defined(DEBUG_WOLFSSL)
 169    #if defined(NO_WOLFSSL_DEBUG_CERTS)
 170        return NOT_COMPILED_IN;
 171    #else
 172        loggingCertEnabled = 0;
 173    #endif
 174    return 0;
 175#else
 176    return NOT_COMPILED_IN;
 177#endif
 178}
 179
 180/* allow this to be set to NULL, so logs can be redirected to default output */
 181int wolfSSL_SetLoggingCb(wolfSSL_Logging_cb log_function)
 182{
 183#ifdef DEBUG_WOLFSSL
 184    LogFunction = log_function;
 185    return 0;
 186#else
 187    (void)log_function;
 188    return NOT_COMPILED_IN;
 189#endif
 190}
 191
 192/* allow this to be set to NULL, so logs can be redirected to default output */
 193wolfSSL_Logging_cb wolfSSL_GetLoggingCb(void)
 194{
 195#ifdef DEBUG_WOLFSSL
 196    return LogFunction;
 197#else
 198    return NULL;
 199#endif
 200}
 201
 202
 203int wolfSSL_Debugging_ON(void)
 204{
 205#ifdef DEBUG_WOLFSSL
 206    loggingEnabled = 1;
 207    #ifndef NO_WOLFSSL_DEBUG_CERTS
 208        /* Certificate debugging is enabled by default during DEBUG_WOLFSSL,
 209         * unless explicitly disabled with NO_WOLFSSL_DEBUG_CERTS */
 210        loggingCertEnabled = 1;
 211    #endif
 212    #if defined(WOLFSSL_APACHE_MYNEWT)
 213        if (loggingApacheNewtRegistered != WOLFSSL_APACHE_MYNEWT_INITALIZED) {
 214            log_register("wolfcrypt", &mynewt_log, &log_console_handler,
 215                                      NULL, LOG_SYSLEVEL);
 216            loggingApacheNewtRegistered = WOLFSSL_APACHE_MYNEWT_INITALIZED;
 217        }
 218    #endif /* WOLFSSL_APACHE_MYNEWT */
 219    return 0;
 220#else
 221    return NOT_COMPILED_IN;
 222#endif /* DEBUG_WOLFSSL */
 223}
 224
 225
 226void wolfSSL_Debugging_OFF(void)
 227{
 228#ifdef DEBUG_WOLFSSL
 229    loggingEnabled = 0;
 230    #ifndef NO_WOLFSSL_DEBUG_CERTS
 231        loggingCertEnabled = 0;
 232    #endif
 233#endif
 234}
 235
 236void wolfSSL_SetLoggingPrefix(const char* prefix)
 237{
 238#if defined(DEBUG_WOLFSSL) || \
 239   (defined(WOLFSSL_DEBUG_CERTS) && !defined(NO_WOLFSSL_DEBUG_CERTS))
 240    log_prefix = prefix;
 241#else
 242    (void)prefix;
 243#endif
 244}
 245
 246#ifdef WOLFSSL_FUNC_TIME
 247/* WARNING: This code is only to be used for debugging performance.
 248 *          The code is not thread-safe.
 249 *          Do not use WOLFSSL_FUNC_TIME in production code.
 250 */
 251void WOLFSSL_START(int funcNum)
 252{
 253    if (funcNum < WC_FUNC_COUNT) {
 254        double now = current_time(0) * 1000.0;
 255    #ifdef WOLFSSL_FUNC_TIME_LOG
 256        WOLFSSL_DEBUG_PRINTF("%17.3f: START - %s\n",
 257                             now, wc_func_name[funcNum]);
 258    #endif
 259        wc_func_start[funcNum] = now;
 260    }
 261}
 262
 263void WOLFSSL_END(int funcNum)
 264{
 265    if (funcNum < WC_FUNC_COUNT) {
 266        double now = current_time(0) * 1000.0;
 267        wc_func_time[funcNum] += now - wc_func_start[funcNum];
 268    #ifdef WOLFSSL_FUNC_TIME_LOG
 269        WOLFSSL_DEBUG_PRINTF("%17.3f: END   - %s\n",
 270                             now, wc_func_name[funcNum]);
 271    #endif
 272    }
 273}
 274
 275void WOLFSSL_TIME(int count)
 276{
 277    int i;
 278    double avg, total = 0;
 279
 280    for (i = 0; i < WC_FUNC_COUNT; i++) {
 281        if (wc_func_time[i] > 0) {
 282            avg = wc_func_time[i] / count;
 283            WOLFSSL_DEBUG_PRINTF("%8.3f ms: %s\n", avg, wc_func_name[i]);
 284            total += avg;
 285        }
 286    }
 287    WOLFSSL_DEBUG_PRINTF("%8.3f ms\n", total);
 288}
 289#endif
 290
 291#if defined(DEBUG_WOLFSSL) || \
 292    (defined(WOLFSSL_DEBUG_CERTS) && !defined(NO_WOLFSSL_DEBUG_CERTS))
 293
 294#ifdef HAVE_STACK_SIZE_VERBOSE
 295#include <wolfssl/wolfcrypt/mem_track.h>
 296#endif
 297
 298static void wolfssl_log(const int logLevel, const char* const file_name,
 299                        int line_number, const char* const logMessage)
 300{
 301    (void)file_name;
 302    (void)line_number;
 303    if (LogFunction)
 304        LogFunction(logLevel, logMessage);
 305    else {
 306#if defined(WOLFSSL_USER_LOG)
 307        WOLFSSL_USER_LOG(logMessage);
 308#elif defined(WOLFSSL_DEBUG_PRINTF_FN)
 309    #ifdef WOLFSSL_MDK_ARM
 310        fflush(stdout);
 311    #endif
 312    /* see settings.h for platform-specific line endings */
 313    #ifndef WOLFSSL_DEBUG_LINE_ENDING
 314        #define WOLFSSL_DEBUG_LINE_ENDING "\n"
 315    #endif
 316        if (log_prefix != NULL) {
 317            if (file_name != NULL) {
 318                WOLFSSL_DEBUG_PRINTF_FN(WOLFSSL_DEBUG_PRINTF_FIRST_ARGS
 319                        "[%s]: [%s L %d] %s" WOLFSSL_DEBUG_LINE_ENDING,
 320                        log_prefix, file_name, line_number, logMessage);
 321            }
 322            else {
 323                WOLFSSL_DEBUG_PRINTF_FN(WOLFSSL_DEBUG_PRINTF_FIRST_ARGS
 324                   "[%s]: %s" WOLFSSL_DEBUG_LINE_ENDING, log_prefix, logMessage);
 325            } /* file_name check */
 326        }
 327        else {
 328            if (file_name != NULL) {
 329                WOLFSSL_DEBUG_PRINTF_FN(WOLFSSL_DEBUG_PRINTF_FIRST_ARGS
 330                        "[%s L %d] %s" WOLFSSL_DEBUG_LINE_ENDING,
 331                        file_name, line_number, logMessage);
 332            }
 333            else {
 334                WOLFSSL_DEBUG_PRINTF_FN(WOLFSSL_DEBUG_PRINTF_FIRST_ARGS
 335                        "%s" WOLFSSL_DEBUG_LINE_ENDING, logMessage);
 336            } /* file_name check */
 337        } /* log_prefix check */
 338    #ifdef WOLFSSL_MDK_ARM
 339        fflush(stdout);
 340    #endif
 341#elif defined(ARDUINO)
 342        wolfSSL_Arduino_Serial_Print(logMessage);
 343#elif defined(WOLFSSL_UTASKER)
 344        fnDebugMsg((char*)logMessage);
 345        fnDebugMsg("\r\n");
 346#elif defined(STACK_SIZE_CHECKPOINT_MSG) && \
 347      defined(HAVE_STACK_SIZE_VERBOSE) && defined(HAVE_STACK_SIZE_VERBOSE_LOG)
 348        STACK_SIZE_CHECKPOINT_MSG(logMessage);
 349#else
 350    #error No log method defined.
 351#endif
 352    }
 353}
 354
 355#ifndef WOLFSSL_DEBUG_ERRORS_ONLY
 356
 357/* Certificate debugging available with either regular debugging
 358 * DEBUG_WOLFSSL or just certificate debugging: WOLFSSL_DEBUG_CERTS */
 359#if (defined(WOLFSSL_DEBUG_CERTS) || defined(DEBUG_WOLFSSL)) && \
 360    !defined(NO_WOLFSSL_DEBUG_CERTS)
 361    #include <stdarg.h> /* for var args */
 362
 363    #ifndef WOLFSSL_MSG_CERT_BUF_SZ
 364        #define WOLFSSL_MSG_CERT_BUF_SZ 140
 365    #endif
 366
 367    int WOLFSSL_MSG_CERT(const char* msg)
 368    {
 369        /* Regular debug may have been compiled out */
 370        (void)loggingEnabled;
 371
 372        if ((msg != NULL) && (loggingCertEnabled != 0)) {
 373            wolfssl_log(CERT_LOG, NULL, 0, msg);
 374        }
 375        return 0;
 376    }
 377
 378    #ifdef XVSNPRINTF
 379    #ifdef __clang__
 380    /* tell clang argument 1 is format */
 381    __attribute__((__format__ (__printf__, 1, 0)))
 382    #endif
 383    int WOLFSSL_MSG_CERT_EX(const char* fmt, ...)
 384    {
 385        /* Certificate logging output may have large messages */
 386    #ifdef WOLFSSL_SMALL_STACK
 387        char*  msg;
 388        msg = (char*)XMALLOC(WOLFSSL_MSG_CERT_BUF_SZ, NULL,
 389                             DYNAMIC_TYPE_TMP_BUFFER);
 390        if (msg == NULL) {
 391            return MEMORY_E;
 392        }
 393    #else
 394        char msg[WOLFSSL_MSG_CERT_BUF_SZ];
 395    #endif
 396        int written;
 397        va_list args;
 398        va_start(args, fmt);
 399        /* Assume zero-terminated msg, len less than WOLFSSL_MSG_CERT_BUF_SZ */
 400        written = XVSNPRINTF(msg, WOLFSSL_MSG_CERT_BUF_SZ, fmt, args);
 401        va_end(args);
 402        if ((written > 0) && (loggingCertEnabled != 0)) {
 403            wolfssl_log(INFO_LOG, NULL, 0, msg);
 404        }
 405    WC_FREE_VAR_EX(msg, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 406        return 0;
 407    } /* WOLFSSL_MSG_CERT_EX */
 408    #endif /* XVSNPRINTF */
 409
 410#else /* (!WOLFSSL_DEBUG_CERTS && !DEBUG_WOLFSSL) || NO_WOLFSSL_DEBUG_CERTS */
 411
 412    #ifdef WOLF_NO_VARIADIC_MACROS
 413        #ifdef  __WATCOMC__
 414            /* Do-nothing implementation in header for OW Open Watcom V2 */
 415        #else
 416            int WOLFSSL_MSG_CERT(const char* msg)
 417            {
 418                (void)msg;
 419                return NOT_COMPILED_IN;
 420            }
 421           int WOLFSSL_MSG_CERT_EX(const char* fmt, ...)
 422           {
 423               (void)fmt;
 424               return NOT_COMPILED_IN;
 425           }
 426        #endif
 427    #else
 428        /* using a macro, see logging.h */
 429    #endif
 430#endif /* (!WOLFSSL_DEBUG_CERTS && !DEBUG_WOLFSSL) || NO_WOLFSSL_DEBUG_CERTS */
 431
 432#if defined(XVSNPRINTF) && !defined(NO_WOLFSSL_MSG_EX)
 433#if defined(WOLFSSL_BSDKM)
 434    #include <machine/stdarg.h> /* for var args */
 435#else
 436    #include <stdarg.h> /* for var args */
 437#endif /* WOLFSSL_BSDKM */
 438
 439#ifndef WOLFSSL_MSG_EX_BUF_SZ
 440#define WOLFSSL_MSG_EX_BUF_SZ 100
 441#endif
 442
 443#if !defined(WOLFSSL_MSG_EX) && defined(DEBUG_WOLFSSL)
 444#ifdef __clang__
 445/* tell clang argument 1 is format */
 446__attribute__((__format__ (__printf__, 1, 0)))
 447#endif
 448void WOLFSSL_MSG_EX(const char* fmt, ...)
 449{
 450    if (loggingEnabled) {
 451        char msg[WOLFSSL_MSG_EX_BUF_SZ];
 452        int written;
 453        va_list args;
 454        va_start(args, fmt);
 455        written = XVSNPRINTF(msg, sizeof(msg), fmt, args);
 456        va_end(args);
 457        if (written > 0)
 458            wolfssl_log(INFO_LOG, NULL, 0, msg);
 459    }
 460}
 461#endif
 462
 463#ifdef WOLFSSL_DEBUG_CODEPOINTS
 464void WOLFSSL_MSG_EX2(const char *file, int line, const char* fmt, ...)
 465{
 466    if (loggingEnabled) {
 467        char msg[WOLFSSL_MSG_EX_BUF_SZ];
 468        int written;
 469        va_list args;
 470        va_start(args, fmt);
 471        written = XVSNPRINTF(msg, sizeof(msg), fmt, args);
 472        va_end(args);
 473        if (written > 0)
 474            wolfssl_log(INFO_LOG, file, line, msg);
 475    }
 476}
 477#endif /* WOLFSSL_DEBUG_CODEPOINTS */
 478
 479#else
 480    /* We need a do-nothing function when variadic macros not available */
 481    #ifdef WOLF_NO_VARIADIC_MACROS
 482        /* See header for same-name, do nothing functions */
 483    #else
 484        /* See header for same-name, do nothing macros */
 485    #endif
 486#endif /* XVSNPRINTF && !NO_WOLFSSL_MSG_EX */
 487
 488#ifndef WOLFSSL_MSG
 489void WOLFSSL_MSG(const char* msg)
 490{
 491    if (loggingEnabled)
 492        wolfssl_log(INFO_LOG, NULL, 0, msg);
 493}
 494#endif
 495
 496#ifdef WOLFSSL_DEBUG_CODEPOINTS
 497void WOLFSSL_MSG2(const char *file, int line, const char* msg)
 498{
 499    if (loggingEnabled)
 500        wolfssl_log(INFO_LOG, file, line, msg);
 501}
 502#endif
 503
 504#ifndef WOLFSSL_BUFFER
 505#ifndef LINE_LEN
 506#define LINE_LEN 16
 507#endif
 508void WOLFSSL_BUFFER(const byte* buffer, word32 length)
 509{
 510    int i, buflen = (int)length;
 511    char line[(LINE_LEN * 4) + 3]; /* \t00..0F | chars...chars\0 */
 512
 513    if (!loggingEnabled) {
 514        return;
 515    }
 516
 517    if (!buffer) {
 518        wolfssl_log(INFO_LOG, NULL, 0, "\tNULL");
 519        return;
 520    }
 521
 522    while (buflen > 0) {
 523        int bufidx = 0;
 524        if (XSNPRINTF(&line[bufidx], sizeof(line)-bufidx, "\t")
 525            >= (int)sizeof(line) - bufidx)
 526        {
 527            goto errout;
 528        }
 529        bufidx++;
 530
 531        for (i = 0; i < LINE_LEN; i++) {
 532            if (i < buflen) {
 533                if (XSNPRINTF(&line[bufidx], sizeof(line)-bufidx, "%02x ",
 534                              buffer[i]) >= (int)sizeof(line) - bufidx)
 535                {
 536                    goto errout;
 537                }
 538            }
 539            else {
 540                if (XSNPRINTF(&line[bufidx], sizeof(line)-bufidx, "   ")
 541                    >= (int)sizeof(line) - bufidx)
 542                {
 543                    goto errout;
 544                }
 545            }
 546            bufidx += 3;
 547        }
 548
 549        if (XSNPRINTF(&line[bufidx], sizeof(line)-bufidx, "| ")
 550            >= (int)sizeof(line) - bufidx)
 551        {
 552            goto errout;
 553        }
 554        bufidx++;
 555
 556        for (i = 0; i < LINE_LEN; i++) {
 557            if (i < buflen) {
 558                if (XSNPRINTF(&line[bufidx], sizeof(line)-bufidx,
 559                              "%c", 31 < buffer[i] && buffer[i] < 127
 560                              ? buffer[i]
 561                              : '.')
 562                    >= (int)sizeof(line) - bufidx)
 563                {
 564                    goto errout;
 565                }
 566                bufidx++;
 567            }
 568        }
 569
 570        wolfssl_log(INFO_LOG, NULL, 0, line);
 571        buffer += LINE_LEN;
 572        buflen -= LINE_LEN;
 573    }
 574
 575    return;
 576
 577errout:
 578
 579    wolfssl_log(INFO_LOG, NULL, 0, "\t[Buffer error while rendering]");
 580}
 581#endif /* WOLFSSL_BUFFER */
 582
 583#ifndef WOLFSSL_ENTER
 584void WOLFSSL_ENTER(const char* msg)
 585{
 586    if (loggingEnabled) {
 587        char buffer[WOLFSSL_MAX_ERROR_SZ];
 588        if (XSNPRINTF(buffer, sizeof(buffer), "wolfSSL Entering %s", msg)
 589            >= (int)sizeof(buffer))
 590        {
 591            buffer[sizeof(buffer) - 1] = 0;
 592        }
 593        wolfssl_log(ENTER_LOG, NULL, 0, buffer);
 594    }
 595}
 596#endif /* WOLFSSL_ENTER */
 597
 598#ifdef WOLFSSL_DEBUG_CODEPOINTS
 599void WOLFSSL_ENTER2(const char *file, int line, const char* msg)
 600{
 601    if (loggingEnabled) {
 602        char buffer[WOLFSSL_MAX_ERROR_SZ];
 603        if (XSNPRINTF(buffer, sizeof(buffer), "wolfSSL Entering %s", msg)
 604            >= (int)sizeof(buffer))
 605        {
 606            buffer[sizeof(buffer) - 1] = 0;
 607        }
 608        wolfssl_log(ENTER_LOG, file, line, buffer);
 609    }
 610}
 611#endif /* WOLFSSL_DEBUG_CODEPOINTS */
 612
 613#ifndef WOLFSSL_LEAVE
 614void WOLFSSL_LEAVE(const char* msg, int ret)
 615{
 616    if (loggingEnabled) {
 617        char buffer[WOLFSSL_MAX_ERROR_SZ];
 618        if (XSNPRINTF(buffer, sizeof(buffer), "wolfSSL Leaving %s, return %d",
 619                      msg, ret)
 620            >= (int)sizeof(buffer))
 621        {
 622            buffer[sizeof(buffer) - 1] = 0;
 623        }
 624        wolfssl_log(LEAVE_LOG, NULL, 0, buffer);
 625    }
 626}
 627#endif /* WOLFSSL_LEAVE */
 628
 629#ifdef WOLFSSL_DEBUG_CODEPOINTS
 630void WOLFSSL_LEAVE2(const char *file, int line, const char* msg, int ret)
 631{
 632    if (loggingEnabled) {
 633        char buffer[WOLFSSL_MAX_ERROR_SZ];
 634        if (XSNPRINTF(buffer, sizeof(buffer), "wolfSSL Leaving %s, return %d",
 635                      msg, ret)
 636            >= (int)sizeof(buffer))
 637        {
 638            buffer[sizeof(buffer) - 1] = 0;
 639        }
 640        wolfssl_log(LEAVE_LOG, file, line, buffer);
 641    }
 642}
 643#endif
 644
 645#ifdef WOLFSSL_DEBUG_CODEPOINTS
 646    /* restore the wrappers */
 647    #define WOLFSSL_MSG(msg) WOLFSSL_MSG2(__FILE__, __LINE__, msg)
 648    #define WOLFSSL_ENTER(msg) WOLFSSL_ENTER2(__FILE__, __LINE__, msg)
 649    #define WOLFSSL_LEAVE(msg, ret) WOLFSSL_LEAVE2(__FILE__, __LINE__, msg, ret)
 650    #ifdef XVSNPRINTF
 651/*        #define WOLFSSL_MSG_EX(fmt, args...) \
 652                WOLFSSL_MSG_EX2(__FILE__, __LINE__, fmt, ## args)
 653    */
 654    #endif
 655#endif
 656
 657#ifndef WOLFSSL_IS_DEBUG_ON
 658int WOLFSSL_IS_DEBUG_ON(void)
 659{
 660    return loggingEnabled;
 661}
 662#endif /* WOLFSSL_IS_DEBUG_ON */
 663#endif /* !WOLFSSL_DEBUG_ERRORS_ONLY */
 664
 665#else
 666    /* !(DEBUG_WOLFSSL || (WOLFSSL_DEBUG_CERTS && !NO_WOLFSSL_DEBUG_CERTS)) */
 667    /*
 668     * Create some no-op functions for compilers without variadic macros,
 669     * other than Open Watcom V2.
 670     */
 671    #ifdef WOLF_NO_VARIADIC_MACROS
 672        /* no debug and cannot use variadic macros */
 673        #ifdef __WATCOMC__
 674            /* see logging.h for no-op Watcom implementation */
 675        #else
 676            int WOLFSSL_MSG_CERT(const char* msg)
 677            {
 678                (void)msg;
 679                return NOT_COMPILED_IN;
 680            }
 681
 682            int WOLFSSL_MSG_CERT_EX(const char* fmt, ...)
 683            {
 684                (void)fmt;
 685                return NOT_COMPILED_IN;
 686            }
 687        #endif
 688    #else
 689        /* see logging.h for variadic macros */
 690    #endif
 691#endif /* DEBUG_WOLFSSL || (WOLFSSL_DEBUG_CERTS && !NO_WOLFSSL_DEBUG_CERTS) */
 692
 693/* Final catch for no-op WOLFSSL_MSG_EX needing implementation */
 694#ifdef __WATCOMC__
 695    /* See no-op implementation as needed in logging.h */
 696#else
 697    #ifdef DEBUG_WOLFSSL
 698        /* The empty no-op function is not needed when debugging */
 699    #else
 700        #if defined(HAVE_WOLFSSL_MSG_EX) || defined(WOLF_NO_VARIADIC_MACROS)
 701            void WOLFSSL_MSG_EX(const char* fmt, ...)
 702            {
 703                (void)fmt;
 704            }
 705        #else
 706            /* See macro in header */
 707        #endif
 708    #endif
 709#endif
 710
 711
 712
 713#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE) || defined(HAVE_MEMCACHED)
 714
 715#ifdef WOLFSSL_HAVE_ERROR_QUEUE
 716
 717#ifdef ERROR_QUEUE_PER_THREAD
 718/* Keep the error queue in thread-local-storage. The only ways this
 719 * API can deliver meaningful semantics in a multi-threaded setup.
 720 */
 721#ifndef ERROR_QUEUE_MAX
 722/* Same as OpenSSL v1.1.x limit, note that this is per thread */
 723#define ERROR_QUEUE_MAX 16
 724#endif
 725
 726struct wc_error_entry {
 727    char   reason[WOLFSSL_MAX_ERROR_SZ];
 728    char   file[WOLFSSL_MAX_ERROR_SZ];
 729    int    line;
 730    int    err;
 731};
 732
 733struct wc_error_queue {
 734    struct wc_error_entry entries[ERROR_QUEUE_MAX];
 735    size_t head_idx;
 736    size_t count;
 737};
 738
 739/* The complete queue in a thread local without allocations */
 740static THREAD_LS_T struct wc_error_queue wc_errors;
 741
 742/* Using thread-local-storage, we do not need a mutex. */
 743#define ERRQ_LOCK()            0
 744#define ERRQ_UNLOCK()          (void)0
 745
 746/**
 747 * Given a relative index (from head of the error list), return
 748 * the absolute index in the `wc_errors->entries` array for
 749 * the entry or -1 if no such entry exists/is present.
 750 */
 751static int get_abs_idx(int relative_idx)
 752{
 753    if ((wc_errors.count == 0) || (relative_idx >= (int)wc_errors.count)) {
 754        return -1;
 755    }
 756    if (relative_idx < 0) {
 757        return (int)((wc_errors.head_idx + wc_errors.count - 1)
 758                      % ERROR_QUEUE_MAX);
 759    }
 760    return (int)((wc_errors.head_idx + (size_t)relative_idx) % ERROR_QUEUE_MAX);
 761}
 762
 763/**
 764 * Return the error entry at the given relative index, if
 765 * it exists, e.g. `relative_idx` is in a valid range.
 766 */
 767static struct wc_error_entry *get_entry(int relative_idx)
 768{
 769    int abs_idx;
 770
 771    abs_idx = get_abs_idx(relative_idx);
 772    if (abs_idx < 0) {
 773        return NULL;
 774    }
 775    return &wc_errors.entries[abs_idx];
 776}
 777
 778/**
 779 * Return the error code in the given error `entry` and populate
 780 * `file`, `reason` and `line` with its values.
 781 * `entry` may be NULL, in which case BAD_STATE_E is returned.
 782 */
 783static int pass_entry(struct wc_error_entry *entry,
 784                      const char **file, const char **reason,
 785                      int *line)
 786{
 787    if (entry == NULL) {
 788        WOLFSSL_MSG("No Error found in queue");
 789        return BAD_STATE_E;
 790    }
 791    if (file != NULL) {
 792        *file = entry->file;
 793    }
 794    if (reason != NULL) {
 795        *reason = entry->reason;
 796    }
 797    if (line != NULL) {
 798        *line = entry->line;
 799    }
 800    return entry->err;
 801}
 802
 803/**
 804 * Assign entry with values, resets all previously present values.
 805 */
 806static void set_entry(struct wc_error_entry *entry, int error,
 807                      const char *file, const char *reason, int line)
 808{
 809    size_t sz;
 810
 811    XMEMSET(entry, 0, sizeof(struct wc_error_entry));
 812    entry->err = error;
 813
 814    entry->line  = line;
 815    sz = XSTRLEN(reason);
 816    if (sz > WOLFSSL_MAX_ERROR_SZ - 1) {
 817        sz = WOLFSSL_MAX_ERROR_SZ - 1;
 818    }
 819    if (sz > 0) {
 820        XMEMCPY(entry->reason, reason, sz);
 821        entry->reason[WOLFSSL_MAX_ERROR_SZ - 1] = '\0';
 822    }
 823
 824    sz = XSTRLEN(file);
 825    if (sz > WOLFSSL_MAX_ERROR_SZ - 1) {
 826        sz = WOLFSSL_MAX_ERROR_SZ - 1;
 827    }
 828    if (sz > 0) {
 829        XMEMCPY(entry->file, file, sz);
 830        entry->file[WOLFSSL_MAX_ERROR_SZ - 1]  = '\0';
 831    }
 832}
 833
 834/* Internal function that is called by wolfCrypt_Init() */
 835int wc_LoggingInit(void)
 836{
 837    return 0;
 838}
 839
 840/* internal function that is called by wolfCrypt_Cleanup */
 841int wc_LoggingCleanup(void)
 842{
 843    /* clear logging entries */
 844    wc_ClearErrorNodes();
 845    return 0;
 846}
 847
 848/**
 849 * Get the values from the HEAD of the ERR queue, but keep it in place.
 850 * If the queue is empty, return BAD_STATE_E.
 851 */
 852int wc_PeekErrorNode(int idx, const char **file, const char **reason,
 853                     int *line)
 854{
 855    return pass_entry(get_entry(idx), file, reason, line);
 856}
 857
 858/**
 859 * Get the values from the HEAD of the ERR queue and remove it.
 860 * If the queue is empty, return BAD_STATE_E.
 861 */
 862int wc_PullErrorNode(const char **file, const char **reason, int *line)
 863{
 864    struct wc_error_entry *entry;
 865    int ret;
 866
 867    entry = get_entry(0);
 868    ret = pass_entry(entry, file, reason, line);
 869
 870    if (entry != NULL) {
 871      wc_RemoveErrorNode(0);
 872    }
 873    return ret;
 874}
 875
 876/* create new error node and add it to the queue
 877 * buffers are assumed to be of size WOLFSSL_MAX_ERROR_SZ for this internal
 878 * function. */
 879int wc_AddErrorNode(int error, int line, char* reason, char* file)
 880{
 881    struct wc_error_entry *entry;
 882    size_t idx;
 883
 884    if (wc_errors.count >= ERROR_QUEUE_MAX) {
 885        WOLFSSL_MSG("Error queue is full, at ERROR_QUEUE_MAX");
 886        return MEMORY_E;
 887    }
 888
 889    idx = (wc_errors.head_idx + wc_errors.count) % ERROR_QUEUE_MAX;
 890    entry = &wc_errors.entries[idx];
 891    set_entry(entry, error, file, reason, line);
 892    ++wc_errors.count;
 893
 894    return 0;
 895}
 896
 897/**
 898 * Remove the entry at relative position `relative_idx` from the ERR queue.
 899 * For `relative_idx == 0` it removes the queue's head entry, for -1
 900 * it removes the last entry in the queue.
 901 */
 902void wc_RemoveErrorNode(int relative_idx)
 903{
 904    int abs_idx = get_abs_idx(relative_idx);
 905
 906    if (abs_idx >= 0) {
 907        size_t move_count;
 908        if (abs_idx >= (int)wc_errors.head_idx) {
 909            /* removed entry sits "above" head (or is head),
 910             * move entries below it "up" */
 911            move_count = (size_t)abs_idx - wc_errors.head_idx;
 912            if (move_count > 0) {
 913                XMEMMOVE(&wc_errors.entries[wc_errors.head_idx + 1],
 914                         &wc_errors.entries[wc_errors.head_idx],
 915                         sizeof(wc_errors.entries[0]) * move_count);
 916            }
 917            wc_errors.head_idx = (wc_errors.head_idx + 1) % ERROR_QUEUE_MAX;
 918            --wc_errors.count;
 919        }
 920        else {
 921            /* removed entry sits "below" head (wrap around),
 922             * move entries above it "down" */
 923            int last_idx = get_abs_idx(-1);
 924            if (last_idx >= abs_idx) {  /* this SHOULD always be true */
 925                move_count = (size_t)(last_idx - abs_idx);
 926                if (move_count > 0) {
 927                    XMEMMOVE(&wc_errors.entries[abs_idx],
 928                             &wc_errors.entries[abs_idx + 1],
 929                             sizeof(wc_errors.entries[0]) * move_count);
 930                }
 931                --wc_errors.count;
 932            }
 933        }
 934    }
 935}
 936
 937/**
 938 * Clear the ERR queue.
 939 */
 940void wc_ClearErrorNodes(void)
 941{
 942    if (wc_errors.count > 0) {
 943        XMEMSET(&wc_errors, 0, sizeof(wc_errors));
 944    }
 945}
 946
 947int wc_SetLoggingHeap(void* h)
 948{
 949    (void)h;
 950    return 0;
 951}
 952
 953int wc_ERR_remove_state(void)
 954{
 955    wc_ClearErrorNodes();
 956    return 0;
 957}
 958
 959/**
 960 * Get the first entry's values in the ERR queue that is not filtered
 961 * by the provided `ignore_err` callback. All ignored entries are removed,
 962 * making the returned entry the head of the ERR queue afterwards.
 963 *
 964 * In case all entries are ignored, the ERR queue will be empty afterwards.
 965 * For an empty ERR queue  0 is returned.
 966 *
 967 * `ignore_err` may be NULL, in which case this returns the HEAD values.
 968 *
 969 * `flags` is present for OpenSSL compatibility, but will always be
 970 * set to 0, since we do not keep flags at ERR entries.
 971 */
 972unsigned long wc_PeekErrorNodeLineData(const char **file, int *line,
 973                                       const char **data, int *flags,
 974                                       int (*ignore_err)(int err))
 975{
 976    WOLFSSL_ENTER("wc_PeekErrorNodeLineData");
 977
 978    /* No data or flags stored - error display only in Nginx. */
 979    if (data != NULL) {
 980        *data = "";
 981    }
 982    if (flags != NULL) {
 983        *flags = 0;
 984    }
 985
 986    while (1) {
 987        int ret = wc_PeekErrorNode(0, file, NULL, line);
 988        if (ret == WC_NO_ERR_TRACE(BAD_STATE_E)) {
 989            WOLFSSL_MSG("Issue peeking at error node in queue");
 990            return 0;
 991        }
 992        /* OpenSSL uses positive error codes */
 993        if (ret < 0) {
 994            ret = -ret;
 995        }
 996        /* an error that the caller wants to ignore? */
 997        if (ignore_err && ignore_err(ret)) {
 998          wc_RemoveErrorNode(0);
 999          continue;
1000        }
1001
1002        return (unsigned long)ret;
1003    }
1004}
1005
1006/**
1007 * Get the error value at the HEAD of the ERR queue or 0 if the queue
1008 * is empty. The HEAD entry is removed by this call.
1009 */
1010int wc_GetErrorNodeErr(void)
1011{
1012    int ret;
1013
1014    WOLFSSL_ENTER("wc_GetErrorNodeErr");
1015
1016    ret = wc_PullErrorNode(NULL, NULL, NULL);
1017    if (ret < 0) {
1018        if (ret == WC_NO_ERR_TRACE(BAD_STATE_E)) {
1019            ret = 0; /* no errors in queue */
1020        }
1021        else {
1022            WOLFSSL_MSG("Error with pulling error node!");
1023            WOLFSSL_LEAVE("wolfSSL_ERR_get_error", ret);
1024            ret = 0 - ret; /* return absolute value of error */
1025            /* panic and try to clear out nodes */
1026            wc_ClearErrorNodes();
1027        }
1028    }
1029    return ret;
1030}
1031
1032#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
1033/* This callback allows the application to provide a custom error printing
1034 * function. */
1035void wc_ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
1036                            void *u)
1037{
1038    size_t i;
1039
1040    WOLFSSL_ENTER("wc_ERR_print_errors_cb");
1041
1042    if (cb == NULL) {
1043        /* Invalid param */
1044        return;
1045    }
1046
1047    for (i = 0; i < wc_errors.count; ++i) {
1048        struct wc_error_entry *entry = get_entry((int)i);
1049        if (entry == NULL)
1050            break;
1051        cb(entry->reason, XSTRLEN(entry->reason), u);
1052    }
1053
1054    wc_ClearErrorNodes();
1055}
1056#endif /* !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) */
1057
1058#else /* ERROR_QUEUE_PER_THREAD */
1059/* Error queue is a global list. This is the original implementation and
1060 * the fallback on platforms that do not have thread-local-storage.
1061 *
1062 * Access and manipulations of the list are protected by a mutex, however
1063 * that does not prevent errors from another thread showing up. Therefore,
1064 * its usefulness  is limited to applications with restricted thread
1065 * concurrency in using wolfSSL.
1066 */
1067#ifndef ERROR_QUEUE_MAX
1068/* With a global list, we allow a higher limit. */
1069#define ERROR_QUEUE_MAX 100
1070#endif
1071
1072/* The information we keep about a single error */
1073struct wc_error_queue {
1074    void*  heap; /* the heap hint used with nodes creation */
1075    struct wc_error_queue* next;
1076    struct wc_error_queue* prev;
1077    char   error[WOLFSSL_MAX_ERROR_SZ];
1078    char   file[WOLFSSL_MAX_ERROR_SZ];
1079    int    value;
1080    int    line;
1081};
1082
1083/* The global list of errors encountered */
1084static struct wc_error_queue* wc_errors;
1085static int wc_errors_count = 0;
1086/* pointer to last node in queue to make insertion O(1) */
1087static struct wc_error_queue* wc_last_node;
1088/* The 'current' cursor the application is using to access the list */
1089static struct wc_error_queue* wc_current_node;
1090
1091/* heap info currently used for allocation of entries */
1092static void* wc_error_heap;
1093
1094/* mutex for list operation protection */
1095static wolfSSL_Mutex wc_error_mutex WOLFSSL_MUTEX_INITIALIZER_CLAUSE(wc_error_mutex);
1096#define ERRQ_MUTEX_INIT()      wc_InitMutex(&wc_error_mutex)
1097#define ERRQ_MUTEX_FREE()      wc_FreeMutex(&wc_error_mutex)
1098#define ERRQ_LOCK()            wc_LockMutex(&wc_error_mutex)
1099#define ERRQ_UNLOCK()          wc_UnLockMutex(&wc_error_mutex)
1100
1101/* Internal function that is called by wolfCrypt_Init() */
1102int wc_LoggingInit(void)
1103{
1104#ifndef WOLFSSL_MUTEX_INITIALIZER
1105    if (ERRQ_MUTEX_INIT() != 0) {
1106        WOLFSSL_MSG("Bad Init Mutex");
1107        return BAD_MUTEX_E;
1108    }
1109#endif
1110    wc_errors_count = 0;
1111    wc_errors          = NULL;
1112    wc_current_node    = NULL;
1113    wc_last_node       = NULL;
1114    return 0;
1115}
1116
1117
1118/* internal function that is called by wolfCrypt_Cleanup */
1119int wc_LoggingCleanup(void)
1120{
1121    /* clear logging entries */
1122    wc_ClearErrorNodes();
1123    /* free mutex */
1124#ifndef WOLFSSL_MUTEX_INITIALIZER
1125    if (ERRQ_MUTEX_FREE() != 0) {
1126        WOLFSSL_MSG("Bad Mutex free");
1127        return BAD_MUTEX_E;
1128    }
1129#endif
1130    return 0;
1131}
1132
1133static int peekErrorNode(int idx, const char **file, const char **reason,
1134        int *line)
1135{
1136    struct wc_error_queue* err;
1137
1138    if (idx < 0) {
1139        err = wc_last_node;
1140    }
1141    else {
1142        int i;
1143
1144        err = (struct wc_error_queue*)wc_errors;
1145        for (i = 0; i < idx; i++) {
1146            if (err == NULL) {
1147                WOLFSSL_MSG("Error node not found. Bad index?");
1148                return BAD_FUNC_ARG;
1149            }
1150            err = err->next;
1151        }
1152    }
1153
1154    if (err == NULL) {
1155        WOLFSSL_MSG("No Errors in queue");
1156        return BAD_STATE_E;
1157    }
1158
1159    if (file != NULL) {
1160        *file = err->file;
1161    }
1162    if (reason != NULL) {
1163        *reason = err->error;
1164    }
1165    if (line != NULL) {
1166        *line = err->line;
1167    }
1168
1169    return err->value;
1170}
1171
1172/* peek at an error node
1173 *
1174 * idx : if -1 then the most recent node is looked at,
1175 *       otherwise search through queue for node at the given index starting
1176 *          from the absolute head wc_errors
1177 * file  : pointer to internal file string
1178 * reason : pointer to internal error reason
1179 * line  : line number that error happened at
1180 *
1181 * Returns a negative value in error case, on success returns the nodes error
1182 * value which is positive (absolute value)
1183 */
1184int wc_PeekErrorNode(int idx, const char **file, const char **reason,
1185        int *line)
1186{
1187    int ret;
1188
1189    if (ERRQ_LOCK() != 0) {
1190        WOLFSSL_MSG("Lock debug mutex failed");
1191        return BAD_MUTEX_E;
1192    }
1193    ret = peekErrorNode(idx, file, reason, line);
1194    ERRQ_UNLOCK();
1195    return ret;
1196}
1197
1198static int pullErrorNode(const char **file, const char **reason, int *line)
1199{
1200    struct wc_error_queue* err;
1201    int value;
1202
1203    err = wc_current_node;
1204    if (err == NULL) {
1205        WOLFSSL_MSG("No Errors in queue");
1206        return BAD_STATE_E;
1207    }
1208
1209    if (file != NULL) {
1210        *file = err->file;
1211    }
1212    if (reason != NULL) {
1213        *reason = err->error;
1214    }
1215    if (line != NULL) {
1216        *line = err->line;
1217    }
1218    value = err->value;
1219    wc_current_node = err->next;
1220
1221    return value;
1222}
1223
1224/* Pulls the current node from error queue and increments current state.
1225 * Note: this does not delete nodes because input arguments are pointing to
1226 *       node buffers.
1227 *
1228 * file   pointer to file that error was in. Can be NULL to return no file.
1229 * reason error string giving reason for error. Can be NULL to return no reason.
1230 * line   return line number of where error happened.
1231 *
1232 * returns the error value on success and BAD_MUTEX_E or BAD_STATE_E on failure
1233 */
1234int wc_PullErrorNode(const char **file, const char **reason, int *line)
1235{
1236    int value;
1237
1238    if (ERRQ_LOCK() != 0) {
1239        WOLFSSL_MSG("Lock debug mutex failed");
1240        return BAD_MUTEX_E;
1241    }
1242
1243    value = pullErrorNode(file, reason, line);
1244
1245    ERRQ_UNLOCK();
1246    return value;
1247}
1248
1249/* create new error node and add it to the queue
1250 * buffers are assumed to be of size WOLFSSL_MAX_ERROR_SZ for this internal
1251 * function. */
1252int wc_AddErrorNode(int error, int line, char* buf, char* file)
1253{
1254    struct wc_error_queue* err;
1255
1256    if (wc_errors_count >= ERROR_QUEUE_MAX) {
1257        WOLFSSL_MSG("Error queue is full, at ERROR_QUEUE_MAX");
1258        return MEMORY_E;
1259    }
1260
1261    err = (struct wc_error_queue*)XMALLOC(
1262            sizeof(struct wc_error_queue), wc_error_heap, DYNAMIC_TYPE_LOG);
1263    if (err == NULL) {
1264        WOLFSSL_MSG("Unable to create error node for log");
1265        return MEMORY_E;
1266    }
1267    else {
1268        int sz;
1269
1270        XMEMSET(err, 0, sizeof(struct wc_error_queue));
1271        err->heap = wc_error_heap;
1272        sz = (int)XSTRLEN(buf);
1273        if (sz > WOLFSSL_MAX_ERROR_SZ - 1) {
1274            sz = WOLFSSL_MAX_ERROR_SZ - 1;
1275        }
1276        if (sz > 0) {
1277            XMEMCPY(err->error, buf, (size_t)sz);
1278        }
1279
1280        sz = (int)XSTRLEN(file);
1281        if (sz > WOLFSSL_MAX_ERROR_SZ - 1) {
1282            sz = WOLFSSL_MAX_ERROR_SZ - 1;
1283        }
1284        if (sz > 0) {
1285            XMEMCPY(err->file, file, (size_t)sz);
1286        }
1287
1288        err->value = error;
1289        err->line  = line;
1290
1291        /* make sure is terminated */
1292        err->error[WOLFSSL_MAX_ERROR_SZ - 1] = '\0';
1293        err->file[WOLFSSL_MAX_ERROR_SZ - 1]  = '\0';
1294
1295
1296        /* since is queue place new node at last of the list */
1297        if (wc_last_node == NULL) {
1298            /* case of first node added to queue */
1299            if (wc_errors != NULL) {
1300                /* check for unexpected case before over writing wc_errors */
1301                WOLFSSL_MSG("ERROR in adding new node to logging queue!!");
1302                /* In the event both wc_last_node and wc_errors are NULL, err
1303                 * goes unassigned to external wc_errors, wc_last_node. Free
1304                 * err in this instance since wc_ClearErrorNodes will not
1305                 */
1306                XFREE(err, wc_error_heap, DYNAMIC_TYPE_LOG);
1307            }
1308            else {
1309                wc_errors    = err;
1310                wc_last_node = err;
1311                wc_current_node = err;
1312            }
1313        }
1314        else {
1315            wc_last_node->next = err;
1316            err->prev = wc_last_node;
1317            wc_last_node = err;
1318
1319            /* check the case where have read to the end of the queue and the
1320             * current node to read needs updated */
1321            if (wc_current_node == NULL) {
1322                wc_current_node = err;
1323            }
1324        }
1325        wc_errors_count++;
1326    }
1327    return 0;
1328}
1329
1330/* returns the current index into the queue, which is the node that
1331 * wc_current_node is pointing to. It can be greater than zero in cases
1332 * where wc_PullErrorNode() has been called without the node having been
1333 * removed. */
1334static int getErrorNodeCurrentIdx(void)
1335{
1336    int ret = 0;
1337    struct wc_error_queue* current;
1338
1339    current = (struct wc_error_queue*)wc_errors;
1340    while (current != wc_current_node && current != NULL) {
1341        current = current->next;
1342        ret++;
1343    }
1344
1345    /* wc_current_node was not found in the list! use index 0 */
1346    if (current == NULL) {
1347        ret = 0;
1348    }
1349    return ret;
1350}
1351
1352static void removeErrorNode(int idx)
1353{
1354    struct wc_error_queue* current;
1355
1356    if (idx == -1) {
1357        current = wc_last_node;
1358    }
1359    else {
1360        current = (struct wc_error_queue*)wc_errors;
1361        for (; current != NULL && idx > 0; idx--)
1362             current = current->next;
1363    }
1364    if (current != NULL) {
1365        if (current->prev != NULL)
1366            current->prev->next = current->next;
1367        if (current->next != NULL)
1368            current->next->prev = current->prev;
1369        if (wc_last_node == current)
1370            wc_last_node = current->prev;
1371        if (wc_errors == current)
1372            wc_errors = current->next;
1373        if (wc_current_node == current)
1374            wc_current_node = current->next;
1375        XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
1376        wc_errors_count--;
1377
1378        /* last node left in list was free'd, reset list head */
1379        if (wc_errors_count == 0) {
1380            wc_errors       = NULL;
1381            wc_last_node    = NULL;
1382            wc_current_node = NULL;
1383        }
1384    }
1385}
1386
1387/* Removes the error node at the specified index.
1388 * idx : if -1 then the most recent node is looked at,
1389 *       otherwise search through queue for node at the given index starting
1390 *          from the absolute head wc_errors
1391 */
1392void wc_RemoveErrorNode(int idx)
1393{
1394    if (ERRQ_LOCK() != 0) {
1395        WOLFSSL_MSG("Lock debug mutex failed");
1396        return;
1397    }
1398
1399    removeErrorNode(idx);
1400
1401    ERRQ_UNLOCK();
1402}
1403
1404static void clearErrorNodes(void)
1405{
1406    struct wc_error_queue* current;
1407    struct wc_error_queue* next;
1408    /* free all nodes from error queue (even previously 'pulled' ones) starting
1409     * at the lists absolute head of wc_errors */
1410
1411    current = (struct wc_error_queue*)wc_errors;
1412    while (current != NULL) {
1413        next = current->next;
1414        XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
1415        current = next;
1416    }
1417
1418    wc_errors_count = 0;
1419    wc_errors       = NULL;
1420    wc_last_node    = NULL;
1421    wc_current_node = NULL;
1422}
1423
1424/* Clears out the list of error nodes.
1425 */
1426void wc_ClearErrorNodes(void)
1427{
1428    if (ERRQ_LOCK() != 0) {
1429        WOLFSSL_MSG("Lock debug mutex failed");
1430        return;
1431    }
1432
1433    clearErrorNodes();
1434
1435    ERRQ_UNLOCK();
1436}
1437
1438int wc_SetLoggingHeap(void* h)
1439{
1440    if (ERRQ_LOCK() != 0) {
1441        WOLFSSL_MSG("Lock debug mutex failed");
1442        return BAD_MUTEX_E;
1443    }
1444    wc_error_heap = h;
1445    ERRQ_UNLOCK();
1446    return 0;
1447}
1448
1449/* frees all nodes in the queue
1450 *
1451 * id  this is the thread id
1452 */
1453int wc_ERR_remove_state(void)
1454{
1455    struct wc_error_queue* current;
1456    struct wc_error_queue* next;
1457
1458    if (ERRQ_LOCK() != 0) {
1459        WOLFSSL_MSG("Lock debug mutex failed");
1460        return BAD_MUTEX_E;
1461    }
1462
1463    /* free all nodes from error queue */
1464    current = (struct wc_error_queue*)wc_errors;
1465    while (current != NULL) {
1466        next = current->next;
1467        XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
1468        current = next;
1469    }
1470
1471    wc_errors_count = 0;
1472    wc_errors          = NULL;
1473    wc_last_node       = NULL;
1474
1475    ERRQ_UNLOCK();
1476
1477    return 0;
1478}
1479
1480unsigned long wc_PeekErrorNodeLineData(const char **file, int *line,
1481                                       const char **data, int *flags,
1482                                       int (*ignore_err)(int err))
1483{
1484    int idx;
1485
1486    WOLFSSL_ENTER("wc_PeekErrorNodeLineData");
1487
1488/* No data or flags stored - error display only in Nginx. */
1489    if (data != NULL) {
1490        *data = "";
1491    }
1492    if (flags != NULL) {
1493        *flags = 0;
1494    }
1495
1496    if (ERRQ_LOCK() != 0) {
1497        WOLFSSL_MSG("Lock debug mutex failed");
1498        return (unsigned long)(0 - BAD_MUTEX_E);
1499    }
1500
1501    idx = getErrorNodeCurrentIdx();
1502    while (1) {
1503        int ret = peekErrorNode(idx, file, NULL, line);
1504        if (ret == WC_NO_ERR_TRACE(BAD_MUTEX_E) ||
1505            ret == WC_NO_ERR_TRACE(BAD_FUNC_ARG) ||
1506            ret == WC_NO_ERR_TRACE(BAD_STATE_E)) {
1507            ERRQ_UNLOCK();
1508            WOLFSSL_MSG("Issue peeking at error node in queue");
1509            return 0;
1510        }
1511        /* OpenSSL uses positive error codes */
1512        if (ret < 0) {
1513            ret = -ret;
1514        }
1515
1516        if (ignore_err && ignore_err(ret)) {
1517          removeErrorNode(idx);
1518          continue;
1519        }
1520
1521        ERRQ_UNLOCK();
1522        return (unsigned long)ret;
1523    }
1524}
1525
1526int wc_GetErrorNodeErr(void)
1527{
1528    int ret;
1529
1530    WOLFSSL_ENTER("wc_GetErrorNodeErr");
1531
1532    if (ERRQ_LOCK() != 0) {
1533        WOLFSSL_MSG("Lock debug mutex failed");
1534        return (0 - BAD_MUTEX_E);
1535    }
1536
1537    ret = pullErrorNode(NULL, NULL, NULL);
1538    if (ret < 0) {
1539        if (ret == WC_NO_ERR_TRACE(BAD_STATE_E)) {
1540            ret = 0; /* no errors in queue */
1541        }
1542        else {
1543            WOLFSSL_MSG("Error with pulling error node!");
1544            WOLFSSL_LEAVE("wolfSSL_ERR_get_error", ret);
1545            ret = 0 - ret; /* return absolute value of error */
1546            /* panic and try to clear out nodes */
1547            clearErrorNodes();
1548        }
1549    }
1550    else {
1551        int idx = getErrorNodeCurrentIdx();
1552        if (idx < 0) {
1553            WOLFSSL_MSG("Error with getting current index!");
1554            ret = BAD_STATE_E;
1555            WOLFSSL_LEAVE("wolfSSL_ERR_get_error", ret);
1556
1557            /* panic and try to clear out nodes and reset queue state */
1558            clearErrorNodes();
1559        }
1560        else if (idx > 0) {
1561            idx -= 1;
1562            removeErrorNode(idx);
1563        }
1564        else {
1565            /* if current idx is 0 then the queue only had one node */
1566            removeErrorNode(idx);
1567        }
1568    }
1569
1570    ERRQ_UNLOCK();
1571    return ret;
1572}
1573
1574#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
1575/* This callback allows the application to provide a custom error printing
1576 * function. */
1577void wc_ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
1578                            void *u)
1579{
1580    WOLFSSL_ENTER("wc_ERR_print_errors_cb");
1581
1582    if (cb == NULL) {
1583        /* Invalid param */
1584        return;
1585    }
1586
1587    if (ERRQ_LOCK() != 0) {
1588        WOLFSSL_MSG("Lock debug mutex failed");
1589    }
1590    else {
1591        /* free all nodes from error queue and print them to file */
1592        struct wc_error_queue *current;
1593        struct wc_error_queue *next;
1594
1595        current = (struct wc_error_queue *)wc_errors;
1596        while (current != NULL)
1597        {
1598            next = current->next;
1599            cb(current->error, XSTRLEN(current->error), u);
1600            XFREE(current, current->heap, DYNAMIC_TYPE_LOG);
1601            current = next;
1602        }
1603
1604        /* set global pointers to match having been freed */
1605        wc_errors_count = 0;
1606        wc_errors = NULL;
1607        wc_last_node = NULL;
1608
1609        ERRQ_UNLOCK();
1610    }
1611}
1612#endif /* !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) */
1613
1614#endif /* !ERROR_QUEUE_PER_THREAD */
1615
1616#else  /* WOLFSSL_HAVE_ERROR_QUEUE */
1617/* NO ERROR_QUEUE at all */
1618
1619int wc_LoggingInit(void)
1620{
1621    return 0;
1622}
1623
1624
1625/* internal function that is called by wolfCrypt_Cleanup */
1626int wc_LoggingCleanup(void)
1627{
1628    return 0;
1629}
1630
1631int wc_PeekErrorNode(int idx, const char **file, const char **reason,
1632        int *line)
1633{
1634    (void)idx;
1635    (void)file;
1636    (void)reason;
1637    (void)line;
1638    WOLFSSL_MSG("Error queue turned off, can not peak nodes");
1639    return NOT_COMPILED_IN;
1640}
1641
1642int wc_PullErrorNode(const char **file, const char **reason, int *line)
1643{
1644    (void)file;
1645    (void)reason;
1646    (void)line;
1647    WOLFSSL_MSG("Error queue turned off, can not pull nodes");
1648    return NOT_COMPILED_IN;
1649}
1650
1651int wc_AddErrorNode(int error, int line, char* buf, char* file)
1652{
1653    (void)error;
1654    (void)line;
1655    (void)buf;
1656    (void)file;
1657    WOLFSSL_MSG("Error queue turned off, can not add nodes");
1658    return NOT_COMPILED_IN;
1659}
1660
1661void wc_RemoveErrorNode(int idx)
1662{
1663    (void)idx;
1664    WOLFSSL_MSG("Error queue turned off, can not remove nodes");
1665}
1666
1667void wc_ClearErrorNodes(void)
1668{
1669    WOLFSSL_MSG("Error queue turned off, can not clear nodes");
1670}
1671
1672int wc_SetLoggingHeap(void* h)
1673{
1674    (void)h;
1675    return 0;
1676}
1677
1678int wc_ERR_remove_state(void)
1679{
1680    return 0;
1681}
1682
1683unsigned long wc_PeekErrorNodeLineData(const char **file, int *line,
1684                                       const char **data, int *flags,
1685                                       int (*ignore_err)(int err))
1686{
1687    WOLFSSL_ENTER("wc_PeekErrorNodeLineData");
1688
1689    (void)line;
1690    (void)file;
1691    (void)ignore_err;
1692    if (data != NULL) {
1693        *data = "";
1694    }
1695    if (flags != NULL) {
1696        *flags = 0;
1697    }
1698    return (unsigned long)(0 - NOT_COMPILED_IN);
1699}
1700
1701int wc_GetErrorNodeErr(void)
1702{
1703    WOLFSSL_ENTER("wc_GetErrorNodeErr");
1704    return (0 - NOT_COMPILED_IN);
1705}
1706
1707#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
1708void wc_ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
1709                            void *u)
1710{
1711    WOLFSSL_ENTER("wc_ERR_print_errors_cb");
1712    (void)cb;
1713    (void)u;
1714}
1715#endif /* !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) */
1716
1717#endif /* !WOLFSSL_HAVE_ERROR_QUEUE */
1718
1719#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
1720/* empties out the error queue into the file */
1721static int wc_ERR_dump_to_file (const char *str, size_t len, void *u)
1722{
1723    XFILE fp = (XFILE ) u;
1724    if (fprintf(fp, "%-*.*s\n", (int)len, (int)len, str) < 0)
1725        return IO_FAILED_E;
1726    return 0;
1727}
1728
1729void wc_ERR_print_errors_fp(XFILE fp)
1730{
1731    WOLFSSL_ENTER("wc_ERR_print_errors_fp");
1732
1733    /* Send all errors to the wc_ERR_dump_to_file function */
1734    wc_ERR_print_errors_cb(wc_ERR_dump_to_file, fp);
1735}
1736
1737#endif /* !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) */
1738
1739#endif /* defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
1740          || defined(HAVE_MEMCACHED) */
1741
1742/*
1743 * When using OPENSSL_EXTRA or DEBUG_WOLFSSL_VERBOSE macro then WOLFSSL_ERROR is
1744 * mapped to new function WOLFSSL_ERROR_LINE which gets the line # and function
1745 * name where WOLFSSL_ERROR is called at.
1746 */
1747#if defined(DEBUG_WOLFSSL) || defined(OPENSSL_ALL) || \
1748    defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) || \
1749    defined(OPENSSL_EXTRA)
1750
1751#ifdef WOLFSSL_HAVE_ERROR_QUEUE
1752void WOLFSSL_ERROR_LINE(int error, const char* func, unsigned int line,
1753        const char* file, void* usrCtx)
1754#else
1755void WOLFSSL_ERROR(int error)
1756#endif
1757{
1758#ifdef WOLFSSL_ASYNC_CRYPT
1759    if (error != WC_NO_ERR_TRACE(WC_PENDING_E))
1760#endif
1761    {
1762        char buffer[WOLFSSL_MAX_ERROR_SZ];
1763
1764    #ifdef WOLFSSL_HAVE_ERROR_QUEUE
1765        (void)usrCtx; /* a user ctx for future flexibility */
1766        (void)func;
1767
1768        if (ERRQ_LOCK() != 0) {
1769            WOLFSSL_MSG("Lock debug mutex failed");
1770            (void)XSNPRINTF(buffer, sizeof(buffer),
1771                    "wolfSSL error occurred, error = %d", error);
1772        }
1773        else {
1774            #if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY)
1775            /* If running in compatibility mode do not add want read and
1776               want right to error queue */
1777            if (error != WC_NO_ERR_TRACE(WANT_READ) &&
1778                error != WC_NO_ERR_TRACE(WANT_WRITE)) {
1779            #endif
1780            if (error < 0)
1781                error = error - (2 * error); /* get absolute value */
1782            (void)XSNPRINTF(buffer, sizeof(buffer),
1783                    "wolfSSL error occurred, error = %d line:%u file:%s",
1784                    error, line, file);
1785
1786            if (wc_AddErrorNode(error, (int)line, buffer, (char*)file) != 0) {
1787                WOLFSSL_MSG("Error creating logging node");
1788                /* with void function there is no return here, continue on
1789                 * to unlock mutex and log what buffer was created. */
1790            }
1791            #if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY)
1792            }
1793            else {
1794                (void)XSNPRINTF(buffer, sizeof(buffer),
1795                    "wolfSSL error occurred, error = %d", error);
1796            }
1797            #endif
1798
1799            ERRQ_UNLOCK();
1800        }
1801    #else
1802        (void)XSNPRINTF(buffer, sizeof(buffer),
1803                "wolfSSL error occurred, error = %d", error);
1804    #endif
1805
1806    #ifdef DEBUG_WOLFSSL
1807        if (loggingEnabled)
1808            wolfssl_log(ERROR_LOG, NULL, 0, buffer);
1809    #endif
1810    }
1811}
1812
1813void WOLFSSL_ERROR_MSG(const char* msg)
1814{
1815#ifdef DEBUG_WOLFSSL
1816    if (loggingEnabled)
1817        wolfssl_log(ERROR_LOG, NULL, 0, msg);
1818#else
1819    (void)msg;
1820#endif
1821}
1822
1823#endif  /* DEBUG_WOLFSSL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
1824
1825#ifdef WOLFSSL_DEBUG_TRACE_ERROR_CODES
1826
1827#ifndef WOLFSSL_DEBUG_TRACE_ERROR_CODES_INIT_STATE
1828    #define WOLFSSL_DEBUG_TRACE_ERROR_CODES_INIT_STATE 1
1829#endif
1830
1831#ifdef WOLFSSL_ATOMIC_OPS
1832static wolfSSL_Atomic_Int wc_debug_trace_error_codes_state =
1833    WOLFSSL_ATOMIC_INITIALIZER(WOLFSSL_DEBUG_TRACE_ERROR_CODES_INIT_STATE);
1834#else
1835static int wc_debug_trace_error_codes_state =
1836    WOLFSSL_DEBUG_TRACE_ERROR_CODES_INIT_STATE;
1837#endif
1838
1839int wc_debug_trace_error_codes_enabled(void) {
1840    return WOLFSSL_ATOMIC_LOAD(wc_debug_trace_error_codes_state);
1841}
1842
1843int wc_debug_trace_error_codes_set(int state) {
1844    return wolfSSL_Atomic_Int_Exchange(&wc_debug_trace_error_codes_state,
1845                                       state);
1846}
1847
1848#endif /* WOLFSSL_DEBUG_TRACE_ERROR_CODES */
1849
1850#ifdef WOLFSSL_DEBUG_BACKTRACE_ERROR_CODES
1851
1852#ifdef WOLFSSL_LINUXKM
1853
1854int wc_backtrace_render(void) {
1855    dump_stack();
1856    return 0;
1857}
1858
1859#else /* !WOLFSSL_LINUXKM */
1860
1861#include <backtrace-supported.h>
1862
1863#if BACKTRACE_SUPPORTED != 1
1864    #error WOLFSSL_DEBUG_BACKTRACE_ERROR_CODES is defined but BACKTRACE_SUPPORTED is 0.
1865#endif
1866
1867#if !defined(WOLFSSL_MUTEX_INITIALIZER) && defined(WOLFSSL_NO_ATOMICS)
1868    #error WOLFSSL_DEBUG_BACKTRACE_ERROR_CODES requires WOLFSSL_MUTEX_INITIALIZER or wolfSSL_Atomic_Ints.
1869#endif
1870
1871#include <backtrace.h>
1872
1873#ifdef XFILE
1874
1875static XFILE wolfssl_backtrace_file = XBADFILE;
1876
1877XFILE wc_backtrace_set_fp(XFILE new_fp) {
1878    XFILE old_fp = wolfssl_backtrace_file;
1879    if (new_fp == NULL)
1880        wolfssl_backtrace_file = XBADFILE;
1881    else
1882        wolfssl_backtrace_file = new_fp;
1883    return old_fp;
1884}
1885
1886#define WOLFSSL_BACKTRACE_PRINTF(...) (                             \
1887    (wolfssl_backtrace_file == XBADFILE) ?                          \
1888     WOLFSSL_DEBUG_PRINTF(__VA_ARGS__) :                            \
1889     WOLFSSL_DEBUG_PRINTF_FN(wolfssl_backtrace_file, __VA_ARGS__))
1890
1891#else /* !XFILE */
1892
1893/* libbacktrace doesn't support any targets with no XFILE, but keep it buildable
1894 * just in case.
1895 */
1896#define WOLFSSL_BACKTRACE_PRINTF(...) WOLFSSL_DEBUG_PRINTF(__VA_ARGS__)
1897
1898#endif /* !XFILE */
1899
1900static int backtrace_callback(void *data, uintptr_t pc, const char *filename,
1901                              int lineno, const char *function)
1902{
1903    if (function == NULL)
1904        return 0;
1905    /* the first callback is for the call to wc_print_backtrace() -- skip it. */
1906    if (*(int *)data == 0) {
1907        *(int *)data = 1;
1908        return 0;
1909    }
1910    WOLFSSL_BACKTRACE_PRINTF("    #%d %p in %s %s:%d\n", (*(int *)data)++,
1911                         (void *)pc, function, filename, lineno);
1912    return 0;
1913}
1914
1915static void backtrace_error(void *data, const char *msg, int errnum) {
1916    (void)data;
1917    WOLFSSL_BACKTRACE_PRINTF("ERR TRACE: error %d while backtracing: %s",
1918                         errnum, msg);
1919}
1920
1921static void backtrace_creation_error(void *data, const char *msg, int errnum) {
1922    (void)data;
1923    WOLFSSL_BACKTRACE_PRINTF("ERR TRACE: internal error %d "
1924            "while initializing backtrace facility: %s", errnum, msg);
1925}
1926
1927static int backtrace_init(struct backtrace_state **backtrace_state) {
1928#ifdef WOLFSSL_MUTEX_INITIALIZER
1929    static wolfSSL_Mutex backtrace_create_state_mutex =
1930        WOLFSSL_MUTEX_INITIALIZER(backtrace_create_state_mutex);
1931    if (wc_LockMutex(&backtrace_create_state_mutex) != 0)
1932        return -1;
1933#elif defined(WOLFSSL_ATOMIC_OPS)
1934    static wolfSSL_Atomic_Int init_count = 0;
1935    if (wolfSSL_Atomic_Int_FetchAdd(&init_count, 1) != 1)
1936        return -1;
1937#endif
1938    if (*backtrace_state == NULL) {
1939        /* passing a NULL filename to backtrace_create_state() tells
1940         * libbacktrace to use a target-specific strategy to determine the
1941         * executable.  "libbacktrace supports ELF, PE/COFF, Mach-O, and XCOFF
1942         * executables with DWARF debugging information.  In other words, it
1943         * supports GNU/Linux, *BSD, macOS, Windows, and AIX."
1944         */
1945        *backtrace_state = backtrace_create_state(
1946            NULL, 0, backtrace_creation_error, NULL);
1947    }
1948#ifdef WOLFSSL_MUTEX_INITIALIZER
1949    wc_UnLockMutex(&backtrace_create_state_mutex);
1950#endif
1951    if (*backtrace_state == NULL)
1952        return -1;
1953    return 0;
1954}
1955
1956int wc_backtrace_render(void) {
1957    static wolfSSL_Mutex backtrace_mutex
1958        WOLFSSL_MUTEX_INITIALIZER_CLAUSE(backtrace_mutex);
1959    static struct backtrace_state *backtrace_state = NULL;
1960    int depth = 0;
1961    int ret;
1962
1963#ifndef WOLFSSL_MUTEX_INITIALIZER
1964    static wolfSSL_Atomic_Int init_count = 0;
1965    if (init_count != 1) {
1966        int cur_init_count = wolfSSL_Atomic_Int_FetchSub(&init_count, 1);
1967        if (cur_init_count != 0) {
1968            (void)wolfSSL_Atomic_Int_FetchAdd(&init_count, 1);
1969            return WC_NO_ERR_TRACE(DEADLOCK_AVERTED_E);
1970        }
1971        ret = wc_InitMutex(&backtrace_mutex);
1972        if (ret != 0)
1973            return ret;
1974        /* set init_count to 1, race-free: (-1) - (0-2) = 1 */
1975        (void)wolfSSL_Atomic_Int_FetchSub(&init_count, cur_init_count - 2);
1976    }
1977#endif
1978
1979    /* backtrace_state can't be shared between threads even when
1980     * BACKTRACE_SUPPORTS_THREADS == 1, so we serialize the render op.  this
1981     * helpfully mutexes the initialization too.
1982     */
1983    ret = wc_LockMutex(&backtrace_mutex);
1984    if (ret != 0)
1985        return ret;
1986
1987    if (backtrace_state == NULL) {
1988        if (backtrace_init(&backtrace_state) < 0) {
1989            wc_UnLockMutex(&backtrace_mutex);
1990            return WC_NO_ERR_TRACE(BAD_STATE_E);
1991        }
1992    }
1993
1994    /* note that the optimizer can produce misleading backtraces, even with
1995     * -funwind-tables.  in contrast, the macro-generated "ERR TRACE" message
1996     * from WC_ERR_TRACE() always accurately identifies the error code point.
1997     */
1998    backtrace_full(backtrace_state, 0, backtrace_callback, backtrace_error,
1999                   (void *)&depth);
2000
2001    wc_UnLockMutex(&backtrace_mutex);
2002
2003    return 0;
2004}
2005#endif /* !WOLFSSL_LINUXKM */
2006
2007#endif /* WOLFSSL_DEBUG_BACKTRACE_ERROR_CODES */