boost/beast/http/impl/fields.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_FIELDS_HPP #define BOOST_BEAST_HTTP_IMPL_FIELDS_HPP #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/buffers_ref.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/static_string.hpp> #include <boost/beast/core/detail/temporary_buffer.hpp> #include <boost/beast/core/static_string.hpp> #include <boost/beast/http/verb.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/http/status.hpp> #include <boost/beast/http/chunk_encode.hpp> #include <boost/core/exchange.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> #include <string> namespace boost { namespace beast { namespace http { template<class Allocator> class basic_fields<Allocator>::writer { public: using iter_type = typename list_t::const_iterator; struct field_iterator { iter_type it_; using value_type = net::const_buffer; using pointer = value_type const*; using reference = value_type const; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; field_iterator() = default; field_iterator(field_iterator&& other) = default; field_iterator(field_iterator const& other) = default; field_iterator& operator=(field_iterator&& other) = default; field_iterator& operator=(field_iterator const& other) = default; explicit field_iterator(iter_type it) : it_(it) { } bool operator==(field_iterator const& other) const { return it_ == other.it_; } bool operator!=(field_iterator const& other) const { return !(*this == other); } reference operator*() const { return it_->buffer(); } field_iterator& operator++() { ++it_; return *this; } field_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } field_iterator& operator--() { --it_; return *this; } field_iterator operator--(int) { auto temp = *this; --(*this); return temp; } }; class field_range { field_iterator first_; field_iterator last_; public: using const_iterator = field_iterator; using value_type = typename const_iterator::value_type; field_range(iter_type first, iter_type last) : first_(first) , last_(last) { } const_iterator begin() const { return first_; } const_iterator end() const { return last_; } }; using view_type = buffers_cat_view< net::const_buffer, net::const_buffer, net::const_buffer, field_range, chunk_crlf>; basic_fields const& f_; boost::optional<view_type> view_; char buf_[13]; public: using const_buffers_type = beast::detail::buffers_ref<view_type>; writer(basic_fields const& f, unsigned version, verb v); writer(basic_fields const& f, unsigned version, unsigned code); writer(basic_fields const& f); const_buffers_type get() const { return const_buffers_type(*view_); } }; template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f) : f_(f) { view_.emplace( net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf()); } template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f, unsigned version, verb v) : f_(f) { /* request "<method>" " <target>" " HTTP/X.Y\r\n" (11 chars) */ string_view sv; if(v == verb::unknown) sv = f_.get_method_impl(); else sv = to_string(v); // target_or_reason_ has a leading SP buf_[0] = ' '; buf_[1] = 'H'; buf_[2] = 'T'; buf_[3] = 'T'; buf_[4] = 'P'; buf_[5] = '/'; buf_[6] = '0' + static_cast<char>(version / 10); buf_[7] = '.'; buf_[8] = '0' + static_cast<char>(version % 10); buf_[9] = '\r'; buf_[10]= '\n'; view_.emplace( net::const_buffer{sv.data(), sv.size()}, net::const_buffer{ f_.target_or_reason_.data(), f_.target_or_reason_.size()}, net::const_buffer{buf_, 11}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf()); } template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f, unsigned version, unsigned code) : f_(f) { /* response "HTTP/X.Y ### " (13 chars) "<reason>" "\r\n" */ buf_[0] = 'H'; buf_[1] = 'T'; buf_[2] = 'T'; buf_[3] = 'P'; buf_[4] = '/'; buf_[5] = '0' + static_cast<char>(version / 10); buf_[6] = '.'; buf_[7] = '0' + static_cast<char>(version % 10); buf_[8] = ' '; buf_[9] = '0' + static_cast<char>(code / 100); buf_[10]= '0' + static_cast<char>((code / 10) % 10); buf_[11]= '0' + static_cast<char>(code % 10); buf_[12]= ' '; string_view sv; if(! f_.target_or_reason_.empty()) sv = f_.target_or_reason_; else sv = obsolete_reason(static_cast<status>(code)); view_.emplace( net::const_buffer{buf_, 13}, net::const_buffer{sv.data(), sv.size()}, net::const_buffer{"\r\n", 2}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf{}); } //------------------------------------------------------------------------------ template<class Allocator> char* basic_fields<Allocator>:: value_type:: data() const { return const_cast<char*>( reinterpret_cast<char const*>( static_cast<element const*>(this) + 1)); } template<class Allocator> net::const_buffer basic_fields<Allocator>:: value_type:: buffer() const { return net::const_buffer{data(), static_cast<std::size_t>(off_) + len_ + 2}; } template<class Allocator> basic_fields<Allocator>:: value_type:: value_type(field name, string_view sname, string_view value) : off_(static_cast<off_t>(sname.size() + 2)) , len_(static_cast<off_t>(value.size())) , f_(name) { //BOOST_ASSERT(name == field::unknown || // iequals(sname, to_string(name))); char* p = data(); p[off_-2] = ':'; p[off_-1] = ' '; p[off_ + len_] = '\r'; p[off_ + len_ + 1] = '\n'; sname.copy(p, sname.size()); value.copy(p + off_, value.size()); } template<class Allocator> field basic_fields<Allocator>:: value_type:: name() const { return f_; } template<class Allocator> string_view const basic_fields<Allocator>:: value_type:: name_string() const { return {data(), static_cast<std::size_t>(off_ - 2)}; } template<class Allocator> string_view const basic_fields<Allocator>:: value_type:: value() const { return {data() + off_, static_cast<std::size_t>(len_)}; } template<class Allocator> basic_fields<Allocator>:: element:: element(field name, string_view sname, string_view value) : value_type(name, sname, value) { } //------------------------------------------------------------------------------ template<class Allocator> basic_fields<Allocator>:: ~basic_fields() { delete_list(); realloc_string(method_, {}); realloc_string( target_or_reason_, {}); } template<class Allocator> basic_fields<Allocator>:: basic_fields(Allocator const& alloc) noexcept : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields&& other) noexcept : boost::empty_value<Allocator>(boost::empty_init_t(), std::move(other.get())) , set_(std::move(other.set_)) , list_(std::move(other.list_)) , method_(boost::exchange(other.method_, {})) , target_or_reason_(boost::exchange(other.target_or_reason_, {})) { } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields&& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { if(this->get() != other.get()) { copy_all(other); } else { set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; } } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields const& other) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc_traits:: select_on_container_copy_construction(other.get())) { copy_all(other); } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields const& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { copy_all(other); } template<class Allocator> template<class OtherAlloc> basic_fields<Allocator>:: basic_fields(basic_fields<OtherAlloc> const& other) { copy_all(other); } template<class Allocator> template<class OtherAlloc> basic_fields<Allocator>:: basic_fields(basic_fields<OtherAlloc> const& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { copy_all(other); } template<class Allocator> auto basic_fields<Allocator>:: operator=(basic_fields&& other) noexcept( alloc_traits::propagate_on_container_move_assignment::value) -> basic_fields& { static_assert(is_nothrow_move_assignable<Allocator>::value, "Allocator must be noexcept assignable."); if(this == &other) return *this; move_assign(other, std::integral_constant<bool, alloc_traits:: propagate_on_container_move_assignment::value>{}); return *this; } template<class Allocator> auto basic_fields<Allocator>:: operator=(basic_fields const& other) -> basic_fields& { copy_assign(other, std::integral_constant<bool, alloc_traits::propagate_on_container_copy_assignment::value>{}); return *this; } template<class Allocator> template<class OtherAlloc> auto basic_fields<Allocator>:: operator=(basic_fields<OtherAlloc> const& other) -> basic_fields& { clear_all(); copy_all(other); return *this; } //------------------------------------------------------------------------------ // // Element access // //------------------------------------------------------------------------------ template<class Allocator> string_view const basic_fields<Allocator>:: at(field name) const { BOOST_ASSERT(name != field::unknown); auto const it = find(name); if(it == end()) BOOST_THROW_EXCEPTION(std::out_of_range{ "field not found"}); return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: at(string_view name) const { auto const it = find(name); if(it == end()) BOOST_THROW_EXCEPTION(std::out_of_range{ "field not found"}); return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: operator[](field name) const { BOOST_ASSERT(name != field::unknown); auto const it = find(name); if(it == end()) return {}; return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: operator[](string_view name) const { auto const it = find(name); if(it == end()) return {}; return it->value(); } //------------------------------------------------------------------------------ // // Modifiers // //------------------------------------------------------------------------------ template<class Allocator> void basic_fields<Allocator>:: clear() { delete_list(); set_.clear(); list_.clear(); } template<class Allocator> inline void basic_fields<Allocator>:: insert(field name, string_view const& value) { BOOST_ASSERT(name != field::unknown); insert(name, to_string(name), value); } template<class Allocator> void basic_fields<Allocator>:: insert(string_view sname, string_view const& value) { auto const name = string_to_field(sname); insert(name, sname, value); } template<class Allocator> void basic_fields<Allocator>:: insert(field name, string_view sname, string_view const& value) { auto& e = new_element(name, sname, static_cast<string_view>(value)); auto const before = set_.upper_bound(sname, key_compare{}); if(before == set_.begin()) { BOOST_ASSERT(count(sname) == 0); set_.insert_before(before, e); list_.push_back(e); return; } auto const last = std::prev(before); // VFALCO is it worth comparing `field name` first? if(! beast::iequals(sname, last->name_string())) { BOOST_ASSERT(count(sname) == 0); set_.insert_before(before, e); list_.push_back(e); return; } // keep duplicate fields together in the list set_.insert_before(before, e); list_.insert(++list_.iterator_to(*last), e); } template<class Allocator> void basic_fields<Allocator>:: set(field name, string_view const& value) { BOOST_ASSERT(name != field::unknown); set_element(new_element(name, to_string(name), static_cast<string_view>(value))); } template<class Allocator> void basic_fields<Allocator>:: set(string_view sname, string_view const& value) { set_element(new_element( string_to_field(sname), sname, value)); } template<class Allocator> auto basic_fields<Allocator>:: erase(const_iterator pos) -> const_iterator { auto next = pos; auto& e = *next++; set_.erase(set_.iterator_to(e)); list_.erase(pos); delete_element(const_cast<element&>(e)); return next; } template<class Allocator> std::size_t basic_fields<Allocator>:: erase(field name) { BOOST_ASSERT(name != field::unknown); return erase(to_string(name)); } template<class Allocator> std::size_t basic_fields<Allocator>:: erase(string_view name) { std::size_t n =0; set_.erase_and_dispose(name, key_compare{}, [&](element* e) { ++n; list_.erase(list_.iterator_to(*e)); delete_element(*e); }); return n; } template<class Allocator> void basic_fields<Allocator>:: swap(basic_fields<Allocator>& other) { swap(other, std::integral_constant<bool, alloc_traits::propagate_on_container_swap::value>{}); } template<class Allocator> void swap( basic_fields<Allocator>& lhs, basic_fields<Allocator>& rhs) { lhs.swap(rhs); } //------------------------------------------------------------------------------ // // Lookup // //------------------------------------------------------------------------------ template<class Allocator> inline std::size_t basic_fields<Allocator>:: count(field name) const { BOOST_ASSERT(name != field::unknown); return count(to_string(name)); } template<class Allocator> std::size_t basic_fields<Allocator>:: count(string_view name) const { return set_.count(name, key_compare{}); } template<class Allocator> inline auto basic_fields<Allocator>:: find(field name) const -> const_iterator { BOOST_ASSERT(name != field::unknown); return find(to_string(name)); } template<class Allocator> auto basic_fields<Allocator>:: find(string_view name) const -> const_iterator { auto const it = set_.find( name, key_compare{}); if(it == set_.end()) return list_.end(); return list_.iterator_to(*it); } template<class Allocator> inline auto basic_fields<Allocator>:: equal_range(field name) const -> std::pair<const_iterator, const_iterator> { BOOST_ASSERT(name != field::unknown); return equal_range(to_string(name)); } template<class Allocator> auto basic_fields<Allocator>:: equal_range(string_view name) const -> std::pair<const_iterator, const_iterator> { auto result = set_.equal_range(name, key_compare{}); if(result.first == result.second) return {list_.end(), list_.end()}; return { list_.iterator_to(*result.first), ++list_.iterator_to(*(--result.second))}; } //------------------------------------------------------------------------------ namespace detail { struct iequals_predicate { bool operator()(string_view s) const { return beast::iequals(s, sv1) || beast::iequals(s, sv2); } string_view sv1; string_view sv2; }; // Filter the last item in a token list BOOST_BEAST_DECL void filter_token_list_last( beast::detail::temporary_buffer& s, string_view value, iequals_predicate const& pred); BOOST_BEAST_DECL void keep_alive_impl( beast::detail::temporary_buffer& s, string_view value, unsigned version, bool keep_alive); } // detail //------------------------------------------------------------------------------ // Fields template<class Allocator> inline string_view basic_fields<Allocator>:: get_method_impl() const { return method_; } template<class Allocator> inline string_view basic_fields<Allocator>:: get_target_impl() const { if(target_or_reason_.empty()) return target_or_reason_; return { target_or_reason_.data() + 1, target_or_reason_.size() - 1}; } template<class Allocator> inline string_view basic_fields<Allocator>:: get_reason_impl() const { return target_or_reason_; } template<class Allocator> bool basic_fields<Allocator>:: get_chunked_impl() const { auto const te = token_list{ (*this)[field::transfer_encoding]}; for(auto it = te.begin(); it != te.end();) { auto const next = std::next(it); if(next == te.end()) return beast::iequals(*it, "chunked"); it = next; } return false; } template<class Allocator> bool basic_fields<Allocator>:: get_keep_alive_impl(unsigned version) const { auto const it = find(field::connection); if(version < 11) { if(it == end()) return false; return token_list{ it->value()}.exists("keep-alive"); } if(it == end()) return true; return ! token_list{ it->value()}.exists("close"); } template<class Allocator> bool basic_fields<Allocator>:: has_content_length_impl() const { return count(field::content_length) > 0; } template<class Allocator> inline void basic_fields<Allocator>:: set_method_impl(string_view s) { realloc_string(method_, s); } template<class Allocator> inline void basic_fields<Allocator>:: set_target_impl(string_view s) { realloc_target( target_or_reason_, s); } template<class Allocator> inline void basic_fields<Allocator>:: set_reason_impl(string_view s) { realloc_string( target_or_reason_, s); } template<class Allocator> void basic_fields<Allocator>:: set_chunked_impl(bool value) { beast::detail::temporary_buffer buf; auto it = find(field::transfer_encoding); if(value) { // append "chunked" if(it == end()) { set(field::transfer_encoding, "chunked"); return; } auto const te = token_list{it->value()}; for(auto itt = te.begin();;) { auto const next = std::next(itt); if(next == te.end()) { if(beast::iequals(*itt, "chunked")) return; // already set break; } itt = next; } buf.append(it->value(), ", chunked"); set(field::transfer_encoding, buf.view()); return; } // filter "chunked" if(it == end()) return; detail::filter_token_list_last(buf, it->value(), {"chunked", {}}); if(! buf.empty()) set(field::transfer_encoding, buf.view()); else erase(field::transfer_encoding); } template<class Allocator> void basic_fields<Allocator>:: set_content_length_impl( boost::optional<std::uint64_t> const& value) { if(! value) erase(field::content_length); else { set(field::content_length, to_static_string(*value)); } } template<class Allocator> void basic_fields<Allocator>:: set_keep_alive_impl( unsigned version, bool keep_alive) { // VFALCO What about Proxy-Connection ? auto const value = (*this)[field::connection]; beast::detail::temporary_buffer buf; detail::keep_alive_impl(buf, value, version, keep_alive); if(buf.empty()) erase(field::connection); else set(field::connection, buf.view()); } //------------------------------------------------------------------------------ template<class Allocator> auto basic_fields<Allocator>:: new_element(field name, string_view sname, string_view value) -> element& { if(sname.size() + 2 > (std::numeric_limits<off_t>::max)()) BOOST_THROW_EXCEPTION(std::length_error{ "field name too large"}); if(value.size() + 2 > (std::numeric_limits<off_t>::max)()) BOOST_THROW_EXCEPTION(std::length_error{ "field value too large"}); value = detail::trim(value); std::uint16_t const off = static_cast<off_t>(sname.size() + 2); std::uint16_t const len = static_cast<off_t>(value.size()); auto a = rebind_type{this->get()}; auto const p = alloc_traits::allocate(a, (sizeof(element) + off + len + 2 + sizeof(align_type) - 1) / sizeof(align_type)); return *(::new(p) element(name, sname, value)); } template<class Allocator> void basic_fields<Allocator>:: delete_element(element& e) { auto a = rebind_type{this->get()}; auto const n = (sizeof(element) + e.off_ + e.len_ + 2 + sizeof(align_type) - 1) / sizeof(align_type); e.~element(); alloc_traits::deallocate(a, reinterpret_cast<align_type*>(&e), n); } template<class Allocator> void basic_fields<Allocator>:: set_element(element& e) { auto it = set_.lower_bound( e.name_string(), key_compare{}); if(it == set_.end() || ! beast::iequals( e.name_string(), it->name_string())) { set_.insert_before(it, e); list_.push_back(e); return; } for(;;) { auto next = it; ++next; set_.erase(it); list_.erase(list_.iterator_to(*it)); delete_element(*it); it = next; if(it == set_.end() || ! beast::iequals(e.name_string(), it->name_string())) break; } set_.insert_before(it, e); list_.push_back(e); } template<class Allocator> void basic_fields<Allocator>:: realloc_string(string_view& dest, string_view s) { if(dest.empty() && s.empty()) return; auto a = typename beast::detail::allocator_traits< Allocator>::template rebind_alloc< char>(this->get()); char* p = nullptr; if(! s.empty()) { p = a.allocate(s.size()); s.copy(p, s.size()); } if(! dest.empty()) a.deallocate(const_cast<char*>( dest.data()), dest.size()); if(p) dest = {p, s.size()}; else dest = {}; } template<class Allocator> void basic_fields<Allocator>:: realloc_target( string_view& dest, string_view s) { // The target string are stored with an // extra space at the beginning to help // the writer class. if(dest.empty() && s.empty()) return; auto a = typename beast::detail::allocator_traits< Allocator>::template rebind_alloc< char>(this->get()); char* p = nullptr; if(! s.empty()) { p = a.allocate(1 + s.size()); p[0] = ' '; s.copy(p + 1, s.size()); } if(! dest.empty()) a.deallocate(const_cast<char*>( dest.data()), dest.size()); if(p) dest = {p, 1 + s.size()}; else dest = {}; } template<class Allocator> template<class OtherAlloc> void basic_fields<Allocator>:: copy_all(basic_fields<OtherAlloc> const& other) { for(auto const& e : other.list_) insert(e.name(), e.name_string(), e.value()); realloc_string(method_, other.method_); realloc_string(target_or_reason_, other.target_or_reason_); } template<class Allocator> void basic_fields<Allocator>:: clear_all() { clear(); realloc_string(method_, {}); realloc_string(target_or_reason_, {}); } template<class Allocator> void basic_fields<Allocator>:: delete_list() { for(auto it = list_.begin(); it != list_.end();) delete_element(*it++); } //------------------------------------------------------------------------------ template<class Allocator> inline void basic_fields<Allocator>:: move_assign(basic_fields& other, std::true_type) { clear_all(); set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; other.method_ = {}; other.target_or_reason_ = {}; this->get() = other.get(); } template<class Allocator> inline void basic_fields<Allocator>:: move_assign(basic_fields& other, std::false_type) { clear_all(); if(this->get() != other.get()) { copy_all(other); } else { set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; other.method_ = {}; other.target_or_reason_ = {}; } } template<class Allocator> inline void basic_fields<Allocator>:: copy_assign(basic_fields const& other, std::true_type) { clear_all(); this->get() = other.get(); copy_all(other); } template<class Allocator> inline void basic_fields<Allocator>:: copy_assign(basic_fields const& other, std::false_type) { clear_all(); copy_all(other); } template<class Allocator> inline void basic_fields<Allocator>:: swap(basic_fields& other, std::true_type) { using std::swap; swap(this->get(), other.get()); swap(set_, other.set_); swap(list_, other.list_); swap(method_, other.method_); swap(target_or_reason_, other.target_or_reason_); } template<class Allocator> inline void basic_fields<Allocator>:: swap(basic_fields& other, std::false_type) { BOOST_ASSERT(this->get() == other.get()); using std::swap; swap(set_, other.set_); swap(list_, other.list_); swap(method_, other.method_); swap(target_or_reason_, other.target_or_reason_); } } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/fields.ipp> #endif #endif