iostream.c File Reference

#include "asterisk.h"
#include "asterisk/iostream.h"
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include "asterisk/astobj2.h"
#include "asterisk/logger.h"
#include "asterisk/strings.h"
#include "asterisk/threadstorage.h"
#include "asterisk/time.h"
#include "asterisk/utils.h"

Include dependency graph for iostream.c:

Go to the source code of this file.

Data Structures
struct	ast_iostream

Functions
int	ast_iostream_close (struct ast_iostream *stream)
	Close an iostream.
ssize_t	ast_iostream_discard (struct ast_iostream *stream, size_t size)
	Discard the specified number of bytes from an iostream.
struct ast_iostream *	ast_iostream_from_fd (int *fd)
	Create an iostream from a file descriptor.
int	ast_iostream_get_fd (struct ast_iostream *stream)
	Get an iostream's file descriptor.
SSL *	ast_iostream_get_ssl (struct ast_iostream *stream)
	Get a pointer to an iostream's OpenSSL SSL structure.
ssize_t	ast_iostream_gets (struct ast_iostream *stream, char *buffer, size_t size)
	Read a LF-terminated string from an iostream.
void	ast_iostream_nonblock (struct ast_iostream *stream)
	Make an iostream non-blocking.
ssize_t	ast_iostream_printf (struct ast_iostream *stream, const char *format,...)
	Write a formatted string to an iostream.
ssize_t	ast_iostream_read (struct ast_iostream *stream, void *buffer, size_t count)
	Read data from an iostream.
void	ast_iostream_set_exclusive_input (struct ast_iostream *stream, int exclusive_input)
	Set the iostream if it can exclusively depend upon the set timeouts.
int	ast_iostream_set_sni_hostname (struct ast_iostream *stream, const char *sni_hostname)
	Set the iostream's SNI hostname for TLS client connections.
void	ast_iostream_set_timeout_disable (struct ast_iostream *stream)
	Disable the iostream timeout timer.
void	ast_iostream_set_timeout_idle_inactivity (struct ast_iostream *stream, int timeout, int timeout_reset)
	Set the iostream inactivity & idle timeout timers.
void	ast_iostream_set_timeout_inactivity (struct ast_iostream *stream, int timeout)
	Set the iostream inactivity timeout timer.
void	ast_iostream_set_timeout_sequence (struct ast_iostream *stream, struct timeval start, int timeout)
	Set the iostream I/O sequence timeout timer.
int	ast_iostream_start_tls (struct ast_iostream **pstream, SSL_CTX *ssl_ctx, int client)
	Begin TLS on an iostream.
int	ast_iostream_wait_for_input (struct ast_iostream *stream, int timeout)
	Wait for input on the iostream's file descriptor.
ssize_t	ast_iostream_write (struct ast_iostream *stream, const void *buffer, size_t size)
	Write data to an iostream.
static void	iostream_dtor (void *cookie)
static ssize_t	iostream_read (struct ast_iostream *stream, void *buf, size_t size)

Function Documentation

ast_iostream_close()

int ast_iostream_close

(

struct ast_iostream *

stream

)

Close an iostream.

Parameters

stream

A pointer to an iostream

Return values

0	success
-1	failure

Note

On failure, errno may be set providing additional information on why the failure occurred.

Definition at line 539 of file iostream.c.

