feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
2cfe3ba1b80c3db219b8712cb1559de8f57239fc
boost_beast/include/boost/beast/http/detail/basic_parser.hpp

259 lines
4.9 KiB
C++
Raw Normal View History

New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
//
Check BOOST_NO_CXX11_THREAD_LOCAL
2019-02-21 07:00:31 -08:00
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
//
// 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)
//
Boost prep
2017-07-20 13:40:34 -07:00
// Official repository: https://github.com/boostorg/beast
//
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_HPP
#define BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_HPP
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/core/string.hpp>
#include <boost/beast/http/error.hpp>
#include <boost/beast/http/detail/rfc7230.hpp>
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
#include <boost/config.hpp>
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#include <boost/version.hpp>
#include <cstddef>
#include <utility>
Boost prep
2017-07-20 13:40:34 -07:00
namespace boost {
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
namespace beast {
namespace http {
namespace detail {
Replace static_string in parser close #1574 This change yields a modest performance improment of 1-2% by replacing the exception-based handling of buffer overflow with one based on regular conditional checks. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-04-12 01:32:36 +02:00
template <std::size_t N>
class char_buffer
{
public:
bool try_push_back(char c)
{
if (size_ == N)
return false;
buf_[size_++] = c;
return true;
}
bool try_append(char const* first, char const* last)
{
std::size_t const n = last - first;
if (n > N - size_)
return false;
std::memmove(&buf_[size_], first, n);
size_ += n;
return true;
}
void clear() noexcept
{
size_ = 0;
}
char* data() noexcept
{
return buf_;
}
char const* data() const noexcept
{
return buf_;
}
std::size_t size() const noexcept
{
return size_;
}
bool empty() const noexcept
{
return size_ == 0;
}
private:
std::size_t size_= 0;
char buf_[N];
};
Fix parse_dec algorithm fix #1211
2018-07-30 01:28:48 +03:00
struct basic_parser_base
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
{
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
// limit on the size of the obs-fold buffer
//
// https://stackoverflow.com/questions/686217/maximum-on-http-header-values
//
static std::size_t constexpr max_obs_fold = 4096;
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
enum class state
{
nothing_yet = 0,
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
start_line,
fields,
Refactor HTTP serialization and parsing (API Change): fix #404 Parsing and serialization interfaces have been fine tuned and unified. For parsing these stream operations are defined: * read * read_header * read_some * async_read * async_read_header * async_read_some For serialization these stream operations are defined: * write * write_header * write_some * async_write * async_write_header * async_write_some
2017-05-31 08:01:55 -07:00
body0,
body,
body_to_eof0,
body_to_eof,
chunk_header0,
chunk_header,
chunk_body,
complete
};
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
bool
is_digit(char c)
{
return static_cast<unsigned char>(c-'0') < 10;
}
static
bool
is_print(char c)
{
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
return static_cast<unsigned char>(c-32) < 95;
}
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
BOOST_BEAST_DECL
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
static
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
char const*
trim_front(char const* it, char const* end);
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
BOOST_BEAST_DECL
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
static
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
char const*
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
trim_back(
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
char const* it, char const* first);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
Use beast::string_view alias
2017-05-05 14:45:15 -07:00
string_view
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
make_string(char const* first, char const* last)
{
return {first, static_cast<
std::size_t>(last - first)};
}
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
//--------------------------------------------------------------------------
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
static
bool
is_pathchar(char c);
BOOST_BEAST_DECL
static
bool
unhex(unsigned char& d, char c);
BOOST_BEAST_DECL
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
std::pair<char const*, bool>
find_fast(
char const* buf,
char const* buf_end,
char const* ranges,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
size_t ranges_size);
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
char const*
find_eol(
char const* it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
static
char const*
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
find_eom(char const* p, char const* last);
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
//--------------------------------------------------------------------------
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
char const*
parse_token_to_eol(
char const* p,
char const* last,
char const*& token_last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
bool
parse_dec(char const* it, char const* last, std::uint64_t& v);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
BOOST_BEAST_DECL
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
static
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
bool
parse_hex(char const*& it, std::uint64_t& v);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
bool
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
parse_crlf(char const*& it);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_method(
char const*& it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
string_view& result, error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_target(
char const*& it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
string_view& result, error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_version(
char const*& it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
int& result, error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_status(
char const*& it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
unsigned short& result, error_code& ec);
More split compilation in HTTP close #1541 - Remove unused private functions: `skip_ows_rev`, `skip_obs_fold`. - Enable split compilation in `http/detail/rfc7230.hpp`. - More split compilation in `basic_parser`. - Remove some unnecessary includes. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-03-23 00:10:29 +01:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_reason(
char const*& it, char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
string_view& result, error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
static
basic_parser optimizations: fix #185, fix #489 * SSE4.2 is detected * basic_parser uses SSE4.2 if available * basic_parser tries to parse on the initial buffer and if it does not find the end of header it shifts to a new strategy of waiting for the end of header to defeat slow loris attacks. This coincidentally is also faster than the previous algorithm.
2017-06-30 08:46:22 -07:00
void
parse_field(
char const*& p,
char const* last,
string_view& name,
string_view& value,
Replace static_string in parser close #1574 This change yields a modest performance improment of 1-2% by replacing the exception-based handling of buffer overflow with one based on regular conditional checks. Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
2019-04-12 01:32:36 +02:00
char_buffer<max_obs_fold>& buf,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
error_code& ec);
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
BOOST_BEAST_DECL
static
Refactor chunked parsing (API Change): * parser now has a callback feature for intercepting chunk headers and chunk bodies * The names for basic_parser derived class callbacks have been refactored * basic_parser offers an additional callback for distinguishing chunk body data. Actions Required: * Adjust signatures for required members of user-defined subclasses of basic_parser * Use the new basic_parser chunk callbacks for accessing chunk extensions and chunk bodies.
2017-07-12 18:06:36 -07:00
void
parse_chunk_extensions(
char const*& it,
char const* last,
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
error_code& ec);
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
};
} // detail
} // http
} // beast
Boost prep
2017-07-20 13:40:34 -07:00
} // boost
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
Move parser definitions to .ipp
2019-03-02 08:57:26 -08:00
#ifdef BOOST_BEAST_HEADER_ONLY
#include <boost/beast/http/detail/basic_parser.ipp>
#endif
New HTTP interfaces (API Change): fix #123 fix #154 fix #265 This completely replaces the HTTP parser used to read and parse incoming messages. The new version is faster than the old one, and written in fewer lines. A summary of changes: * parse and async_parse renamed to read and async_read * basic_parser is optimized for linear buffers, use flat_streambuf for the best performance with these functions: - http::read - http::read_some - http::async_read - http::async_read_some * The overloads of read() and async_read() which take just a header have been removed, since they would throw away important parse metadata. * The derived class callbacks for basic_parser have been streamlined. All strings passed to callbacks are presented in their entirety, instead of being provided in pieces. These changes allow use-cases that were previously difficult or impossible, such as: - Efficient relaying - Late body type commitment - Expect: 100-continue handling
2016-11-20 07:32:41 -05:00
#endif
Copy Permalink