luna - wolfssl/doc/dox_comments/header

   1/*!
   2    \brief This function is the receive embedded callback.
   3
   4    \return Success This function returns the number of bytes read.
   5    \return WOLFSSL_CBIO_ERR_WANT_READ returned with a “Would block” message
   6    if the last error was SOCKET_EWOULDBLCOK or SOCKET_EAGAIN.
   7    \return WOLFSSL_CBIO_ERR_TIMEOUT returned with a “Socket timeout” message.
   8    \return WOLFSSL_CBIO_ERR_CONN_RST returned with a “Connection reset”
   9    message if the last error was  SOCKET_ECONNRESET.
  10    \return WOLFSSL_CBIO_ERR_ISR returned with a “Socket interrupted” message
  11    if the last error was SOCKET_EINTR.
  12    \return WOLFSSL_CBIO_ERR_WANT_READ returned with a “Connection refused”
  13    message if the last error was SOCKET_ECONNREFUSED.
  14    \return WOLFSSL_CBIO_ERR_CONN_CLOSE returned with a “Connection aborted”
  15    message if the last error was SOCKET_ECONNABORTED.
  16    \return WOLFSSL_CBIO_ERR_GENERAL returned with a “General error” message
  17    if the last error was not specified.
  18
  19    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
  20    \param buf a char pointer representation of the buffer.
  21    \param sz the size of the buffer.
  22    \param ctx a void pointer to user registered context. In the default case
  23    the ctx is a socket descriptor pointer.
  24
  25    _Example_
  26    \code
  27    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
  28    WOLFSSL* ssl = wolfSSL_new(ctx);
  29    char* buf;
  30    int sz;
  31    void* ctx;
  32    int bytesRead = EmbedReceive(ssl, buf, sz, ctx);
  33    if(bytesRead <= 0){
  34	    // There were no bytes read. Failure case.
  35    }
  36    \endcode
  37
  38    \sa EmbedSend
  39    \sa wolfSSL_CTX_SetIORecv
  40    \sa wolfSSL_SSLSetIORecv
  41*/
  42int EmbedReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx);
  43
  44/*!
  45    \brief This function is the send embedded callback.
  46
  47    \return Success This function returns the number of bytes sent.
  48    \return WOLFSSL_CBIO_ERR_WANT_WRITE returned with a “Would block” message
  49    if the last error was SOCKET_EWOULDBLOCK or SOCKET_EAGAIN.
  50    \return WOLFSSL_CBIO_ERR_CONN_RST returned with a “Connection reset”
  51    message if the last error was SOCKET_ECONNRESET.
  52    \return WOLFSSL_CBIO_ERR_ISR returned with a “Socket interrupted” message
  53    if the last error was SOCKET_EINTR.
  54    \return WOLFSSL_CBIO_ERR_CONN_CLOSE returned with a “Socket EPIPE” message
  55    if the last error was SOCKET_EPIPE.
  56    \return WOLFSSL_CBIO_ERR_GENERAL returned with a “General error” message
  57    if the last error was not specified.
  58
  59    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
  60    \param buf a char pointer representing the buffer.
  61    \param sz the size of the buffer.
  62    \param ctx a void pointer to user registered context.
  63
  64    _Example_
  65    \code
  66    WOLFSSL* ssl = wolfSSL_new(ctx);
  67    char* buf;
  68    int sz;
  69    void* ctx;
  70    int dSent = EmbedSend(ssl, buf, sz, ctx);
  71    if(dSent <= 0){
  72    	// No byes sent. Failure case.
  73    }
  74    \endcode
  75
  76    \sa EmbedReceive
  77    \sa wolfSSL_CTX_SetIOSend
  78    \sa wolfSSL_SSLSetIOSend
  79*/
  80int EmbedSend(WOLFSSL* ssl, char* buf, int sz, void* ctx);
  81
  82/*!
  83    \brief This function is the receive embedded callback.
  84
  85    \return Success This function returns the nb bytes read if the execution
  86    was successful.
  87    \return WOLFSSL_CBIO_ERR_WANT_READ if the connection refused or if a
  88    ‘would block’ error was thrown in the function.
  89    \return WOLFSSL_CBIO_ERR_TIMEOUT returned if the socket timed out.
  90    \return WOLFSSL_CBIO_ERR_CONN_RST returned if the connection reset.
  91    \return WOLFSSL_CBIO_ERR_ISR returned if the socket was interrupted.
  92    \return WOLFSSL_CBIO_ERR_GENERAL returned if there was a general error.
  93
  94    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
  95    \param buf a constant char pointer to the buffer.
  96    \param sz an int type representing the size of the buffer.
  97    \param ctx a void pointer to the WOLFSSL_CTX context.
  98
  99    _Example_
 100    \code
 101    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 102    WOLFSSL* ssl = WOLFSSL_new(ctx);
 103    char* buf;
 104    int sz = sizeof(buf)/sizeof(char);
 105    (void*)ctx;
 106    …
 107    int nb = EmbedReceiveFrom(ssl, buf, sz, ctx);
 108    if(nb > 0){
 109	    // nb is the number of bytes written and is positive
 110    }
 111    \endcode
 112
 113    \sa EmbedSendTo
 114    \sa wolfSSL_CTX_SetIORecv
 115    \sa wolfSSL_SSLSetIORecv
 116    \sa wolfSSL_dtls_get_current_timeout
 117*/
 118int EmbedReceiveFrom(WOLFSSL* ssl, char* buf, int sz, void* ctx);
 119
 120/*!
 121    \brief This function is the send embedded callback.
 122
 123    \return Success This function returns the number of bytes sent.
 124    \return WOLFSSL_CBIO_ERR_WANT_WRITE returned with a “Would Block” message
 125    if the last error was either SOCKET_EWOULDBLOCK or SOCKET_EAGAIN error.
 126    \return WOLFSSL_CBIO_ERR_CONN_RST returned with a “Connection reset”
 127    message if the last error was SOCKET_ECONNRESET.
 128    \return WOLFSSL_CBIO_ERR_ISR returned with a “Socket interrupted” message
 129    if the last error was SOCKET_EINTR.
 130    \return WOLFSSL_CBIO_ERR_CONN_CLOSE returned with a “Socket EPIPE” message
 131    if the last error was WOLFSSL_CBIO_ERR_CONN_CLOSE.
 132    \return WOLFSSL_CBIO_ERR_GENERAL returned with a “General error” message
 133    if the last error was not specified.
 134
 135    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 136    \param buf a char pointer representing the buffer.
 137    \param sz the size of the buffer.
 138    \param ctx a void pointer to the user registered context. The default case
 139    is a WOLFSSL_DTLS_CTX structure.
 140
 141    _Example_
 142    \code
 143    WOLFSSL* ssl;
 144    …
 145    char* buf;
 146    int sz;
 147    void* ctx;
 148
 149    int sEmbed = EmbedSendto(ssl, buf, sz, ctx);
 150    if(sEmbed <= 0){
 151    	// No bytes sent. Failure case.
 152    }
 153    \endcode
 154
 155    \sa EmbedReceiveFrom
 156    \sa wolfSSL_CTX_SetIOSend
 157    \sa wolfSSL_SSLSetIOSend
 158*/
 159int EmbedSendTo(WOLFSSL* ssl, char* buf, int sz, void* ctx);
 160
 161/*!
 162    \brief This function is the DTLS Generate Cookie callback.
 163
 164    \return Success This function returns the number of bytes copied
 165    into the buffer.
 166    \return GEN_COOKIE_E returned if the getpeername failed in
 167    EmbedGenerateCookie.
 168
 169    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 170    \param buf byte pointer representing the buffer. It is the destination
 171    from XMEMCPY().
 172    \param sz the size of the buffer.
 173    \param ctx a void pointer to user registered context.
 174
 175    _Example_
 176    \code
 177    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 178    WOLFSSL* ssl = wolfSSL_new(ctx);
 179    byte buffer[BUFFER_SIZE];
 180    int sz = sizeof(buffer)/sizeof(byte);
 181    void* ctx;
 182    …
 183    int ret = EmbedGenerateCookie(ssl, buffer, sz, ctx);
 184
 185    if(ret > 0){
 186    	// EmbedGenerateCookie code block for success
 187    }
 188    \endcode
 189
 190    \sa wolfSSL_CTX_SetGenCookie
 191*/
 192int EmbedGenerateCookie(WOLFSSL* ssl, byte* buf,
 193                                    int sz, void* ctx);
 194
 195/*!
 196    \brief This function frees the response buffer.
 197
 198    \return none No returns.
 199
 200    \param ctx a void pointer to heap hint.
 201    \param resp a byte pointer representing the response.
 202
 203    _Example_
 204    \code
 205    void* ctx;
 206    byte* resp; // Response buffer.
 207    …
 208    EmbedOcspRespFree(ctx, resp);
 209    \endcode
 210
 211    \sa wolfSSL_CertManagerSetOCSP_Cb
 212    \sa wolfSSL_CertManagerEnableOCSPStapling
 213    \sa wolfSSL_CertManagerEnableOCSP
 214*/
 215void EmbedOcspRespFree(void* ctx, byte* resp);
 216
 217/*!
 218    \brief This function registers a receive callback for wolfSSL to get input
 219    data.  By default, wolfSSL uses EmbedReceive() as the callback which uses
 220    the system’s TCP recv() function.  The user can register a function to get
 221    input from memory, some other network module, or from anywhere.  Please see
 222    the EmbedReceive() function in src/io.c as a guide for how the function
 223    should work and for error codes.  In particular, IO_ERR_WANT_READ should
 224    be returned for non blocking receive when no data is ready.
 225
 226    \return none no Returns.
 227
 228    \param ctx pointer to the SSL context, created with wolfSSL_CTX_new().
 229    \param callback function to be registered as the receive callback for the
 230    wolfSSL context, ctx. The signature of this function must follow that as
 231    shown above in the Synopsis section.
 232
 233    _Example_
 234    \code
 235    WOLFSSL_CTX* ctx = 0;
 236    // Receive callback prototype
 237    int MyEmbedReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx);
 238    // Register the custom receive callback with wolfSSL
 239    wolfSSL_CTX_SetIORecv(ctx, MyEmbedReceive);
 240    int MyEmbedReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx)
 241    {
 242	    // custom EmbedReceive function
 243    }
 244    \endcode
 245
 246    \sa wolfSSL_CTX_SetIOSend
 247    \sa wolfSSL_SetIOReadCtx
 248    \sa wolfSSL_SetIOWriteCtx
 249*/
 250void wolfSSL_CTX_SetIORecv(WOLFSSL_CTX* ctx, CallbackIORecv CBIORecv);
 251
 252/*!
 253    \brief This function registers a context for the SSL session’s receive
 254    callback function.  By default, wolfSSL sets the file descriptor passed to
 255    wolfSSL_set_fd() as the context when wolfSSL is using the system’s TCP
 256    library. If you’ve registered your own receive callback you may want to set
 257    a specific context for the session.  For example, if you’re using memory
 258    buffers the context may be a pointer to a structure describing where and
 259    how to access the memory buffers.
 260
 261    \return none No returns.
 262
 263    \param ssl pointer to the SSL session, created with wolfSSL_new().
 264    \param rctx pointer to the context to be registered with the SSL session’s
 265    (ssl) receive callback function.
 266
 267    _Example_
 268    \code
 269    int sockfd;
 270    WOLFSSL* ssl = 0;
 271    ...
 272    // Manually setting the socket fd as the receive CTX, for example
 273    wolfSSL_SetIOReadCtx(ssl, &sockfd);
 274    ...
 275    \endcode
 276
 277    \sa wolfSSL_CTX_SetIORecv
 278    \sa wolfSSL_CTX_SetIOSend
 279    \sa wolfSSL_SetIOWriteCtx
 280*/
 281void wolfSSL_SetIOReadCtx( WOLFSSL* ssl, void *ctx);
 282
 283/*!
 284    \brief This function registers a context for the SSL session’s send
 285    callback function.  By default, wolfSSL sets the file descriptor passed to
 286    wolfSSL_set_fd() as the context when wolfSSL is using the system’s TCP
 287    library. If you’ve registered your own send callback you may want to set a
 288    specific context for the session.  For example, if you’re using memory
 289    buffers the context may be a pointer to a structure describing where and
 290    how to access the memory buffers.
 291
 292    \return none No returns.
 293
 294    \param ssl pointer to the SSL session, created with wolfSSL_new().
 295    \param wctx pointer to the context to be registered with the SSL session’s
 296    (ssl) send callback function.
 297
 298    _Example_
 299    \code
 300    int sockfd;
 301    WOLFSSL* ssl = 0;
 302    ...
 303    // Manually setting the socket fd as the send CTX, for example
 304    wolfSSL_SetIOWriteCtx(ssl, &sockfd);
 305    ...
 306    \endcode
 307
 308    \sa wolfSSL_CTX_SetIORecv
 309    \sa wolfSSL_CTX_SetIOSend
 310    \sa wolfSSL_SetIOReadCtx
 311*/
 312void wolfSSL_SetIOWriteCtx(WOLFSSL* ssl, void *ctx);
 313
 314/*!
 315    \ingroup IO
 316
 317    \brief This function returns the IOCB_ReadCtx member of the WOLFSSL struct.
 318
 319    \return pointer This function returns a void pointer to the IOCB_ReadCtx
 320    member of the WOLFSSL structure.
 321    \return NULL returned if the WOLFSSL struct is NULL.
 322
 323    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 324
 325    _Example_
 326    \code
 327    WOLFSSL* ssl = wolfSSL_new(ctx);
 328    void* ioRead;
 329    ...
 330    ioRead = wolfSSL_GetIOReadCtx(ssl);
 331    if(ioRead == NULL){
 332    	// Failure case. The ssl object was NULL.
 333    }
 334    \endcode
 335
 336    \sa wolfSSL_GetIOWriteCtx
 337    \sa wolfSSL_SetIOReadFlags
 338    \sa wolfSSL_SetIOWriteCtx
 339    \sa wolfSSL_SetIOReadCtx
 340    \sa wolfSSL_CTX_SetIOSend
 341*/
 342void* wolfSSL_GetIOReadCtx( WOLFSSL* ssl);
 343
 344/*!
 345    \ingroup IO
 346
 347    \brief This function returns the IOCB_WriteCtx member of the WOLFSSL structure.
 348
 349    \return pointer This function returns a void pointer to the IOCB_WriteCtx
 350    member of the WOLFSSL structure.
 351    \return NULL returned if the WOLFSSL struct is NULL.
 352
 353    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 354
 355    _Example_
 356    \code
 357    WOLFSSL* ssl;
 358    void* ioWrite;
 359    ...
 360    ioWrite = wolfSSL_GetIOWriteCtx(ssl);
 361    if(ioWrite == NULL){
 362    	// The function returned NULL.
 363    }
 364    \endcode
 365
 366    \sa wolfSSL_GetIOReadCtx
 367    \sa wolfSSL_SetIOWriteCtx
 368    \sa wolfSSL_SetIOReadCtx
 369    \sa wolfSSL_CTX_SetIOSend
 370*/
 371void* wolfSSL_GetIOWriteCtx(WOLFSSL* ssl);
 372
 373/*!
 374    \brief This function sets the flags for the receive callback to use for
 375    the given SSL session.  The receive callback could be either the default
 376    wolfSSL EmbedReceive callback, or a custom callback specified by the user
 377    (see  wolfSSL_CTX_SetIORecv). The default flag value is set internally by
 378    wolfSSL to the value of 0. The default wolfSSL receive callback uses the
 379    recv() function to receive data from the socket. From the recv() man page:
 380    “The flags argument to a recv() function is formed by or'ing one or more
 381    of the values: MSG_OOB process out-of-band data, MSG_PEEK peek at incoming
 382    message, MSG_WAITALL	wait for full request or error. The MSG_OOB flag
 383    requests receipt of out-of-band data that would not be received in the
 384    normal data stream. Some protocols place expedited data at the head of
 385    the normal data queue, and thus this flag cannot be used with such
 386    protocols. The MSG_PEEK flag causes the receive operation to return
 387    data from the beginning of the receive queue without removing that data
 388    from the queue.  Thus, a subsequent receive call will return the same data.
 389    The MSG_WAITALL flag requests that the operation block until the full
 390    request is satisfied.  However, the call may still return less data than
 391    requested if a signal is caught, an error or disconnect occurs, or the next
 392    data to be received is of a different type than that returned.”
 393
 394    \return none No returns.
 395
 396    \param ssl pointer to the SSL session, created with wolfSSL_new().
 397    \param flags value of the I/O read flags for the specified SSL
 398    session (ssl).
 399
 400    _Example_
 401    \code
 402    WOLFSSL* ssl = 0;
 403    ...
 404    // Manually setting recv flags to 0
 405    wolfSSL_SetIOReadFlags(ssl, 0);
 406    ...
 407    \endcode
 408
 409    \sa wolfSSL_CTX_SetIORecv
 410    \sa wolfSSL_CTX_SetIOSend
 411    \sa wolfSSL_SetIOReadCtx
 412*/
 413void wolfSSL_SetIOReadFlags( WOLFSSL* ssl, int flags);
 414
 415/*!
 416    \brief This function sets the flags for the send callback to use for the
 417    given SSL session.  The send callback could be either the default wolfSSL
 418    EmbedSend callback, or a custom callback specified by the user (see
 419    wolfSSL_CTX_SetIOSend). The default flag value is set internally by wolfSSL
 420    to the value of 0. The default wolfSSL send callback uses the send()
 421    function to send data from the socket.  From the send() man page: “The
 422    flags parameter may include one or more of the following:
 423    #define MSG_OOB 0x1  // process out-of-band data,
 424    #define MSG_DONTROUTE  0x4  // bypass routing, use direct interface.
 425    The flag MSG_OOB is used to send 'out-of-band' data on sockets that
 426    support this notion (e.g.  SOCK_STREAM); the underlying protocol must also
 427    support 'out-of-band' data.  MSG_DONTROUTE is usually used only by
 428    diagnostic or routing programs.”
 429
 430    \return none No returns.
 431
 432    \param ssl pointer to the SSL session, created with wolfSSL_new().
 433    \param flags value of the I/O send flags for the specified SSL session (ssl).
 434
 435    _Example_
 436    \code
 437    WOLFSSL* ssl = 0;
 438    ...
 439    // Manually setting send flags to 0
 440    wolfSSL_SetIOWriteFlags(ssl, 0);
 441    ...
 442    \endcode
 443
 444    \sa wolfSSL_CTX_SetIORecv
 445    \sa wolfSSL_CTX_SetIOSend
 446    \sa wolfSSL_SetIOReadCtx
 447*/
 448void wolfSSL_SetIOWriteFlags(WOLFSSL* ssl, int flags);
 449
 450/*!
 451    \ingroup IO
 452
 453    \brief This function sets the nxSocket and nxWait members of the nxCtx
 454    struct within the WOLFSSL structure.
 455
 456    \return none No returns.
 457
 458    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 459    \param nxSocket a pointer to type NX_TCP_SOCKET that is set to the
 460    nxSocket member of the nxCTX structure.
 461    \param waitOption a ULONG type that is set to the nxWait member of
 462    the nxCtx structure.
 463
 464    _Example_
 465    \code
 466    WOLFSSL* ssl = wolfSSL_new(ctx);
 467    NX_TCP_SOCKET* nxSocket;
 468    ULONG waitOption;
 469    …
 470    if(ssl != NULL || nxSocket != NULL || waitOption <= 0){
 471    wolfSSL_SetIO_NetX(ssl, nxSocket, waitOption);
 472    } else {
 473    	// You need to pass in good parameters.
 474    }
 475    \endcode
 476
 477    \sa set_fd
 478    \sa NetX_Send
 479    \sa NetX_Receive
 480*/
 481void wolfSSL_SetIO_NetX(WOLFSSL* ssl, NX_TCP_SOCKET* nxsocket,
 482                                      ULONG waitoption);
 483
 484/*!
 485    \brief This function sets the callback for the CBIOCookie member of the
 486    WOLFSSL_CTX structure. The CallbackGenCookie type is a function pointer
 487    and has the signature:	int (*CallbackGenCookie)(WOLFSSL* ssl, unsigned
 488    char* buf, int sz, void* ctx);
 489
 490    \return none No returns.
 491
 492    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 493    \param cb a CallbackGenCookie type function pointer with the signature
 494    of CallbackGenCookie.
 495
 496    _Example_
 497    \code
 498    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 499    WOLFSSL* ssl = wolfSSL_new(ctx);
 500    …
 501    int SetGenCookieCB(WOLFSSL* ssl, unsigned char* buf, int sz, void* ctx){
 502	// Callback function body.
 503    }
 504    …
 505    wolfSSL_CTX_SetGenCookie(ssl->ctx, SetGenCookieCB);
 506    \endcode
 507
 508    \sa CallbackGenCookie
 509*/
 510void  wolfSSL_CTX_SetGenCookie(WOLFSSL_CTX* ctx, CallbackGenCookie cb);
 511
 512/*!
 513    \ingroup Setup
 514
 515    \brief This function returns the IOCB_CookieCtx member of the
 516    WOLFSSL structure.
 517
 518    \return pointer The function returns a void pointer value stored in
 519    the IOCB_CookieCtx.
 520    \return NULL if the WOLFSSL struct is NULL
 521
 522    \param ssl a pointer to a WOLFSSL structure, created using wolfSSL_new().
 523
 524    _Example_
 525    \code
 526    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 527    WOLFSSL* ssl = wolfSSL_new(ctx);
 528    void* cookie;
 529    ...
 530    cookie = wolfSSL_GetCookieCtx(ssl);
 531    if(cookie != NULL){
 532	// You have the cookie
 533    }
 534    \endcode
 535
 536    \sa wolfSSL_SetCookieCtx
 537    \sa wolfSSL_CTX_SetGenCookie
 538*/
 539void* wolfSSL_GetCookieCtx(WOLFSSL* ssl);
 540
 541
 542/*!
 543    \ingroup Setup
 544
 545    \brief This function sets up the ISO-TP context if wolfSSL, for use when
 546    wolfSSL is compiled with WOLFSSL_ISOTP
 547
 548    \return 0 on success, WOLFSSL_CBIO_ERR_GENERAL on failure
 549
 550    \param ssl the wolfSSL context
 551    \param ctx a user created ISOTP context which this function initializes
 552    \param recv_fn a user CAN bus receive callback
 553    \param send_fn a user CAN bus send callback
 554    \param delay_fn a user microsecond granularity delay function
 555    \param receive_delay a set amount of microseconds to delay each CAN bus
 556    packet
 557    \param receive_buffer a user supplied buffer to receive data, recommended
 558    that is allocated to ISOTP_DEFAULT_BUFFER_SIZE bytes
 559    \param receive_buffer_size - The size of receive_buffer
 560    \param arg an arbitrary pointer sent to recv_fn and send_fn
 561
 562    _Example_
 563    \code
 564    struct can_info can_con_info;
 565    isotp_wolfssl_ctx isotp_ctx;
 566    char *receive_buffer = malloc(ISOTP_DEFAULT_BUFFER_SIZE);
 567    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(method);
 568    WOLFSSL* ssl = wolfSSL_new(ctx);
 569    ...
 570    wolfSSL_SetIO_ISOTP(ssl, &isotp_ctx, can_receive, can_send, can_delay, 0,
 571            receive_buffer, ISOTP_DEFAULT_BUFFER_SIZE, &can_con_info);
 572    \endcode
 573 */
 574int wolfSSL_SetIO_ISOTP(WOLFSSL *ssl, isotp_wolfssl_ctx *ctx,
 575        can_recv_fn recv_fn, can_send_fn send_fn, can_delay_fn delay_fn,
 576        word32 receive_delay, char *receive_buffer, int receive_buffer_size,
 577        void *arg);
 578
 579/*!
 580    \ingroup Setup
 581
 582    \brief This function disables reading from the IO layer.
 583
 584    \param ssl the wolfSSL context
 585
 586    _Example_
 587    \code
 588    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(method);
 589    WOLFSSL* ssl = wolfSSL_new(ctx);
 590    wolfSSL_SSLDisableRead(ssl);
 591    \endcode
 592
 593    \sa wolfSSL_CTX_SetIORecv
 594    \sa wolfSSL_SSLSetIORecv
 595    \sa wolfSSL_SSLEnableRead
 596 */
 597void wolfSSL_SSLDisableRead(WOLFSSL *ssl);
 598
 599/*!
 600    \ingroup Setup
 601
 602    \brief This function enables reading from the IO layer. Reading is enabled
 603           by default and should be used to undo wolfSSL_SSLDisableRead();
 604
 605    \param ssl the wolfSSL context
 606
 607    _Example_
 608    \code
 609    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(method);
 610    WOLFSSL* ssl = wolfSSL_new(ctx);
 611    wolfSSL_SSLDisableRead(ssl);
 612    ...
 613    wolfSSL_SSLEnableRead(ssl);
 614    \endcode
 615
 616    \sa wolfSSL_CTX_SetIORecv
 617    \sa wolfSSL_SSLSetIORecv
 618    \sa wolfSSL_SSLEnableRead
 619 */
 620void wolfSSL_SSLEnableRead(WOLFSSL *ssl);
 621
 622/*!
 623    \brief Set a custom DTLS recvfrom callback for a WOLFSSL session.
 624
 625    This function allows you to specify a custom callback function for receiving
 626    datagrams (DTLS) using the `recvfrom`-style interface. The callback must match
 627    the WolfSSLRecvFrom function pointer type and is expected to behave like the
 628    POSIX `recvfrom()` function, including its return values and error handling.
 629
 630    \param ssl      A pointer to a WOLFSSL structure, created using wolfSSL_new().
 631    \param recvFrom The custom callback function to use for DTLS datagram receive.
 632
 633    _Example_
 634    \code
 635    wolfSSL_SetRecvFrom(ssl, my_recvfrom_cb);
 636    \endcode
 637
 638    \sa WolfSSLRecvFrom
 639    \sa wolfSSL_SetSendTo
 640    \sa EmbedReceiveFrom
 641    \sa wolfSSL_CTX_SetIORecv
 642    \sa wolfSSL_SSLSetIORecv
 643*/
 644WOLFSSL_API void wolfSSL_SetRecvFrom(WOLFSSL* ssl, WolfSSLRecvFrom recvFrom);
 645
 646/*!
 647    \brief Set a custom DTLS sendto callback for a WOLFSSL session.
 648
 649    This function allows you to specify a custom callback function for sending
 650    datagrams (DTLS) using the `sendto`-style interface. The callback must match
 651    the WolfSSLSento function pointer type and is expected to behave like the
 652    POSIX `sendto()` function, including its return values and error handling.
 653
 654    \param ssl    A pointer to a WOLFSSL structure, created using wolfSSL_new().
 655    \param sendTo The custom callback function to use for DTLS datagram send.
 656
 657    _Example_
 658    \code
 659    wolfSSL_SetSendTo(ssl, my_sendto_cb);
 660    \endcode
 661
 662    \sa WolfSSLSento
 663    \sa wolfSSL_SetRecvFrom
 664    \sa EmbedSendTo
 665    \sa wolfSSL_CTX_SetIOSend
 666    \sa wolfSSL_SSLSetIOSend
 667*/
 668WOLFSSL_API void wolfSSL_SetSendTo(WOLFSSL* ssl, WolfSSLSento sendTo);
 669
 670/*!
 671    \ingroup IO
 672    \brief Waits for socket to be ready for I/O with timeout.
 673
 674    \return 0 on success
 675    \return negative on error
 676
 677    \param sockfd Socket file descriptor
 678    \param to_sec Timeout in seconds
 679
 680    _Example_
 681    \code
 682    SOCKET_T sockfd;
 683    int ret = wolfIO_Select(sockfd, 5);
 684    \endcode
 685
 686    \sa wolfIO_TcpConnect
 687*/
 688int wolfIO_Select(SOCKET_T sockfd, int to_sec);
 689
 690/*!
 691    \ingroup IO
 692    \brief Connects to TCP server with timeout.
 693
 694    \return 0 on success
 695    \return negative on error
 696
 697    \param sockfd Pointer to socket file descriptor
 698    \param ip IP address string
 699    \param port Port number
 700    \param to_sec Timeout in seconds
 701
 702    _Example_
 703    \code
 704    SOCKET_T sockfd;
 705    int ret = wolfIO_TcpConnect(&sockfd, "127.0.0.1", 443, 5);
 706    \endcode
 707
 708    \sa wolfIO_TcpBind
 709*/
 710int wolfIO_TcpConnect(SOCKET_T* sockfd, const char* ip,
 711                      unsigned short port, int to_sec);
 712
 713/*!
 714    \ingroup IO
 715    \brief Accepts TCP connection.
 716
 717    \return Socket descriptor on success
 718    \return negative on error
 719
 720    \param sockfd Socket file descriptor
 721    \param peer_addr Peer address structure
 722    \param peer_len Peer address length
 723
 724    _Example_
 725    \code
 726    SOCKET_T sockfd;
 727    SOCKADDR peer;
 728    XSOCKLENT len = sizeof(peer);
 729    int ret = wolfIO_TcpAccept(sockfd, &peer, &len);
 730    \endcode
 731
 732    \sa wolfIO_TcpBind
 733*/
 734int wolfIO_TcpAccept(SOCKET_T sockfd, SOCKADDR* peer_addr,
 735                     XSOCKLENT* peer_len);
 736
 737/*!
 738    \ingroup IO
 739    \brief Binds TCP socket to port.
 740
 741    \return 0 on success
 742    \return negative on error
 743
 744    \param sockfd Pointer to socket file descriptor
 745    \param port Port number
 746
 747    _Example_
 748    \code
 749    SOCKET_T sockfd;
 750    int ret = wolfIO_TcpBind(&sockfd, 443);
 751    \endcode
 752
 753    \sa wolfIO_TcpAccept
 754*/
 755int wolfIO_TcpBind(SOCKET_T* sockfd, word16 port);
 756
 757/*!
 758    \ingroup IO
 759    \brief Sends data on socket.
 760
 761    \return Number of bytes sent on success
 762    \return negative on error
 763
 764    \param sd Socket descriptor
 765    \param buf Buffer to send
 766    \param sz Buffer size
 767    \param wrFlags Write flags
 768
 769    _Example_
 770    \code
 771    SOCKET_T sd;
 772    char buf[100];
 773    int ret = wolfIO_Send(sd, buf, sizeof(buf), 0);
 774    \endcode
 775
 776    \sa wolfIO_Recv
 777*/
 778int wolfIO_Send(SOCKET_T sd, char *buf, int sz, int wrFlags);
 779
 780/*!
 781    \ingroup IO
 782    \brief Receives data from socket.
 783
 784    \return Number of bytes received on success
 785    \return negative on error
 786
 787    \param sd Socket descriptor
 788    \param buf Buffer to receive into
 789    \param sz Buffer size
 790    \param rdFlags Read flags
 791
 792    _Example_
 793    \code
 794    SOCKET_T sd;
 795    char buf[100];
 796    int ret = wolfIO_Recv(sd, buf, sizeof(buf), 0);
 797    \endcode
 798
 799    \sa wolfIO_Send
 800*/
 801int wolfIO_Recv(SOCKET_T sd, char *buf, int sz, int rdFlags);
 802
 803/*!
 804    \ingroup IO
 805    \brief Sends datagram to address.
 806
 807    \return Number of bytes sent on success
 808    \return negative on error
 809
 810    \param sd Socket descriptor
 811    \param addr Destination address
 812    \param buf Buffer to send
 813    \param sz Buffer size
 814    \param wrFlags Write flags
 815
 816    _Example_
 817    \code
 818    SOCKET_T sd;
 819    WOLFSSL_BIO_ADDR addr;
 820    char buf[100];
 821    int ret = wolfIO_SendTo(sd, &addr, buf, sizeof(buf), 0);
 822    \endcode
 823
 824    \sa wolfIO_RecvFrom
 825*/
 826int wolfIO_SendTo(SOCKET_T sd, WOLFSSL_BIO_ADDR *addr, char *buf, int sz,
 827                  int wrFlags);
 828
 829/*!
 830    \ingroup IO
 831    \brief Receives datagram from address.
 832
 833    \return Number of bytes received on success
 834    \return negative on error
 835
 836    \param sd Socket descriptor
 837    \param addr Source address
 838    \param buf Buffer to receive into
 839    \param sz Buffer size
 840    \param rdFlags Read flags
 841
 842    _Example_
 843    \code
 844    SOCKET_T sd;
 845    WOLFSSL_BIO_ADDR addr;
 846    char buf[100];
 847    int ret = wolfIO_RecvFrom(sd, &addr, buf, sizeof(buf), 0);
 848    \endcode
 849
 850    \sa wolfIO_SendTo
 851*/
 852int wolfIO_RecvFrom(SOCKET_T sd, WOLFSSL_BIO_ADDR *addr, char *buf, int sz,
 853                    int rdFlags);
 854
 855/*!
 856    \ingroup IO
 857    \brief BIO send callback.
 858
 859    \return Number of bytes sent on success
 860    \return negative on error
 861
 862    \param ssl SSL object
 863    \param buf Buffer to send
 864    \param sz Buffer size
 865    \param ctx Context pointer
 866
 867    _Example_
 868    \code
 869    WOLFSSL* ssl;
 870    char buf[100];
 871    int ret = wolfSSL_BioSend(ssl, buf, sizeof(buf), NULL);
 872    \endcode
 873
 874    \sa wolfSSL_BioReceive
 875*/
 876int wolfSSL_BioSend(WOLFSSL* ssl, char *buf, int sz, void *ctx);
 877
 878/*!
 879    \ingroup IO
 880    \brief BIO receive callback.
 881
 882    \return Number of bytes received on success
 883    \return negative on error
 884
 885    \param ssl SSL object
 886    \param buf Buffer to receive into
 887    \param sz Buffer size
 888    \param ctx Context pointer
 889
 890    _Example_
 891    \code
 892    WOLFSSL* ssl;
 893    char buf[100];
 894    int ret = wolfSSL_BioReceive(ssl, buf, sizeof(buf), NULL);
 895    \endcode
 896
 897    \sa wolfSSL_BioSend
 898*/
 899int wolfSSL_BioReceive(WOLFSSL* ssl, char* buf, int sz, void* ctx);
 900
 901/*!
 902    \ingroup IO
 903    \brief Receives multicast datagram.
 904
 905    \return Number of bytes received on success
 906    \return negative on error
 907
 908    \param ssl SSL object
 909    \param buf Buffer to receive into
 910    \param sz Buffer size
 911    \param ctx Context pointer
 912
 913    _Example_
 914    \code
 915    WOLFSSL* ssl;
 916    char buf[100];
 917    int ret = EmbedReceiveFromMcast(ssl, buf, sizeof(buf), NULL);
 918    \endcode
 919
 920    \sa EmbedReceiveFrom
 921*/
 922int EmbedReceiveFromMcast(WOLFSSL *ssl, char *buf, int sz, void *ctx);
 923
 924/*!
 925    \ingroup IO
 926    \brief Builds HTTP OCSP request.
 927
 928    \return Request size on success
 929    \return negative on error
 930
 931    \param domainName Domain name
 932    \param path URL path
 933    \param ocspReqSz OCSP request size
 934    \param buf Output buffer
 935    \param bufSize Buffer size
 936
 937    _Example_
 938    \code
 939    char buf[1024];
 940    int ret = wolfIO_HttpBuildRequestOcsp("example.com", "/ocsp", 100,
 941                                          (unsigned char*)buf, sizeof(buf));
 942    \endcode
 943
 944    \sa wolfIO_HttpProcessResponseOcsp
 945*/
 946int wolfIO_HttpBuildRequestOcsp(const char* domainName, const char* path,
 947                                 int ocspReqSz, unsigned char* buf,
 948                                 int bufSize);
 949
 950/*!
 951    \ingroup IO
 952    \brief Processes HTTP OCSP response with generic I/O.
 953
 954    \return 0 on success
 955    \return negative on error
 956
 957    \param ioCb I/O callback
 958    \param ioCbCtx I/O callback context
 959    \param respBuf Response buffer pointer
 960    \param httpBuf HTTP buffer
 961    \param httpBufSz HTTP buffer size
 962    \param heap Heap hint
 963
 964    _Example_
 965    \code
 966    unsigned char* resp = NULL;
 967    unsigned char httpBuf[1024];
 968    int ret = wolfIO_HttpProcessResponseOcspGenericIO(myIoCb, ctx, &resp,
 969                                                      httpBuf,
 970                                                      sizeof(httpBuf), NULL);
 971    \endcode
 972
 973    \sa wolfIO_HttpProcessResponseOcsp
 974*/
 975int wolfIO_HttpProcessResponseOcspGenericIO(WolfSSLGenericIORecvCb ioCb,
 976                                            void* ioCbCtx,
 977                                            unsigned char** respBuf,
 978                                            unsigned char* httpBuf,
 979                                            int httpBufSz, void* heap);
 980
 981/*!
 982    \ingroup IO
 983    \brief Processes HTTP OCSP response.
 984
 985    \return 0 on success
 986    \return negative on error
 987
 988    \param sfd Socket file descriptor
 989    \param respBuf Response buffer pointer
 990    \param httpBuf HTTP buffer
 991    \param httpBufSz HTTP buffer size
 992    \param heap Heap hint
 993
 994    _Example_
 995    \code
 996    int sfd;
 997    unsigned char* resp = NULL;
 998    unsigned char httpBuf[1024];
 999    int ret = wolfIO_HttpProcessResponseOcsp(sfd, &resp, httpBuf,
1000                                             sizeof(httpBuf), NULL);
1001    \endcode
1002
1003    \sa wolfIO_HttpBuildRequestOcsp
1004*/
1005int wolfIO_HttpProcessResponseOcsp(int sfd, unsigned char** respBuf,
1006                                   unsigned char* httpBuf, int httpBufSz,
1007                                   void* heap);
1008
1009/*!
1010    \ingroup IO
1011    \brief OCSP lookup callback.
1012
1013    \return 0 on success
1014    \return negative on error
1015
1016    \param ctx Context pointer
1017    \param url URL string
1018    \param urlSz URL size
1019    \param ocspReqBuf OCSP request buffer
1020    \param ocspReqSz OCSP request size
1021    \param ocspRespBuf OCSP response buffer pointer
1022
1023    _Example_
1024    \code
1025    byte* resp = NULL;
1026    byte req[100];
1027    int ret = EmbedOcspLookup(NULL, "http://example.com/ocsp", 25, req,
1028                              sizeof(req), &resp);
1029    \endcode
1030
1031    \sa EmbedOcspRespFree
1032*/
1033int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
1034                    byte* ocspReqBuf, int ocspReqSz, byte** ocspRespBuf);
1035
1036/*!
1037    \ingroup IO
1038    \brief Builds HTTP CRL request.
1039
1040    \return Request size on success
1041    \return negative on error
1042
1043    \param url URL string
1044    \param urlSz URL size
1045    \param domainName Domain name
1046    \param buf Output buffer
1047    \param bufSize Buffer size
1048
1049    _Example_
1050    \code
1051    char buf[1024];
1052    int ret = wolfIO_HttpBuildRequestCrl("http://example.com/crl", 22,
1053                                         "example.com",
1054                                         (unsigned char*)buf, sizeof(buf));
1055    \endcode
1056
1057    \sa wolfIO_HttpProcessResponseCrl
1058*/
1059int wolfIO_HttpBuildRequestCrl(const char* url, int urlSz,
1060                                const char* domainName, unsigned char* buf,
1061                                int bufSize);
1062
1063/*!
1064    \ingroup IO
1065    \brief Processes HTTP CRL response.
1066
1067    \return 0 on success
1068    \return negative on error
1069
1070    \param crl CRL object
1071    \param sfd Socket file descriptor
1072    \param httpBuf HTTP buffer
1073    \param httpBufSz HTTP buffer size
1074
1075    _Example_
1076    \code
1077    WOLFSSL_CRL crl;
1078    int sfd;
1079    unsigned char httpBuf[1024];
1080    int ret = wolfIO_HttpProcessResponseCrl(&crl, sfd, httpBuf,
1081                                            sizeof(httpBuf));
1082    \endcode
1083
1084    \sa wolfIO_HttpBuildRequestCrl
1085*/
1086int wolfIO_HttpProcessResponseCrl(WOLFSSL_CRL* crl, int sfd,
1087                                  unsigned char* httpBuf, int httpBufSz);
1088
1089/*!
1090    \ingroup IO
1091    \brief CRL lookup callback.
1092
1093    \return 0 on success
1094    \return negative on error
1095
1096    \param crl CRL object
1097    \param url URL string
1098    \param urlSz URL size
1099
1100    _Example_
1101    \code
1102    WOLFSSL_CRL crl;
1103    int ret = EmbedCrlLookup(&crl, "http://example.com/crl", 22);
1104    \endcode
1105
1106    \sa wolfIO_HttpBuildRequestCrl
1107*/
1108int EmbedCrlLookup(WOLFSSL_CRL* crl, const char* url, int urlSz);
1109
1110/*!
1111    \ingroup IO
1112    \brief Decodes URL into components.
1113
1114    \return 0 on success
1115    \return negative on error
1116
1117    \param url URL string
1118    \param urlSz URL size
1119    \param outName Output domain name
1120    \param outPath Output path
1121    \param outPort Output port
1122
1123    _Example_
1124    \code
1125    char name[256], path[256];
1126    unsigned short port;
1127    int ret = wolfIO_DecodeUrl("http://example.com:443/path", 28, name,
1128                               path, &port);
1129    \endcode
1130
1131    \sa wolfIO_HttpBuildRequest
1132*/
1133int wolfIO_DecodeUrl(const char* url, int urlSz, char* outName,
1134                     char* outPath, unsigned short* outPort);
1135
1136/*!
1137    \ingroup IO
1138    \brief Builds generic HTTP request.
1139
1140    \return Request size on success
1141    \return negative on error
1142
1143    \param reqType Request type (GET, POST, etc.)
1144    \param domainName Domain name
1145    \param path URL path
1146    \param pathLen Path length
1147    \param reqSz Request body size
1148    \param contentType Content type
1149    \param buf Output buffer
1150    \param bufSize Buffer size
1151
1152    _Example_
1153    \code
1154    char buf[1024];
1155    int ret = wolfIO_HttpBuildRequest("POST", "example.com", "/api", 4,
1156                                      100, "application/json",
1157                                      (unsigned char*)buf, sizeof(buf));
1158    \endcode
1159
1160    \sa wolfIO_HttpProcessResponse
1161*/
1162int wolfIO_HttpBuildRequest(const char* reqType, const char* domainName,
1163                             const char* path, int pathLen, int reqSz,
1164                             const char* contentType, unsigned char* buf,
1165                             int bufSize);
1166
1167/*!
1168    \ingroup IO
1169    \brief Processes HTTP response with generic I/O.
1170
1171    \return 0 on success
1172    \return negative on error
1173
1174    \param ioCb I/O callback
1175    \param ioCbCtx I/O callback context
1176    \param appStrList Application string list
1177    \param respBuf Response buffer pointer
1178    \param httpBuf HTTP buffer
1179    \param httpBufSz HTTP buffer size
1180    \param dynType Dynamic type
1181    \param heap Heap hint
1182
1183    _Example_
1184    \code
1185    unsigned char* resp = NULL;
1186    unsigned char httpBuf[1024];
1187    const char* appStrs[] = {"200 OK", NULL};
1188    int ret = wolfIO_HttpProcessResponseGenericIO(myIoCb, ctx, appStrs,
1189                                                  &resp, httpBuf,
1190                                                  sizeof(httpBuf), 0, NULL);
1191    \endcode
1192
1193    \sa wolfIO_HttpProcessResponse
1194*/
1195int wolfIO_HttpProcessResponseGenericIO(WolfSSLGenericIORecvCb ioCb,
1196                                        void* ioCbCtx,
1197                                        const char** appStrList,
1198                                        unsigned char** respBuf,
1199                                        unsigned char* httpBuf,
1200                                        int httpBufSz, int dynType,
1201                                        void* heap);
1202
1203/*!
1204    \ingroup IO
1205    \brief Processes HTTP response.
1206
1207    \return 0 on success
1208    \return negative on error
1209
1210    \param sfd Socket file descriptor
1211    \param appStrList Application string list
1212    \param respBuf Response buffer pointer
1213    \param httpBuf HTTP buffer
1214    \param httpBufSz HTTP buffer size
1215    \param dynType Dynamic type
1216    \param heap Heap hint
1217
1218    _Example_
1219    \code
1220    int sfd;
1221    unsigned char* resp = NULL;
1222    unsigned char httpBuf[1024];
1223    const char* appStrs[] = {"200 OK", NULL};
1224    int ret = wolfIO_HttpProcessResponse(sfd, appStrs, &resp, httpBuf,
1225                                         sizeof(httpBuf), 0, NULL);
1226    \endcode
1227
1228    \sa wolfIO_HttpBuildRequest
1229*/
1230int wolfIO_HttpProcessResponse(int sfd, const char** appStrList,
1231                               unsigned char** respBuf,
1232                               unsigned char* httpBuf, int httpBufSz,
1233                               int dynType, void* heap);
1234
1235/*!
1236    \ingroup IO
1237    \brief Sets I/O send callback for context.
1238
1239    \return none No returns
1240
1241    \param ctx SSL context
1242    \param CBIOSend Send callback
1243
1244    _Example_
1245    \code
1246    WOLFSSL_CTX* ctx;
1247    wolfSSL_CTX_SetIOSend(ctx, mySendCallback);
1248    \endcode
1249
1250    \sa wolfSSL_SSLSetIOSend
1251*/
1252void wolfSSL_CTX_SetIOSend(WOLFSSL_CTX *ctx, CallbackIOSend CBIOSend);
1253
1254/*!
1255    \ingroup IO
1256    \brief Sets I/O receive callback for SSL object.
1257
1258    \return none No returns
1259
1260    \param ssl SSL object
1261    \param CBIORecv Receive callback
1262
1263    _Example_
1264    \code
1265    WOLFSSL* ssl;
1266    wolfSSL_SSLSetIORecv(ssl, myRecvCallback);
1267    \endcode
1268
1269    \sa wolfSSL_CTX_SetIORecv
1270*/
1271void wolfSSL_SSLSetIORecv(WOLFSSL *ssl, CallbackIORecv CBIORecv);
1272
1273/*!
1274    \ingroup IO
1275    \brief Sets I/O send callback for SSL object.
1276
1277    \return none No returns
1278
1279    \param ssl SSL object
1280    \param CBIOSend Send callback
1281
1282    _Example_
1283    \code
1284    WOLFSSL* ssl;
1285    wolfSSL_SSLSetIOSend(ssl, mySendCallback);
1286    \endcode
1287
1288    \sa wolfSSL_CTX_SetIOSend
1289*/
1290void wolfSSL_SSLSetIOSend(WOLFSSL *ssl, CallbackIOSend CBIOSend);
1291
1292/*!
1293    \ingroup IO
1294    \brief Sets I/O for Mynewt platform.
1295
1296    \return none No returns
1297
1298    \param ssl SSL object
1299    \param mnSocket Mynewt socket
1300    \param mnSockAddrIn Mynewt socket address
1301
1302    _Example_
1303    \code
1304    WOLFSSL* ssl;
1305    struct mn_socket sock;
1306    struct mn_sockaddr_in addr;
1307    wolfSSL_SetIO_Mynewt(ssl, &sock, &addr);
1308    \endcode
1309
1310    \sa wolfSSL_SetIO_LwIP
1311*/
1312void wolfSSL_SetIO_Mynewt(WOLFSSL* ssl, struct mn_socket* mnSocket,
1313                          struct mn_sockaddr_in* mnSockAddrIn);
1314
1315/*!
1316    \ingroup IO
1317    \brief Sets I/O for LwIP platform.
1318
1319    \return 0 on success
1320    \return negative on error
1321
1322    \param ssl SSL object
1323    \param pcb Protocol control block
1324    \param recv Receive callback
1325    \param sent Sent callback
1326    \param arg Argument pointer
1327
1328    _Example_
1329    \code
1330    WOLFSSL* ssl;
1331    struct tcp_pcb* pcb;
1332    int ret = wolfSSL_SetIO_LwIP(ssl, pcb, myRecv, mySent, NULL);
1333    \endcode
1334
1335    \sa wolfSSL_SetIO_Mynewt
1336*/
1337int wolfSSL_SetIO_LwIP(WOLFSSL* ssl, void *pcb, tcp_recv_fn recv,
1338                       tcp_sent_fn sent, void *arg);
1339
1340/*!
1341    \ingroup IO
1342    \brief Sets cookie context for DTLS.
1343
1344    \return none No returns
1345
1346    \param ssl SSL object
1347    \param ctx Cookie context
1348
1349    _Example_
1350    \code
1351    WOLFSSL* ssl;
1352    void* ctx;
1353    wolfSSL_SetCookieCtx(ssl, ctx);
1354    \endcode
1355
1356    \sa wolfSSL_GetCookieCtx
1357*/
1358void wolfSSL_SetCookieCtx(WOLFSSL* ssl, void *ctx);
1359
1360/*!
1361    \ingroup IO
1362    \brief Gets cookie context for DTLS.
1363
1364    \return Cookie context pointer
1365
1366    \param ssl SSL object
1367
1368    _Example_
1369    \code
1370    WOLFSSL* ssl;
1371    void* ctx = wolfSSL_GetCookieCtx(ssl);
1372    \endcode
1373
1374    \sa wolfSSL_SetCookieCtx
1375*/
1376void* wolfSSL_GetCookieCtx(WOLFSSL* ssl);
1377
1378/*!
1379    \ingroup IO
1380    \brief Sets get peer callback for context.
1381
1382    \return none No returns
1383
1384    \param ctx SSL context
1385    \param cb Get peer callback
1386
1387    _Example_
1388    \code
1389    WOLFSSL_CTX* ctx;
1390    wolfSSL_CTX_SetIOGetPeer(ctx, myGetPeerCallback);
1391    \endcode
1392
1393    \sa wolfSSL_CTX_SetIOSetPeer
1394*/
1395void wolfSSL_CTX_SetIOGetPeer(WOLFSSL_CTX* ctx, CallbackGetPeer cb);
1396
1397/*!
1398    \ingroup IO
1399    \brief Sets set peer callback for context.
1400
1401    \return none No returns
1402
1403    \param ctx SSL context
1404    \param cb Set peer callback
1405
1406    _Example_
1407    \code
1408    WOLFSSL_CTX* ctx;
1409    wolfSSL_CTX_SetIOSetPeer(ctx, mySetPeerCallback);
1410    \endcode
1411
1412    \sa wolfSSL_CTX_SetIOGetPeer
1413*/
1414void wolfSSL_CTX_SetIOSetPeer(WOLFSSL_CTX* ctx, CallbackSetPeer cb);
1415
1416/*!
1417    \ingroup IO
1418    \brief Gets peer information.
1419
1420    \return 0 on success
1421    \return negative on error
1422
1423    \param ssl SSL object
1424    \param ip IP address buffer
1425    \param ipSz IP address buffer size pointer
1426    \param port Port number pointer
1427    \param fam Address family pointer
1428
1429    _Example_
1430    \code
1431    WOLFSSL* ssl;
1432    char ip[46];
1433    int ipSz = sizeof(ip);
1434    unsigned short port;
1435    int fam;
1436    int ret = EmbedGetPeer(ssl, ip, &ipSz, &port, &fam);
1437    \endcode
1438
1439    \sa EmbedSetPeer
1440*/
1441int EmbedGetPeer(WOLFSSL* ssl, char* ip, int* ipSz, unsigned short* port,
1442                 int* fam);
1443
1444/*!
1445    \ingroup IO
1446    \brief Sets peer information.
1447
1448    \return 0 on success
1449    \return negative on error
1450
1451    \param ssl SSL object
1452    \param ip IP address string
1453    \param ipSz IP address string size
1454    \param port Port number
1455    \param fam Address family
1456
1457    _Example_
1458    \code
1459    WOLFSSL* ssl;
1460    int ret = EmbedSetPeer(ssl, "127.0.0.1", 9, 443, AF_INET);
1461    \endcode
1462
1463    \sa EmbedGetPeer
1464*/
1465int EmbedSetPeer(WOLFSSL* ssl, char* ip, int ipSz, unsigned short port,
1466                 int fam);