{
    if (!stream) {
        errno = EBADF;
        return -1;
    }
 
    if (stream->fd != -1) {
#if defined(DO_SSL)
        if (stream->ssl) {
            int res;
 
            /*
             * According to the TLS standard, it is acceptable for an
             * application to only send its shutdown alert and then
             * close the underlying connection without waiting for
             * the peer's response (this way resources can be saved,
             * as the process can already terminate or serve another
             * connection).
             */
            res = SSL_shutdown(stream->ssl);
            if (res < 0) {
                int sslerr = SSL_get_error(stream->ssl, res);
                char err[256];
                ast_log(LOG_ERROR, "SSL_shutdown() failed: %s, %s\n",
                    ERR_error_string(sslerr, err), ssl_error_to_string(sslerr, res));
            }
 
#if !(defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER < 0x2070000L)) && (OPENSSL_VERSION_NUMBER >= 0x10100000L)
            if (!SSL_is_server(stream->ssl)) {
#else
            if (!stream->ssl->server) {
#endif
                /* For client threads, ensure that the error stack is cleared */
#if defined(LIBRESSL_VERSION_NUMBER) || (OPENSSL_VERSION_NUMBER < 0x10100000L)
#if OPENSSL_VERSION_NUMBER >= 0x10000000L
                ERR_remove_thread_state(NULL);
#else
                ERR_remove_state(0);
#endif  /* OPENSSL_VERSION_NUMBER >= 0x10000000L */
#endif  /* OPENSSL_VERSION_NUMBER  < 0x10100000L */
            }
 
            SSL_free(stream->ssl);
            stream->ssl = NULL;
        }
#endif  /* defined(DO_SSL) */
 
        /*
         * Issuing shutdown() is necessary here to avoid a race
         * condition where the last data written may not appear
         * in the TCP stream.  See ASTERISK-23548
         */
        shutdown(stream->fd, SHUT_RDWR);
        if (close(stream->fd)) {
            ast_log(LOG_ERROR, "close() failed: %s\n", strerror(errno));
        }
        stream->fd = -1;
    }
    ao2_t_ref(stream, -1, "Closed ast_iostream");
 
    return 0;
}

References ao2_t_ref, ast_log, errno, ast_iostream::fd, LOG_ERROR, NULL, and ast_iostream::ssl.

Referenced by app_exec(), ast_tcptls_close_session_file(), ast_websocket_close(), auth_http_callback(), close_mansession_file(), generic_http_callback(), session_destroy_fn(), and session_instance_destructor().

ast_iostream_discard()

ssize_t ast_iostream_discard	(	struct ast_iostream *	stream,
		size_t	count
	)

Discard the specified number of bytes from an iostream.

Parameters

stream	A pointer to an iostream
count	The number of bytes to discard.

Returns

Upon successful completion, returns the number of bytes discarded. Otherwise, -1 is returned and errno may be set indicating the error.

Definition at line 368 of file iostream.c.

{
    char buf[1024];
    size_t remaining = size;
    ssize_t ret;
 
    while (remaining) {
        ret = ast_iostream_read(stream, buf, remaining > sizeof(buf) ? sizeof(buf) : remaining);
        if (ret <= 0) {
            return ret;
        }
        remaining -= ret;
    }
 
    return size;
}

References ast_iostream_read(), and buf.

Referenced by http_body_discard_contents().

ast_iostream_from_fd()

struct ast_iostream * ast_iostream_from_fd

(

int *

fd

)

Create an iostream from a file descriptor.

Parameters

fd	A pointer to an open file descriptor

Returns

A newly allocated iostream or NULL if allocation fails.

Definition at line 611 of file iostream.c.

{
    struct ast_iostream *stream;
 
    stream = ao2_alloc_options(sizeof(*stream), iostream_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (stream) {
        stream->timeout = -1;
        stream->timeout_reset = -1;
        stream->fd = *fd;
        *fd = -1;
    }
 
    return stream;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_iostream::fd, iostream_dtor(), ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by app_exec(), ast_tcptls_client_create(), ast_tcptls_server_root(), auth_http_callback(), and generic_http_callback().

ast_iostream_get_fd()

int ast_iostream_get_fd

(

struct ast_iostream *

stream

)

Get an iostream's file descriptor.

Parameters

stream

A pointer to an iostream

Returns

The file descriptor for the given iostream

Return values

-1	if the iostream has no open file descriptor.

Definition at line 85 of file iostream.c.

{
    return stream->fd;
}

References ast_iostream::fd.

Referenced by action_waitevent(), ast_websocket_fd(), ast_websocket_uri_cb(), auth_http_callback(), eivr_comm(), get_input(), handle_kickmanconn(), handle_showmanconn(), httpd_helper_thread(), phoneprov_callback(), process_output(), and session_do().

ast_iostream_get_ssl()

SSL * ast_iostream_get_ssl

(

struct ast_iostream *

stream

)

Get a pointer to an iostream's OpenSSL SSL structure.

Parameters

stream

A pointer to an iostream

Returns

A pointer to the OpenSSL SSL structure for the given iostream

Return values

NULL	if TLS has not been initiated.

Note

If OpenSSL support is not included in the build, this will always return NULL.

Definition at line 109 of file iostream.c.

{
    return stream->ssl;
}

References ast_iostream::ssl.

Referenced by ast_websocket_uri_cb(), handle_tcptls_connection(), and websocket_client_connect().

ast_iostream_gets()

ssize_t ast_iostream_gets	(	struct ast_iostream *	stream,
		char *	buffer,
		size_t	size
	)

Read a LF-terminated string from an iostream.

Parameters

stream	A pointer to an iostream
buffer	Pointer to a buffer to store the read bytes.
size	The total size of buffer in bytes.

Returns

The number of bytes stored in buffer, excluding the null byte used to terminate the string. If the size of buffer (indicated by the caller with the size argument) is not sufficient to store the entire line it will be truncated to fit the available space. The contents of buffer will always be terminated with a null byte. In the case of an error, -1 will be returned and errno may be set indicating the error.

Definition at line 311 of file iostream.c.

{
    size_t remaining = size;
    ssize_t accum_size = 0;
    ssize_t len;
    char *newline;
 
    for (;;) {
        /* Search for newline */
        newline = memchr(stream->rbufhead, '\n', stream->rbuflen);
        if (newline) {
            len = newline - stream->rbufhead + 1;
            if (len > remaining - 1) {
                len = remaining - 1;
            }
            break;
        }
 
        /* Enough buffered line data to fill request buffer? */
        if (stream->rbuflen >= remaining - 1) {
            len = remaining - 1;
            break;
        }
        if (stream->rbuflen) {
            /* Put leftover buffered line data into request buffer */
            memcpy(buffer + accum_size, stream->rbufhead, stream->rbuflen);
            remaining -= stream->rbuflen;
            accum_size += stream->rbuflen;
            stream->rbuflen = 0;
        }
        stream->rbufhead = stream->rbuf;
 
        len = iostream_read(stream, stream->rbuf, sizeof(stream->rbuf));
        if (len == 0) {
            /* Nothing new was read.  Return whatever we have accumulated. */
            break;
        }
        if (len < 0) {
            if (accum_size) {
                /* We have an accumulated buffer so return that instead. */
                len = 0;
                break;
            }
            return len;
        }
        stream->rbuflen += len;
    }
 
    /* Return read buffer string length */
    memcpy(buffer + accum_size, stream->rbufhead, len);
    buffer[accum_size + len] = 0;
    stream->rbuflen -= len;
    stream->rbufhead += len;
 
    return accum_size + len;
}

References iostream_read(), len(), ast_iostream::rbuf, ast_iostream::rbufhead, and ast_iostream::rbuflen.

Referenced by eivr_comm(), http_body_discard_chunk_trailer_headers(), http_body_get_chunk_length(), http_request_headers_get(), httpd_process_request(), and websocket_client_handshake_get_response().

ast_iostream_nonblock()

void ast_iostream_nonblock

(

struct ast_iostream *

stream

)

Make an iostream non-blocking.

Parameters

stream

A pointer to an iostream

Definition at line 104 of file iostream.c.

{
    ast_fd_set_flags(stream->fd, O_NONBLOCK);
}

References ast_fd_set_flags, and ast_iostream::fd.

Referenced by ast_websocket_set_nonblock(), httpd_helper_thread(), and session_do().

ast_iostream_printf()

ssize_t ast_iostream_printf	(	struct ast_iostream *	stream,
		const char *	format,
			...
	)

Write a formatted string to an iostream.

Parameters

stream	A pointer to an iostream
format	A format string, as documented by printf(3)
...	Arguments for the provided format string

Returns

The number of bytes written, or -1 if an error occurs. Note that if -1 is returned, the number of bytes written to the iostream is unspecified.

Definition at line 502 of file iostream.c.

{
    char sbuf[512], *buf = sbuf;
    int len, len2, ret = -1;
    va_list va;
 
    va_start(va, format);
    len = vsnprintf(buf, sizeof(sbuf), format, va);
    va_end(va);
 
    if (len > sizeof(sbuf) - 1) {
        /* Add one to the string length to accommodate the NULL byte */
        size_t buf_len = len + 1;
 
        buf = ast_malloc(buf_len);
        if (!buf) {
            return -1;
        }
        va_start(va, format);
        len2 = vsnprintf(buf, buf_len, format, va);
        va_end(va);
        if (len2 != len) {
            goto error;
        }
    }
 
    if (ast_iostream_write(stream, buf, len) == len)
        ret = len;
 
error:
    if (buf != sbuf) {
        ast_free(buf);
    }
 
    return ret;
}

References ast_free, ast_iostream_write(), ast_malloc, buf, error(), and len().

Referenced by ast_http_send(), ast_websocket_uri_cb(), and websocket_client_handshake().

ast_iostream_read()

ssize_t ast_iostream_read	(	struct ast_iostream *	stream,
		void *	buffer,
		size_t	count
	)

Read data from an iostream.

Parameters

stream	A pointer to an iostream
buffer	Pointer to a buffer to store the read bytes.
count	The number of bytes to read.

Returns

Upon successful completion, returns a non-negative integer indicating the number of bytes actually read. Otherwise, returns -1 and may set errno to indicate the error.

Definition at line 284 of file iostream.c.

{
    if (!count) {
        /* You asked for no data you got no data. */
        return 0;
    }
 
    if (!stream || stream->fd == -1) {
        errno = EBADF;
        return -1;
    }
 
    /* Get any remains from the read buffer */
    if (stream->rbuflen) {
        size_t r = count;
        if (r > stream->rbuflen) {
            r = stream->rbuflen;
        }
        memcpy(buffer, stream->rbufhead, r);
        stream->rbuflen -= r;
        stream->rbufhead += r;
        return r;
    }
 
    return iostream_read(stream, buffer, count);
}

References errno, ast_iostream::fd, iostream_read(), ast_iostream::rbufhead, and ast_iostream::rbuflen.

Referenced by ast_iostream_discard(), get_input(), http_body_check_chunk_sync(), http_body_read_contents(), readmimefile(), and ws_safe_read().

ast_iostream_set_exclusive_input()

void ast_iostream_set_exclusive_input	(	struct ast_iostream *	stream,
		int	exclusive_input
	)

Set the iostream if it can exclusively depend upon the set timeouts.

Parameters

stream	A pointer to an iostream
exclusive_input	TRUE if stream can exclusively wait for fd input. Otherwise, the stream will not wait for fd input. It will wait while trying to send data.

Note

The stream timeouts still need to be set.

Definition at line 149 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    stream->exclusive_input = exclusive_input;
}

References ast_assert, ast_iostream::exclusive_input, and NULL.

Referenced by ast_websocket_set_nonblock(), ast_websocket_uri_cb(), httpd_helper_thread(), and session_do().

ast_iostream_set_sni_hostname()

int ast_iostream_set_sni_hostname	(	struct ast_iostream *	stream,
		const char *	sni_hostname
	)

Set the iostream's SNI hostname for TLS client connections.

Parameters

stream	A pointer to an iostream
sni_hostname	The hostname to use for SNI when in client mode

Return values

0	if the hostname was set successfully.
-1	if memory could not be allocated for the hostname.

Definition at line 156 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    ast_free(stream->sni_hostname);
    stream->sni_hostname = ast_strdup(sni_hostname);
 
    return stream->sni_hostname ? 0 : -1;
}

References ast_assert, ast_free, ast_strdup, NULL, and ast_iostream::sni_hostname.

Referenced by ast_tcptls_client_create().

ast_iostream_set_timeout_disable()

void ast_iostream_set_timeout_disable

(

struct ast_iostream *

stream

)

Disable the iostream timeout timer.

Parameters

stream

A pointer to an iostream

Definition at line 114 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    stream->timeout = -1;
    stream->timeout_reset = -1;
}

