basic_parser.hpp

Go to the documentation of this file.

//
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot 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_BASIC_PARSER_HPP
#define BOOST_BEAST_HTTP_BASIC_PARSER_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/core/error.hpp>
#include <boost/beast/core/string.hpp>
#include <boost/beast/http/field.hpp>
#include <boost/beast/http/verb.hpp>
#include <boost/beast/http/detail/basic_parser.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/optional.hpp>
#include <boost/assert.hpp>
#include <limits>
#include <memory>
#include <type_traits>
#include <utility>

namespace boost {
namespace beast {
namespace http {










template<bool isRequest, class Derived>
class basic_parser
    : private detail::basic_parser_base
{
    template<bool OtherIsRequest, class OtherDerived>
    friend class basic_parser;

    // limit on the size of the stack flat buffer
    static std::size_t constexpr max_stack_buffer = 8192;

    // Message will be complete after reading header
    static unsigned constexpr flagSkipBody              = 1<<  0;

    // Consume input buffers across semantic boundaries
    static unsigned constexpr flagEager                 = 1<<  1;

    // The parser has read at least one byte
    static unsigned constexpr flagGotSome               = 1<<  2;

    // Message semantics indicate a body is expected.
    // cleared if flagSkipBody set
    //
    static unsigned constexpr flagHasBody               = 1<<  3;

    static unsigned constexpr flagHTTP11                = 1<<  4;
    static unsigned constexpr flagNeedEOF               = 1<<  5;
    static unsigned constexpr flagExpectCRLF            = 1<<  6;
    static unsigned constexpr flagConnectionClose       = 1<<  7;
    static unsigned constexpr flagConnectionUpgrade     = 1<<  8;
    static unsigned constexpr flagConnectionKeepAlive   = 1<<  9;
    static unsigned constexpr flagContentLength         = 1<< 10;
    static unsigned constexpr flagChunked               = 1<< 11;
    static unsigned constexpr flagUpgrade               = 1<< 12;
    static unsigned constexpr flagFinalChunk            = 1<< 13;

    static
    std::uint64_t
    default_body_limit(std::true_type)
    {
        // limit for requests
        return 1 * 1024 * 1024; // 1MB
    }

    static
    std::uint64_t
    default_body_limit(std::false_type)
    {
        // limit for responses
        return 8 * 1024 * 1024; // 8MB
    }

    std::uint64_t body_limit_;      // max payload body
    std::uint64_t len_;             // size of chunk or body
    std::unique_ptr<char[]> buf_;   // temp storage
    std::size_t buf_len_ = 0;       // size of buf_
    std::size_t skip_ = 0;          // resume search here
    std::uint32_t
        header_limit_ = 8192;       // max header size
    unsigned short status_;         // response status
    state state_ =                  // initial state
        state::nothing_yet;
    unsigned f_ = 0;                // flags

public:
    using is_request =
        std::integral_constant<bool, isRequest>;

    ~basic_parser();

    basic_parser(basic_parser const&) = delete;

    basic_parser& operator=(basic_parser const&) = delete;

    basic_parser();

    template<class OtherDerived>
    basic_parser(basic_parser<isRequest, OtherDerived>&&);

    basic_parser&
    base()
    {
        return *this;
    }

    basic_parser const&
    base() const
    {
        return *this;
    }

    bool
    got_some() const
    {
        return state_ != state::nothing_yet;
    }

    bool
    is_done() const
    {
        return state_ == state::complete;
    }

    bool
    is_header_done() const
    {
        return state_ > state::fields;
    }

    bool
    is_upgrade() const
    {
        return (f_ & flagConnectionUpgrade) != 0;
    }

    bool
    is_chunked() const
    {
        return (f_ & flagChunked) != 0;
    }

    bool
    is_keep_alive() const;

    boost::optional<std::uint64_t>
    content_length() const;

    bool
    need_eof() const
    {
        return (f_ & flagNeedEOF) != 0;
    }

    void
    body_limit(std::uint64_t v)
    {
        body_limit_ = v;
    }

    void
    header_limit(std::uint32_t v)
    {
        header_limit_ = v;
    }

    bool
    eager() const
    {
        return (f_ & flagEager) != 0;
    }

    void
    eager(bool v)
    {
        if(v)
            f_ |= flagEager;
        else
            f_ &= ~flagEager;
    }

    bool
    skip()
    {
        return (f_ & flagSkipBody) != 0;
    }

    void
    skip(bool v);

    template<class ConstBufferSequence>
    std::size_t
    put(ConstBufferSequence const& buffers, error_code& ec);

#if ! BOOST_BEAST_DOXYGEN
    std::size_t
    put(boost::asio::const_buffers_1 const& buffer,
        error_code& ec);
#endif

    void
    put_eof(error_code& ec);

private:
    inline
    Derived&
    impl()
    {
        return *static_cast<Derived*>(this);
    }

    template<class ConstBufferSequence>
    std::size_t
    put_from_stack(std::size_t size,
        ConstBufferSequence const& buffers,
            error_code& ec);

    void
    maybe_need_more(
        char const* p, std::size_t n,
            error_code& ec);

    void
    parse_start_line(
        char const*& p, char const* last,
            error_code& ec, std::true_type);

    void
    parse_start_line(
        char const*& p, char const* last,
            error_code& ec, std::false_type);

    void
    parse_fields(
        char const*& p, char const* last,
            error_code& ec);

    void
    finish_header(
        error_code& ec, std::true_type);

    void
    finish_header(
        error_code& ec, std::false_type);

    void
    parse_body(char const*& p,
        std::size_t n, error_code& ec);

    void
    parse_body_to_eof(char const*& p,
        std::size_t n, error_code& ec);

    void
    parse_chunk_header(char const*& p,
        std::size_t n, error_code& ec);

    void
    parse_chunk_body(char const*& p,
        std::size_t n, error_code& ec);

    void
    do_field(field f,
        string_view value, error_code& ec);
};

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

#include <boost/beast/http/impl/basic_parser.ipp>

#endif