robot/include/boost/beast/http/impl/read.hpp

//
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
// Copyright (c) 2020 Richard Hodges (hodges.r@gmail.com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//

#ifndef BOOST_BEAST_HTTP_IMPL_READ_HPP
#define BOOST_BEAST_HTTP_IMPL_READ_HPP

#include <boost/beast/http/type_traits.hpp>
#include <boost/beast/http/error.hpp>
#include <boost/beast/http/parser.hpp>
#include <boost/beast/http/read.hpp>
#include <boost/beast/core/async_base.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/core/detail/read.hpp>
#include <boost/asio/append.hpp>
#include <boost/asio/compose.hpp>
#include <boost/asio/coroutine.hpp>
#include <boost/asio/error.hpp>

namespace boost {
namespace beast {
namespace http {

namespace detail {

struct parser_is_done
{
    template<bool isRequest>
    bool
    operator()(basic_parser<isRequest> const& p) const
    {
        return p.is_done();
    }
};

struct parser_is_header_done
{
    template<bool isRequest>
    bool
    operator()(basic_parser<isRequest> const& p) const
    {
        return p.is_header_done();
    }
};

//------------------------------------------------------------------------------

template<
    class Stream, class DynamicBuffer,
    bool isRequest, class Body, class Allocator,
    class Handler>
class read_msg_op
    : public beast::stable_async_base<
        Handler, beast::executor_type<Stream>>
    , public asio::coroutine
{
    using parser_type =
        parser<isRequest, Body, Allocator>;

    using message_type =
        typename parser_type::value_type;

    struct data
    {
        Stream& s;
        message_type& m;
        parser_type p;

        data(
            Stream& s_,
            message_type& m_)
            : s(s_)
            , m(m_)
            , p(std::move(m))
        {
        }
    };

    data& d_;

public:
    template<class Handler_>
    read_msg_op(
        Handler_&& h,
        Stream& s,
        DynamicBuffer& b,
        message_type& m)
        : stable_async_base<
            Handler, beast::executor_type<Stream>>(
                std::forward<Handler_>(h), s.get_executor())
        , d_(beast::allocate_stable<data>(
            *this, s, m))
    {
        BOOST_ASIO_HANDLER_LOCATION((
            __FILE__, __LINE__,
            "http::async_read(msg)"));

        http::async_read(d_.s, b, d_.p, std::move(*this));
    }

    void
    operator()(
        error_code ec,
        std::size_t bytes_transferred)
    {
        if(! ec)
            d_.m = d_.p.release();
        this->complete_now(ec, bytes_transferred);
    }
};

template <typename AsyncReadStream>
struct run_read_msg_op
{
    AsyncReadStream* stream;

    using executor_type = typename AsyncReadStream::executor_type;

    executor_type
    get_executor() const noexcept
    {
        return stream->get_executor();
    }

    template<
        class ReadHandler,
        class DynamicBuffer,
        bool isRequest, class Body, class Allocator>
    void
    operator()(
        ReadHandler&& h,
        DynamicBuffer* b,
        message<isRequest, Body,
            basic_fields<Allocator>>* m)
    {
        // If you get an error on the following line it means
        // that your handler does not meet the documented type
        // requirements for the handler.

        static_assert(
            beast::detail::is_invocable<ReadHandler,
            void(error_code, std::size_t)>::value,
            "ReadHandler type requirements not met");

        read_msg_op<
            AsyncReadStream,
            DynamicBuffer,
            isRequest, Body, Allocator,
            typename std::decay<ReadHandler>::type>(
                std::forward<ReadHandler>(h), *stream, *b, *m);
    }
};

template<class AsyncReadStream, class DynamicBuffer, bool isRequest>
class read_some_op : asio::coroutine
{
    AsyncReadStream& s_;
    DynamicBuffer& b_;
    basic_parser<isRequest>& p_;
    std::size_t bytes_transferred_;
    bool cont_;

public:
    read_some_op(
        AsyncReadStream& s,
        DynamicBuffer& b,
        basic_parser<isRequest>& p)
        : s_(s)
        , b_(b)
        , p_(p)
        , bytes_transferred_(0)
        , cont_(false)
    {
    }