References ast_assert, NULL, ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by ast_websocket_close(), ast_websocket_write(), send_string(), and session_do().

ast_iostream_set_timeout_idle_inactivity()

void ast_iostream_set_timeout_idle_inactivity	(	struct ast_iostream *	stream,
		int	timeout,
		int	timeout_reset
	)

Set the iostream inactivity & idle timeout timers.

Parameters

stream	A pointer to an iostream
timeout	Number of milliseconds to wait for initial data transfer with the peer.
timeout_reset	Number of milliseconds to wait for subsequent data transfer with the peer.

As an example, if you want to timeout a peer if they do not send an initial message within 5 seconds or if they do not send a message at least every 30 seconds, you would set timeout to 5000 and timeout_reset to 30000.

Note

Setting either of these timeouts to -1 will disable them.

Definition at line 131 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    stream->start.tv_sec = 0;
    stream->timeout = timeout;
    stream->timeout_reset = timeout_reset;
}

References ast_assert, NULL, ast_iostream::start, ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by httpd_helper_thread().

ast_iostream_set_timeout_inactivity()

void ast_iostream_set_timeout_inactivity	(	struct ast_iostream *	stream,
		int	timeout
	)

Set the iostream inactivity timeout timer.

Parameters

stream	A pointer to an iostream
timeout	Number of milliseconds to wait for data transfer with the peer.

