Method socketSendBytesImpl

src/IO/WriteBufferFromPocoSocket.cpp:38–74

}

ssize_t WriteBufferFromPocoSocket::socketSendBytesImpl(const char * ptr, size_t size)
{
    ssize_t res = 0;

    /// If async_callback is specified, set socket to non-blocking mode
    /// and try to write data to it, if socket is not ready for writing,
    /// run async_callback and try again later.
    /// It is expected that file descriptor may be polled externally.
    /// Note that send timeout is not checked here. External code should check it while polling.
    if (async_callback)
    {
        socket.setBlocking(false);
        /// Set socket to blocking mode at the end.
        SCOPE_EXIT_SAFE(socket.setBlocking(true));
        bool secure = socket.secure();
        res = socket.impl()->sendBytes(ptr, static_cast<int>(size));

        /// Check EAGAIN and ERR_SSL_WANT_WRITE/ERR_SSL_WANT_READ for secure socket (writing to secure socket can read too).
        while (res < 0 && (errno == EAGAIN || (secure && (checkSSLWantRead(res) || checkSSLWantWrite(res)))))
        {
            /// In case of ERR_SSL_WANT_READ we should wait for socket to be ready for reading, otherwise - for writing.
            if (secure && checkSSLWantRead(res))
                async_callback(socket.impl()->sockfd(), socket.getReceiveTimeout(), AsyncEventTimeoutType::RECEIVE, socket_description, AsyncTaskExecutor::Event::READ | AsyncTaskExecutor::Event::ERROR);
            else
                async_callback(socket.impl()->sockfd(), socket.getSendTimeout(), AsyncEventTimeoutType::SEND, socket_description, AsyncTaskExecutor::Event::WRITE | AsyncTaskExecutor::Event::ERROR);

            /// Try to write again.
            res = socket.impl()->sendBytes(ptr, static_cast<int>(size));
        }
    }
    else
    {
        res = socket.impl()->sendBytes(ptr, static_cast<int>(size));
    }

    return res;
}

void WriteBufferFromPocoSocket::socketSendBytes(const char * ptr, size_t size)
{