* detail::read_size_helper is removed
* public function read_size helps determine the optimum
size for calls to a DynamicBuffer's prepare function.
* special case for Asio types which don't conform to
the concept but have their own helper function.
When the parser is presented with an input buffer
sequence with length greater than one, the input is
flattened using stack space instead of dynamic
allocation if the buffer size is no greater than 8192.
* Container interface more closely matches std::vector
* While preserving the invariant that duplicate fields
with the same case-insensitive name have their order
preserved.
read_size_helper can return zero if the buffer reaches
its maximum size, causing infinite loops in HTTP. The
function maybe_read_size_helper is provided to throw
an exception instead of returning a value for this case.
* frame_info struct is removed
* read_frame and async_read_frame return a bool indicating
if the frame is the last frame of the current message.
Actions Required:
* Remove the frame_info parameter from all read frame call sites
* Check the return value 'fin' for calls to read_frame
* Change ReadHandlers passed to async_read_frame to have
the signature void(error_code, bool fin), use the bool
to indicate if the frame is the last frame.
fix#446
* Read signatures no longer include `opcode`
* stream::got_binary and stream::got_text inform the caller if
the current incoming message is binary or text.
Actions Required:
* Remove the `opcode` reference parameter from calls to synchronous
and asynchronous read functions, replace the logic with calls to
stream::got_binary and stream::got_text instead.
fix#446
* The ping_callback option struct is removed.
Actions Required:
* Change call sites which use ping_callback with set_option to
call stream::ping_callback instead.
fix#446
* The write_buffer_size option struct is removed.
Actions Required:
* Change call sites which use write_buffer_size with set_option to
call stream::write_buffer_size instead.
fix#446
* The read_message_max option struct is removed.
Actions Required:
* Change call sites which use read_message_max with set_option to
call stream::read_message_max instead.
fix#446
* The read_buffer_size option struct is removed
Actions Required:
* Change call sites which use read_buffer_size with set_option to
call stream::read_buffer_size instead.
fix#446
* message_type is removed
Actions Required:
* Change call sites which use message_type with set_option
to call stream::binary or stream::text instead.
fix#374, fix#446
* auto_fragment option struct is removed
Actions Required:
* Change call sites which use auto_fragment with set_option
to call stream::auto_fragment instead.
fix#440
WARNING
multi_buffer constructor now takes a maximum size instead of the
"allocation size". This is a breaking change. The allocation size
feature is removed. To update calling code, remove the allocation
size parameter from call sites.
* multi_buffer now uses a geometric growth algorithm for better performance.
The static buffer is updated:
* reset() is no longer a member. Use b.consume(b.size()) instead.
* Simplified implementaton, uses asio instead of custom types
* Better stream performance: consuming the input makes room
available in the output. This class is now suitable for
HTTP reads.
These changes permit the static_buffer wrapper to adapt a user
memory buffer if desired, including a stack based array.
The static_buffer_n class may also be used for this purpose,
it comes with its own storage.
fix#431, fix#430
The read_some and async_read_some HTTP operations no longer
return the number of bytes that the caller should consume.
Instead, the bytes are automatically removed from the dynamic
buffer as indicated by the parser.
* header::result is a family of functions to replace header::status
* header interface now uses status enum and also ints
* reason-phrase is no longer stored unless the user explicitly
requests it.
* When serializing, the standard reason is used for the
corresponding status code unless the user has changed it.
The verb interfaces now use verb::unknown instead of
boost::optional<verb> == boost::none to indicate that
the request-method is an unrecognized string.
The http::header interface is modified to focus more on the
verb enum rather than the string. For recognized verbs, the
implementation stores an integer instead of the string.
Unknown verbs are still stored as strings.
* header::method now returns a verb
* header::method_string returns the method text
fix#404
Parsing and serialization interfaces have been fine tuned and unified.
For parsing these stream operations are defined:
* read
* read_header
* read_some
* async_read
* async_read_header
* async_read_some
For serialization these stream operations are defined:
* write
* write_header
* write_some
* async_write
* async_write_header
* async_write_some
fix#398
A new enum status is added for the status code.
The function obsolete_reason returns default reason phrasing.
If a response has an empty reason, the serializer will
automatically insert the default reason phrase for the
status code.
fix#397
method enum class is added to represent all known request methods.
Functions are provided to convert from strings to and from the method
enumeration.
The fields container is modified to also work with the enum.
A new class `serializer` is introduced to permit incremental
serialization of HTTP messages. Existing free functions are
re-implemented in terms of this new class.
* The BodyReader concept is refined to support a greater variety
of strategies for providing buffers representing the body to
the serialization algorithms.
* Added buffer_body, a new model of Body which allows the caller
to provide a series of owned buffers using their own serialization
loop.
* Added empty_body, a model of Body which is for serialization only,
to represent HTTP messages with no content body.
* Removed overloads of write and async_write which send only
the HTTP header.
* Removed public interfaces for performing low-level chunk encoding.
The concept type traits are renamed for consistency,
and consolidated into a single header file <beast/core/type_traits.hpp>
A new section, Core Concepts, is added to the documentation describing all
of the core utility classes and functions. This also includes a complete
explanation and sample program describing how to write asynchronous initiation
functions and their associated composed operations.
This function converts integers to their decimal
representation as a static string.
In addition, static_string::resize no longer initializes
characters if the new size is larger.
A new function, buffers(), returns an implementation defined object
which wraps a ConstBufferSequence and supports formatting to a
std::ostream.
The function to_string is removed, as the new implementation allows
conversion to string using boost::lexical_cast on the return value
of the call to buffers(). Streaming to an output stream is more
efficient: no dynamic allocations are performed.
Example:
streambuf sb;
std::cout << buffers(sb.data()) << std::endl;
This eliminates beast::write output for dynamic buffers and replaces
it with the function ostream() that wraps a caller provided dynamic
buffer and returns the result as a std::ostream derived object.
Callers may now produce formatted output into any object meeting the
requirements of DynamicBuffer using operator<< and the standard stream
modifiers such as std::endl.
This new technique is more efficient, as implementations of operator<<
can now write directly into the output using std::ostream::write and
std::ostream::put.
Example of use:
beast::streambuf sb;
beast::ostream(sb) << "Hello, world!" << std::endl;
fix#124
The http::header data members "method", "url", and "reason"
are changed from data members, to pairs of get and set
functions which forward the call to the Fields type used
to instantiate the template.
Previously, these data members were implemented using
std::string. With this change, the implementation of the
Fields type used to instantiate the template is now in
control of the representation of those values. This permits
custom memory allocation strategies including uniform use of
the Allocator type already provided to beast::http::basic_fields.
fix#332
This removes the keep_alive option from the WebSocket stream.
Callers who wish to control the behavior of the Connection
header may do so in the decorator and completion handlers
for the handshake and accept functions.
fix#325
This removes unused and misleading handshake error codes.
All semantic handshake failures are now reported using
the same code, error::handshake_failed. Errors originating
from stream operations still use the underlying stream
error codes (for example: boost::asio::error::connection_reset).
fix#195
This function returns `true` when the passed HTTP Request
indicates a WebSocket Upgrade. It does not validate the
contents of the fields: it just trivially accepts requests
which can only be a WebSocket Upgrade message.
Callers who wish to manually read HTTP requests in their
server implementation can use this function to determine if
the request should be routed to an instance of websocket::stream.
fix#80, #212, fix#303, fix#314, fix#317
websocket::stream now provides the following families of
functions for performing handshakes:
When operating in the server role:
* stream::accept
* stream::accept_ex
* stream::async_accept
* stream::async_accept_ex
When operating in the client role:
* stream::handshake
* stream::handshake_ex
* stream::async_handshake
* stream::async_handshake_ex
Member functions ending with "_ex" allow an additional
RequestDecorator parameter (for the accept family of
functions) or ResponseDecorator parameter (for the
handshake family of functions).
The decorator is called to optionally modify the contents
of the HTTP request or HTTP response object generated by
the implementation, before the message is sent. This
permits callers to set the User-Agent or Server fields,
add or modify HTTP fields related to subprotocols, or
perform any required transformation of the HTTP message
for application-specific needs.
The handshake() family of functions now have an additional
set of overloads accepting a parameter of type response_type&,
allowing the caller to receive the HTTP Response to the
Upgrade handshake. This permits inspection of the response
to handle things like subprotocols, authentication, or
other application-specific needs.
The new implementation does not require any state to be
stored in the stream object. Therefore, websocket::stream
objects are now smaller in size.
The overload of set_option for setting a decorator on the
stream is removed. The only way to set decorators now is
with a suitable overload of accept or handshake.
This adds enough functions to the accept and async_accept
overload set to cover all combinations of request, buffers,
and error_code parameters. This also fixes a defect where
providing a complete Upgrade request when there are additional
unprocessed octets remaining in the callers stream buffer
could not be furnished to the WebSocket implementation.
fix#123fix#154fix#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
Objects of this type meet the requirements of DynamicBuffer
and offer an additional invariant: buffer sequences returned
by data() and prepare() are always of length one.
fix#271
This modifies the websocket stream implementation's composed
operations to allow caller-initiated asynchronous pings and
frame/message writes to take place at the same time.
fix#261
This fixes a rare condition when responding to a ping or
close frame where the wr_block_ stream variable is not
correctly set for a short window of time.
fix#257
This fixes a problem when doing split parsing (header then body).
The problem arises when the first buffer passed to the header
parser contains exactly the full header and nothing more. The
symptom is that when parsing the body, the parse will erroneously
be considered complete.
* Add handler_ptr test and increase coverage
* Add test for prepare_buffer
* Move is_call_possible tests to a .cpp file
* Tidy up docs and declarations
fix#248
This additionally invokes the pong callback for received pings, allowing
callers to more efficiently detect when a connection is still lively:
* pong_callback renamed to ping_callback
* Callback signature has an extra `bool` to indicate if the received
control frame is a ping or pong.
fix#242
* Add public constructors
* Add handler_ptr::empty()
* Add handler_ptr::element_type
* Remove make_handler_ptr free function
* Compiler error if element_type is an array type
* handler_ptr::get() returns nullptr if no object is owned
fix#215
This change guarantees that temporary memory allocated
through the asio hooks by the Beast implementation is
deallocated before invoking the final handler when performing
composed operations.
The change is accomplished by replacing std::shared_ptr with
a thread-safe custom container handler_ptr to manage composed
operation state. The container tracks other instances which
manage the same object and resets them in a safe way before
invoking the final handler.
handler_ptr is provided as a public interface so that users of
this library can utilize the same idiom to write their own
composed operations.
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.
buffer_cat now determines if all of the buffer sequences in
the list of passed buffer sequences each have value types which
are convertible to mutable_buffer. The returned concatenated
sequence will be a MutableBufferSequence if all the passed
buffer sequences meet the requirements of MutableBufferSequence,
else the returned concatenated sequence will be a ConstBufferSequence.
This fixes a bug where instantiations of consuming_buffers with
buffer sequence types whose value_type is not const_buffer or
mutable_buffer can cause compilation errors.
The function consumed_buffers is removed.
This fixes a bug where calling prepare_buffers on a buffer
sequence whose value_type is not const_buffer or mutable_buffer
causes compilation errors.
The documentation is also tidied up.
fix#154, fix#156
This adds public interfaces for transforming buffer
sequences into their chunk-encoded equivalents. The
transformations are O(1) in space and time.
message_headers is now a set of partial class template
specializations instead of a template class alias. This solves
a problem where template functions taking message_headers as a
parameter could not deduce argument types, since std::conditional
obscured the deduced context.
Both classes are refactored to share declarations using an #ifdef,
to eliminate an ugly set of extra declarations needed when building
the documentation.
Copy and move class special members are added.
A new function message::base() is provided which returns the
message_headers portion of a message.
* New overload of fail() specifies file and line
* BEAST_EXPECTS only evaluates the reason string on a failure
- This speeds up tests that call BEAST_EXPECTS
These changes support parsing the headers separately from the body.
* on_headers now returns void
* on_body_what is a new required callback which returns body_what
basic_parser_v1 now requires that all callbacks appropriate
to the message are present and have the correct signatures.
Compile errors will result from compiling parsers which are
missing callbacks.
fix#114, fix#117, fix#136
* Added init() to Reader requirements
* Reader must be nothrow constructible
* Reader is now constructed right before reading the body
- The message passed on construction is filled in
When the derived class provides a member function with the
corresponding callback name, but the signature is different,
a compile error will be generated instead of silently ignoring
the member function.
This patch rectifies flush() of beast::http::parser_v1
to properly handle the case when an HTTP header has
empty value.
Without the fix an empty-valued HTTP header is being
concatenated with the header directly following it.
This situation can be replicated using eg. curl:
curl <url> -H "X-First;" -H "X-Second: bla"
What Beast's client would see is a single header named
as "X-FirstX-Second".
These directories are removed, to make it easier for developers
to delete the entire directory contents when rebuilding CMake targets
after a configuration change.
New overloads of suite::expect take the file and line number
as individual parameters, cleaning up the file name output
by showing only the filename part (to not leak the full path,
which might contain sensitive information).
A new macro BEAST_EXPECTS allows an additional reason
string as well as reporting the file and line. Typical usage:
```
error_code ec;
...
if(! BEAST_EXPECTS(! ec, ec.message()))
return;
```