    template<class Self>
    void operator()(
        Self& self,
        error_code ec = {},
        std::size_t bytes_transferred = 0)
    {
        BOOST_ASIO_CORO_REENTER(*this)
        {
            if(b_.size() == 0)
                goto do_read;
            for(;;)
            {
                // parse
                {
                    auto const used = p_.put(b_.data(), ec);
                    bytes_transferred_ += used;
                    b_.consume(used);
                }
                if(ec != http::error::need_more)
                    break;

            do_read:
                BOOST_ASIO_CORO_YIELD
                {
                    cont_ = true;
                    // VFALCO This was read_size_or_throw
                    auto const size = read_size(b_, 65536);
                    if(size == 0)
                    {
                        BOOST_BEAST_ASSIGN_EC(ec, error::buffer_overflow);
                        goto upcall;
                    }
                    auto const mb =
                        beast::detail::dynamic_buffer_prepare(
                            b_, size, ec, error::buffer_overflow);
                    if(ec)
                        goto upcall;

                    BOOST_ASIO_HANDLER_LOCATION((
                        __FILE__, __LINE__,
                        "http::async_read_some"));

                    s_.async_read_some(*mb, std::move(self));
                }
                b_.commit(bytes_transferred);
                if(ec == net::error::eof)
                {
                    BOOST_ASSERT(bytes_transferred == 0);
                    if(p_.got_some())
                    {
                        // caller sees EOF on next read
                        ec.assign(0, ec.category());
                        p_.put_eof(ec);
                        if(ec)
                            goto upcall;
                        BOOST_ASSERT(p_.is_done());
                        goto upcall;
                    }
                    BOOST_BEAST_ASSIGN_EC(ec, error::end_of_stream);
                    break;
                }
                if(ec)
                    break;
            }

        upcall:
            if(! cont_)
            {
                BOOST_ASIO_CORO_YIELD
                {
                    BOOST_ASIO_HANDLER_LOCATION((
                        __FILE__, __LINE__,
                        "http::async_read_some"));


                    const auto ex =
                        asio::get_associated_immediate_executor(
                            self, s_.get_executor());

                    net::dispatch(ex, net::append(std::move(self), ec));
                }
            }
            self.complete(ec, bytes_transferred_);
        }
    }
};

template<class Stream, class DynamicBuffer, bool isRequest, class Condition>
class read_op
    : asio::coroutine
{
    Stream& s_;
    DynamicBuffer& b_;
    basic_parser<isRequest>& p_;
    std::size_t bytes_transferred_;

public:
    read_op(Stream& s, DynamicBuffer& b, basic_parser<isRequest>& p)
    : s_(s)
    , b_(b)
    , p_(p)
    , bytes_transferred_(0)
    {
    }

    template<class Self>
    void operator()(Self& self, error_code ec = {}, std::size_t bytes_transferred = 0)
    {
        BOOST_ASIO_CORO_REENTER(*this)
        {
            if (Condition{}(p_))
            {
                BOOST_ASIO_CORO_YIELD
                {
                    BOOST_ASIO_HANDLER_LOCATION((
                        __FILE__, __LINE__,
                        "http::async_read"));

                    const auto ex =
                        asio::get_associated_immediate_executor(
                            self, s_.get_executor());

                    net::dispatch(ex, std::move(self));
                }
            }
            else
            {
                do
                {
                    BOOST_ASIO_CORO_YIELD
                    {
                        BOOST_ASIO_HANDLER_LOCATION((
                            __FILE__, __LINE__,
                            "http::async_read"));

                        async_read_some(
                            s_, b_, p_, std::move(self));
                    }
                    bytes_transferred_ += bytes_transferred;
                } while (!ec &&
                         !Condition{}(p_));
            }
            self.complete(ec, bytes_transferred_);
        }
    }
};


template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read_some(SyncReadStream& s, DynamicBuffer& b, basic_parser<isRequest>& p, error_code& ec)
{
    std::size_t total = 0;
    ec.clear();
    if(b.size() == 0)
        goto do_read;
    for(;;)
    {
        // parse
        {
            auto const used = p.put(b.data(), ec);
            total += used;
            b.consume(used);
        }
        if(ec != http::error::need_more)
            break;

    do_read:
        // VFALCO This was read_size_or_throw
        auto const size = read_size(b, 65536);
        if(size == 0)
        {
            BOOST_BEAST_ASSIGN_EC(ec, error::buffer_overflow);
            return total;
        }
        auto const mb =
            beast::detail::dynamic_buffer_prepare(
                b, size, ec, error::buffer_overflow);
        if(ec)
            return total;
        std::size_t
            bytes_transferred =
                s.read_some(*mb, ec);
        b.commit(bytes_transferred);
        if(ec == net::error::eof)
        {
            BOOST_ASSERT(bytes_transferred == 0);
            if(p.got_some())
            {
                // caller sees EOF on next read
                ec.assign(0, ec.category());
                p.put_eof(ec);
                if(ec)
                    return total;
                BOOST_ASSERT(p.is_done());
                return total;
            }
            BOOST_BEAST_ASSIGN_EC(ec, error::end_of_stream);
            break;
        }
        if(ec)
            break;
    }

    return total;
}

template<class Condition, class Stream, class DynamicBuffer, bool isRequest>
std::size_t sync_read_op(Stream& s, DynamicBuffer& b, basic_parser<isRequest>& p, error_code& ec)
{
    std::size_t total = 0;
    ec.clear();

    if (!Condition{}(p))
    {
        do
        {
            total +=
                detail::read_some(s, b, p, ec);
        } while (!ec &&
                 !Condition{}(p));
    }
    return total;
}

} // detail

//------------------------------------------------------------------------------

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read_some(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    error_code ec;
    auto const bytes_transferred =
        http::read_some(stream, buffer, parser, ec);
    if(ec)
        BOOST_THROW_EXCEPTION(system_error{ec});
    return bytes_transferred;
}

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read_some(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    error_code& ec)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    return detail::read_some(stream, buffer, parser, ec);
}

template<
    class AsyncReadStream,
    class DynamicBuffer,
    bool isRequest,
    BOOST_BEAST_ASYNC_TPARAM2 ReadHandler>
BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
async_read_some(
    AsyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    ReadHandler&& handler)
{
    return net::async_compose<ReadHandler,
        void(beast::error_code, std::size_t)>(
            detail::read_some_op<AsyncReadStream, DynamicBuffer, isRequest> {
                stream,
                buffer,
                parser
            },
            handler,
            stream);
}

//------------------------------------------------------------------------------

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read_header(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    error_code ec;
    auto const bytes_transferred =
        http::read_header(stream, buffer, parser, ec);
    if(ec)
        BOOST_THROW_EXCEPTION(system_error{ec});
    return bytes_transferred;
}

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read_header(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    error_code& ec)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    parser.eager(false);
    return detail::sync_read_op<
        detail::parser_is_header_done>(
            stream, buffer, parser, ec);
}

template<
    class AsyncReadStream,
    class DynamicBuffer,
    bool isRequest,
    BOOST_BEAST_ASYNC_TPARAM2 ReadHandler>
BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
async_read_header(
    AsyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    ReadHandler&& handler)
{
    parser.eager(false);
    return net::async_compose<
        ReadHandler,
        void(error_code, std::size_t)>(
        detail::read_op<
            AsyncReadStream,
            DynamicBuffer,
            isRequest,
            detail::parser_is_header_done>(
                stream, buffer, parser),
            handler, stream);
}

//------------------------------------------------------------------------------

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    error_code ec;
    auto const bytes_transferred =
        http::read(stream, buffer, parser, ec);
    if(ec)
        BOOST_THROW_EXCEPTION(system_error{ec});
    return bytes_transferred;
}

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest>
std::size_t
read(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    error_code& ec)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    parser.eager(true);
    return detail::sync_read_op<
        detail::parser_is_done>(
            stream, buffer, parser, ec);
}

