UT_BoostAsioExt.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_BoostAsioExt.h
 *
 * COMMENTS:
 *      Place for all boost.asio extensions (i.e. sendfile).
 */

#ifndef __UT_BOOSTASIOEXT_H__
#define __UT_BOOSTASIOEXT_H__

#include "UT_API.h"

#include "UT_IpAddress.h"

#include <vector>
#include <limits>

// -----------------------------------------------------------------------------
// Extensions to Boost.Asio
// -----------------------------------------------------------------------------

inline UT_IpAddress
UTconvertIPAddressType(hboost::asio::ip::address& from)
{
    if (from.is_v4())
    {
        return UT_IpAddress(UT_IpAddressV4(from.to_v4().to_uint()));
    }
    return UT_IpAddress(UT_IpAddressV6(from.to_v6().to_bytes()));
}

#if !defined(WIN32)
/// Sendfile system call async support
#define UT_SUPPORT_SENDFILE

#if defined(LINUX)
#include <sys/sendfile.h>
#elif defined(MBSD)
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#endif

struct UT_SendfileOp
{
    // NB: Implementation from:
    // https://www.boost.org/doc/libs/1_75_0/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking/overload1.html

    UT_SendfileOp(
            ASIO_TCPSocket& socket,
            int fd,
            off_t offset,
            std::size_t size)
        : mySocket(socket), myFD(fd), myOffset(offset), mySize(size), myBytesTransferred(0)
    {
    }

    template <typename Self>
    void operator()(
            Self& self,
            hboost::system::error_code ec = hboost::system::error_code(),
            std::size_t bytes_transfered = 0)
    {
        // Make sure the underlying socket is non-blocking for this to work.
        if (!ec)
        {
            if (!mySocket.native_non_blocking())
                mySocket.native_non_blocking(true, ec);
        }

        if (!ec)
        {
            for (;;)
            {
                errno = 0;
#if defined(LINUX)
                int n = ::sendfile(
                        mySocket.native_handle(), myFD, &myOffset, mySize);
#elif defined(MBSD)
                // On OSX the sendfile call differs from Linux version so we
                // try to replicate its behaviour after the fact.
                // - returns 0 on success or -1 on error. Instead if it was a
                //      success adjust n to reflect how much was written.
                // - the offset does not get adjusted like it does for Linux.
                //      Instead the offset gets adjusted based on the amount
                //      read after the fact.
                //
                off_t size = static_cast<off_t>(mySize);
                int n = ::sendfile(
                        myFD, mySocket.native_handle(), myOffset, &size, nullptr /*hdtr*/, 0 /*flags*/);
                if (n >= 0)
                {
                    myOffset += size;
                    n = size;
                }
#endif
                ec = hboost::system::error_code(
                        n < 0 ? errno : 0,
                        hboost::asio::error::get_system_category());
                // Adjust our parameters based on what was just read.
                myBytesTransferred += ec ? 0 : n;
                mySize -= ec ? 0 : n;

                // If interrupted by a signal then try again right away
                if (ec == hboost::asio::error::interrupted)
                    continue;

                // Check if we need to run the operation again.
                if (ec == hboost::asio::error::would_block
                    || ec == hboost::asio::error::try_again)
                {
                    // Wait for the socket to become ready again.
                    mySocket.async_wait(
                            ASIO_TCPSocket::wait_write, std::move(self));
                    return;
                }

                if (ec || n == 0 || mySize <= 0)
                {
                    // An error occurred, or we have reach the end of what we
                    // wanted to send. Either way we are finished here and the
                    // completion handler can be called.
                    break;
                }
            }
        }

        self.complete(ec, myBytesTransferred);
    }

    ASIO_TCPSocket& mySocket;
    int myFD;
    off_t myOffset;
    std::size_t mySize;
    std::size_t myBytesTransferred;
};

/// Async composed function to use the system sendfile call. The completion
/// token is only called if the operation is completely finished or an error
/// of some kind has occurred.
template <typename CompletionToken>
auto
UTasyncSendfile(
        ASIO_TCPSocket& socket,
        int fd,
        off_t offset,
        std::size_t size,
        CompletionToken&& token) ->
        typename hboost::asio::async_result<
                typename std::decay<CompletionToken>::type,
                void(hboost::system::error_code, std::size_t)>::return_type
{
    return hboost::asio::async_compose<
            CompletionToken, void(hboost::system::error_code, std::size_t)>(
            UT_SendfileOp{socket, fd, offset, size}, token, socket);
}
#endif // !defined(WIN32)

#endif // __UT_BOOSTASIOLINUXEXT_H__