luna - wolfssl/src/bio.c

   1/* bio.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(_WIN32) && !defined(_GNU_SOURCE)
  25    /* turn on GNU extensions for XVASPRINTF with wolfSSL_BIO_printf */
  26    #define _GNU_SOURCE 1
  27#endif
  28
  29#if !defined(WOLFSSL_BIO_INCLUDED)
  30    #ifndef WOLFSSL_IGNORE_FILE_WARN
  31        #warning bio.c does not need to be compiled separately from ssl.c
  32    #endif
  33#else
  34
  35/*
  36 * WOLFSSL_BIO_RESIZE_THRESHOLD:
  37 *     The amount of data to return before we attempt to resize the internal
  38 *     buffers. After we have returned more than this define amount of bytes of
  39 *     data, we will resize the buffers to get rid of excess memory.
  40 */
  41
  42
  43/* Helper function to decode a base64 input
  44 *
  45 * returns size of resulting buffer on success
  46 */
  47static int wolfSSL_BIO_BASE64_read(WOLFSSL_BIO* bio, void* buf, int len)
  48{
  49    word32 frmtSz = (word32)len;
  50
  51    WOLFSSL_ENTER("wolfSSL_BIO_BASE64_read");
  52
  53    if (Base64_Decode((const byte*)buf, (word32)len, (byte*)buf, &frmtSz) !=0) {
  54        WOLFSSL_MSG("Err doing base64 decode");
  55        return WOLFSSL_FATAL_ERROR;
  56    }
  57
  58    (void)bio;
  59    return (int)frmtSz;
  60}
  61
  62
  63/* Helper function to read from WOLFSSL_BIO_BIO type
  64 *
  65 * returns amount in bytes read on success
  66 */
  67static int wolfSSL_BIO_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
  68{
  69    int   sz1;
  70    int   sz2;
  71    char* pt;
  72
  73    if (buf == NULL || len == 0)
  74        return 0;
  75
  76    /* default no retry */
  77    bio->flags &= ~(WOLFSSL_BIO_FLAG_READ|WOLFSSL_BIO_FLAG_RETRY);
  78    sz1 = wolfSSL_BIO_nread(bio, &pt, len);
  79    if (sz1 > 0) {
  80        XMEMCPY(buf, pt, sz1);
  81        buf = (char*)buf + sz1;
  82        len -= sz1;
  83        if (len > 0) {
  84            /* try again to see if maybe we wrapped around the ring buffer */
  85            sz2 = wolfSSL_BIO_nread(bio, &pt, len);
  86            if (sz2 > 0) {
  87                XMEMCPY(buf, pt, sz2);
  88                sz1 += sz2;
  89            }
  90        }
  91    }
  92    if (sz1 == 0) {
  93        bio->flags |= WOLFSSL_BIO_FLAG_READ|WOLFSSL_BIO_FLAG_RETRY;
  94        sz1 = -1;
  95    }
  96
  97    return sz1;
  98}
  99
 100#ifndef WOLFSSL_BIO_RESIZE_THRESHOLD
 101#define WOLFSSL_BIO_RESIZE_THRESHOLD 100
 102#endif
 103
 104/* Handles reading from a memory type BIO and advancing the state.
 105 *
 106 * bio  WOLFSSL_BIO to read from
 107 * buf  buffer to put data from bio in
 108 * len  amount of data to be read
 109 *
 110 * returns size read on success
 111 */
 112static int wolfSSL_BIO_MEMORY_read(WOLFSSL_BIO* bio, void* buf, int len)
 113{
 114    int sz;
 115
 116#ifndef WOLFSSL_DEBUG_OPENSSL
 117    if (len > 1)
 118#endif
 119    {
 120    WOLFSSL_ENTER("wolfSSL_BIO_MEMORY_read");
 121    }
 122
 123    sz = wolfSSL_BIO_pending(bio);
 124    if (sz > 0) {
 125        int memSz;
 126
 127        if (bio->mem_buf == NULL) {
 128            WOLFSSL_MSG("bio->mem_buf is null");
 129            return WOLFSSL_BIO_ERROR;
 130        }
 131
 132        if (sz > len) {
 133            sz = len;
 134        }
 135
 136        memSz = (int)bio->mem_buf->length - bio->rdIdx;
 137        if (memSz < sz) {
 138            WOLFSSL_MSG("Not enough memory for reading");
 139            return WOLFSSL_BIO_ERROR;
 140        }
 141
 142        XMEMCPY(buf, bio->mem_buf->data + bio->rdIdx, (size_t)sz);
 143        bio->rdIdx += sz;
 144
 145        if (bio->rdIdx >= bio->wrSz) {
 146            if (bio->flags & WOLFSSL_BIO_FLAG_MEM_RDONLY) {
 147                bio->wrSz = bio->wrSzReset;
 148            }
 149            else {
 150                /* All data read resize down to WOLFSSL_BIO_RESIZE_THRESHOLD */
 151                if (bio->mem_buf->max > WOLFSSL_BIO_RESIZE_THRESHOLD &&
 152                    wolfSSL_BUF_MEM_resize(bio->mem_buf, WOLFSSL_BIO_RESIZE_THRESHOLD) == 0) {
 153                    WOLFSSL_MSG("wolfSSL_BUF_MEM_resize error");
 154                    return WOLFSSL_BIO_ERROR;
 155                }
 156                bio->rdIdx = 0;
 157                bio->wrSz = 0;
 158                bio->mem_buf->length = 0;
 159            }
 160            bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
 161        }
 162        else if (bio->rdIdx >= WOLFSSL_BIO_RESIZE_THRESHOLD &&
 163                !(bio->flags & WOLFSSL_BIO_FLAG_MEM_RDONLY)) {
 164            /* Resize the memory so we are not taking up more than necessary.
 165             * memmove reverts internally to memcpy if areas don't overlap */
 166            XMEMMOVE(bio->mem_buf->data, bio->mem_buf->data + bio->rdIdx,
 167                    (size_t)bio->wrSz - (size_t)bio->rdIdx);
 168            bio->wrSz -= bio->rdIdx;
 169            bio->rdIdx = 0;
 170            /* Resize down to WOLFSSL_BIO_RESIZE_THRESHOLD for fewer
 171             * allocations. */
 172            if (wolfSSL_BUF_MEM_resize(bio->mem_buf,
 173                bio->wrSz > WOLFSSL_BIO_RESIZE_THRESHOLD ?
 174                (size_t)bio->wrSz : WOLFSSL_BIO_RESIZE_THRESHOLD) == 0) {
 175                WOLFSSL_MSG("wolfSSL_BUF_MEM_resize error");
 176                return WOLFSSL_BIO_ERROR;
 177            }
 178            bio->mem_buf->length = (size_t)bio->wrSz;
 179            bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
 180        }
 181    }
 182    else {
 183        if (bio->eof < 0) /* Sanity check the eof value */
 184            return bio->eof;
 185        else {
 186            WOLFSSL_MSG("Weird bio->eof value. Returning default");
 187            return WOLFSSL_BIO_ERROR;
 188        }
 189    }
 190
 191    return sz;
 192}
 193
 194int wolfSSL_BIO_method_type(const WOLFSSL_BIO *b)
 195{
 196    return b != NULL ? b->type : (int)WOLFSSL_BIO_UNDEF;
 197}
 198
 199#ifndef WOLFCRYPT_ONLY
 200#ifndef NO_TLS
 201/* Helper function to read from WOLFSSL_BIO_SSL type
 202 *
 203 * returns the number of bytes read on success
 204 */
 205static int wolfSSL_BIO_SSL_read(WOLFSSL_BIO* bio, void* buf,
 206        int len, WOLFSSL_BIO* front)
 207{
 208    int ret;
 209
 210    WOLFSSL_ENTER("wolfSSL_BIO_SSL_read");
 211
 212    /* already got eof, again is error */
 213    if ((front == NULL) || front->eof)
 214        return WOLFSSL_FATAL_ERROR;
 215
 216    bio->flags &= ~(WOLFSSL_BIO_FLAG_RETRY); /* default no retry */
 217    ret = wolfSSL_read(bio->ptr.ssl, buf, len);
 218    if (ret == 0)
 219        front->eof = 1;
 220    else if (ret < 0) {
 221        int err = wolfSSL_get_error(bio->ptr.ssl, 0);
 222        if ( !(err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE) ) {
 223            front->eof = 1;
 224        }
 225        else {
 226            bio->flags |= WOLFSSL_BIO_FLAG_RETRY; /* should retry */
 227        }
 228    }
 229
 230    return ret;
 231}
 232#endif /* !NO_TLS */
 233
 234static int wolfSSL_BIO_MD_read(WOLFSSL_BIO* bio, void* buf, int sz)
 235{
 236    if (wolfSSL_EVP_MD_CTX_type(bio->ptr.md_ctx) == WC_NID_hmac) {
 237        if (wolfSSL_EVP_DigestSignUpdate(bio->ptr.md_ctx, buf,
 238                        (unsigned int)sz) != WOLFSSL_SUCCESS)
 239        {
 240            return WOLFSSL_FATAL_ERROR;
 241        }
 242    }
 243    else {
 244        if (wolfSSL_EVP_DigestUpdate(bio->ptr.md_ctx, buf, (size_t)sz)
 245                != WOLFSSL_SUCCESS) {
 246            return WOLFSSL_FATAL_ERROR;
 247        }
 248    }
 249    return sz;
 250}
 251#endif /* !WOLFCRYPT_ONLY */
 252
 253
 254/* Used to read data from a WOLFSSL_BIO structure
 255 *
 256 * bio  structure to read data from
 257 * buf  buffer to hold the result
 258 * len  length of buf buffer
 259 *
 260 * returns the number of bytes read on success
 261 */
 262int wolfSSL_BIO_read(WOLFSSL_BIO* bio, void* buf, int len)
 263{
 264    int ret = 0;
 265    WOLFSSL_BIO* front = bio;
 266    int sz  = 0;
 267
 268#ifndef WOLFSSL_DEBUG_OPENSSL
 269    if (len > 1)
 270#endif
 271    {
 272    WOLFSSL_ENTER("wolfSSL_BIO_read");
 273    }
 274
 275    if (len < 0) {
 276        return WOLFSSL_BIO_ERROR;
 277    }
 278
 279    /* info cb, abort if user returns <= 0*/
 280    if (front != NULL && front->infoCb != NULL) {
 281        ret = (int)front->infoCb(front, WOLFSSL_BIO_CB_READ, (const char*)buf,
 282                                                                     len, 0, 1);
 283        if (ret <= 0) {
 284            return ret;
 285        }
 286    }
 287
 288    /* start at end of list (or a WOLFSSL_BIO_SSL object since it takes care of
 289     * the rest of the chain) and work backwards */
 290    while (bio != NULL && bio->next != NULL && bio->type != WOLFSSL_BIO_SSL) {
 291        bio = bio->next;
 292    }
 293
 294    while (bio != NULL && ret >= 0) {
 295#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 296        int inhibit_flow_increment = 0;
 297#endif
 298        /* check for custom read */
 299        if (bio->method && bio->method->readCb) {
 300            ret = bio->method->readCb(bio, (char*)buf, len);
 301        }
 302        else {
 303            switch (bio->type) {
 304            case WOLFSSL_BIO_BASE64: /* formatting data */
 305                if (sz > 0)
 306                    ret = wolfSSL_BIO_BASE64_read(bio, buf, sz);
 307                break;
 308            case WOLFSSL_BIO_BIO: /* read BIOs */
 309                ret = wolfSSL_BIO_BIO_read(bio, buf, len);
 310#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 311                inhibit_flow_increment = 1;
 312#endif
 313                break;
 314            case WOLFSSL_BIO_MEMORY:
 315                ret = wolfSSL_BIO_MEMORY_read(bio, buf, len);
 316                break;
 317            case WOLFSSL_BIO_FILE:
 318            #ifndef NO_FILESYSTEM
 319                if (bio->ptr.fh) {
 320                    ret = (int)XFREAD(buf, 1, (size_t)len, bio->ptr.fh);
 321                }
 322                else {
 323                #if defined(XREAD) && !defined(NO_WOLFSSL_DIR) && \
 324                    !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
 325                    ret = (int)XREAD(bio->num.fd, buf, (size_t)len);
 326                #else
 327                    WOLFSSL_MSG("No file pointer and XREAD not enabled");
 328                    ret = NOT_COMPILED_IN;
 329                #endif
 330                }
 331            #else
 332                WOLFSSL_MSG("WOLFSSL_BIO_FILE used with NO_FILESYSTEM");
 333                ret = NOT_COMPILED_IN;
 334            #endif /* !NO_FILESYSTEM */
 335                break;
 336            case WOLFSSL_BIO_SSL:
 337            #if !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS)
 338                ret = wolfSSL_BIO_SSL_read(bio, buf, len, front);
 339            #else
 340                WOLFSSL_MSG("WOLFSSL_BIO_SSL used with WOLFCRYPT_ONLY");
 341                ret = NOT_COMPILED_IN;
 342            #endif
 343                break;
 344            case WOLFSSL_BIO_MD: /* data passing through BIO MD wrapper */
 345            #ifndef WOLFCRYPT_ONLY
 346                ret = wolfSSL_BIO_MD_read(bio, buf, ret);
 347            #else
 348                WOLFSSL_MSG("WOLFSSL_BIO_MD used with WOLFCRYPT_ONLY");
 349                ret = NOT_COMPILED_IN;
 350            #endif
 351                break;
 352            case WOLFSSL_BIO_SOCKET:
 353            #ifdef USE_WOLFSSL_IO
 354                /* BIO requires built-in socket support
 355                 *  (cannot be used with WOLFSSL_USER_IO) */
 356                bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
 357                ret = wolfIO_Recv(bio->num.fd, (char*)buf, len, 0);
 358                if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ)) {
 359                    bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
 360                }
 361                if (ret < 0) {
 362                    ret = WOLFSSL_BIO_ERROR;
 363                }
 364            #else
 365                ret = NOT_COMPILED_IN;
 366            #endif
 367                break;
 368
 369            case WOLFSSL_BIO_DGRAM:
 370            #if defined(WOLFSSL_HAVE_BIO_ADDR) && defined(WOLFSSL_DTLS) && \
 371                defined(USE_WOLFSSL_IO)
 372                /* BIO requires built-in socket support
 373                 *  (cannot be used with WOLFSSL_USER_IO) */
 374                bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
 375                if (bio->connected)
 376                    ret = wolfIO_Recv(bio->num.fd, (char*)buf, len, 0);
 377                else {
 378                    wolfSSL_BIO_ADDR_clear(&bio->peer_addr);
 379                    ret = wolfIO_RecvFrom(bio->num.fd, &bio->peer_addr,
 380                                          (char*)buf, len, 0);
 381                }
 382                if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ)) {
 383                    bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
 384                }
 385                if (ret < 0) {
 386                    ret = WOLFSSL_BIO_ERROR;
 387                }
 388            #else
 389                ret = NOT_COMPILED_IN;
 390            #endif
 391                break;
 392
 393            case WOLFSSL_BIO_NULL:
 394                ret = 0;
 395                break;
 396
 397            } /* switch */
 398        }
 399
 400#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 401        if ((ret > 0) && (!inhibit_flow_increment)) {
 402            bio->bytes_read += (word32)ret;
 403        }
 404#endif
 405
 406        /* case where front of list is done */
 407        if (bio == front) {
 408            break; /* at front of list so be done */
 409        }
 410
 411        if (ret > 0) {
 412            sz = ret; /* adjust size for formatting */
 413        }
 414
 415        /* previous WOLFSSL_BIO in list working towards head of list */
 416        bio = bio->prev;
 417    }
 418
 419    /* info cb, user can override return value */
 420    if (front != NULL && front->infoCb != NULL) {
 421        ret = (int)front->infoCb(front,
 422                                 WOLFSSL_BIO_CB_READ | WOLFSSL_BIO_CB_RETURN,
 423                                 (const char*)buf, len, 0, ret);
 424    }
 425
 426    return ret;
 427}
 428
 429
 430#ifdef WOLFSSL_BASE64_ENCODE
 431/* Converts data into base64 output
 432 *
 433 * returns the resulting buffer size on success.
 434 */
 435/**
 436 * `out` buffer is allocated here and the caller is responsible
 437 *       for free'ing it
 438 * `data` and `out` can be the same in which case `data` should
 439 *       always be set to `out` after this function call succeeds
 440 */
 441static int wolfSSL_BIO_BASE64_write(WOLFSSL_BIO* bio, const void* data,
 442        word32 inLen, byte** out, word32* outLen, void* heap)
 443{
 444    byte* tmp = NULL;
 445    word32 sz = 0;
 446
 447    WOLFSSL_ENTER("wolfSSL_BIO_BASE64_write");
 448
 449    if (bio == NULL || data == NULL || out == NULL || outLen == NULL) {
 450        return BAD_FUNC_ARG;
 451    }
 452
 453    /* get the encoded length */
 454    if (bio->flags & WOLFSSL_BIO_FLAG_BASE64_NO_NL) {
 455        if (Base64_Encode_NoNl((const byte*)data, inLen, NULL,
 456                    &sz) != WC_NO_ERR_TRACE(LENGTH_ONLY_E)) {
 457            WOLFSSL_MSG("Error with base64 get length");
 458            return WOLFSSL_FATAL_ERROR;
 459        }
 460    }
 461    else {
 462        if (Base64_Encode((const byte*)data, inLen, NULL, &sz)
 463              != WC_NO_ERR_TRACE(LENGTH_ONLY_E))
 464        {
 465            WOLFSSL_MSG("Error with base64 get length");
 466            return WOLFSSL_FATAL_ERROR;
 467        }
 468    }
 469
 470    if (sz == 0) {
 471        *outLen = 0;
 472        return 0; /* nothing to do */
 473    }
 474
 475    /* allocate temp buffer, since base64 encode does not allow inline */
 476    tmp = (byte*)XMALLOC(sz, heap, DYNAMIC_TYPE_TMP_BUFFER);
 477    if (tmp == NULL) {
 478        WOLFSSL_MSG("Memory error");
 479        return WOLFSSL_FATAL_ERROR;
 480    }
 481    if (bio->flags & WOLFSSL_BIO_FLAG_BASE64_NO_NL) {
 482        if (Base64_Encode_NoNl((const byte*)data, inLen,
 483                tmp, &sz) < 0) {
 484            WOLFSSL_MSG("Base64_Encode_NoNl error");
 485            XFREE(tmp, heap, DYNAMIC_TYPE_TMP_BUFFER);
 486            return WOLFSSL_FATAL_ERROR;
 487        }
 488    }
 489    else {
 490        if (Base64_Encode((const byte*)data, inLen,
 491                tmp, &sz) < 0) {
 492            WOLFSSL_MSG("Base64_Encode error");
 493            XFREE(tmp, heap, DYNAMIC_TYPE_TMP_BUFFER);
 494            return WOLFSSL_FATAL_ERROR;
 495        }
 496    }
 497
 498    if (*out != NULL)
 499        XFREE(*out, heap, DYNAMIC_TYPE_TMP_BUFFER);
 500    *out = tmp;
 501    *outLen = sz;
 502    /* out is free'd by caller */
 503
 504    (void)heap;
 505
 506    return (int)inLen;
 507}
 508#endif /* WOLFSSL_BASE64_ENCODE */
 509
 510#if !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS)
 511/* Helper function for writing to a WOLFSSL_BIO_SSL type
 512 *
 513 * returns the amount written in bytes on success
 514 */
 515static int wolfSSL_BIO_SSL_write(WOLFSSL_BIO* bio, const void* data,
 516        int len, WOLFSSL_BIO* front)
 517{
 518    int ret;
 519
 520    WOLFSSL_ENTER("wolfSSL_BIO_SSL_write");
 521
 522    if (bio->ptr.ssl == NULL) {
 523        return BAD_FUNC_ARG;
 524    }
 525
 526    bio->flags &= ~(WOLFSSL_BIO_FLAG_RETRY); /* default no retry */
 527    ret = wolfSSL_write(bio->ptr.ssl, data, len);
 528    if (ret == 0)
 529        front->eof = 1;
 530    else if (ret < 0) {
 531        int err = wolfSSL_get_error(bio->ptr.ssl, 0);
 532        if ( !(err == WOLFSSL_ERROR_WANT_READ || err == WOLFSSL_ERROR_WANT_WRITE) ) {
 533            front->eof = 1;
 534        }
 535        else {
 536            bio->flags |= WOLFSSL_BIO_FLAG_RETRY; /* should retry */
 537        }
 538    }
 539    return ret;
 540}
 541#endif /* !WOLFCRYPT_ONLY && !NO_TLS */
 542
 543/* Writes to a WOLFSSL_BIO_BIO type.
 544 *
 545 * returns the amount written on success
 546 */
 547static int wolfSSL_BIO_BIO_write(WOLFSSL_BIO* bio, const void* data,
 548        int len)
 549{
 550    int   sz1;
 551    int   sz2;
 552    char* buf;
 553
 554    WOLFSSL_ENTER("wolfSSL_BIO_BIO_write");
 555
 556    /* adding in sanity checks for static analysis tools */
 557    if (bio == NULL || data == NULL || len == 0)
 558        return 0;
 559
 560    /* default no retry */
 561    bio->flags &= ~(WOLFSSL_BIO_FLAG_WRITE|WOLFSSL_BIO_FLAG_RETRY);
 562    sz1 = wolfSSL_BIO_nwrite(bio, &buf, len);
 563    if (sz1 == 0) {
 564        bio->flags |= WOLFSSL_BIO_FLAG_WRITE|WOLFSSL_BIO_FLAG_RETRY;
 565        WOLFSSL_MSG("No room left to write");
 566        return WOLFSSL_BIO_ERROR;
 567    }
 568    if (sz1 < 0) {
 569        WOLFSSL_MSG("Error in wolfSSL_BIO_nwrite");
 570        return sz1;
 571    }
 572    XMEMCPY(buf, data, (size_t)sz1);
 573    data = (char*)data + sz1;
 574    len -= sz1;
 575
 576    if (len > 0) {
 577        /* try again to see if maybe we wrapped around the ring buffer */
 578        sz2 = wolfSSL_BIO_nwrite(bio, &buf, len);
 579        if (sz2 > 0) {
 580            XMEMCPY(buf, data, (size_t)sz2);
 581            sz1 += sz2;
 582            if (len > sz2)
 583                bio->flags |= WOLFSSL_BIO_FLAG_WRITE|WOLFSSL_BIO_FLAG_RETRY;
 584        }
 585    }
 586
 587
 588    return sz1;
 589}
 590
 591
 592/* for complete compatibility a bio memory write allocs its own memory
 593 * until the application runs out ....
 594 *
 595 * bio  structure to hold incoming data
 596 * data buffer holding the data to be written
 597 * len  length of data buffer
 598 *
 599 * returns the amount of data written on success or WOLFSSL_BIO_ERROR
 600 * for failure cases.
 601 */
 602static int wolfSSL_BIO_MEMORY_write(WOLFSSL_BIO* bio, const void* data,
 603        int len)
 604{
 605    WOLFSSL_ENTER("wolfSSL_BIO_MEMORY_write");
 606
 607    /* ossl returns 0 on bio == NULL */
 608    if (bio == NULL) {
 609        return 0;
 610    }
 611
 612    if (bio->mem_buf == NULL || data == NULL) {
 613        WOLFSSL_MSG("one of input parameters is null");
 614        return WOLFSSL_BIO_ERROR;
 615    }
 616
 617    if (bio->flags & WOLFSSL_BIO_FLAG_MEM_RDONLY) {
 618        return WOLFSSL_BIO_ERROR;
 619    }
 620
 621    if (len <= 0)
 622        return 0; /* Nothing to write */
 623
 624    if (wolfSSL_BUF_MEM_grow_ex(bio->mem_buf, ((size_t)bio->wrSz) +
 625                                                    ((size_t)len), 0) == 0) {
 626        WOLFSSL_MSG("Error growing memory area");
 627        return WOLFSSL_BIO_ERROR;
 628    }
 629
 630    if (bio->mem_buf->data == NULL) {
 631        WOLFSSL_MSG("Buffer data is NULL");
 632        return WOLFSSL_BIO_ERROR;
 633    }
 634
 635    XMEMCPY(bio->mem_buf->data + bio->wrSz, data, (size_t)len);
 636    bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
 637    bio->num.length = bio->mem_buf->max;
 638    bio->wrSz += len;
 639    bio->wrIdx += len;
 640
 641    return len;
 642}
 643
 644
 645#ifndef WOLFCRYPT_ONLY
 646/* Helper function for writing to a WOLFSSL_BIO_MD type
 647 *
 648 * returns the amount written in bytes on success (0)
 649 */
 650static int wolfSSL_BIO_MD_write(WOLFSSL_BIO* bio, const void* data, int len)
 651{
 652    int ret = 0;
 653
 654    if (bio == NULL || data == NULL) {
 655        return BAD_FUNC_ARG;
 656    }
 657
 658    if (wolfSSL_EVP_MD_CTX_type(bio->ptr.md_ctx) == WC_NID_hmac) {
 659        if (wolfSSL_EVP_DigestSignUpdate(bio->ptr.md_ctx, data,
 660                    (unsigned int)len) != WOLFSSL_SUCCESS) {
 661            ret = WOLFSSL_BIO_ERROR;
 662        }
 663    }
 664    else {
 665        if (wolfSSL_EVP_DigestUpdate(bio->ptr.md_ctx, data, (size_t)len)
 666                != WOLFSSL_SUCCESS) {
 667            ret =  WOLFSSL_BIO_ERROR;
 668        }
 669    }
 670    return ret;
 671}
 672#endif /* WOLFCRYPT_ONLY */
 673
 674
 675/* Writes data to a WOLFSSL_BIO structure
 676 *
 677 * bio  structure to write to
 678 * data holds the data to be written
 679 * len  length of data buffer
 680 *
 681 * returns the amount written in bytes on success
 682 */
 683int wolfSSL_BIO_write(WOLFSSL_BIO* bio, const void* data, int len)
 684{
 685    int ret = 0;
 686#ifdef WOLFSSL_BASE64_ENCODE
 687    /* Use extra return var as we want to return how much of input we have
 688     * written, not how big the base64 encoding ended up being */
 689    int retB64 = 0;
 690#endif
 691    WOLFSSL_BIO* front = bio;
 692    void* frmt = NULL;
 693    word32 frmtSz = 0;
 694
 695    WOLFSSL_ENTER("wolfSSL_BIO_write");
 696
 697    if (len < 0) {
 698        return WOLFSSL_BIO_ERROR;
 699    }
 700
 701    /* info cb, abort if user returns <= 0*/
 702    if (front != NULL && front->infoCb != NULL) {
 703        ret = (int)front->infoCb(front, WOLFSSL_BIO_CB_WRITE,
 704                (const char*)data, len, 0, 1);
 705        if (ret <= 0) {
 706            return ret;
 707        }
 708    }
 709
 710    while (bio != NULL && ret >= 0) {
 711#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 712        int inhibit_flow_increment = 0;
 713#endif
 714        /* check for custom write */
 715        if (bio->method && bio->method->writeCb) {
 716            ret = bio->method->writeCb(bio, (const char*)data, len);
 717        }
 718        else {
 719            switch (bio->type) {
 720            case WOLFSSL_BIO_BASE64:
 721            {
 722            #ifdef WOLFSSL_BASE64_ENCODE
 723                ret = retB64 = wolfSSL_BIO_BASE64_write(bio, data, (word32)len,
 724                                            (byte**)&frmt, &frmtSz, front->heap);
 725                if (ret > 0) {
 726                    /* change so that data is formatted buffer */
 727                    data = frmt;
 728                    len  = (int)frmtSz;
 729                }
 730            #else
 731                WOLFSSL_MSG("WOLFSSL_BIO_BASE64 used without "
 732                            "WOLFSSL_BASE64_ENCODE");
 733                ret = NOT_COMPILED_IN;
 734            #endif /* WOLFSSL_BASE64_ENCODE */
 735                break;
 736            }
 737            case WOLFSSL_BIO_BIO: /* write bios */
 738                ret = wolfSSL_BIO_BIO_write(bio, data, len);
 739#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 740                inhibit_flow_increment = 1;
 741#endif
 742                break;
 743            case WOLFSSL_BIO_MEMORY:
 744                ret = wolfSSL_BIO_MEMORY_write(bio, data, len);
 745                break;
 746            case WOLFSSL_BIO_FILE:
 747            #ifndef NO_FILESYSTEM
 748                if (bio->ptr.fh) {
 749                    ret = (int)XFWRITE(data, 1, (size_t)len, bio->ptr.fh);
 750                }
 751                else {
 752                #if defined(XWRITE) && !defined(NO_WOLFSSL_DIR) && \
 753                    !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
 754                    ret = (int)XWRITE(bio->num.fd, data, (size_t)len);
 755                #else
 756                    WOLFSSL_MSG("No file pointer and XWRITE not enabled");
 757                    ret = NOT_COMPILED_IN;
 758                #endif
 759                }
 760            #else
 761                WOLFSSL_MSG("WOLFSSL_BIO_FILE used with NO_FILESYSTEM");
 762                ret = NOT_COMPILED_IN;
 763            #endif /* !NO_FILESYSTEM */
 764                break;
 765            case WOLFSSL_BIO_SSL:
 766            #if !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS)
 767                /* already got eof, again is error */
 768                if (front->eof) {
 769                    ret = WOLFSSL_FATAL_ERROR;
 770                }
 771                else {
 772                    ret = wolfSSL_BIO_SSL_write(bio, data, len, front);
 773                }
 774                /* Rest of chain is taken care of inside call */
 775                goto exit_chain;
 776            #else
 777                WOLFSSL_MSG("WOLFSSL_BIO_SSL used with WOLFCRYPT_ONLY");
 778                ret = NOT_COMPILED_IN;
 779            #endif
 780                break;
 781            case WOLFSSL_BIO_MD:
 782            #ifndef WOLFCRYPT_ONLY
 783                if (bio->next != NULL) { /* data passing through MD BIO */
 784                    ret = wolfSSL_BIO_MD_write(bio, data, len);
 785                }
 786            #else
 787                WOLFSSL_MSG("WOLFSSL_BIO_MD used with WOLFCRYPT_ONLY");
 788                ret = NOT_COMPILED_IN;
 789            #endif
 790                break;
 791            case WOLFSSL_BIO_SOCKET:
 792            #ifdef USE_WOLFSSL_IO
 793                /* BIO requires built-in socket support
 794                 *  (cannot be used with WOLFSSL_USER_IO) */
 795                bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
 796                ret = wolfIO_Send(bio->num.fd, (char*)data, len, 0);
 797                if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_WRITE)) {
 798                    bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
 799                }
 800                if (ret < 0) {
 801                    ret = WOLFSSL_BIO_ERROR;
 802                }
 803            #else
 804                ret = NOT_COMPILED_IN;
 805            #endif
 806                break;
 807
 808            case WOLFSSL_BIO_DGRAM:
 809                #if defined(WOLFSSL_HAVE_BIO_ADDR) && defined(WOLFSSL_DTLS) && \
 810                    defined(USE_WOLFSSL_IO)
 811                /* BIO requires built-in socket support
 812                 *  (cannot be used with WOLFSSL_USER_IO) */
 813                bio->flags &= ~WOLFSSL_BIO_FLAG_RETRY;
 814                if (bio->connected)
 815                    ret = wolfIO_Send(bio->num.fd, (char*)data, len, 0);
 816                else if (bio->peer_addr.sa.sa_family == AF_UNSPEC)
 817                    ret = SOCKET_ERROR_E;
 818                else
 819                    ret = wolfIO_SendTo(bio->num.fd, &bio->peer_addr, (char*)data, len, 0);
 820                if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_WRITE)) {
 821                    bio->flags |= WOLFSSL_BIO_FLAG_RETRY;
 822                }
 823                if (ret < 0) {
 824                    ret = WOLFSSL_BIO_ERROR;
 825                }
 826            #else
 827                ret = NOT_COMPILED_IN;
 828            #endif
 829                break;
 830
 831            case WOLFSSL_BIO_NULL:
 832                ret = len;
 833                break;
 834
 835            } /* switch */
 836        }
 837
 838#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
 839        if ((ret > 0) && (! inhibit_flow_increment))
 840            bio->bytes_written += (word32)ret;
 841#endif
 842
 843        /* advance to the next bio in list */
 844        bio = bio->next;
 845    }
 846
 847#if !defined(WOLFCRYPT_ONLY) && !defined(NO_TLS)
 848exit_chain:
 849#endif
 850
 851    /* info cb, user can override return value */
 852    if (front != NULL && front->infoCb != NULL) {
 853        ret = (int)front->infoCb(front,
 854                                 WOLFSSL_BIO_CB_WRITE | WOLFSSL_BIO_CB_RETURN,
 855                                 (const char*)data, len, 0, ret);
 856    }
 857
 858    if (front != NULL) {
 859        XFREE(frmt, front->heap, DYNAMIC_TYPE_TMP_BUFFER);
 860    }
 861
 862#ifdef WOLFSSL_BASE64_ENCODE
 863    if (retB64 > 0 && ret > 0)
 864        return retB64;
 865    else
 866#endif
 867        return ret;
 868}
 869
 870
 871/* Wrapper for other BIO type functions, expected to grow as OpenSSL compatibility
 872 * layer grows.
 873 *
 874 * return info. specific to the cmd that is passed in.
 875 */
 876#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
 877long wolfSSL_BIO_ctrl(WOLFSSL_BIO *bio, int cmd, long larg, void *parg)
 878{
 879    long ret;
 880
 881    (void)larg; /* not currently used */
 882
 883    WOLFSSL_ENTER("wolfSSL_BIO_ctrl");
 884
 885    if (bio == NULL) {
 886        return WOLFSSL_FAILURE;
 887    }
 888
 889    if (bio->method && bio->method->ctrlCb) {
 890        return bio->method->ctrlCb(bio, cmd, larg, parg);
 891    }
 892
 893    switch(cmd) {
 894        case WOLFSSL_BIO_CTRL_PENDING:
 895        case WOLFSSL_BIO_CTRL_WPENDING:
 896            ret = (long)wolfSSL_BIO_ctrl_pending(bio);
 897            break;
 898        case WOLFSSL_BIO_CTRL_INFO:
 899            ret = (long)wolfSSL_BIO_get_mem_data(bio, parg);
 900            break;
 901        case WOLFSSL_BIO_CTRL_FLUSH:
 902            ret = (long)wolfSSL_BIO_flush(bio);
 903            break;
 904        case WOLFSSL_BIO_CTRL_RESET:
 905            ret = (long)wolfSSL_BIO_reset(bio);
 906            break;
 907
 908#ifdef WOLFSSL_HAVE_BIO_ADDR
 909        case WOLFSSL_BIO_CTRL_DGRAM_CONNECT:
 910        case WOLFSSL_BIO_CTRL_DGRAM_SET_PEER:
 911        {
 912            socklen_t addr_size;
 913            if (parg == NULL) {
 914                ret = WOLFSSL_FAILURE;
 915                break;
 916            }
 917            addr_size = wolfSSL_BIO_ADDR_size((WOLFSSL_BIO_ADDR *)parg);
 918            if (addr_size == 0) {
 919                ret = WOLFSSL_FAILURE;
 920                break;
 921            }
 922            XMEMCPY(&bio->peer_addr, parg, addr_size);
 923            ret = WOLFSSL_SUCCESS;
 924            break;
 925        }
 926
 927        case WOLFSSL_BIO_CTRL_DGRAM_SET_CONNECTED:
 928            if (parg == NULL) {
 929                wolfSSL_BIO_ADDR_clear(&bio->peer_addr);
 930                bio->connected = 0;
 931            }
 932            else {
 933                socklen_t addr_size = wolfSSL_BIO_ADDR_size((WOLFSSL_BIO_ADDR *)parg);
 934                if (addr_size == 0) {
 935                    ret = WOLFSSL_FAILURE;
 936                    break;
 937                }
 938                XMEMCPY(&bio->peer_addr, parg, addr_size);
 939                bio->connected = 1;
 940            }
 941            ret = WOLFSSL_SUCCESS;
 942            break;
 943
 944        case WOLFSSL_BIO_CTRL_DGRAM_QUERY_MTU:
 945            ret = 0; /* not implemented */
 946            break;
 947
 948#endif /* WOLFSSL_HAVE_BIO_ADDR */
 949
 950        default:
 951            WOLFSSL_MSG("CMD not yet implemented");
 952            ret = WOLFSSL_FAILURE;
 953            break;
 954    }
 955    return ret;
 956}
 957
 958/* Increment the WOLFSSL_BIO ref count by one, prevents BIO from being
 959 * freed until ref count is back down to 1.
 960 *
 961 * bio  the structure to increment ref count
 962 *
 963 * returns 1 on success, 0 on failure */
 964
 965int wolfSSL_BIO_up_ref(WOLFSSL_BIO* bio)
 966{
 967    if (bio) {
 968        int ret;
 969        wolfSSL_RefInc(&bio->ref, &ret);
 970    #ifdef WOLFSSL_REFCNT_ERROR_RETURN
 971        if (ret != 0) {
 972            WOLFSSL_MSG("Failed to lock BIO mutex");
 973            return WOLFSSL_FAILURE;
 974        }
 975    #else
 976        (void)ret;
 977    #endif
 978
 979        return WOLFSSL_SUCCESS;
 980    }
 981
 982    return WOLFSSL_FAILURE;
 983}
 984
 985#ifdef WOLFSSL_HAVE_BIO_ADDR
 986WOLFSSL_BIO_ADDR *wolfSSL_BIO_ADDR_new(void) {
 987    WOLFSSL_BIO_ADDR *addr =
 988        (WOLFSSL_BIO_ADDR *)XMALLOC(sizeof(*addr), NULL, DYNAMIC_TYPE_BIO);
 989    if (addr)
 990        addr->sa.sa_family = AF_UNSPEC;
 991    return addr;
 992}
 993
 994void wolfSSL_BIO_ADDR_free(WOLFSSL_BIO_ADDR *addr) {
 995    XFREE(addr, NULL, DYNAMIC_TYPE_BIO);
 996}
 997
 998void wolfSSL_BIO_ADDR_clear(WOLFSSL_BIO_ADDR *addr) {
 999    if (addr == NULL)
1000        return;
1001    XMEMSET(addr, 0, sizeof(*addr));
1002    addr->sa.sa_family = AF_UNSPEC;
1003}
1004
1005socklen_t wolfSSL_BIO_ADDR_size(const WOLFSSL_BIO_ADDR *addr) {
1006    if (addr == NULL)
1007        return 0;
1008    switch (addr->sa.sa_family) {
1009#ifndef WOLFSSL_NO_BIO_ADDR_IN
1010    case AF_INET:
1011        return sizeof(addr->sa_in);
1012#endif
1013#ifdef WOLFSSL_IPV6
1014    case AF_INET6:
1015        return sizeof(addr->sa_in6);
1016#endif
1017#if defined(HAVE_SYS_UN_H) && !defined(WOLFSSL_NO_SOCKADDR_UN)
1018    case AF_UNIX:
1019        return sizeof(addr->sa_un);
1020#endif
1021    default:
1022        /* must return zero if length can't be determined, to avoid buffer
1023         * overruns in callers.
1024         */
1025        return 0;
1026    }
1027}
1028#endif /* WOLFSSL_HAVE_BIO_ADDR */
1029
1030#endif /* OPENSSL_ALL || OPENSSL_EXTRA */
1031
1032/* helper function for wolfSSL_BIO_gets
1033 * size till a newline is hit
1034 * returns the number of bytes including the new line character
1035 */
1036static int wolfSSL_getLineLength(char* in, int inSz)
1037{
1038    int i;
1039
1040    for (i = 0; i < inSz; i++) {
1041        if (in[i] == '\n') {
1042            return i + 1; /* includes new line character */
1043        }
1044    }
1045
1046    return inSz; /* rest of buffer is all one line */
1047}
1048
1049
1050/* Gets the next line from bio. Goes until a new line character or end of
1051 * buffer is reached.
1052 *
1053 * bio  the structure to read a new line from
1054 * buf  buffer to hold the result
1055 * sz   the size of "buf" buffer
1056 *
1057 * returns the size of the result placed in buf on success and a 0 or negative
1058 *         value in an error case.
1059 */
1060int wolfSSL_BIO_gets(WOLFSSL_BIO* bio, char* buf, int sz)
1061{
1062    int ret = WOLFSSL_BIO_UNSET;
1063
1064    WOLFSSL_ENTER("wolfSSL_BIO_gets");
1065
1066    if (bio == NULL || buf == NULL) {
1067        return WOLFSSL_FAILURE;
1068    }
1069
1070    /* not enough space for character plus terminator */
1071    if (sz <= 1) {
1072        return 0;
1073    }
1074
1075    /* info cb, abort if user returns <= 0*/
1076    if (bio->infoCb != NULL) {
1077        ret = (int)bio->infoCb(bio, WOLFSSL_BIO_CB_GETS, buf, sz, 0, 1);
1078        if (ret <= 0) {
1079            return ret;
1080        }
1081    }
1082
1083    /* check if is custom method */
1084    if (bio->method && bio->method->getsCb) {
1085        return bio->method->getsCb(bio, buf, sz);
1086    }
1087
1088    switch (bio->type) {
1089#ifndef NO_FILESYSTEM
1090        case WOLFSSL_BIO_FILE:
1091            if (bio->ptr.fh == XBADFILE) {
1092                return WOLFSSL_BIO_ERROR;
1093            }
1094
1095            #if defined(MICRIUM) || defined(LSR_FS) || defined(EBSNET)
1096            WOLFSSL_MSG("XFGETS not ported for this system yet");
1097            ret = XFGETS(buf, sz, bio->ptr.fh);
1098            #else
1099            if (XFGETS(buf, sz, bio->ptr.fh) != NULL) {
1100                ret = (int)XSTRLEN(buf);
1101            }
1102            else {
1103                ret = WOLFSSL_BIO_ERROR;
1104            }
1105            #endif
1106            break;
1107#endif /* NO_FILESYSTEM */
1108        case WOLFSSL_BIO_MEMORY:
1109            {
1110                const byte* c;
1111                int   cSz;
1112                cSz = wolfSSL_BIO_pending(bio);
1113                if (cSz == 0) {
1114                    ret = 0; /* Nothing to read */
1115                    buf[0] = '\0';
1116                    break;
1117                }
1118
1119                if (wolfSSL_BIO_get_mem_data(bio, (void*)&c) <= 0) {
1120                    ret = WOLFSSL_BIO_ERROR;
1121                    break;
1122                }
1123
1124                cSz = wolfSSL_getLineLength((char*)c, cSz);
1125                if (cSz >= sz) {
1126                    cSz = sz - 1;
1127                }
1128
1129                ret = wolfSSL_BIO_MEMORY_read(bio, (void*)buf, cSz);
1130                if (ret > 0) {
1131                    buf[ret] = '\0';
1132                }
1133                else {
1134                    buf[0] = '\0';
1135                }
1136                break;
1137            }
1138        case WOLFSSL_BIO_BIO:
1139            {
1140                char* c;
1141                int   cSz;
1142                cSz = wolfSSL_BIO_nread0(bio, &c);
1143                if (cSz <= 0) {
1144                    ret = 0; /* Nothing to read */
1145                    buf[0] = '\0';
1146                    break;
1147                }
1148
1149                cSz = wolfSSL_getLineLength(c, cSz);
1150                if (cSz >= sz) {
1151                    cSz = sz - 1;
1152                }
1153
1154                ret = wolfSSL_BIO_nread(bio, &c, cSz);
1155                if (ret > 0) {
1156                    XMEMCPY(buf, c, (size_t)ret);
1157                    buf[ret] = '\0';
1158                }
1159                else {
1160                    buf[0] = '\0';
1161                }
1162                break;
1163            }
1164
1165#ifndef WOLFCRYPT_ONLY
1166        /* call final on hash */
1167        case WOLFSSL_BIO_MD:
1168            if (wolfSSL_EVP_MD_CTX_size(bio->ptr.md_ctx) > sz) {
1169                WOLFSSL_MSG("Output buffer was too small for digest");
1170                ret = WOLFSSL_FAILURE;
1171            }
1172            else {
1173                unsigned int szOut = 0;
1174                ret = wolfSSL_EVP_DigestFinal(bio->ptr.md_ctx,
1175                        (unsigned char*)buf, &szOut);
1176                if (ret == WOLFSSL_SUCCESS) {
1177                    ret = (int)szOut;
1178                }
1179            }
1180            break;
1181#endif /* WOLFCRYPT_ONLY */
1182
1183        case WOLFSSL_BIO_NULL:
1184            ret = 0;
1185            break;
1186
1187        default:
1188            WOLFSSL_MSG("BIO type not supported yet with wolfSSL_BIO_gets");
1189    }
1190
1191    /* info cb, user can override return value */
1192    if (bio->infoCb != NULL) {
1193        ret = (int)bio->infoCb(bio, WOLFSSL_BIO_CB_GETS | WOLFSSL_BIO_CB_RETURN,
1194                               buf, sz, 0, ret);
1195    }
1196
1197    return ret;
1198}
1199
1200
1201/* Writes a null terminated string to bio.
1202 *
1203 * bio  the structure to write to
1204 * buf  buffer to holding input string
1205 *
1206 * returns the size of the result placed in bio on success and a 0 or negative
1207 *         value in an error case. -2 is returned if the implementation is not
1208 *         supported for the BIO type.
1209 */
1210int wolfSSL_BIO_puts(WOLFSSL_BIO* bio, const char* buf)
1211{
1212    int sz;
1213
1214    if (bio == NULL || buf == NULL) {
1215        return WOLFSSL_FATAL_ERROR;
1216    }
1217
1218    /* check if is custom method */
1219    if (bio->method && bio->method->putsCb) {
1220        return bio->method->putsCb(bio, buf);
1221    }
1222
1223    sz = (int)XSTRLEN(buf);
1224    if (sz <= 0) {
1225        return WOLFSSL_FATAL_ERROR;
1226    }
1227
1228    return wolfSSL_BIO_write(bio, buf, sz);
1229}
1230
1231
1232/* searches through bio list for a BIO of type "type"
1233 * returns NULL on failure to find a given type */
1234WOLFSSL_BIO* wolfSSL_BIO_find_type(WOLFSSL_BIO* bio, int type)
1235{
1236    WOLFSSL_BIO* local = NULL;
1237    WOLFSSL_BIO* current;
1238
1239    WOLFSSL_ENTER("wolfSSL_BIO_find_type");
1240
1241    if (bio == NULL) {
1242        return local;
1243    }
1244
1245    current = bio;
1246    while (current != NULL) {
1247        if (current->type == type) {
1248            WOLFSSL_MSG("Found matching WOLFSSL_BIO type");
1249            local = current;
1250            break;
1251        }
1252        current = current->next;
1253    }
1254
1255    return local;
1256}
1257
1258
1259/* returns a pointer to the next WOLFSSL_BIO in the chain on success.
1260 * If a failure case then NULL is returned */
1261WOLFSSL_BIO* wolfSSL_BIO_next(WOLFSSL_BIO* bio)
1262{
1263    WOLFSSL_ENTER("wolfSSL_BIO_next");
1264
1265    if (bio == NULL) {
1266        WOLFSSL_MSG("Bad argument passed in");
1267        return NULL;
1268    }
1269
1270    return bio->next;
1271}
1272
1273/* BIO_wpending returns the number of bytes pending to be written. */
1274size_t wolfSSL_BIO_wpending(const WOLFSSL_BIO *bio)
1275{
1276    WOLFSSL_ENTER("wolfSSL_BIO_wpending");
1277
1278    if (bio == NULL)
1279        return 0;
1280
1281    if (bio->type == WOLFSSL_BIO_MEMORY) {
1282        return (size_t)bio->wrSz;
1283    }
1284
1285    /* type BIO_BIO then check paired buffer */
1286    if (bio->type == WOLFSSL_BIO_BIO && bio->pair != NULL) {
1287        WOLFSSL_BIO* pair = bio->pair;
1288        return (size_t)pair->wrIdx;
1289    }
1290
1291    return 0;
1292}
1293
1294/* Custom wolfSSL API to check if current bio object supports checking
1295 * pending state.
1296 */
1297int wolfSSL_BIO_supports_pending(const WOLFSSL_BIO *bio)
1298{
1299    while (bio) {
1300        if (bio->type == WOLFSSL_BIO_SSL ||
1301                bio->type == WOLFSSL_BIO_MEMORY ||
1302                bio->type == WOLFSSL_BIO_BIO)
1303            return 1;
1304        bio = bio->next;
1305    }
1306    return 0;
1307}
1308
1309/* Return the number of pending bytes in read and write buffers */
1310size_t wolfSSL_BIO_ctrl_pending(WOLFSSL_BIO *bio)
1311{
1312#ifdef WOLFSSL_DEBUG_OPENSSL
1313    WOLFSSL_ENTER("wolfSSL_BIO_ctrl_pending");
1314#endif
1315
1316    for (; bio != NULL; bio = bio->next) {
1317        if (bio->method != NULL && bio->method->ctrlCb != NULL) {
1318            long ret;
1319            WOLFSSL_MSG("Calling custom BIO ctrl pending callback");
1320            ret = bio->method->ctrlCb(bio, WOLFSSL_BIO_CTRL_PENDING, 0, NULL);
1321            return (ret < 0) ? 0 : (size_t)ret;
1322        }
1323
1324        switch (bio->type) {
1325        case WOLFSSL_BIO_MD:
1326        case WOLFSSL_BIO_BASE64:
1327            /* wrappers only, skip to next bio in chain */
1328            continue;
1329#ifndef WOLFCRYPT_ONLY
1330        case WOLFSSL_BIO_SSL:
1331            if (bio->ptr.ssl != NULL)
1332                return (size_t)wolfSSL_pending(bio->ptr.ssl);
1333            return 0;
1334#endif
1335        case WOLFSSL_BIO_MEMORY:
1336            return (size_t)(bio->wrSz - bio->rdIdx);
1337        case WOLFSSL_BIO_BIO:
1338            if (bio->pair != NULL) {
1339                WOLFSSL_BIO* pair = bio->pair;
1340                if (pair->wrIdx > 0 && pair->wrIdx <= pair->rdIdx) {
1341                    /* wrap around state */
1342                    return ((size_t)pair->wrSz) - ((size_t)pair->rdIdx) +
1343                                                        ((size_t)pair->wrIdx);
1344                }
1345                else {
1346                    return (size_t)(pair->wrIdx - pair->rdIdx);
1347                }
1348            }
1349            return 0;
1350        default:
1351            return 0;
1352        }
1353    }
1354    return 0;
1355}
1356
1357
1358long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **ptr)
1359{
1360    WOLFSSL_BIO* front = bio;
1361    long ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
1362
1363    WOLFSSL_ENTER("wolfSSL_BIO_get_mem_ptr");
1364
1365    if (bio == NULL || ptr == NULL) {
1366        return WOLFSSL_FAILURE;
1367    }
1368
1369    /* start at end and work backwards to find a memory BIO in the BIO chain */
1370    while ((bio != NULL) && (bio->next != NULL)) {
1371        bio = bio->next;
1372    }
1373
1374    while (bio != NULL) {
1375
1376        if (bio->type == WOLFSSL_BIO_MEMORY) {
1377            *ptr = bio->mem_buf;
1378            ret = WOLFSSL_SUCCESS;
1379        }
1380
1381        if (bio == front) {
1382            break;
1383        }
1384        bio = bio->prev;
1385    }
1386
1387    if (ret == WOLFSSL_SUCCESS)
1388        return ret;
1389    else
1390        return WOLFSSL_FAILURE;
1391}
1392
1393#ifdef OPENSSL_ALL
1394    int wolfSSL_BIO_set_mem_buf(WOLFSSL_BIO* bio, WOLFSSL_BUF_MEM* bufMem,
1395                                int closeFlag)
1396    {
1397        if (!bio || !bufMem ||
1398           (closeFlag != WOLFSSL_BIO_NOCLOSE && closeFlag != WOLFSSL_BIO_CLOSE))
1399            return BAD_FUNC_ARG;
1400
1401        if (bio->mem_buf)
1402            if (closeFlag == BIO_CLOSE)
1403                wolfSSL_BUF_MEM_free(bio->mem_buf);
1404
1405        bio->mem_buf = bufMem;
1406        bio->shutdown = closeFlag ? WOLFSSL_BIO_CLOSE : WOLFSSL_BIO_NOCLOSE;
1407
1408        bio->wrSz = (int)bio->mem_buf->length;
1409        bio->wrSzReset = bio->wrSz;
1410        bio->num.length = bio->mem_buf->max;
1411        bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
1412        bio->wrIdx = 0;
1413        bio->rdIdx = 0;
1414
1415        return WOLFSSL_SUCCESS;
1416    }
1417#endif
1418
1419long wolfSSL_BIO_int_ctrl(WOLFSSL_BIO *bp, int cmd, long larg, int iarg)
1420{
1421    (void) bp;
1422    (void) cmd;
1423    (void) larg;
1424    (void) iarg;
1425    WOLFSSL_STUB("BIO_int_ctrl");
1426    return 0;
1427}
1428
1429
1430int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
1431{
1432    WOLFSSL_ENTER("wolfSSL_BIO_set_write_buf_size");
1433
1434    if (bio == NULL || bio->type != WOLFSSL_BIO_BIO || (int)size < 0) {
1435        return WOLFSSL_FAILURE;
1436    }
1437
1438    /* if already in pair then do not change size */
1439    if (bio->pair != NULL) {
1440        WOLFSSL_MSG("WOLFSSL_BIO is paired, free from pair before changing");
1441        return WOLFSSL_FAILURE;
1442    }
1443
1444    if (bio->ptr.mem_buf_data != NULL) {
1445        XFREE(bio->ptr.mem_buf_data, bio->heap, DYNAMIC_TYPE_OPENSSL);
1446    }
1447
1448    bio->ptr.mem_buf_data = (byte*)XMALLOC((size_t)size, bio->heap,
1449                                           DYNAMIC_TYPE_OPENSSL);
1450    if (bio->ptr.mem_buf_data == NULL) {
1451        WOLFSSL_MSG("Memory allocation error");
1452        bio->wrSz  = 0;
1453        bio->num.length = 0;
1454        bio->wrIdx = 0;
1455        bio->rdIdx = 0;
1456        if (bio->mem_buf != NULL) {
1457            bio->mem_buf->data = NULL;
1458            bio->mem_buf->length = 0;
1459            bio->mem_buf->max = 0;
1460        }
1461        return WOLFSSL_FAILURE;
1462    }
1463    bio->wrSz  = (int)size;
1464    bio->num.length = (size_t)size;
1465    bio->wrIdx = 0;
1466    bio->rdIdx = 0;
1467    if (bio->mem_buf != NULL) {
1468        bio->mem_buf->data = (char*)bio->ptr.mem_buf_data;
1469        bio->mem_buf->length = bio->num.length;
1470        bio->mem_buf->max = bio->num.length;
1471    }
1472
1473    return WOLFSSL_SUCCESS;
1474}
1475
1476
1477/* Joins two BIO_BIO types. The write of b1 goes to the read of b2 and vice
1478 * versa. Creating something similar to a two way pipe.
1479 * Reading and writing between the two BIOs is not thread safe, they are
1480 * expected to be used by the same thread. */
1481int wolfSSL_BIO_make_bio_pair(WOLFSSL_BIO *b1, WOLFSSL_BIO *b2)
1482{
1483    WOLFSSL_ENTER("wolfSSL_BIO_make_bio_pair");
1484
1485    if (b1 == NULL || b2 == NULL) {
1486        WOLFSSL_LEAVE("wolfSSL_BIO_make_bio_pair", BAD_FUNC_ARG);
1487        return WOLFSSL_FAILURE;
1488    }
1489
1490    /* both are expected to be of type BIO and not already paired */
1491    if (b1->type != WOLFSSL_BIO_BIO || b2->type != WOLFSSL_BIO_BIO ||
1492        b1->pair != NULL || b2->pair != NULL) {
1493        WOLFSSL_MSG("Expected type BIO and not already paired");
1494        return WOLFSSL_FAILURE;
1495    }
1496
1497    /* set default write size if not already set */
1498    if (b1->ptr.mem_buf_data == NULL && wolfSSL_BIO_set_write_buf_size(b1,
1499                            WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
1500        return WOLFSSL_FAILURE;
1501    }
1502
1503    if (b2->ptr.mem_buf_data == NULL && wolfSSL_BIO_set_write_buf_size(b2,
1504                            WOLFSSL_BIO_SIZE) != WOLFSSL_SUCCESS) {
1505        return WOLFSSL_FAILURE;
1506    }
1507
1508    b1->pair = b2;
1509    b2->pair = b1;
1510
1511    return WOLFSSL_SUCCESS;
1512}
1513
1514
1515int wolfSSL_BIO_ctrl_reset_read_request(WOLFSSL_BIO *b)
1516{
1517    WOLFSSL_ENTER("wolfSSL_BIO_ctrl_reset_read_request");
1518
1519    if (b == NULL || b->type == WOLFSSL_BIO_MEMORY) {
1520        return WOLFSSL_FAILURE;
1521    }
1522
1523    b->readRq = 0;
1524
1525    return WOLFSSL_SUCCESS;
1526}
1527
1528
1529/* Does not advance read index pointer */
1530int wolfSSL_BIO_nread0(WOLFSSL_BIO *bio, char **buf)
1531{
1532    WOLFSSL_ENTER("wolfSSL_BIO_nread0");
1533
1534    if (bio == NULL || buf == NULL) {
1535        WOLFSSL_MSG("NULL argument passed in");
1536        return -2;
1537    }
1538
1539    /* if paired read from pair */
1540    if (bio->pair != NULL) {
1541        WOLFSSL_BIO* pair = bio->pair;
1542
1543        /* case where have wrapped around write buffer */
1544        *buf = (char*)pair->ptr.mem_buf_data + pair->rdIdx;
1545        if (pair->wrIdx > 0 && pair->rdIdx >= pair->wrIdx) {
1546            return pair->wrSz - pair->rdIdx;
1547        }
1548        else {
1549            return pair->wrIdx - pair->rdIdx;
1550        }
1551    }
1552
1553    return -2;
1554}
1555
1556
1557/* similar to wolfSSL_BIO_nread0 but advances the read index */
1558int wolfSSL_BIO_nread(WOLFSSL_BIO *bio, char **buf, int num)
1559{
1560    int sz = WOLFSSL_BIO_UNSET;
1561
1562    WOLFSSL_ENTER("wolfSSL_BIO_nread");
1563
1564    if (bio == NULL || buf == NULL) {
1565        WOLFSSL_MSG("NULL argument passed in");
1566        return WOLFSSL_FAILURE;
1567    }
1568
1569    if (bio->type == WOLFSSL_BIO_MEMORY) {
1570        return WOLFSSL_FAILURE;
1571    }
1572
1573    if (bio->pair != NULL) {
1574        /* special case if asking to read 0 bytes */
1575        if (num == 0) {
1576            *buf = (char*)bio->pair->ptr.mem_buf_data + bio->pair->rdIdx;
1577            return 0;
1578        }
1579
1580        if (num < 0) {
1581            return WOLFSSL_BIO_ERROR;
1582        }
1583
1584        /* get amount able to read and set buffer pointer */
1585        sz = wolfSSL_BIO_nread0(bio, buf);
1586        if (sz < 0) {
1587            return WOLFSSL_BIO_ERROR;
1588        }
1589
1590        if (num < sz) {
1591            sz = num;
1592        }
1593        bio->pair->rdIdx += sz;
1594#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
1595        bio->pair->bytes_read += (word32)sz;
1596#endif
1597
1598        /* check if have read to the end of the buffer and need to reset */
1599        if (bio->pair->rdIdx == bio->pair->wrSz) {
1600            bio->pair->rdIdx = 0;
1601            if (bio->pair->wrIdx == bio->pair->wrSz) {
1602                bio->pair->wrIdx = 0;
1603            }
1604        }
1605
1606        /* check if read up to write index, if so then reset index */
1607        if (bio->pair->rdIdx == bio->pair->wrIdx) {
1608            bio->pair->rdIdx = 0;
1609            bio->pair->wrIdx = 0;
1610        }
1611    }
1612
1613    return sz;
1614}
1615
1616
1617int wolfSSL_BIO_nwrite(WOLFSSL_BIO *bio, char **buf, int num)
1618{
1619    int sz = WOLFSSL_BIO_UNSET;
1620
1621    WOLFSSL_ENTER("wolfSSL_BIO_nwrite");
1622
1623    if (bio == NULL || buf == NULL) {
1624        WOLFSSL_MSG("NULL argument passed in");
1625        return 0;
1626    }
1627
1628    if (bio->type != WOLFSSL_BIO_BIO) {
1629        return WOLFSSL_FAILURE;
1630    }
1631
1632    if (bio->pair != NULL) {
1633        if (num == 0) {
1634            *buf = (char*)bio->ptr.mem_buf_data + bio->wrIdx;
1635            return 0;
1636        }
1637
1638        if (num < 0) {
1639            return WOLFSSL_BIO_ERROR;
1640        }
1641
1642        if (bio->wrIdx < bio->rdIdx) {
1643            /* if wrapped around only write up to read index. In this case
1644             * rdIdx is always greater then wrIdx so sz will not be negative. */
1645            sz = bio->rdIdx - bio->wrIdx;
1646        }
1647        else if (bio->rdIdx > 0 && bio->wrIdx == bio->rdIdx) {
1648            return WOLFSSL_BIO_ERROR; /* no more room to write */
1649        }
1650        else {
1651            /* write index is past read index so write to end of buffer */
1652            sz = bio->wrSz - bio->wrIdx;
1653
1654            if (sz <= 0) {
1655                /* either an error has occurred with write index or it is at the
1656                 * end of the write buffer. */
1657                if (bio->rdIdx == 0) {
1658                    /* no more room, nothing has been read */
1659                    return WOLFSSL_BIO_ERROR;
1660                }
1661
1662                bio->wrIdx = 0;
1663
1664                /* check case where read index is not at 0 */
1665                if (bio->rdIdx > 0) {
1666                    sz = bio->rdIdx; /* can write up to the read index */
1667                }
1668                else {
1669                    sz = bio->wrSz; /* no restriction other then buffer size */
1670                }
1671            }
1672        }
1673
1674        if (num < sz) {
1675            sz = num;
1676        }
1677        *buf = (char*)bio->ptr.mem_buf_data + bio->wrIdx;
1678        bio->wrIdx += sz;
1679#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
1680        bio->bytes_written += (word32)sz;
1681#endif
1682
1683        /* if at the end of the buffer and space for wrap around then set
1684         * write index back to 0 */
1685        if (bio->wrIdx == bio->wrSz && bio->rdIdx > 0) {
1686            bio->wrIdx = 0;
1687        }
1688    }
1689
1690    return sz;
1691}
1692
1693#ifdef WOLFSSL_BIO_HAVE_FLOW_STATS
1694word64 wolfSSL_BIO_number_read(WOLFSSL_BIO *bio)
1695{
1696    word64 ret = 0;
1697    if (bio == NULL) {
1698        WOLFSSL_MSG("NULL argument passed in");
1699        return 0;
1700    }
1701    while (bio) {
1702        ret += bio->bytes_read;
1703        bio = bio->next;
1704    }
1705
1706    return ret;
1707}
1708
1709word64 wolfSSL_BIO_number_written(WOLFSSL_BIO *bio)
1710{
1711    word64 ret = 0;
1712    if (bio == NULL) {
1713        WOLFSSL_MSG("NULL argument passed in");
1714        return 0;
1715    }
1716    while (bio) {
1717        ret += bio->bytes_written;
1718        bio = bio->next;
1719    }
1720
1721    return ret;
1722}
1723#endif /* WOLFSSL_BIO_HAVE_FLOW_STATS */
1724
1725/* Reset BIO to initial state */
1726int wolfSSL_BIO_reset(WOLFSSL_BIO *bio)
1727{
1728    WOLFSSL_ENTER("wolfSSL_BIO_reset");
1729
1730    if (bio == NULL) {
1731        WOLFSSL_MSG("NULL argument passed in");
1732        /* -1 is consistent failure even for FILE type */
1733        return WOLFSSL_BIO_ERROR;
1734    }
1735
1736    if (bio->method != NULL && bio->method->ctrlCb != NULL) {
1737        WOLFSSL_MSG("Calling custom BIO reset callback");
1738        return (int)bio->method->ctrlCb(bio, WOLFSSL_BIO_CTRL_RESET, 0, NULL);
1739    }
1740
1741    switch (bio->type) {
1742        #ifndef NO_FILESYSTEM
1743        case WOLFSSL_BIO_FILE:
1744            if (XFSEEK(bio->ptr.fh, 0, XSEEK_SET) != 0)
1745                return WOLFSSL_BIO_ERROR;
1746            else
1747                return WOLFSSL_SUCCESS;
1748        #endif
1749
1750        case WOLFSSL_BIO_BIO:
1751            bio->rdIdx = 0;
1752            bio->wrIdx = 0;
1753            return WOLFSSL_SUCCESS;
1754
1755        case WOLFSSL_BIO_MEMORY:
1756            bio->rdIdx = 0;
1757            if (bio->flags & WOLFSSL_BIO_FLAG_MEM_RDONLY) {
1758                bio->wrIdx = bio->wrSzReset;
1759                bio->wrSz  = bio->wrSzReset;
1760            }
1761            else {
1762                bio->wrSz  = 0;
1763                XFREE(bio->ptr.mem_buf_data, bio->heap, DYNAMIC_TYPE_OPENSSL);
1764                bio->ptr.mem_buf_data = NULL;
1765                bio->num.length = 0;
1766                if (bio->mem_buf != NULL) {
1767                    bio->mem_buf->data = NULL;
1768                    bio->mem_buf->length = 0;
1769                    bio->mem_buf->max = 0;
1770                }
1771            }
1772            return WOLFSSL_SUCCESS;
1773
1774#ifndef WOLFCRYPT_ONLY
1775        case WOLFSSL_BIO_MD:
1776            if (bio->ptr.md_ctx != NULL) {
1777                const WOLFSSL_EVP_MD* md =
1778                    wolfSSL_EVP_MD_CTX_md(bio->ptr.md_ctx);
1779                wolfSSL_EVP_MD_CTX_cleanup(bio->ptr.md_ctx);
1780                wolfSSL_EVP_MD_CTX_init(bio->ptr.md_ctx);
1781                wolfSSL_EVP_DigestInit(bio->ptr.md_ctx, md);
1782            }
1783            return WOLFSSL_SUCCESS;
1784#endif /* WOLFCRYPT_ONLY */
1785
1786        default:
1787            WOLFSSL_MSG("Unknown BIO type needs added to reset function");
1788    }
1789
1790    return WOLFSSL_BIO_ERROR;
1791}
1792
1793#ifndef NO_FILESYSTEM
1794/**
1795 * Creates a new file BIO object
1796 * @param fd file descriptor for to use for the new object
1797 * @param close_flag BIO_NOCLOSE or BIO_CLOSE
1798 * @return New BIO object or NULL on failure
1799 */
1800WOLFSSL_BIO *wolfSSL_BIO_new_fd(int fd, int close_flag)
1801{
1802    WOLFSSL_BIO* bio;
1803
1804    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
1805    if (!bio) {
1806        WOLFSSL_MSG("wolfSSL_BIO_new error");
1807        return NULL;
1808    }
1809
1810    if (wolfSSL_BIO_set_fd(bio, fd, close_flag) != WOLFSSL_SUCCESS) {
1811        wolfSSL_BIO_free(bio);
1812        WOLFSSL_MSG("wolfSSL_BIO_set_fp error");
1813        return NULL;
1814    }
1815
1816    return bio;
1817}
1818
1819long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c)
1820{
1821    WOLFSSL_ENTER("wolfSSL_BIO_set_fp");
1822
1823    if (bio == NULL || fp == XBADFILE) {
1824        WOLFSSL_LEAVE("wolfSSL_BIO_set_fp", BAD_FUNC_ARG);
1825        return WOLFSSL_FAILURE;
1826    }
1827
1828    if (bio->type != WOLFSSL_BIO_FILE) {
1829        return WOLFSSL_FAILURE;
1830    }
1831
1832    bio->shutdown = (byte)c;
1833    bio->ptr.fh = fp;
1834
1835    return WOLFSSL_SUCCESS;
1836}
1837
1838
1839long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp)
1840{
1841    WOLFSSL_ENTER("wolfSSL_BIO_get_fp");
1842
1843    if (bio == NULL || fp == NULL) {
1844        return WOLFSSL_FAILURE;
1845    }
1846
1847    if (bio->type != WOLFSSL_BIO_FILE) {
1848        return WOLFSSL_FAILURE;
1849    }
1850
1851    *fp = bio->ptr.fh;
1852
1853    return WOLFSSL_SUCCESS;
1854}
1855
1856/* overwrites file */
1857int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
1858{
1859    WOLFSSL_ENTER("wolfSSL_BIO_write_filename");
1860
1861    if (bio == NULL || name == NULL) {
1862        return WOLFSSL_FAILURE;
1863    }
1864
1865    if (bio->type == WOLFSSL_BIO_FILE) {
1866        if (bio->ptr.fh != XBADFILE && bio->shutdown == WOLFSSL_BIO_CLOSE) {
1867            XFCLOSE(bio->ptr.fh);
1868        }
1869
1870        /* 'b' flag is ignored on POSIX targets, but on Windows it assures
1871         * inhibition of LF<->CRLF rewriting, so that there is consistency
1872         * between the size and contents of the representation in memory and on
1873         * disk.
1874         */
1875        bio->ptr.fh = XFOPEN(name, "wb");
1876        if (bio->ptr.fh == XBADFILE) {
1877            return WOLFSSL_FAILURE;
1878        }
1879        bio->shutdown = WOLFSSL_BIO_CLOSE;
1880
1881        return WOLFSSL_SUCCESS;
1882    }
1883
1884    return WOLFSSL_FAILURE;
1885}
1886
1887
1888int wolfSSL_BIO_seek(WOLFSSL_BIO *bio, int ofs)
1889{
1890      WOLFSSL_ENTER("wolfSSL_BIO_seek");
1891
1892      if (bio == NULL) {
1893          return WOLFSSL_FATAL_ERROR;
1894      }
1895
1896      /* offset ofs from beginning of file */
1897      if (bio->type == WOLFSSL_BIO_FILE &&
1898              XFSEEK(bio->ptr.fh, ofs, SEEK_SET) < 0) {
1899          return WOLFSSL_FATAL_ERROR;
1900      }
1901
1902      return 0;
1903}
1904/* wolfSSL_BIO_tell is provided as compatible API with
1905 * BIO_tell which returns the current file position of a file related BIO.
1906 * Returns the current file position on success and -1 for failure.
1907 * Returns 0 for a BIOs except file related BIO.
1908 */
1909int wolfSSL_BIO_tell(WOLFSSL_BIO* bio)
1910{
1911    int pos;
1912
1913    WOLFSSL_ENTER("wolfSSL_BIO_tell");
1914
1915    if (bio == NULL) {
1916        return WOLFSSL_FATAL_ERROR;
1917    }
1918
1919    if (bio->type != WOLFSSL_BIO_FILE) {
1920        return 0;
1921    }
1922
1923    pos = (int)XFTELL(bio->ptr.fh);
1924    if (pos < 0)
1925        return WOLFSSL_FATAL_ERROR;
1926    else
1927        return pos;
1928}
1929#endif /* NO_FILESYSTEM */
1930
1931
1932long wolfSSL_BIO_set_mem_eof_return(WOLFSSL_BIO *bio, int v)
1933{
1934    WOLFSSL_ENTER("wolfSSL_BIO_set_mem_eof_return");
1935
1936    if (bio != NULL && bio->type == WOLFSSL_BIO_MEMORY) {
1937        bio->eof = v;
1938        return WOLFSSL_SUCCESS;
1939    }
1940    else
1941        return WOLFSSL_FAILURE;
1942}
1943
1944int wolfSSL_BIO_get_len(WOLFSSL_BIO *bio)
1945{
1946    int len = 0;
1947#ifndef NO_FILESYSTEM
1948    long memSz = 0;
1949    XFILE file;
1950#endif
1951
1952    WOLFSSL_ENTER("wolfSSL_BIO_get_len");
1953
1954    if (bio == NULL) {
1955        WOLFSSL_MSG("WOLFSSL_BIO was null");
1956        len = BAD_FUNC_ARG;
1957    }
1958    else if ((len = wolfSSL_BIO_pending(bio)) > 0) {
1959    }
1960#ifndef NO_FILESYSTEM
1961    else if (bio->type == WOLFSSL_BIO_FILE) {
1962        if (wolfSSL_BIO_get_fp(bio, &file) != WOLFSSL_SUCCESS)
1963            len = BAD_FUNC_ARG;
1964        if (len == 0) {
1965            len = wolfssl_file_len(file, &memSz);
1966            if (len == WC_NO_ERR_TRACE(WOLFSSL_BAD_FILETYPE))
1967                len = 0;
1968        }
1969        if (len == 0) {
1970            len = (int)memSz;
1971        }
1972    }
1973#endif
1974    return len;
1975}
1976
1977
1978void wolfSSL_BIO_set_callback(WOLFSSL_BIO *bio, wolf_bio_info_cb callback_func)
1979{
1980    WOLFSSL_ENTER("wolfSSL_BIO_set_callback");
1981
1982    if (bio != NULL) {
1983        bio->infoCb = callback_func;
1984    }
1985}
1986
1987
1988wolf_bio_info_cb wolfSSL_BIO_get_callback(WOLFSSL_BIO *bio)
1989{
1990    WOLFSSL_ENTER("wolfSSL_BIO_get_callback");
1991
1992    if (bio != NULL) {
1993        return bio->infoCb;
1994    }
1995
1996    return NULL;
1997}
1998
1999
2000void wolfSSL_BIO_set_callback_arg(WOLFSSL_BIO *bio, char *arg)
2001{
2002    WOLFSSL_ENTER("wolfSSL_BIO_set_callback_arg");
2003
2004    if (bio != NULL) {
2005        bio->infoArg = arg;
2006    }
2007}
2008
2009
2010char* wolfSSL_BIO_get_callback_arg(const WOLFSSL_BIO *bio)
2011{
2012    WOLFSSL_ENTER("wolfSSL_BIO_get_callback_arg");
2013
2014    if (bio != NULL) {
2015        return bio->infoArg;
2016    }
2017
2018    return NULL;
2019}
2020
2021
2022/* store a user pointer in the WOLFSSL_BIO structure */
2023void wolfSSL_BIO_set_data(WOLFSSL_BIO* bio, void *ptr)
2024{
2025    WOLFSSL_ENTER("wolfSSL_BIO_set_data");
2026
2027    if (bio != NULL) {
2028        bio->usrCtx = ptr;
2029    }
2030}
2031
2032
2033void* wolfSSL_BIO_get_data(WOLFSSL_BIO* bio)
2034{
2035    WOLFSSL_ENTER("wolfSSL_BIO_get_data");
2036
2037    if (bio != NULL)
2038        return bio->usrCtx;
2039
2040    WOLFSSL_MSG("WOLFSSL_BIO was null");
2041    return NULL;
2042}
2043
2044void wolfSSL_BIO_set_init(WOLFSSL_BIO* bio, int init)
2045{
2046    WOLFSSL_ENTER("wolfSSL_BIO_set_init");
2047    if (bio != NULL)
2048        bio->init = (byte)(init != 0);
2049}
2050
2051int wolfSSL_BIO_get_init(WOLFSSL_BIO* bio)
2052{
2053    WOLFSSL_ENTER("wolfSSL_BIO_get_init");
2054    return bio != NULL && bio->init;
2055}
2056
2057/* If flag is 0 then blocking is set, if 1 then non blocking.
2058 * Always returns WOLFSSL_SUCCESS.
2059 */
2060long wolfSSL_BIO_set_nbio(WOLFSSL_BIO* bio, long on)
2061{
2062    WOLFSSL_ENTER("wolfSSL_BIO_set_nbio");
2063
2064    if (bio) {
2065        switch (bio->type) {
2066            case WOLFSSL_BIO_SOCKET:
2067            case WOLFSSL_BIO_DGRAM:
2068            #ifdef XFCNTL
2069                {
2070                    int ret;
2071                    int flag = XFCNTL(bio->num.fd, F_GETFL, 0);
2072                    if (on) {
2073                        ret = XFCNTL(bio->num.fd, F_SETFL, flag | O_NONBLOCK);
2074                    }
2075                    else {
2076                        ret = XFCNTL(bio->num.fd, F_SETFL, flag & ~O_NONBLOCK);
2077                    }
2078
2079                    if (ret == -1) {
2080                        WOLFSSL_MSG("Call to XFCNTL failed");
2081                    }
2082                }
2083            #endif
2084                break;
2085            case WOLFSSL_BIO_SSL:
2086            #ifdef WOLFSSL_DTLS
2087                wolfSSL_dtls_set_using_nonblock(bio->ptr.ssl, (int)on);
2088            #endif
2089                break;
2090
2091            default:
2092                WOLFSSL_MSG("Unsupported bio type for non blocking");
2093                break;
2094        }
2095    }
2096
2097    (void)on;
2098
2099    return WOLFSSL_SUCCESS;
2100}
2101
2102/* creates a new custom WOLFSSL_BIO_METHOD */
2103WOLFSSL_BIO_METHOD *wolfSSL_BIO_meth_new(int type, const char *name)
2104{
2105    WOLFSSL_BIO_METHOD* meth;
2106
2107    WOLFSSL_ENTER("wolfSSL_BIO_meth_new");
2108
2109    meth = (WOLFSSL_BIO_METHOD*)XMALLOC(sizeof(WOLFSSL_BIO_METHOD), NULL,
2110            DYNAMIC_TYPE_OPENSSL);
2111    if (meth == NULL) {
2112        WOLFSSL_MSG("Error allocating memory for WOLFSSL_BIO_METHOD");
2113        return NULL;
2114    }
2115    XMEMSET(meth, 0, sizeof(WOLFSSL_BIO_METHOD));
2116    meth->type = type;
2117    XSTRNCPY(meth->name, name, MAX_BIO_METHOD_NAME - 1);
2118
2119    return meth;
2120}
2121
2122
2123void wolfSSL_BIO_meth_free(WOLFSSL_BIO_METHOD *biom)
2124{
2125    WOLFSSL_ENTER("wolfSSL_BIO_meth_free");
2126    XFREE(biom, NULL, DYNAMIC_TYPE_OPENSSL);
2127}
2128
2129
2130int wolfSSL_BIO_meth_set_write(WOLFSSL_BIO_METHOD *biom,
2131        wolfSSL_BIO_meth_write_cb biom_write)
2132{
2133    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_write");
2134    if (biom) {
2135        biom->writeCb = biom_write;
2136        return WOLFSSL_SUCCESS;
2137    }
2138    return WOLFSSL_FAILURE;
2139}
2140
2141
2142int wolfSSL_BIO_meth_set_read(WOLFSSL_BIO_METHOD *biom,
2143        wolfSSL_BIO_meth_read_cb biom_read)
2144{
2145    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_read");
2146    if (biom) {
2147        biom->readCb = biom_read;
2148        return WOLFSSL_SUCCESS;
2149    }
2150    return WOLFSSL_FAILURE;
2151}
2152
2153
2154int wolfSSL_BIO_meth_set_puts(WOLFSSL_BIO_METHOD *biom,
2155        wolfSSL_BIO_meth_puts_cb biom_puts)
2156{
2157    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_puts");
2158    if (biom) {
2159        biom->putsCb = biom_puts;
2160        return WOLFSSL_SUCCESS;
2161    }
2162    return WOLFSSL_FAILURE;
2163}
2164
2165
2166int wolfSSL_BIO_meth_set_gets(WOLFSSL_BIO_METHOD *biom,
2167        wolfSSL_BIO_meth_gets_cb biom_gets)
2168{
2169    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_gets");
2170    if (biom) {
2171        biom->getsCb = biom_gets;
2172        return WOLFSSL_SUCCESS;
2173    }
2174    return WOLFSSL_FAILURE;
2175}
2176
2177
2178int wolfSSL_BIO_meth_set_ctrl(WOLFSSL_BIO_METHOD *biom,
2179        wolfSSL_BIO_meth_ctrl_get_cb biom_ctrl)
2180{
2181    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_ctrl");
2182    if (biom) {
2183        biom->ctrlCb = biom_ctrl;
2184        return WOLFSSL_SUCCESS;
2185    }
2186    return WOLFSSL_FAILURE;
2187}
2188
2189
2190int wolfSSL_BIO_meth_set_create(WOLFSSL_BIO_METHOD *biom,
2191        wolfSSL_BIO_meth_create_cb biom_create)
2192{
2193    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_create");
2194    if (biom) {
2195        biom->createCb = biom_create;
2196        return WOLFSSL_SUCCESS;
2197    }
2198    return WOLFSSL_FAILURE;
2199}
2200
2201
2202int wolfSSL_BIO_meth_set_destroy(WOLFSSL_BIO_METHOD *biom,
2203        wolfSSL_BIO_meth_destroy_cb biom_destroy)
2204{
2205    WOLFSSL_ENTER("wolfSSL_BIO_meth_set_destroy");
2206    if (biom) {
2207        biom->freeCb = biom_destroy;
2208        return WOLFSSL_SUCCESS;
2209    }
2210    return WOLFSSL_FAILURE;
2211}
2212
2213
2214/* this compatibility function can be used for multiple BIO types */
2215int wolfSSL_BIO_get_mem_data(WOLFSSL_BIO* bio, void* p)
2216{
2217    WOLFSSL_BIO* mem_bio;
2218
2219#ifdef WOLFSSL_DEBUG_OPENSSL
2220    WOLFSSL_ENTER("wolfSSL_BIO_get_mem_data");
2221#endif
2222
2223    if (bio == NULL)
2224        return WOLFSSL_FATAL_ERROR;
2225    if (bio->method != NULL && bio->method->ctrlCb != NULL) {
2226        WOLFSSL_MSG("Calling custom BIO get mem data callback");
2227        return (int)bio->method->ctrlCb(bio, WOLFSSL_BIO_CTRL_INFO, 0, p);
2228    }
2229    mem_bio = bio;
2230    /* Return pointer from last memory BIO in chain */
2231    while (bio->next) {
2232        bio = bio->next;
2233        if (bio->type == WOLFSSL_BIO_MEMORY)
2234            mem_bio = bio;
2235    }
2236
2237    if (p) {
2238        *(byte**)p = mem_bio->ptr.mem_buf_data + mem_bio->rdIdx;
2239    }
2240
2241    return mem_bio->wrSz - mem_bio->rdIdx;
2242}
2243
2244int wolfSSL_BIO_pending(WOLFSSL_BIO* bio)
2245{
2246    return (int)wolfSSL_BIO_ctrl_pending(bio);
2247}
2248
2249
2250int wolfSSL_BIO_flush(WOLFSSL_BIO* bio)
2251{
2252    WOLFSSL_ENTER("wolfSSL_BIO_flush");
2253
2254    if (bio == NULL)
2255        return WOLFSSL_FAILURE;
2256
2257    if (bio->method != NULL && bio->method->ctrlCb != NULL) {
2258        WOLFSSL_MSG("Calling custom BIO flush callback");
2259        return (int)bio->method->ctrlCb(bio, WOLFSSL_BIO_CTRL_FLUSH, 0, NULL);
2260    }
2261    else if (bio->type == WOLFSSL_BIO_FILE) {
2262#if !defined(NO_FILESYSTEM) && defined(XFFLUSH)
2263        if (XFFLUSH(bio->ptr.fh) != 0)
2264            return WOLFSSL_FAILURE;
2265
2266#endif /* !NO_FILESYSTEM && XFFLUSH */
2267    }
2268    return WOLFSSL_SUCCESS;
2269}
2270
2271
2272#ifdef OPENSSL_EXTRA
2273
2274    WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_md(void)
2275    {
2276        static WOLFSSL_BIO_METHOD meth =
2277                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_MD);
2278
2279        WOLFSSL_ENTER("wolfSSL_BIO_f_md");
2280
2281        return &meth;
2282    }
2283
2284    /* return the context and initialize the BIO state */
2285    int wolfSSL_BIO_get_md_ctx(WOLFSSL_BIO *bio, WOLFSSL_EVP_MD_CTX **mdcp)
2286    {
2287        int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
2288
2289        if ((bio != NULL) && (mdcp != NULL)) {
2290            *mdcp = bio->ptr.md_ctx;
2291            ret = WOLFSSL_SUCCESS;
2292        }
2293
2294        if (ret == WOLFSSL_SUCCESS)
2295            return ret;
2296        else
2297            return WOLFSSL_FAILURE;
2298    }
2299
2300    WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_buffer(void)
2301    {
2302        static WOLFSSL_BIO_METHOD meth =
2303                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BUFFER);
2304
2305        WOLFSSL_ENTER("wolfSSL_BIO_f_buffer");
2306
2307        return &meth;
2308    }
2309
2310    #ifndef NO_WOLFSSL_STUB
2311    long wolfSSL_BIO_set_write_buffer_size(WOLFSSL_BIO* bio, long size)
2312    {
2313        /* wolfSSL has internal buffer, compatibility only */
2314        WOLFSSL_STUB("BIO_set_write_buffer_size");
2315
2316        WOLFSSL_MSG("Buffer resize failed");
2317
2318        (void)bio;
2319        (void)size;
2320
2321        /* Even though this is only a STUB at the moment many user applications
2322         * may attempt to use this. OpenSSL documentation specifies the return
2323         * "return 1 if the buffer was successfully resized or 0 for failure."
2324         * since wolfSSL does not resize the buffer will always return failure
2325         * by default due to memory concerns until this stub is promoted to
2326         * a non-stub function */
2327        return WOLFSSL_FAILURE; /* 0, no resize happened */
2328    }
2329    #endif
2330
2331    WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_bio(void)
2332    {
2333        static WOLFSSL_BIO_METHOD bio_meth =
2334                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BIO);
2335
2336        WOLFSSL_ENTER("wolfSSL_BIO_s_bio");
2337
2338        return &bio_meth;
2339    }
2340
2341
2342#ifndef NO_FILESYSTEM
2343    WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_file(void)
2344    {
2345        static WOLFSSL_BIO_METHOD file_meth =
2346                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_FILE);
2347
2348        WOLFSSL_ENTER("wolfSSL_BIO_s_file");
2349
2350        return &file_meth;
2351    }
2352#endif
2353
2354
2355    WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_ssl(void)
2356    {
2357        static WOLFSSL_BIO_METHOD meth =
2358                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_SSL);
2359
2360        WOLFSSL_ENTER("wolfSSL_BIO_f_ssl");
2361
2362        return &meth;
2363    }
2364
2365    WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_null(void)
2366    {
2367        static WOLFSSL_BIO_METHOD meth =
2368                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_NULL);
2369
2370        WOLFSSL_ENTER("wolfSSL_BIO_s_null");
2371
2372        return &meth;
2373    }
2374
2375    WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_socket(void)
2376    {
2377        static WOLFSSL_BIO_METHOD meth =
2378                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_SOCKET);
2379
2380        WOLFSSL_ENTER("wolfSSL_BIO_s_socket");
2381
2382        return &meth;
2383    }
2384
2385
2386    WOLFSSL_BIO* wolfSSL_BIO_new_socket(int sfd, int closeF)
2387    {
2388        WOLFSSL_BIO* bio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket());
2389
2390        WOLFSSL_ENTER("wolfSSL_BIO_new_socket");
2391        if (bio) {
2392            bio->type  = WOLFSSL_BIO_SOCKET;
2393            bio->shutdown = (byte)closeF;
2394            bio->num.fd = (SOCKET_T)sfd;
2395        }
2396        return bio;
2397    }
2398
2399
2400#if defined(WOLFSSL_HAVE_BIO_ADDR) && defined(WOLFSSL_DTLS)
2401    WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_datagram(void)
2402    {
2403        static WOLFSSL_BIO_METHOD meth =
2404                WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_DGRAM);
2405
2406        WOLFSSL_ENTER("wolfSSL_BIO_s_datagram");
2407
2408        return &meth;
2409    }
2410
2411
2412    WOLFSSL_BIO* wolfSSL_BIO_new_dgram(int fd, int closeF)
2413    {
2414        WOLFSSL_BIO* bio = wolfSSL_BIO_new(wolfSSL_BIO_s_datagram());
2415
2416        WOLFSSL_ENTER("wolfSSL_BIO_new_dgram");
2417        if (bio) {
2418            bio->shutdown = (byte)closeF;
2419            bio->num.fd = (SOCKET_T)fd;
2420        }
2421        return bio;
2422    }
2423#endif
2424
2425
2426    /**
2427     * Create new socket BIO object. This is a pure TCP connection with
2428     * no SSL or TLS protection.
2429     * @param str IP address to connect to
2430     * @return New BIO object or NULL on failure
2431     */
2432    WOLFSSL_BIO *wolfSSL_BIO_new_connect(const char *str)
2433    {
2434        WOLFSSL_BIO *bio;
2435        WOLFSSL_ENTER("wolfSSL_BIO_new_connect");
2436        bio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket());
2437        if (bio) {
2438            const char* port;
2439#ifdef WOLFSSL_IPV6
2440            const char* ipv6Start = XSTRSTR(str, "[");
2441            const char* ipv6End = XSTRSTR(str, "]");
2442
2443            if (ipv6End)
2444                port = XSTRSTR(ipv6End, ":");
2445            else
2446#endif
2447                port = XSTRSTR(str, ":");
2448
2449            if (port != NULL)
2450                bio->port = (word16)XATOI(port + 1);
2451            else
2452                port = str + XSTRLEN(str); /* point to null terminator */
2453
2454#ifdef WOLFSSL_IPV6
2455            if (ipv6Start && ipv6End) {
2456                str = ipv6Start + 1;
2457                port = ipv6End;
2458            }
2459#endif
2460            bio->ip = (char*)XMALLOC(
2461                    (size_t)(port - str) + 1, /* +1 for null char */
2462                    bio->heap, DYNAMIC_TYPE_OPENSSL);
2463            if (bio->ip != NULL) {
2464                XMEMCPY(bio->ip, str, (size_t)(port - str));
2465                bio->ip[port - str] = '\0';
2466                bio->type  = WOLFSSL_BIO_SOCKET;
2467            }
2468            else {
2469                wolfSSL_BIO_free(bio);
2470                bio = NULL;
2471            }
2472        }
2473        return bio;
2474    }
2475
2476    /**
2477     * Create new socket BIO object. This is a pure TCP connection with
2478     * no SSL or TLS protection.
2479     * @param port port  to connect to
2480     * @return New BIO object or NULL on failure
2481     */
2482    WOLFSSL_BIO *wolfSSL_BIO_new_accept(const char *port)
2483    {
2484        WOLFSSL_BIO *bio;
2485        WOLFSSL_ENTER("wolfSSL_BIO_new_accept");
2486
2487        if (port == NULL) {
2488            return NULL;
2489        }
2490
2491        bio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket());
2492        if (bio) {
2493            const char* portStr = port;
2494#ifdef WOLFSSL_IPV6
2495            const char* ipv6End = XSTRSTR(port, "]");
2496            if (ipv6End) {
2497                portStr = XSTRSTR(ipv6End, ":");
2498            }
2499#endif
2500            bio->port = (word16)XATOI(portStr);
2501            bio->type  = WOLFSSL_BIO_SOCKET;
2502        }
2503        return bio;
2504    }
2505
2506
2507    /**
2508     * Set the port to connect to in the BIO object
2509     * @param b BIO object
2510     * @param port destination port
2511     * @return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure
2512     */
2513    long wolfSSL_BIO_set_conn_port(WOLFSSL_BIO *b, char* port)
2514    {
2515        int p;
2516        WOLFSSL_ENTER("wolfSSL_BIO_set_conn_port");
2517
2518        if (!b || !port) {
2519            WOLFSSL_MSG("Bad parameter");
2520            return WOLFSSL_FAILURE;
2521        }
2522
2523        p = XATOI(port);
2524        if (!p || p < 0) {
2525            WOLFSSL_MSG("Port parsing error");
2526            return WOLFSSL_FAILURE;
2527        }
2528
2529        while (b != NULL && b->type != WOLFSSL_BIO_SOCKET) {
2530            b = b->next;
2531        }
2532        if (b == NULL) {
2533            WOLFSSL_MSG("Failed to find socket BIO in chain.");
2534            return WOLFSSL_FAILURE;
2535        }
2536
2537        b->port = (word16)p;
2538        return WOLFSSL_SUCCESS;
2539    }
2540
2541#ifdef HAVE_HTTP_CLIENT
2542    /**
2543     * Attempt to connect to the destination address and port
2544     * @param b BIO object
2545     * @return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure
2546     */
2547    long wolfSSL_BIO_do_connect(WOLFSSL_BIO *b)
2548    {
2549        SOCKET_T sfd = SOCKET_INVALID;
2550        WOLFSSL_ENTER("wolfSSL_BIO_do_connect");
2551
2552        if (!b) {
2553            WOLFSSL_MSG("Bad parameter");
2554            return WOLFSSL_FAILURE;
2555        }
2556
2557        while (b && b->type != WOLFSSL_BIO_SOCKET)
2558            b = b->next;
2559
2560        if (!b) {
2561            WOLFSSL_MSG("No socket BIO in chain");
2562            return WOLFSSL_FAILURE;
2563        }
2564
2565        if (wolfIO_TcpConnect(&sfd, b->ip, b->port, 0) < 0 ) {
2566            WOLFSSL_MSG("wolfIO_TcpConnect error");
2567            return WOLFSSL_FAILURE;
2568        }
2569
2570        b->num.fd = sfd;
2571        b->shutdown = WOLFSSL_BIO_CLOSE;
2572        return WOLFSSL_SUCCESS;
2573    }
2574
2575#ifdef HAVE_SOCKADDR
2576    int wolfSSL_BIO_do_accept(WOLFSSL_BIO *b)
2577    {
2578        SOCKET_T sfd = SOCKET_INVALID;
2579        WOLFSSL_ENTER("wolfSSL_BIO_do_accept");
2580
2581        if (!b) {
2582            WOLFSSL_MSG("Bad parameter");
2583            return WOLFSSL_FAILURE;
2584        }
2585
2586        while (b && b->type != WOLFSSL_BIO_SOCKET)
2587            b = b->next;
2588
2589        if (!b) {
2590            WOLFSSL_MSG("No socket BIO in chain");
2591            return WOLFSSL_FAILURE;
2592        }
2593
2594        if (b->num.fd == SOCKET_INVALID) {
2595            if (wolfIO_TcpBind(&sfd, b->port) < 0) {
2596                WOLFSSL_MSG("wolfIO_TcpBind error");
2597                return WOLFSSL_FAILURE;
2598            }
2599            b->num.fd = sfd;
2600            b->shutdown = WOLFSSL_BIO_CLOSE;
2601        }
2602        else {
2603            WOLFSSL_BIO* new_bio;
2604            int newfd = wolfIO_TcpAccept(b->num.fd, NULL, NULL);
2605            if (newfd < 0) {
2606                WOLFSSL_MSG("wolfIO_TcpBind error");
2607                return WOLFSSL_FAILURE;
2608            }
2609            /* Create a socket BIO for using the accept'ed connection */
2610            new_bio = wolfSSL_BIO_new_socket(newfd, WOLFSSL_BIO_CLOSE);
2611            if (new_bio == NULL) {
2612                WOLFSSL_MSG("wolfSSL_BIO_new_socket error");
2613                CloseSocket(newfd);
2614                return WOLFSSL_FAILURE;
2615            }
2616            wolfSSL_BIO_set_callback(new_bio,
2617                    wolfSSL_BIO_get_callback(b));
2618            wolfSSL_BIO_set_callback_arg(new_bio,
2619                    wolfSSL_BIO_get_callback_arg(b));
2620            /* Push onto bio chain for user retrieval */
2621            if (wolfSSL_BIO_push(b, new_bio) == NULL) {
2622                WOLFSSL_MSG("wolfSSL_BIO_push error");
2623                /* newfd is closed when bio is free'd */
2624                wolfSSL_BIO_free(new_bio);
2625                return WOLFSSL_FAILURE;
2626            }
2627        }
2628
2629        return WOLFSSL_SUCCESS;
2630    }
2631#endif /* HAVE_SOCKADDR */
2632#endif /* HAVE_HTTP_CLIENT */
2633
2634    int wolfSSL_BIO_eof(WOLFSSL_BIO* b)
2635    {
2636        int ret = 0;
2637        WOLFSSL_ENTER("wolfSSL_BIO_eof");
2638
2639        if (b == NULL)
2640            return 1; /* Undefined in OpenSSL. Let's signal we're done. */
2641
2642        switch (b->type) {
2643            case WOLFSSL_BIO_SSL:
2644                ret = b->eof;
2645                break;
2646            default:
2647                ret = wolfSSL_BIO_get_len(b) == 0;
2648                break;
2649        }
2650
2651        return ret;
2652    }
2653
2654#ifndef NO_TLS
2655    long wolfSSL_BIO_do_handshake(WOLFSSL_BIO *b)
2656    {
2657        WOLFSSL_ENTER("wolfSSL_BIO_do_handshake");
2658        if (b == NULL) {
2659            WOLFSSL_MSG("Bad parameter");
2660            return WOLFSSL_FAILURE;
2661        }
2662        if (b->type == WOLFSSL_BIO_SSL && b->ptr.ssl != NULL) {
2663            return wolfSSL_negotiate(b->ptr.ssl);
2664        }
2665        else {
2666            WOLFSSL_MSG("Not SSL BIO or no SSL object set");
2667            return WOLFSSL_FAILURE;
2668        }
2669    }
2670
2671    void wolfSSL_BIO_ssl_shutdown(WOLFSSL_BIO* b)
2672    {
2673        WOLFSSL_ENTER("wolfSSL_BIO_ssl_shutdown");
2674
2675        if (b == NULL) {
2676            WOLFSSL_MSG("BIO is null.");
2677            return;
2678        }
2679
2680        while (b != NULL && b->type != WOLFSSL_BIO_SSL) {
2681            b = b->next;
2682        }
2683        if (b == NULL) {
2684            WOLFSSL_MSG("Failed to find SSL BIO in chain.");
2685            return;
2686        }
2687
2688        if (b->ptr.ssl != NULL) {
2689            int rc = wolfSSL_shutdown(b->ptr.ssl);
2690            if (rc == WC_NO_ERR_TRACE(WOLFSSL_SHUTDOWN_NOT_DONE)) {
2691                /* In this case, call again to give us a chance to read the
2692                 * close notify alert from the other end. */
2693                wolfSSL_shutdown(b->ptr.ssl);
2694            }
2695        }
2696        else {
2697            WOLFSSL_MSG("BIO has no SSL pointer set.");
2698        }
2699    }
2700#endif
2701
2702    long wolfSSL_BIO_set_ssl(WOLFSSL_BIO* b, WOLFSSL* ssl, int closeF)
2703    {
2704        long ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
2705
2706        WOLFSSL_ENTER("wolfSSL_BIO_set_ssl");
2707
2708        if (b != NULL) {
2709            b->ptr.ssl = ssl;
2710            b->shutdown = (byte)closeF;
2711            if (b->next != NULL)
2712                wolfSSL_set_bio(ssl, b->next, b->next);
2713    /* add to ssl for bio free if SSL_free called before/instead of free_all? */
2714            ret = WOLFSSL_SUCCESS;
2715        }
2716
2717        if (ret == WOLFSSL_SUCCESS)
2718            return ret;
2719        else
2720            return WOLFSSL_FAILURE;
2721    }
2722
2723    long wolfSSL_BIO_get_ssl(WOLFSSL_BIO* bio, WOLFSSL** ssl)
2724    {
2725        WOLFSSL_ENTER("wolfSSL_BIO_get_ssl");
2726
2727        if (bio == NULL) {
2728            WOLFSSL_MSG("bio is null.");
2729            return WOLFSSL_FAILURE;
2730        }
2731        if (ssl == NULL) {
2732            WOLFSSL_MSG("ssl is null.");
2733            return WOLFSSL_FAILURE;
2734        }
2735        if (bio->type != WOLFSSL_BIO_SSL) {
2736            WOLFSSL_MSG("bio type is not WOLFSSL_BIO_SSL.");
2737            return WOLFSSL_FAILURE;
2738        }
2739
2740        *ssl = bio->ptr.ssl;
2741
2742        return WOLFSSL_SUCCESS;
2743    }
2744
2745    WOLFSSL_BIO* wolfSSL_BIO_new_ssl(WOLFSSL_CTX* ctx, int client)
2746    {
2747        WOLFSSL* ssl = NULL;
2748        WOLFSSL_BIO* sslBio = NULL;
2749        int err = 0;
2750
2751        WOLFSSL_ENTER("wolfSSL_BIO_new_ssl");
2752
2753        if (ctx == NULL) {
2754            WOLFSSL_MSG("ctx is NULL.");
2755            err = 1;
2756        }
2757
2758        if (err == 0) {
2759            ssl = wolfSSL_new(ctx);
2760            if (ssl == NULL) {
2761                WOLFSSL_MSG("Failed to create SSL object from ctx.");
2762                err = 1;
2763            }
2764        }
2765        if (err == 0) {
2766            sslBio = wolfSSL_BIO_new(wolfSSL_BIO_f_ssl());
2767            if (sslBio == NULL) {
2768                WOLFSSL_MSG("Failed to create SSL BIO.");
2769                err = 1;
2770            }
2771        }
2772        if (err == 0) {
2773            if (!client)
2774                wolfSSL_set_accept_state(ssl);
2775            else
2776                wolfSSL_set_connect_state(ssl);
2777        }
2778        if (err == 0 && wolfSSL_BIO_set_ssl(sslBio, ssl, WOLFSSL_BIO_CLOSE) !=
2779            WOLFSSL_SUCCESS) {
2780            WOLFSSL_MSG("Failed to set SSL pointer in BIO.");
2781            err = 1;
2782        }
2783
2784        if (err) {
2785            wolfSSL_free(ssl);
2786            wolfSSL_BIO_free(sslBio);
2787        }
2788
2789        return sslBio;
2790    }
2791
2792    WOLFSSL_BIO* wolfSSL_BIO_new_ssl_connect(WOLFSSL_CTX* ctx)
2793    {
2794        WOLFSSL_BIO* sslBio = NULL;
2795        WOLFSSL_BIO* connBio = NULL;
2796        int err = 0;
2797
2798        WOLFSSL_ENTER("wolfSSL_BIO_new_ssl_connect");
2799
2800        if (ctx == NULL) {
2801            WOLFSSL_MSG("ctx is NULL.");
2802            err = 1;
2803        }
2804
2805        if (err == 0) {
2806            sslBio = wolfSSL_BIO_new_ssl(ctx, 1);
2807            if (sslBio == NULL) {
2808                WOLFSSL_MSG("Failed to create SSL BIO.");
2809                err = 1;
2810            }
2811        }
2812        if (err == 0) {
2813            connBio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket());
2814            if (connBio == NULL) {
2815                WOLFSSL_MSG("Failed to create connect BIO.");
2816                err = 1;
2817            }
2818            else {
2819                wolfSSL_BIO_push(sslBio, connBio);
2820            }
2821        }
2822
2823        if (err == 1) {
2824            wolfSSL_BIO_free(sslBio);
2825            sslBio = NULL;
2826            wolfSSL_BIO_free(connBio);
2827        }
2828
2829        return sslBio;
2830    }
2831
2832    long wolfSSL_BIO_set_conn_hostname(WOLFSSL_BIO* b, char* name)
2833    {
2834        size_t newLen = 0;
2835
2836        WOLFSSL_ENTER("wolfSSL_BIO_set_conn_hostname");
2837
2838        if (name == NULL) {
2839            WOLFSSL_MSG("Hostname is NULL.");
2840            return WOLFSSL_FAILURE;
2841        }
2842
2843        while (b != NULL && b->type != WOLFSSL_BIO_SOCKET) {
2844            b = b->next;
2845        }
2846        if (b == NULL) {
2847            WOLFSSL_MSG("Failed to find socket BIO in chain.");
2848            return WOLFSSL_FAILURE;
2849        }
2850
2851        newLen = XSTRLEN(name);
2852        if (b->ip != NULL && XSTRLEN(b->ip) != newLen) {
2853            XFREE(b->ip, b->heap, DYNAMIC_TYPE_OPENSSL);
2854            b->ip = NULL;
2855        }
2856        if (b->ip == NULL) {
2857            b->ip = (char*)XMALLOC(newLen + 1, b->heap, DYNAMIC_TYPE_OPENSSL);
2858            if (b->ip == NULL) {
2859                WOLFSSL_MSG("Hostname malloc failed.");
2860                return WOLFSSL_FAILURE;
2861            }
2862        }
2863
2864        XMEMCPY(b->ip, name, newLen);
2865        b->ip[newLen] = '\0';
2866
2867        return WOLFSSL_SUCCESS;
2868    }
2869
2870#ifndef NO_FILESYSTEM
2871    long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, int fd, int closeF)
2872    {
2873        WOLFSSL_ENTER("wolfSSL_BIO_set_fd");
2874
2875        if (b != NULL) {
2876            b->num.fd = (SOCKET_T)fd;
2877            b->shutdown = (byte)closeF;
2878        }
2879
2880        return WOLFSSL_SUCCESS;
2881    }
2882#endif
2883
2884    /* Sets the close flag */
2885    int wolfSSL_BIO_set_close(WOLFSSL_BIO *b, long flag)
2886    {
2887        WOLFSSL_ENTER("wolfSSL_BIO_set_close");
2888        if (b != NULL) {
2889            b->shutdown = (byte)flag;
2890        }
2891
2892        return WOLFSSL_SUCCESS;
2893    }
2894
2895#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
2896    WOLFSSL_BIO* wolfSSL_BIO_new(const WOLFSSL_BIO_METHOD* method)
2897#else
2898    WOLFSSL_BIO* wolfSSL_BIO_new(WOLFSSL_BIO_METHOD* method)
2899#endif
2900    {
2901        WOLFSSL_BIO* bio;
2902
2903        WOLFSSL_ENTER("wolfSSL_BIO_new");
2904        if (method == NULL) {
2905            WOLFSSL_MSG("Bad method pointer passed in");
2906            return NULL;
2907        }
2908
2909        bio = (WOLFSSL_BIO*) XMALLOC(sizeof(WOLFSSL_BIO), 0,
2910                DYNAMIC_TYPE_OPENSSL);
2911        if (bio) {
2912            XMEMSET(bio, 0, sizeof(WOLFSSL_BIO));
2913            bio->type = method->type;
2914#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
2915            bio->method = (WOLFSSL_BIO_METHOD*)method;
2916#else
2917            bio->method = method;
2918#endif
2919            bio->shutdown = WOLFSSL_BIO_CLOSE; /* default to close things */
2920
2921            if ((bio->type == WOLFSSL_BIO_SOCKET) ||
2922                (bio->type == WOLFSSL_BIO_DGRAM))
2923            {
2924                bio->num.fd = SOCKET_INVALID;
2925            }
2926            else if (bio->type == WOLFSSL_BIO_FILE) {
2927#ifndef NO_FILESYSTEM
2928                bio->ptr.fh = XBADFILE;
2929#endif
2930                bio->num.fd = SOCKET_INVALID;
2931            }
2932            else {
2933                bio->num.length = 0;
2934            }
2935            bio->init = 1;
2936
2937        #if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
2938            {
2939                int ret;
2940                wolfSSL_RefInit(&bio->ref, &ret);
2941            #ifdef WOLFSSL_REFCNT_ERROR_RETURN
2942                if (ret != 0) {
2943                    wolfSSL_BIO_free(bio);
2944                    WOLFSSL_MSG("wc_InitMutex failed for WOLFSSL_BIO");
2945                    return NULL;
2946                }
2947            #else
2948                (void)ret;
2949            #endif
2950            }
2951        #endif
2952
2953            if (method->type == WOLFSSL_BIO_MEMORY)
2954                bio->eof = WOLFSSL_BIO_ERROR; /* Return value for empty buffer */
2955            if (method->type == WOLFSSL_BIO_MEMORY ||
2956                    method->type == WOLFSSL_BIO_BIO) {
2957                bio->mem_buf = wolfSSL_BUF_MEM_new();
2958                if (bio->mem_buf == NULL) {
2959                    WOLFSSL_MSG("Memory error");
2960                    wolfSSL_BIO_free(bio);
2961                    return NULL;
2962                }
2963            }
2964
2965            if (method->type == WOLFSSL_BIO_MD) {
2966                bio->ptr.md_ctx = wolfSSL_EVP_MD_CTX_new();
2967                if (bio->ptr.md_ctx == NULL) {
2968                    WOLFSSL_MSG("Memory error");
2969                    wolfSSL_BIO_free(bio);
2970                    return NULL;
2971                }
2972            }
2973
2974            /* check if is custom method */
2975            if (method->createCb) {
2976                method->createCb(bio);
2977            }
2978
2979        }
2980        return bio;
2981    }
2982
2983    WOLFSSL_BIO* wolfSSL_BIO_new_mem_buf(const void* buf, int len)
2984    {
2985        WOLFSSL_BIO* bio = NULL;
2986
2987        if (buf == NULL) {
2988            return bio;
2989        }
2990
2991        bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
2992        if (bio == NULL) {
2993            return bio;
2994        }
2995
2996        if (len < 0) {
2997            /* The length of the string including terminating null. */
2998            len = (int)XSTRLEN((const char*)buf) + 1;
2999        }
3000
3001        if (len > 0 && wolfSSL_BUF_MEM_resize(bio->mem_buf, (size_t)len) == 0) {
3002            wolfSSL_BIO_free(bio);
3003            return NULL;
3004        }
3005
3006        bio->num.length = bio->mem_buf->max;
3007        bio->wrSz = len;
3008        bio->ptr.mem_buf_data = (byte *)bio->mem_buf->data;
3009        if (len > 0 && bio->ptr.mem_buf_data != NULL) {
3010            XMEMCPY(bio->ptr.mem_buf_data, buf, (size_t)len);
3011            bio->flags |= WOLFSSL_BIO_FLAG_MEM_RDONLY;
3012            bio->wrSzReset = bio->wrSz;
3013        }
3014
3015        return bio;
3016    }
3017
3018    /*
3019     * Note : If the flag BIO_NOCLOSE is set then freeing memory buffers is up
3020     *        to the application.
3021     * Returns 1 on success, 0 on failure
3022     */
3023    int wolfSSL_BIO_free(WOLFSSL_BIO* bio)
3024    {
3025        int ret;
3026    #if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
3027        int doFree = 0;
3028    #endif
3029
3030        /* unchain?, doesn't matter in goahead since from free all */
3031        WOLFSSL_ENTER("wolfSSL_BIO_free");
3032        if (bio) {
3033
3034            if (bio->infoCb) {
3035                /* info callback is called before free */
3036                ret = (int)bio->infoCb(bio, WOLFSSL_BIO_CB_FREE, NULL, 0, 0, 1);
3037                if (ret <= 0) {
3038                    return ret;
3039                }
3040            }
3041
3042    #if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
3043            wolfSSL_RefDec(&bio->ref, &doFree, &ret);
3044
3045            if (!doFree) {
3046                /* return success if BIO ref count is not 1 yet */
3047            #ifdef WOLFSSL_REFCNT_ERROR_RETURN
3048                return (ret == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE ;
3049            #else
3050                (void)ret;
3051                return WOLFSSL_SUCCESS;
3052            #endif
3053            }
3054        #ifndef SINGLE_THREADED
3055            wolfSSL_RefFree(&bio->ref);
3056        #endif
3057    #endif
3058
3059        #ifdef HAVE_EX_DATA_CLEANUP_HOOKS
3060            wolfSSL_CRYPTO_cleanup_ex_data(&bio->ex_data);
3061        #endif
3062
3063            /* call custom set free callback */
3064            if (bio->method && bio->method->freeCb) {
3065                bio->method->freeCb(bio);
3066            }
3067
3068            /* remove from pair by setting the paired bios pair to NULL */
3069            if (bio->pair != NULL) {
3070                bio->pair->pair = NULL;
3071            }
3072
3073            XFREE(bio->ip, bio->heap, DYNAMIC_TYPE_OPENSSL);
3074
3075            if (bio->shutdown) {
3076                if (bio->type == WOLFSSL_BIO_SSL && bio->ptr.ssl)
3077                    wolfSSL_free(bio->ptr.ssl);
3078            #ifdef CloseSocket
3079                if (((bio->type == WOLFSSL_BIO_SOCKET) ||
3080                     (bio->type == WOLFSSL_BIO_DGRAM)) &&
3081                    (bio->num.fd != SOCKET_INVALID))
3082                {
3083                    CloseSocket(bio->num.fd);
3084                }
3085            #endif
3086            }
3087
3088        #ifndef NO_FILESYSTEM
3089            if (bio->type == WOLFSSL_BIO_FILE &&
3090                bio->shutdown == WOLFSSL_BIO_CLOSE)
3091            {
3092                if (bio->ptr.fh) {
3093                    XFCLOSE(bio->ptr.fh);
3094                }
3095            #if !defined(USE_WINDOWS_API) && !defined(NO_WOLFSSL_DIR)\
3096                && !defined(WOLFSSL_NUCLEUS) && !defined(WOLFSSL_NUCLEUS_1_2)
3097                else if (bio->num.fd != SOCKET_INVALID) {
3098                    XCLOSE(bio->num.fd);
3099                }
3100            #endif
3101            }
3102        #endif
3103
3104            if (bio->shutdown != WOLFSSL_BIO_NOCLOSE) {
3105                if (bio->type == WOLFSSL_BIO_MEMORY &&
3106                    bio->ptr.mem_buf_data != NULL)
3107                {
3108                    if (bio->mem_buf != NULL) {
3109                        if ((byte *)bio->mem_buf->data != bio->ptr.mem_buf_data)
3110                        {
3111                            XFREE(bio->ptr.mem_buf_data, bio->heap,
3112                                  DYNAMIC_TYPE_OPENSSL);
3113                            bio->ptr.mem_buf_data = NULL;
3114                        }
3115                    }
3116                    else {
3117                        XFREE(bio->ptr.mem_buf_data, bio->heap,
3118                              DYNAMIC_TYPE_OPENSSL);
3119                        bio->ptr.mem_buf_data = NULL;
3120                    }
3121                }
3122                if (bio->mem_buf != NULL) {
3123                    wolfSSL_BUF_MEM_free(bio->mem_buf);
3124                    bio->mem_buf = NULL;
3125                }
3126            }
3127
3128            if (bio->type == WOLFSSL_BIO_MD) {
3129                wolfSSL_EVP_MD_CTX_free(bio->ptr.md_ctx);
3130            }
3131
3132            XFREE(bio, 0, DYNAMIC_TYPE_OPENSSL);
3133            return WOLFSSL_SUCCESS;
3134        }
3135        return WOLFSSL_FAILURE;
3136    }
3137
3138    /* like BIO_free, but no return value */
3139    void wolfSSL_BIO_vfree(WOLFSSL_BIO* bio)
3140    {
3141        wolfSSL_BIO_free(bio);
3142    }
3143
3144
3145    void wolfSSL_BIO_free_all(WOLFSSL_BIO* bio)
3146    {
3147        WOLFSSL_ENTER("wolfSSL_BIO_free_all");
3148        while (bio) {
3149            WOLFSSL_BIO* next = bio->next;
3150            wolfSSL_BIO_free(bio);
3151            bio = next;
3152        }
3153    }
3154
3155
3156    WOLFSSL_BIO* wolfSSL_BIO_push(WOLFSSL_BIO* top, WOLFSSL_BIO* append)
3157    {
3158        WOLFSSL_ENTER("wolfSSL_BIO_push");
3159        if (top == NULL) {
3160            return append;
3161        }
3162        {
3163            WOLFSSL_BIO* cur = append;
3164            while (cur != NULL) {
3165                if (cur == top)
3166                    return top; /* would create cycle */
3167                cur = cur->next;
3168            }
3169        }
3170        top->next = append;
3171        if (append != NULL) {
3172            append->prev = top;
3173        }
3174
3175        /* SSL BIO's should use the next object in the chain for IO */
3176        if (top->type == WOLFSSL_BIO_SSL && top->ptr.ssl)
3177            wolfSSL_set_bio(top->ptr.ssl, append, append);
3178
3179        return top;
3180    }
3181
3182/* Removes a WOLFSSL_BIO struct from the WOLFSSL_BIO linked list.
3183 *
3184 * bio is the WOLFSSL_BIO struct in the list and removed.
3185 *
3186 * The return WOLFSSL_BIO struct is the next WOLFSSL_BIO in the list or NULL if
3187 * there is none.
3188 */
3189WOLFSSL_BIO* wolfSSL_BIO_pop(WOLFSSL_BIO* bio)
3190{
3191    WOLFSSL_BIO* next;
3192
3193    if (bio == NULL) {
3194        WOLFSSL_MSG("Bad argument passed in");
3195        return NULL;
3196    }
3197
3198    if (bio->prev != NULL) {
3199        bio->prev->next = bio->next;
3200    }
3201
3202    if (bio->next != NULL) {
3203        bio->next->prev = bio->prev;
3204    }
3205
3206    next = bio->next;
3207    bio->prev = NULL;
3208    bio->next = NULL;
3209
3210    return next;
3211}
3212
3213
3214
3215WOLFSSL_BIO_METHOD* wolfSSL_BIO_s_mem(void)
3216{
3217    static WOLFSSL_BIO_METHOD meth =
3218            WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_MEMORY);
3219
3220    WOLFSSL_ENTER("wolfSSL_BIO_s_mem");
3221
3222    return &meth;
3223}
3224
3225
3226WOLFSSL_BIO_METHOD* wolfSSL_BIO_f_base64(void)
3227{
3228    static WOLFSSL_BIO_METHOD meth =
3229            WOLFSSL_BIO_METHOD_INIT(WOLFSSL_BIO_BASE64);
3230
3231    WOLFSSL_ENTER("wolfSSL_BIO_f_base64");
3232
3233    return &meth;
3234}
3235
3236
3237/* Set the flag for the bio.
3238 *
3239 * bio   the structure to set the flag in
3240 * flags the flag to use
3241 */
3242void wolfSSL_BIO_set_flags(WOLFSSL_BIO* bio, int flags)
3243{
3244    WOLFSSL_ENTER("wolfSSL_BIO_set_flags");
3245
3246    if (bio != NULL) {
3247        bio->flags |= flags;
3248    }
3249}
3250
3251void wolfSSL_BIO_clear_flags(WOLFSSL_BIO *bio, int flags)
3252{
3253    WOLFSSL_ENTER("wolfSSL_BIO_clear_flags");
3254    if (bio != NULL) {
3255        bio->flags &= ~flags;
3256    }
3257}
3258
3259/* Set ex_data for WOLFSSL_BIO
3260 *
3261 * bio  : BIO structure to set ex_data in
3262 * idx  : Index of ex_data to set
3263 * data : Data to set in ex_data
3264 *
3265 * Returns WOLFSSL_SUCCESS on success or WOLFSSL_FAILURE on failure
3266 */
3267int wolfSSL_BIO_set_ex_data(WOLFSSL_BIO *bio, int idx, void *data)
3268{
3269    WOLFSSL_ENTER("wolfSSL_BIO_set_ex_data");
3270#ifdef HAVE_EX_DATA
3271    if (bio != NULL && idx < MAX_EX_DATA) {
3272        return wolfSSL_CRYPTO_set_ex_data(&bio->ex_data, idx, data);
3273    }
3274#else
3275    (void)bio;
3276    (void)idx;
3277    (void)data;
3278#endif
3279    return WOLFSSL_FAILURE;
3280}
3281
3282int wolfSSL_BIO_get_fd(WOLFSSL_BIO *bio, int* fd)
3283{
3284    WOLFSSL_ENTER("wolfSSL_BIO_get_fd");
3285
3286    if (bio != NULL) {
3287        if (bio->num.fd == SOCKET_INVALID)
3288            return WOLFSSL_BIO_ERROR;
3289        if (fd != NULL)
3290            *fd = (int)bio->num.fd;
3291        return (int)bio->num.fd;
3292    }
3293
3294    return WOLFSSL_BIO_ERROR;
3295}
3296
3297#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
3298/* Set ex_data for WOLFSSL_BIO
3299 *
3300 * bio  : BIO structure to set ex_data in
3301 * idx  : Index of ex_data to set
3302 * data : Data to set in ex_data
3303 * cleanup_routine : Function pointer to clean up data
3304 *
3305 * Returns WOLFSSL_SUCCESS on success or WOLFSSL_FAILURE on failure
3306 */
3307int wolfSSL_BIO_set_ex_data_with_cleanup(
3308    WOLFSSL_BIO *bio,
3309    int idx,
3310    void *data,
3311    wolfSSL_ex_data_cleanup_routine_t cleanup_routine)
3312{
3313    WOLFSSL_ENTER("wolfSSL_BIO_set_ex_data_with_cleanup");
3314    if (bio != NULL && idx < MAX_EX_DATA) {
3315        return wolfSSL_CRYPTO_set_ex_data_with_cleanup(&bio->ex_data, idx, data,
3316                                                       cleanup_routine);
3317    }
3318    return WOLFSSL_FAILURE;
3319}
3320#endif /* HAVE_EX_DATA_CLEANUP_HOOKS */
3321
3322/* Get ex_data in WOLFSSL_BIO at given index
3323 *
3324 * bio  : BIO structure to get ex_data from
3325 * idx  : Index of ex_data to get data from
3326 *
3327 * Returns void pointer to ex_data on success or NULL on failure
3328 */
3329void *wolfSSL_BIO_get_ex_data(WOLFSSL_BIO *bio, int idx)
3330{
3331    WOLFSSL_ENTER("wolfSSL_BIO_get_ex_data");
3332#ifdef HAVE_EX_DATA
3333    if (bio != NULL && idx < MAX_EX_DATA && idx >= 0) {
3334        return wolfSSL_CRYPTO_get_ex_data(&bio->ex_data, idx);
3335    }
3336#else
3337    (void)bio;
3338    (void)idx;
3339#endif
3340    return NULL;
3341}
3342
3343#endif /* OPENSSL_EXTRA */
3344
3345#ifndef NO_FILESYSTEM
3346    PRAGMA_CLANG_DIAG_PUSH
3347    PRAGMA_CLANG("clang diagnostic ignored \"-Wformat-nonliteral\"")
3348#endif
3349
3350#if defined(OPENSSL_EXTRA)
3351/* returns amount printed on success, negative in fail case */
3352#ifdef __clang__
3353/* tell clang argument 2 is format */
3354__attribute__((__format__ (__printf__, 2, 0)))
3355#endif
3356int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format, va_list args)
3357{
3358    int ret = -1;
3359
3360    if (bio == NULL)
3361        return WOLFSSL_FATAL_ERROR;
3362
3363    switch (bio->type) {
3364#if !defined(NO_FILESYSTEM)
3365        case WOLFSSL_BIO_FILE:
3366            if (bio->ptr.fh == XBADFILE) {
3367                return WOLFSSL_FATAL_ERROR;
3368            }
3369            ret = XVFPRINTF(bio->ptr.fh, format, args);
3370            break;
3371#endif
3372
3373        case WOLFSSL_BIO_MEMORY:
3374    /* In Visual Studio versions prior to Visual Studio 2013, the va_* symbols
3375       aren't defined. If using Visual Studio 2013 or later, define
3376       HAVE_VA_COPY. */
3377    #if defined(XVSNPRINTF) && (!defined(_WIN32) || defined(HAVE_VA_COPY))
3378        case WOLFSSL_BIO_SSL:
3379            {
3380                int count;
3381                char* pt = NULL;
3382                va_list copy;
3383
3384                #ifdef FUSION_RTOS
3385                   copy = args;    /* hack, depends on internal implementation
3386                                    * of va_list in VisualDSP++ */
3387                #else
3388                    va_copy(copy, args);
3389                #endif
3390                count = XVSNPRINTF(NULL, 0, format, args);
3391                if (count >= 0)
3392                {
3393                    pt = (char*)XMALLOC((size_t)count + 1, bio->heap,
3394                                        DYNAMIC_TYPE_TMP_BUFFER);
3395                    if (pt != NULL)
3396                    {
3397                        count = XVSNPRINTF(pt, (size_t)count + 1, format, copy);
3398                        if (count >= 0)
3399                        {
3400                            ret = wolfSSL_BIO_write(bio, pt, count);
3401                        }
3402                        XFREE(pt, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
3403                    }
3404                }
3405                va_end(copy);
3406            }
3407            break;
3408    #endif /* XVSNPRINTF && (!_WIN32 || HAVE_VA_COPY) */
3409
3410        default:
3411            WOLFSSL_MSG("Unsupported WOLFSSL_BIO type for wolfSSL_BIO_printf");
3412            break;
3413    }
3414
3415    return ret;
3416}
3417
3418/* returns amount printed on success, negative in fail case */
3419#ifdef __clang__
3420/* tell clang argument 2 is format */
3421__attribute__((__format__ (__printf__, 2, 0)))
3422#endif
3423int wolfSSL_BIO_printf(WOLFSSL_BIO* bio, const char* format, ...)
3424{
3425    int ret;
3426    va_list args;
3427    va_start(args, format);
3428
3429    ret = wolfSSL_BIO_vprintf(bio, format, args);
3430
3431    va_end(args);
3432
3433    return ret;
3434}
3435
3436#ifndef NO_FILESYSTEM
3437    PRAGMA_CLANG_DIAG_POP
3438#endif
3439
3440#undef  BIO_DUMP_LINE_LEN
3441#define BIO_DUMP_LINE_LEN 16
3442int wolfSSL_BIO_dump(WOLFSSL_BIO *bio, const char *buf, int length)
3443{
3444    int ret = 0;
3445#ifndef NO_FILESYSTEM
3446    int lineOffset = 0;
3447#endif
3448
3449    if (bio == NULL)
3450        return 0;
3451
3452#ifndef NO_FILESYSTEM
3453    do
3454    {
3455        int i;
3456        char line[80];
3457        int o;
3458
3459        if (!buf) {
3460            return wolfSSL_BIO_write(bio, "\tNULL", 5);
3461        }
3462
3463        (void)XSNPRINTF(line, sizeof(line), "%04x - ", lineOffset);
3464        o = 7;
3465        for (i = 0; i < BIO_DUMP_LINE_LEN; i++) {
3466            if (i < length)
3467                (void)XSNPRINTF(line + o, (size_t)((int)sizeof(line) - o),
3468                    "%02x ", (unsigned char)buf[i]);
3469            else
3470                (void)XSNPRINTF(line + o, (size_t)((int)sizeof(line) - o),
3471                "   ");
3472            if (i == 7)
3473                (void)XSNPRINTF(line + o + 2, (size_t)((int)sizeof(line) -
3474                (o + 2)), "-");
3475            o += 3;
3476        }
3477        (void)XSNPRINTF(line + o, (size_t)((int)sizeof(line) - o), "  ");
3478        o += 2;
3479        for (i = 0; (i < BIO_DUMP_LINE_LEN) && (i < length); i++) {
3480            (void)XSNPRINTF(line + o, (size_t)((int)sizeof(line) - o), "%c",
3481                     ((31 < buf[i]) && (buf[i] < 127)) ? buf[i] : '.');
3482            o++;
3483        }
3484
3485        line[o++] = '\n';
3486        ret += wolfSSL_BIO_write(bio, line, o);
3487
3488        buf += BIO_DUMP_LINE_LEN;
3489        length -= BIO_DUMP_LINE_LEN;
3490        lineOffset += BIO_DUMP_LINE_LEN;
3491    }
3492    while (length > 0);
3493#else
3494    (void)buf;
3495    (void)length;
3496#endif
3497
3498    return ret;
3499}
3500#endif /* OPENSSL_EXTRA */
3501
3502#if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \
3503    defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \
3504    defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \
3505    defined(WOLFSSL_HAPROXY)
3506
3507    int wolfSSL_BIO_read_filename(WOLFSSL_BIO *b, const char *name) {
3508    #ifndef NO_FILESYSTEM
3509        XFILE fp;
3510
3511        WOLFSSL_ENTER("wolfSSL_BIO_new_file");
3512
3513        if ((wolfSSL_BIO_get_fp(b, &fp) == WOLFSSL_SUCCESS) && (fp != XBADFILE))
3514        {
3515            XFCLOSE(fp);
3516        }
3517
3518        fp = XFOPEN(name, "rb");
3519        if (fp == XBADFILE)
3520            return WOLFSSL_BAD_FILE;
3521
3522        if (wolfSSL_BIO_set_fp(b, fp, WOLFSSL_BIO_CLOSE) != WOLFSSL_SUCCESS) {
3523            XFCLOSE(fp);
3524            return WOLFSSL_BAD_FILE;
3525        }
3526
3527        /* file is closed when bio is free'd */
3528        return WOLFSSL_SUCCESS;
3529    #else
3530        (void)name;
3531        (void)b;
3532        return WOLFSSL_NOT_IMPLEMENTED;
3533    #endif
3534    }
3535
3536#endif
3537
3538#if defined(HAVE_LIGHTY) || defined(HAVE_STUNNEL) \
3539    || defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(OPENSSL_EXTRA)
3540
3541WOLFSSL_BIO *wolfSSL_BIO_new_file(const char *filename, const char *mode)
3542{
3543#ifndef NO_FILESYSTEM
3544    WOLFSSL_BIO* bio;
3545    XFILE fp;
3546
3547    WOLFSSL_ENTER("wolfSSL_BIO_new_file");
3548
3549    fp = XFOPEN(filename, mode);
3550    if (fp == XBADFILE)
3551        return NULL;
3552
3553    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
3554    if (bio == NULL) {
3555        XFCLOSE(fp);
3556        return bio;
3557    }
3558
3559    if (wolfSSL_BIO_set_fp(bio, fp, WOLFSSL_BIO_CLOSE) != WOLFSSL_SUCCESS) {
3560        XFCLOSE(fp);
3561        wolfSSL_BIO_free(bio);
3562        bio = NULL;
3563    }
3564
3565    /* file is closed when BIO is free'd */
3566    return bio;
3567#else
3568    (void)filename;
3569    (void)mode;
3570    return NULL;
3571#endif /* NO_FILESYSTEM */
3572}
3573
3574#ifndef NO_FILESYSTEM
3575WOLFSSL_BIO* wolfSSL_BIO_new_fp(XFILE fp, int close_flag)
3576{
3577    WOLFSSL_BIO* bio;
3578
3579    WOLFSSL_ENTER("wolfSSL_BIO_new_fp");
3580
3581    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
3582    if (bio == NULL) {
3583        return bio;
3584    }
3585
3586    if (wolfSSL_BIO_set_fp(bio, fp, close_flag) != WOLFSSL_SUCCESS) {
3587        wolfSSL_BIO_free(bio);
3588        bio = NULL;
3589    }
3590
3591    /* file is closed when BIO is free'd or by user depending on flag */
3592    return bio;
3593}
3594#endif
3595#endif
3596
3597#if defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO) || defined(WOLFSSL_HAPROXY) \
3598    || defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT)
3599
3600/* Creates a new bio pair.
3601Returns WOLFSSL_SUCCESS if no error, WOLFSSL_FAILURE otherwise.*/
3602int wolfSSL_BIO_new_bio_pair(WOLFSSL_BIO **bio1_p, size_t writebuf1,
3603                                         WOLFSSL_BIO **bio2_p, size_t writebuf2)
3604{
3605    WOLFSSL_BIO *bio1 = NULL, *bio2 = NULL;
3606    int ret = 1;
3607
3608    WOLFSSL_ENTER("wolfSSL_BIO_new_bio_pair");
3609
3610    if (bio1_p == NULL || bio2_p == NULL) {
3611        WOLFSSL_MSG("Bad Function Argument");
3612        return BAD_FUNC_ARG;
3613    }
3614
3615    /* set up the new bio structures and write buf sizes */
3616    if ((bio1 = wolfSSL_BIO_new(wolfSSL_BIO_s_bio())) == NULL) {
3617        WOLFSSL_MSG("Bio allocation failed");
3618        ret = WOLFSSL_FAILURE;
3619    }
3620    if (ret) {
3621        if ((bio2 = wolfSSL_BIO_new(wolfSSL_BIO_s_bio())) == NULL) {
3622            WOLFSSL_MSG("Bio allocation failed");
3623            ret = WOLFSSL_FAILURE;
3624        }
3625    }
3626    if (ret && writebuf1) {
3627        if (!(ret = wolfSSL_BIO_set_write_buf_size(bio1, (long)writebuf1))) {
3628            WOLFSSL_MSG("wolfSSL_BIO_set_write_buf() failure");
3629        }
3630    }
3631    if (ret && writebuf2) {
3632        if (!(ret = wolfSSL_BIO_set_write_buf_size(bio2, (long)writebuf2))) {
3633            WOLFSSL_MSG("wolfSSL_BIO_set_write_buf() failure");
3634        }
3635    }
3636
3637    if (ret) {
3638        if ((ret = wolfSSL_BIO_make_bio_pair(bio1, bio2))) {
3639            *bio1_p = bio1;
3640            *bio2_p = bio2;
3641        }
3642    }
3643    if (!ret) {
3644        wolfSSL_BIO_free(bio1);
3645        bio1 = NULL;
3646        wolfSSL_BIO_free(bio2);
3647        bio2 = NULL;
3648    }
3649    return ret;
3650}
3651
3652#endif
3653
3654#ifdef OPENSSL_ALL
3655
3656void wolfSSL_BIO_set_shutdown(WOLFSSL_BIO* bio, int shut)
3657{
3658    WOLFSSL_ENTER("wolfSSL_BIO_set_shutdown");
3659    if (bio != NULL)
3660        bio->shutdown = (byte)shut;
3661}
3662
3663int wolfSSL_BIO_get_shutdown(WOLFSSL_BIO* bio)
3664{
3665    WOLFSSL_ENTER("wolfSSL_BIO_get_shutdown");
3666    return bio != NULL && bio->shutdown;
3667}
3668
3669void wolfSSL_BIO_clear_retry_flags(WOLFSSL_BIO* bio)
3670{
3671    WOLFSSL_ENTER("wolfSSL_BIO_clear_retry_flags");
3672
3673    if (bio)
3674        bio->flags &= ~(WOLFSSL_BIO_FLAG_READ | WOLFSSL_BIO_FLAG_WRITE |
3675                        WOLFSSL_BIO_FLAG_RETRY);
3676}
3677
3678int wolfSSL_BIO_should_retry(WOLFSSL_BIO *bio)
3679{
3680    int ret = 0;
3681    if (bio != NULL) {
3682        ret = (int)(bio->flags & WOLFSSL_BIO_FLAG_RETRY);
3683    }
3684
3685    return ret;
3686}
3687
3688int wolfSSL_BIO_should_read(WOLFSSL_BIO *bio)
3689{
3690    int ret = 0;
3691    if (bio != NULL) {
3692        ret = (int)(bio->flags & WOLFSSL_BIO_FLAG_READ);
3693    }
3694
3695    return ret;
3696}
3697
3698int wolfSSL_BIO_should_write(WOLFSSL_BIO *bio)
3699{
3700    int ret = 0;
3701    if (bio != NULL) {
3702        ret = (int)(bio->flags & WOLFSSL_BIO_FLAG_WRITE);
3703    }
3704
3705    return ret;
3706}
3707
3708#endif /* OPENSSL_ALL */
3709
3710#endif /* WOLFSSL_BIO_INCLUDED */