template<
    class AsyncReadStream,
    class DynamicBuffer,
    bool isRequest,
    BOOST_BEAST_ASYNC_TPARAM2 ReadHandler>
BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
async_read(
    AsyncReadStream& stream,
    DynamicBuffer& buffer,
    basic_parser<isRequest>& parser,
    ReadHandler&& handler)
{
    static_assert(
        is_async_read_stream<AsyncReadStream>::value,
        "AsyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    parser.eager(true);
    return net::async_compose<
        ReadHandler,
        void(error_code, std::size_t)>(
            detail::read_op<
                AsyncReadStream,
                DynamicBuffer,
                isRequest,
                detail::parser_is_done>(
                    stream, buffer, parser),
            handler, stream);
}

//------------------------------------------------------------------------------

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest, class Body, class Allocator>
std::size_t
read(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    message<isRequest, Body, basic_fields<Allocator>>& msg)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    static_assert(is_body<Body>::value,
        "Body type requirements not met");
    static_assert(is_body_reader<Body>::value,
        "BodyReader type requirements not met");
    error_code ec;
    auto const bytes_transferred =
        http::read(stream, buffer, msg, ec);
    if(ec)
        BOOST_THROW_EXCEPTION(system_error{ec});
    return bytes_transferred;
}

template<
    class SyncReadStream,
    class DynamicBuffer,
    bool isRequest, class Body, class Allocator>
std::size_t
read(
    SyncReadStream& stream,
    DynamicBuffer& buffer,
    message<isRequest, Body, basic_fields<Allocator>>& msg,
    error_code& ec)
{
    static_assert(
        is_sync_read_stream<SyncReadStream>::value,
        "SyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    static_assert(is_body<Body>::value,
        "Body type requirements not met");
    static_assert(is_body_reader<Body>::value,
        "BodyReader type requirements not met");
    parser<isRequest, Body, Allocator> p(std::move(msg));
    p.eager(true);
    auto const bytes_transferred =
        http::read(stream, buffer, p, ec);
    if(ec)
        return bytes_transferred;
    msg = p.release();
    return bytes_transferred;
}

template<
    class AsyncReadStream,
    class DynamicBuffer,
    bool isRequest, class Body, class Allocator,
    BOOST_BEAST_ASYNC_TPARAM2 ReadHandler>
BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
async_read(
    AsyncReadStream& stream,
    DynamicBuffer& buffer,
    message<isRequest, Body, basic_fields<Allocator>>& msg,
    ReadHandler&& handler)
{
    static_assert(
        is_async_read_stream<AsyncReadStream>::value,
        "AsyncReadStream type requirements not met");
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    static_assert(is_body<Body>::value,
        "Body type requirements not met");
    static_assert(is_body_reader<Body>::value,
        "BodyReader type requirements not met");
    return net::async_initiate<
        ReadHandler,
        void(error_code, std::size_t)>(
            detail::run_read_msg_op<AsyncReadStream>{&stream},
                handler, &buffer, &msg);
}

} // http
} // beast
} // boost

#endif