boost/beast/http/impl/message.hpp
// // Copyright (c) 2016-2019 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_IMPL_MESSAGE_HPP #define BOOST_BEAST_HTTP_IMPL_MESSAGE_HPP #include <boost/beast/core/error.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace beast { namespace http { template<class Fields> template<class Arg1, class... ArgN, class> header<true, Fields>:: header(Arg1&& arg1, ArgN&&... argn) : Fields(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...) { } template<class Fields> verb header<true, Fields>:: method() const { return method_; } template<class Fields> void header<true, Fields>:: method(verb v) { if(v == verb::unknown) BOOST_THROW_EXCEPTION( std::invalid_argument{"unknown method"}); method_ = v; this->set_method_impl({}); } template<class Fields> string_view header<true, Fields>:: method_string() const { if(method_ != verb::unknown) return to_string(method_); return this->get_method_impl(); } template<class Fields> void header<true, Fields>:: method_string(string_view s) { method_ = string_to_verb(s); if(method_ != verb::unknown) this->set_method_impl({}); else this->set_method_impl(s); } template<class Fields> string_view header<true, Fields>:: target() const { return this->get_target_impl(); } template<class Fields> void header<true, Fields>:: target(string_view s) { this->set_target_impl(s); } template<class Fields> void swap( header<true, Fields>& h1, header<true, Fields>& h2) { using std::swap; swap( static_cast<Fields&>(h1), static_cast<Fields&>(h2)); swap(h1.version_, h2.version_); swap(h1.method_, h2.method_); } //------------------------------------------------------------------------------ template<class Fields> template<class Arg1, class... ArgN, class> header<false, Fields>:: header(Arg1&& arg1, ArgN&&... argn) : Fields(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...) { } template<class Fields> status header<false, Fields>:: result() const { return int_to_status( static_cast<int>(result_)); } template<class Fields> void header<false, Fields>:: result(status v) { result_ = v; } template<class Fields> void header<false, Fields>:: result(unsigned v) { if(v > 999) BOOST_THROW_EXCEPTION( std::invalid_argument{ "invalid status-code"}); result_ = static_cast<status>(v); } template<class Fields> unsigned header<false, Fields>:: result_int() const { return static_cast<unsigned>(result_); } template<class Fields> string_view header<false, Fields>:: reason() const { auto const s = this->get_reason_impl(); if(! s.empty()) return s; return obsolete_reason(result_); } template<class Fields> void header<false, Fields>:: reason(string_view s) { this->set_reason_impl(s); } template<class Fields> void swap( header<false, Fields>& h1, header<false, Fields>& h2) { using std::swap; swap( static_cast<Fields&>(h1), static_cast<Fields&>(h2)); swap(h1.version_, h2.version_); swap(h1.result_, h2.result_); } //------------------------------------------------------------------------------ template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(header_type&& h, BodyArgs&&... body_args) : header_type(std::move(h)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>(body_args)...) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(header_type const& h, BodyArgs&&... body_args) : header_type(h) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>(body_args)...) { } template<bool isRequest, class Body, class Fields> template<class Version, class> message<isRequest, Body, Fields>:: message(verb method, string_view target, Version version) : header_type(method, target, version) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class> message<isRequest, Body, Fields>:: message(verb method, string_view target, Version version, BodyArg&& body_arg) : header_type(method, target, version) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class FieldsArg, class> message<isRequest, Body, Fields>:: message( verb method, string_view target, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg) : header_type(method, target, version, std::forward<FieldsArg>(fields_arg)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class> message<isRequest, Body, Fields>:: message(status result, Version version) : header_type(result, version) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class> message<isRequest, Body, Fields>:: message(status result, Version version, BodyArg&& body_arg) : header_type(result, version) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class FieldsArg, class> message<isRequest, Body, Fields>:: message(status result, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg) : header_type(result, version, std::forward<FieldsArg>(fields_arg)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args) : message(std::piecewise_construct, body_args, mp11::make_index_sequence< sizeof...(BodyArgs)>{}) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs, class... FieldsArgs> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args, std::tuple<FieldsArgs...> fields_args) : message(std::piecewise_construct, body_args, fields_args, mp11::make_index_sequence< sizeof...(BodyArgs)>{}, mp11::make_index_sequence< sizeof...(FieldsArgs)>{}) { } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: chunked(bool value) { this->set_chunked_impl(value); this->set_content_length_impl(boost::none); } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: content_length( boost::optional<std::uint64_t> const& value) { this->set_content_length_impl(value); this->set_chunked_impl(false); } template<bool isRequest, class Body, class Fields> boost::optional<std::uint64_t> message<isRequest, Body, Fields>:: payload_size() const { return payload_size(detail::is_body_sized<Body>{}); } template<bool isRequest, class Body, class Fields> bool message<isRequest, Body, Fields>:: need_eof(std::false_type) const { // VFALCO Do we need a way to let the caller say "the body is intentionally skipped"? if( this->result() == status::no_content || this->result() == status::not_modified || to_status_class(this->result()) == status_class::informational || has_content_length() || chunked()) return ! keep_alive(); return true; } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: prepare_payload(std::true_type) { auto const n = payload_size(); if(this->method() == verb::trace && (! n || *n > 0)) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid request body"}); if(n) { if(*n > 0 || this->method() == verb::options || this->method() == verb::put || this->method() == verb::post) { this->content_length(n); } else { this->chunked(false); } } else if(this->version() == 11) { this->chunked(true); } else { this->chunked(false); } } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: prepare_payload(std::false_type) { auto const n = payload_size(); if( (! n || *n > 0) && ( (status_class(this->result()) == status_class::informational || this->result() == status::no_content || this->result() == status::not_modified))) { // The response body MUST be empty for this case BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid response body"}); } if(n) this->content_length(n); else if(this->version() == 11) this->chunked(true); else this->chunked(false); } //------------------------------------------------------------------------------ template<bool isRequest, class Body, class Fields> void swap( message<isRequest, Body, Fields>& m1, message<isRequest, Body, Fields>& m2) { using std::swap; swap( static_cast<header<isRequest, Fields>&>(m1), static_cast<header<isRequest, Fields>&>(m2)); swap(m1.body(), m2.body()); } } // http } // beast } // boost #endif