This is basically how much time we are willing to spend in an I/O call before we declare the peer unresponsive.

Note

Setting timeout to -1 disables the timeout.

Setting this timeout replaces the I/O sequence timeout timer.

Definition at line 122 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    stream->start.tv_sec = 0;
    stream->timeout = timeout;
    stream->timeout_reset = timeout;
}

References ast_assert, NULL, ast_iostream::start, ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by ast_websocket_close(), and send_string().

ast_iostream_set_timeout_sequence()

void ast_iostream_set_timeout_sequence	(	struct ast_iostream *	stream,
		struct timeval	start,
		int	timeout
	)

Set the iostream I/O sequence timeout timer.

Parameters

stream	A pointer to an iostream
start	Time the I/O sequence timer starts.
timeout	Number of milliseconds from the start time before timeout.

This is how much time are we willing to allow the peer to complete an operation that can take several I/O calls. The main use is as an authentication timer with us.

Note

Setting timeout to -1 disables the timeout.

Setting this timeout replaces the inactivity timeout timer.

Definition at line 140 of file iostream.c.

{
    ast_assert(stream != NULL);
 
    stream->start = start;
    stream->timeout = timeout;
    stream->timeout_reset = timeout;
}

References ast_assert, NULL, ast_iostream::start, ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by ast_websocket_write(), and session_do().

