feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
7407e3adc33d7959d9f8fec6ba190e4080896102
boost_beast/include/beast/http/read.hpp

484 lines
17 KiB
C++
Raw Normal View History

Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
//
Update copyright dates
2017-02-06 20:07:03 -05:00
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07: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)
//
#ifndef BEAST_HTTP_READ_HPP
#define BEAST_HTTP_READ_HPP
Require Visual Studio 2015 Update 3 or later fix #216
2017-04-10 19:24:27 -07:00
#include <beast/config.hpp>
Tidy up core sources: The core headers are moved to their own directory (but remain in the same namespace).
2016-05-07 14:57:15 -04:00
#include <beast/core/async_completion.hpp>
Refine Parser concept: * Parser is not HTTP-specific * parse algorithms are in their own header * Update documentation
2016-10-09 20:27:24 -04:00
#include <beast/core/error.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 <beast/http/basic_parser.hpp>
Refine message class hierarchy: Two new objects, request_headers and response_headers, represent the portion of HTTP messages excluding the body.
2016-10-09 06:34:35 -04:00
#include <beast/http/message.hpp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
namespace beast {
namespace http {
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
/** Read some HTTP/1 message data from a stream.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
This function synchronously advances the state of the
parser using the provided dynamic buffer and reading
from the input stream as needed. The call will block
until one of the following conditions is true:
@li When expecting a message header, and the complete
header is received.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@li When expecting a chunk header, and the complete
chunk header is received.
@li When expecting body octets, one or more body octets
are received.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@li An error occurs in the stream or parser.
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
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
read additional octets that lie past the end of the object
being parsed. This additional data is stored in the dynamic
buffer, which may be used in subsequent calls.
@param stream The stream from which the data is to be read.
The type must support the @b SyncReadStream concept.
@param dynabuf A @b DynamicBuffer holding additional bytes
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
dynamic buffer's input sequence will be given to the parser
first.
@param parser The parser to use.
@return The number of bytes processed from the dynamic
buffer. The caller should remove these bytes by calling
`consume` on the dynamic buffer.
@throws system_error Thrown on failure.
*/
template<
class SyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived>
std::size_t
read_some(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser);
/** Read some HTTP/1 message data from a stream.
This function synchronously advances the state of the
parser using the provided dynamic buffer and reading
from the input stream as needed. The call will block
until one of the following conditions is true:
@li When expecting a message header, and the complete
header is received.
@li When expecting a chunk header, and the complete
chunk header is received.
@li When expecting body octets, one or more body octets
are received.
@li An error occurs in the stream or parser.
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
read additional octets that lie past the end of the object
being parsed. This additional data is stored in the dynamic
buffer, which may be used in subsequent calls.
@param stream The stream from which the data is to be read.
The type must support the @b SyncReadStream concept.
@param dynabuf A @b DynamicBuffer holding additional bytes
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
dynamic buffer's input sequence will be given to the parser
first.
@param parser The parser to use.
@param ec Set to the error, if any occurred.
@return The number of bytes processed from the dynamic
buffer. The caller should remove these bytes by calling
`consume` on the dynamic buffer.
*/
template<
class SyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived>
std::size_t
read_some(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser,
error_code& ec);
/** Start an asynchronous operation to read some HTTP/1 message data from a stream.
This function asynchronously advances the state of the
parser using the provided dynamic buffer and reading from
the input stream as needed. The function call always
returns immediately. The asynchronous operation will
continue until one of the following conditions is true:
@li When expecting a message header, and the complete
header is received.
@li When expecting a chunk header, and the complete
chunk header is received.
@li When expecting body octets, one or more body octets
are received.
@li An error occurs in the stream or parser.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
This operation is implemented in terms of zero or more calls to
the next layer's `async_read_some` function, and is known as a
<em>composed operation</em>. The program must ensure that the
stream performs no other operations until this operation completes.
The implementation may read additional octets that lie past the
end of the object being parsed. This additional data is stored
in the stream buffer, which may be used in subsequent calls.
The completion handler will be called with the number of bytes
processed from the dynamic buffer. The caller should remove
these bytes by calling `consume` on the dynamic buffer.
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@param stream The stream from which the data is to be read.
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
The type must support the @b AsyncReadStream concept.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param dynabuf A @b DynamicBuffer holding additional bytes
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param parser The parser to use.
@param handler The handler to be called when the request
completes. Copies will be made of the handler as required.
The equivalent function signature of the handler must be:
@code void handler(
error_code const& error, // result of operation
std::size_t bytes_used // the number of bytes to consume
); @endcode
Regardless of whether the asynchronous operation completes
immediately or not, the handler will not be invoked from within
this function. Invocation of the handler will be performed in a
manner equivalent to using `boost::asio::io_service::post`.
*/
template<
class AsyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived,
class ReadHandler>
#if GENERATING_DOCS
void_or_deduced
#else
typename async_completion<
ReadHandler, void(error_code, std::size_t)>::result_type
#endif
async_read_some(
AsyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser,
ReadHandler&& handler);
//------------------------------------------------------------------------------
/** Read an HTTP/1 message from a stream.
This function synchronously reads from a stream and passes
data to the specified parser. The call will block until one
of the following conditions is true:
@li The parser indicates no more additional data is needed.
@li An error occurs in the stream or parser.
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
read additional octets that lie past the end of the object
being parsed. This additional data is stored in the dynamic
buffer, which may be used in subsequent calls.
@param stream The stream from which the data is to be read.
The type must support the @b SyncReadStream concept.
@param dynabuf A @b DynamicBuffer holding additional bytes
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
dynamic buffer's input sequence will be given to the parser
first.
@param parser The parser to use.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@throws system_error Thrown on failure.
*/
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
template<
class SyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived>
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
void
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
read(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser);
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
/** Read an HTTP/1 message from a stream.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
This function synchronously reads from a stream and passes
data to the specified parser. The call will block until one
of the following conditions is true:
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@li The parser indicates that no more data is needed.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@li An error occurs in the stream or parser.
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
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
read additional octets that lie past the end of the object
being parsed. This additional data is stored in the dynamic
buffer, which may be used in subsequent calls.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@param stream The stream from which the data is to be read.
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
The type must support the @b SyncReadStream concept.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param dynabuf A @b DynamicBuffer holding additional bytes
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param parser The parser to use.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@param ec Set to the error, if any occurred.
*/
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
template<
class SyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived>
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
void
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
read(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser,
error_code& ec);
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
/** Start an asynchronous operation to read an HTTP/1 message from a stream.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
This function is used to asynchronously read from a stream and
pass the data to the specified parser. The function call always
returns immediately. The asynchronous operation will continue
until one of the following conditions is true:
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@li The parser indicates that no more data is needed.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@li An error occurs in the stream or parser.
This operation is implemented in terms of one or more calls to
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
the next layer's `async_read_some` function, and is known as a
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
<em>composed operation</em>. The program must ensure that the
stream performs no other operations until this operation completes.
The implementation may read additional octets that lie past the
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
end of the object being parsed. This additional data is stored
in the stream buffer, which may be used in subsequent calls.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param stream The stream from which the data is to be read.
The type must support the @b AsyncReadStream concept.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param dynabuf A @b DynamicBuffer holding additional bytes
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param parser The parser to use.
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
@param handler The handler to be called when the request
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
completes. Copies will be made of the handler as required.
The equivalent function signature of the handler must be:
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
@code void handler(
error_code const& error // result of operation
); @endcode
Regardless of whether the asynchronous operation completes
immediately or not, the handler will not be invoked from within
this function. Invocation of the handler will be performed in a
manner equivalent to using `boost::asio::io_service::post`.
*/
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
template<
class AsyncReadStream,
class DynamicBuffer,
bool isRequest, bool isDirect, class Derived,
class ReadHandler>
Rename to BEAST_DOXYGEN fix #316
2017-04-22 14:56:09 -07:00
#if BEAST_DOXYGEN
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
void_or_deduced
#else
typename async_completion<
ReadHandler, void(error_code)>::result_type
#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
async_read(
AsyncReadStream& stream,
DynamicBuffer& dynabuf,
basic_parser<isRequest, isDirect, Derived>& parser,
ReadHandler&& handler);
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
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
/** Read an HTTP/1 message from a stream.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
This function is used to synchronously read a message from
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
a stream. The call blocks until one of the following conditions
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
is true:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
@li A complete message is read in.
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@li An error occurs in the stream or parser.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
read additional octets that lie past the end of the message
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
being parsed. This additional data is stored in the dynamic
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
buffer, which may be used in subsequent calls.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@param stream The stream from which the data is to be read.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
The type must support the @b `SyncReadStream` concept.
Rename concept to DynamicBuffer (API change): Conform to the Networking TS by renaming the Streambuf concept to DynamicBuffer in all places. Values of types meeting the requirements of DynamicBuffer are renamed to dynabuf. See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers * Headers renamed * Formal parameter names renamed * Template argument types renamed * Documentation updated
2016-05-28 09:23:54 -04:00
@param dynabuf A @b `DynamicBuffer` holding additional bytes
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
first.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
@param msg An object used to store the message. Any
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
contents will be overwritten. The type must support
copy assignment or move assignment.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up error types: * Restructure header material * Clean up namespace type injections * Remove extraneous 'success' constants
2016-10-04 18:00:11 -04:00
@throws system_error Thrown on failure.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
*/
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
template<
class SyncReadStream,
class DynamicBuffer,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
void
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
read(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields>& msg);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
/** Read a HTTP/1 message from a stream.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
This function is used to synchronously read a message from
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
a stream. The call blocks until one of the following conditions
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
is true:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
@li A complete message is read in.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@li An error occurs in the stream or parser.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
This function is implemented in terms of one or more calls
to the stream's `read_some` function. The implementation may
read additional octets that lie past the end of the message
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
being parsed. This additional data is stored in the dynamic
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
buffer, which may be used in subsequent calls.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@param stream The stream from which the data is to be read.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
The type must support the @b `SyncReadStream` concept.
Rename concept to DynamicBuffer (API change): Conform to the Networking TS by renaming the Streambuf concept to DynamicBuffer in all places. Values of types meeting the requirements of DynamicBuffer are renamed to dynabuf. See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers * Headers renamed * Formal parameter names renamed * Template argument types renamed * Documentation updated
2016-05-28 09:23:54 -04:00
@param dynabuf A @b `DynamicBuffer` holding additional bytes
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
first.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@param msg An object used to store the message. Any
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
contents will be overwritten. The type must support
copy assignment or move assignment.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
@param ec Set to the error, if any occurred.
*/
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
template<
class SyncReadStream,
class DynamicBuffer,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
void
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
read(
SyncReadStream& stream,
DynamicBuffer& dynabuf,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields>& msg,
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
error_code& ec);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
/** Read a HTTP/1 message asynchronously from a stream.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
This function is used to asynchronously read a message from
a stream. The function call always returns immediately. The
asynchronous operation will continue until one of the following
conditions is true:
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
@li A complete message is read in.
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
@li An error occurs in the stream or parser.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
This operation is implemented in terms of one or more calls to
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
the stream's `async_read_some` function, and is known as a
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
<em>composed operation</em>. The program must ensure that the
stream performs no other operations until this operation completes.
The implementation may read additional octets that lie past the
end of the message being parsed. This additional data is stored
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
in the dynamic buffer, which may be used in subsequent calls.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
@param stream The stream to read the message from.
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
The type must support the @b `AsyncReadStream` concept.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Rename concept to DynamicBuffer (API change): Conform to the Networking TS by renaming the Streambuf concept to DynamicBuffer in all places. Values of types meeting the requirements of DynamicBuffer are renamed to dynabuf. See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers * Headers renamed * Formal parameter names renamed * Template argument types renamed * Documentation updated
2016-05-28 09:23:54 -04:00
@param dynabuf A @b `DynamicBuffer` holding additional bytes
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
read by the implementation from the stream. This is both
an input and an output parameter; on entry, any data in the
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
dynamic buffer's input sequence will be given to the parser
Parser concept, fixes: A new concept Parser is introduced with routines to read from a stream into the parser. This solves a problem with the old read interface where messages must be default constructible and move assignable. Parser fixes: * Fix detect invalid reason-phrase octets * Fix write_eof to set the 'complete' state on success * Fix consider parse complete if eof received on empty body WebSocket: * Increase coverage
2016-04-30 10:29:39 -04:00
first.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
@param msg An object used to store the header. Any contents
Add read, async_read for message_headers: fix #172, fix #173 This provides overloads of read and async_read to allow reading message_headers objects.
2016-11-07 18:27:53 -05:00
will be overwritten. The type must support copy assignment or
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
move assignment. The object must remain valid at least until
the completion handler is called; ownership is not transferred.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
@param handler The handler to be called when the operation
completes. Copies will be made of the handler as required.
The equivalent function signature of the handler must be:
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
@code void handler(
error_code const& error // result of operation
); @endcode
Regardless of whether the asynchronous operation completes
immediately or not, the handler will not be invoked from within
this function. Invocation of the handler will be performed in a
Tidy up tests, build scripts, and documentation: * Concepts split up into individual files * Function definitions moved to .ipp files * Add more tests to fill gaps in coverage * Fix documentation Xsl
2016-05-01 12:33:35 -04:00
manner equivalent to using `boost::asio::io_service::post`.
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
*/
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
template<
class AsyncReadStream,
class DynamicBuffer,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
bool isRequest, class Body, class Fields,
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
class ReadHandler>
Rename to BEAST_DOXYGEN fix #316
2017-04-22 14:56:09 -07:00
#if BEAST_DOXYGEN
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
void_or_deduced
#else
typename async_completion<
ReadHandler, void(error_code)>::result_type
#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
async_read(
AsyncReadStream& stream,
DynamicBuffer& dynabuf,
Refactor HTTP identifier names (API Change): fix #171 Several names and HTTP identifiers are renamed to be more consistent, self-explanatory, and concise: * "Fields" is a collection of HTTP header fields (rfc7230 section 3.2) * "Header" is the Start Line plus Fields. Another way to look at it is, the HTTP message minus the body. * `basic_fields` replaces `basic_headers` * `fields` replaces `headers` * `Fields` replaces `Headers` in template parameter lists * `header` replaces `message_headers` * `header::fields` replaces `message_headers::fields` The changes are cosmetic and do not affect run-time behavior.
2016-11-10 05:34:49 -05:00
message<isRequest, Body, Fields>& msg,
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
ReadHandler&& handler);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
} // http
} // 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
#include <beast/http/impl/async_read.ipp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <beast/http/impl/read.ipp>
#endif
Copy Permalink