ast_iostream_start_tls()

int ast_iostream_start_tls	(	struct ast_iostream **	stream,
		SSL_CTX *	ctx,
		int	client
	)

Begin TLS on an iostream.

Parameters

stream	A pointer to an iostream pointer
ctx	A pointer to an SSL_CTX which will be passed to SSL_new()
client	Non-zero to indicate that we are the client, zero to indicate that we are the server.

Return values

0	success
-1	failure

Note

The iostream that is passed in stream may be replaced with a different one before this function returns.

On failure, errno may be set providing additional information on why the failure occurred.

Definition at line 627 of file iostream.c.

{
#ifdef DO_SSL
    struct ast_iostream *stream = *pstream;
    int (*ssl_setup)(SSL *) = client ? SSL_connect : SSL_accept;
    int res;
    struct timeval rcv_timeout, snd_timeout;
    struct timeval timeout;
    socklen_t len;
 
    stream->ssl = SSL_new(ssl_ctx);
    if (!stream->ssl) {
        ast_log(LOG_ERROR, "Unable to create new SSL connection\n");
        errno = ENOMEM;
        return -1;
    }
 
    /*
     * This function takes struct ast_iostream **, so it can chain
     * SSL over any ast_iostream. For now we assume it's a file descriptor.
     * But later this should instead use BIO wrapper to tie SSL to another
     * ast_iostream.
     */
    SSL_set_fd(stream->ssl, stream->fd);
 
    if (client && !ast_strlen_zero(stream->sni_hostname)) {
        if (!SSL_set_tlsext_host_name(stream->ssl, stream->sni_hostname)) {
            ast_log(LOG_ERROR, "Unable to set SNI hostname '%s'\n",
                stream->sni_hostname);
            errno = EIO;
            return -1;
        }
    }
 
    /* Get current socket timeout values */
    len = sizeof(rcv_timeout);
    getsockopt(stream->fd, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, &len);
    len = sizeof(snd_timeout);
    getsockopt(stream->fd, SOL_SOCKET, SO_SNDTIMEO, &snd_timeout, &len);
 
    /* Set socket timeout for SSL handshake to prevent hanging connections and allow SSL handshake to timeout */
    timeout.tv_sec = 30;  /* 30 second timeout for SSL handshake */
    timeout.tv_usec = 0;
    setsockopt(stream->fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    setsockopt(stream->fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
 
    res = ssl_setup(stream->ssl);
    if (res <= 0) {
        int sslerr = SSL_get_error(stream->ssl, res);
        char err[256];
 
        ast_log(LOG_ERROR, "Problem setting up ssl connection: %s, %s\n",
            ERR_error_string(sslerr, err), ssl_error_to_string(sslerr, res));
        errno = EIO;
        return -1;
    }
 
    /* Restore socket timeouts from SSL handshake */
    setsockopt(stream->fd, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof(rcv_timeout));
    setsockopt(stream->fd, SOL_SOCKET, SO_SNDTIMEO, &snd_timeout, sizeof(snd_timeout));
 
    return 0;
#else
    ast_log(LOG_ERROR, "SSL not enabled in this build\n");
    errno = ENOTSUP;
    return -1;
#endif
}

References ast_log, ast_strlen_zero(), errno, ast_iostream::fd, len(), LOG_ERROR, ast_iostream::sni_hostname, ast_iostream::ssl, and ast_iostream::start.

Referenced by handle_tcptls_connection().

ast_iostream_wait_for_input()

int ast_iostream_wait_for_input	(	struct ast_iostream *	stream,
		int	timeout
	)

Wait for input on the iostream's file descriptor.

Since

16.8.0

17.2.0

Parameters

stream	A pointer to an iostream
timeout	the number of milliseconds to wait

Return values

-1	if error occurred
0	if the timeout expired
1	if the stream is ready for reading

Definition at line 90 of file iostream.c.

{
#if defined(DO_SSL)
    /* Because SSL is read in blocks, it's possible that the last time we read we
       got more than we asked for and it is now buffered inside OpenSSL. If that
       is the case, calling ast_wait_for_input() will block until the fd is ready
       for reading again, which might never happen. */
    if (stream->ssl && SSL_pending(stream->ssl)) {
        return 1;
    }
#endif
    return ast_wait_for_input(stream->fd, timeout);
}

References ast_wait_for_input(), ast_iostream::fd, and ast_iostream::ssl.

Referenced by ast_websocket_wait_for_input(), and ws_safe_read().

ast_iostream_write()

ssize_t ast_iostream_write	(	struct ast_iostream *	stream,
		const void *	buffer,
		size_t	count
	)

Write data to an iostream.

Parameters

stream	A pointer to an iostream
buffer	Pointer to a buffer from which to read bytes.
count	The number of bytes from buffer to write.

Returns

Upon successful completion, returns the number of bytes actually written to the iostream. This number shall never be greater than count. Otherwise, returns -1 and may set errno to indicate the error.

Definition at line 385 of file iostream.c.

{
    struct timeval start;
    int ms;
    int res;
    int written;
    int remaining;
 
    if (!size) {
        /* You asked to write no data you wrote no data. */
        return 0;
    }
 
    if (!stream || stream->fd == -1) {
        errno = EBADF;
        return -1;
    }
 
    if (stream->start.tv_sec) {
        start = stream->start;
    } else {
        start = ast_tvnow();
    }
 
#if defined(DO_SSL)
    if (stream->ssl) {
        written = 0;
        remaining = size;
        for (;;) {
            int sslerr;
            char err[256];
            res = SSL_write(stream->ssl, buffer + written, remaining);
            if (res == remaining) {
                /* Everything was written. */
                return size;
            }
            if (0 < res) {
                /* Successfully wrote part of the buffer.  Try to write the rest. */
                written += res;
                remaining -= res;
                continue;
            }
            sslerr = SSL_get_error(stream->ssl, res);
            switch (sslerr) {
            case SSL_ERROR_ZERO_RETURN:
                ast_debug(1, "TLS clean shutdown alert writing data\n");
                if (written) {
                    /* Report partial write. */
                    return written;
                }
                errno = EBADF;
                return -1;
            case SSL_ERROR_WANT_READ:
                ms = ast_remaining_ms(start, stream->timeout);
                if (!ms) {
                    /* Report partial write. */
                    ast_debug(1, "TLS timeout writing data (want read)\n");
                    return written;
                }
                ast_wait_for_input(stream->fd, ms);
                break;
            case SSL_ERROR_WANT_WRITE:
                ms = ast_remaining_ms(start, stream->timeout);
                if (!ms) {
                    /* Report partial write. */
                    ast_debug(1, "TLS timeout writing data (want write)\n");
                    return written;
                }
                ast_wait_for_output(stream->fd, ms);
                break;
            default:
                /* Undecoded SSL or transport error. */
                ast_debug(1, "TLS transport or SSL error writing data: %s, %s\n", ERR_error_string(sslerr, err),
                    ssl_error_to_string(sslerr, res));
                if (written) {
                    /* Report partial write. */
                    return written;
                }
                errno = EBADF;
                return -1;
            }
        }
    }
#endif  /* defined(DO_SSL) */
 
    written = 0;
    remaining = size;
    for (;;) {
        res = write(stream->fd, buffer + written, remaining);
        if (res == remaining) {
            /* Yay everything was written. */
            return size;
        }
        if (0 < res) {
            /* Successfully wrote part of the buffer.  Try to write the rest. */
            written += res;
            remaining -= res;
            continue;
        }
        if (errno != EINTR && errno != EAGAIN) {
            /* Not a retryable error. */
            ast_debug(1, "TCP socket error writing: %s\n", strerror(errno));
            if (written) {
                return written;
            }
            return -1;
        }
        ms = ast_remaining_ms(start, stream->timeout);
        if (!ms) {
            /* Report partial write. */
            ast_debug(1, "TCP timeout writing data\n");
            return written;
        }
        ast_wait_for_output(stream->fd, ms);
    }
}

References ast_debug, ast_remaining_ms(), ast_tvnow(), ast_wait_for_input(), ast_wait_for_output(), errno, ast_iostream::fd, ast_iostream::ssl, ast_iostream::start, and ast_iostream::timeout.

Referenced by ast_http_send(), ast_iostream_printf(), ast_websocket_close(), ast_websocket_write(), process_output(), send_eivr_event(), and send_string().

iostream_dtor()

static void iostream_dtor ( void *  cookie )

static

Definition at line 603 of file iostream.c.

{
    struct ast_iostream *stream = cookie;
 
    ast_free(stream->sni_hostname);
    ast_assert(stream->fd == -1);
}

References ast_assert, ast_free, ast_iostream::fd, ast_iostream::sni_hostname, and ast_iostream::start.

Referenced by ast_iostream_from_fd().

iostream_read()

static ssize_t iostream_read ( struct ast_iostream *  stream, void *  buf, size_t  size  )

static

Definition at line 166 of file iostream.c.

{
    struct timeval start;
    int ms;
    int res;
 
    if (stream->start.tv_sec) {
        start = stream->start;
    } else {
        start = ast_tvnow();
    }
 
#if defined(DO_SSL)
    if (stream->ssl) {
        for (;;) {
            int sslerr;
            char err[256];
            res = SSL_read(stream->ssl, buf, size);
            if (0 < res) {
                /* We read some payload data. */
                stream->timeout = stream->timeout_reset;
                return res;
            }
            sslerr = SSL_get_error(stream->ssl, res);
            switch (sslerr) {
            case SSL_ERROR_ZERO_RETURN:
                /* Report EOF for a shutdown */
                ast_debug(1, "TLS clean shutdown alert reading data\n");
                return 0;
            case SSL_ERROR_WANT_READ:
                if (!stream->exclusive_input) {
                    /* We cannot wait for data now. */
                    errno = EAGAIN;
                    return -1;
                }
                while ((ms = ast_remaining_ms(start, stream->timeout))) {
                    res = ast_wait_for_input(stream->fd, ms);
                    if (0 < res) {
                        /* Socket is ready to be read. */
                        break;
                    }
                    if (res < 0) {
                        if (errno == EINTR || errno == EAGAIN) {
                            /* Try again. */
                            continue;
                        }
                        ast_debug(1, "TLS socket error waiting for read data: %s\n",
                            strerror(errno));
                        return -1;
                    }
                }
                break;
            case SSL_ERROR_WANT_WRITE:
                while ((ms = ast_remaining_ms(start, stream->timeout))) {
                    res = ast_wait_for_output(stream->fd, ms);
                    if (0 < res) {
                        /* Socket is ready to be written. */
                        break;
                    }
                    if (res < 0) {
                        if (errno == EINTR || errno == EAGAIN) {
                            /* Try again. */
                            continue;
                        }
                        ast_debug(1, "TLS socket error waiting for write space: %s\n",
                            strerror(errno));
                        return -1;
                    }
                }
                break;
            case SSL_ERROR_SYSCALL:
                /* Some non-recoverable I/O error occurred. The OpenSSL error queue may
                 * contain more information on the error. For socket I/O on Unix systems,
                 * consult errno for details. */
                ast_debug(1, "TLS non-recoverable I/O error occurred: %s, %s\n", ERR_error_string(sslerr, err),
                    ssl_error_to_string(sslerr, res));
                return -1;
            default:
                /* Report EOF for an undecoded SSL or transport error. */
                ast_debug(1, "TLS transport or SSL error reading data:  %s, %s\n", ERR_error_string(sslerr, err),
                    ssl_error_to_string(sslerr, res));
                return -1;
            }
            if (!ms) {
                /* Report EOF for a timeout */
                ast_debug(1, "TLS timeout reading data\n");
                return 0;
            }
        }
    }
#endif  /* defined(DO_SSL) */
 
    for (;;) {
        res = read(stream->fd, buf, size);
        if (0 <= res) {
            /* Got data or we cannot wait for it. */
            stream->timeout = stream->timeout_reset;
            return res;
        }
        if (!stream->exclusive_input) {
            return res;
        }
        if (errno != EINTR && errno != EAGAIN) {
            /* Not a retryable error. */
            ast_debug(1, "TCP socket error reading data: %s\n",
                strerror(errno));
            return -1;
        }
        ms = ast_remaining_ms(start, stream->timeout);
        if (!ms) {
            /* Report EOF for a timeout */
            ast_debug(1, "TCP timeout reading data\n");
            return 0;
        }
        ast_wait_for_input(stream->fd, ms);
    }
}

References ast_debug, ast_remaining_ms(), ast_tvnow(), ast_wait_for_input(), ast_wait_for_output(), buf, errno, ast_iostream::exclusive_input, ast_iostream::fd, ast_iostream::ssl, ast_iostream::start, ast_iostream::timeout, and ast_iostream::timeout_reset.

Referenced by ast_iostream_gets(), and ast_iostream_read().