feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
b9bdb1bbbc624fa1db79a381b039ab7eacd7bff7
boost_beast/include/beast/http/impl/write.ipp

714 lines
18 KiB
Plaintext
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_IMPL_WRITE_IPP
#define BEAST_HTTP_IMPL_WRITE_IPP
HTTP improvements: * Increased code coverage * New Body concepts: is_Body is_ReadableBody is_WritableBody
2016-05-18 12:30:15 -04:00
#include <beast/http/concepts.hpp>
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
#include <beast/http/chunk_encode.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/buffer_cat.hpp>
#include <beast/core/bind_handler.hpp>
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
#include <beast/core/ostream.hpp>
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
#include <beast/core/handler_ptr.hpp>
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
#include <beast/core/multi_buffer.hpp>
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
#include <beast/core/type_traits.hpp>
Move sync_ostream to core/detail
2016-11-07 06:33:03 -05:00
#include <beast/core/detail/sync_ostream.hpp>
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <boost/asio/write.hpp>
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
#include <boost/throw_exception.hpp>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <condition_variable>
#include <mutex>
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
#include <ostream>
#include <sstream>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
#include <type_traits>
namespace beast {
namespace http {
namespace detail {
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
template<class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
write_start_line(std::ostream& os,
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
header<true, Fields> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
BOOST_ASSERT(msg.version == 10 || msg.version == 11);
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
os << msg.method() << " " << msg.target();
Improve first line serialization
2016-10-10 09:00:57 -04:00
switch(msg.version)
{
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
case 10: os << " HTTP/1.0\r\n"; break;
case 11: os << " HTTP/1.1\r\n"; break;
Improve first line serialization
2016-10-10 09:00:57 -04:00
}
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
template<class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
write_start_line(std::ostream& os,
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
header<false, Fields> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
BOOST_ASSERT(msg.version == 10 || msg.version == 11);
Improve first line serialization
2016-10-10 09:00:57 -04:00
switch(msg.version)
{
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
case 10: os << "HTTP/1.0 "; break;
case 11: os << "HTTP/1.1 "; break;
Improve first line serialization
2016-10-10 09:00:57 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
os << msg.status << " " << msg.reason() << "\r\n";
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
template<class FieldSequence>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
write_fields(std::ostream& os,
FieldSequence const& fields)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
//static_assert(is_FieldSequence<FieldSequence>::value,
// "FieldSequence requirements not met");
for(auto const& field : fields)
{
Refactor http::header contents (API Change): 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.
2017-05-02 15:49:22 -07:00
auto const name = field.name();
BOOST_ASSERT(! name.empty());
if(name[0] == ':')
continue;
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
os << field.name() << ": " << field.value() << "\r\n";
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
} // detail
//------------------------------------------------------------------------------
namespace detail {
template<class Stream, class Handler>
class write_streambuf_op
{
struct data
{
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
bool cont;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
Stream& s;
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
multi_buffer b;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
int state = 0;
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
data(Handler& handler, Stream& s_,
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
multi_buffer&& sb_)
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
: s(s_)
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
, b(std::move(sb_))
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
};
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
handler_ptr<data, Handler> d_;
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
public:
write_streambuf_op(write_streambuf_op&&) = default;
write_streambuf_op(write_streambuf_op const&) = default;
template<class DeducedHandler, class... Args>
write_streambuf_op(DeducedHandler&& h, Stream& s,
Args&&... args)
Better handler_ptr (API Change): 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
2017-01-29 19:46:17 -05:00
: d_(std::forward<DeducedHandler>(h),
s, std::forward<Args>(args)...)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
(*this)(error_code{}, 0, false);
}
void
operator()(error_code ec,
std::size_t bytes_transferred, bool again = true);
friend
void* asio_handler_allocate(
std::size_t size, write_streambuf_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, write_streambuf_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
friend
bool asio_handler_is_continuation(write_streambuf_op* op)
{
return op->d_->cont;
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, write_streambuf_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
};
template<class Stream, class Handler>
void
write_streambuf_op<Stream, Handler>::
operator()(error_code ec, std::size_t, bool again)
{
auto& d = *d_;
d.cont = d.cont || again;
while(! ec && d.state != 99)
{
switch(d.state)
{
case 0:
{
d.state = 99;
boost::asio::async_write(d.s,
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
d.b.data(), std::move(*this));
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
return;
}
}
}
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
d_.invoke(ec);
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
} // detail
template<class SyncWriteStream,
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 Fields>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
void
write(SyncWriteStream& stream,
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
header<isRequest, Fields> const& msg)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
"SyncWriteStream requirements not met");
error_code ec;
write(stream, msg, ec);
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
template<class SyncWriteStream,
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 Fields>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
void
write(SyncWriteStream& stream,
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
header<isRequest, Fields> const& msg,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
error_code& ec)
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
"SyncWriteStream requirements not met");
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
multi_buffer b;
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
{
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
auto os = ostream(b);
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
detail::write_start_line(os, msg);
detail::write_fields(os, msg.fields);
os << "\r\n";
}
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
boost::asio::write(stream, b.data(), ec);
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
template<class AsyncWriteStream,
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 Fields,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
class WriteHandler>
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
async_return_type<
WriteHandler, void(error_code)>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
async_write(AsyncWriteStream& stream,
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
header<isRequest, Fields> const& msg,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
WriteHandler&& handler)
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_async_write_stream<AsyncWriteStream>::value,
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
"AsyncWriteStream requirements not met");
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
async_completion<WriteHandler,
void(error_code)> init{handler};
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
multi_buffer b;
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
{
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
auto os = ostream(b);
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
detail::write_start_line(os, msg);
detail::write_fields(os, msg.fields);
os << "\r\n";
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
detail::write_streambuf_op<AsyncWriteStream,
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
handler_type<WriteHandler, void(error_code)>>{
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
init.completion_handler, stream, std::move(b)};
return init.result.get();
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
}
//------------------------------------------------------------------------------
namespace detail {
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
template<bool isRequest, class Body, class Fields>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
struct write_preparation
{
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> const& msg;
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
typename Body::writer w;
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
multi_buffer b;
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
bool chunked;
bool close;
explicit
write_preparation(
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> const& msg_)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
: msg(msg_)
, w(msg)
Add HTTP field value parsers: ext_list: Iterable container of comma separated extensions, where each extension is a token followed an optional list of semicolon delimited parameters, with each parameter consisting of a name / value pair. The value can be a token or quoted-string. param_list: Iterable container of semicolon delimited parameters, where each parameter is a name / value pair. The value can be a token or quoted-string. token_list Iterable container of comma delimited tokens. * Remove obsolete rfc2616 functions * Refactor and consolidate case-insensitive string helpers
2016-05-24 06:17:04 -04:00
, chunked(token_list{
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
msg.fields["Transfer-Encoding"]}.exists("chunked"))
Add HTTP field value parsers: ext_list: Iterable container of comma separated extensions, where each extension is a token followed an optional list of semicolon delimited parameters, with each parameter consisting of a name / value pair. The value can be a token or quoted-string. param_list: Iterable container of semicolon delimited parameters, where each parameter is a name / value pair. The value can be a token or quoted-string. token_list Iterable container of comma delimited tokens. * Remove obsolete rfc2616 functions * Refactor and consolidate case-insensitive string helpers
2016-05-24 06:17:04 -04:00
, close(token_list{
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
msg.fields["Connection"]}.exists("close") ||
(msg.version < 11 && ! msg.fields.exists(
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
"Content-Length")))
{
}
void
init(error_code& ec)
{
w.init(ec);
if(ec)
return;
Update copyright dates
2017-02-06 20:07:03 -05:00
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
auto os = ostream(b);
New ostream() returns dynamic buffer output stream (API Change): 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;
2017-05-03 15:29:23 -07:00
write_start_line(os, msg);
write_fields(os, msg.fields);
os << "\r\n";
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
};
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
template<class Stream, class Handler,
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
class write_op
{
struct data
{
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
bool cont;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
Stream& s;
// VFALCO How do we use handler_alloc in write_preparation?
write_preparation<
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
isRequest, Body, Fields> wp;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
int state = 0;
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
data(Handler& handler, Stream& s_,
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> const& m_)
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
: s(s_)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
, wp(m_)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
};
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
class writef0_lambda
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
write_op& self_;
public:
explicit
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
writef0_lambda(write_op& self)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
: self_(self)
{
}
template<class ConstBufferSequence>
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
void operator()(ConstBufferSequence const& buffers) const
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
auto& d = *self_.d_;
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
// write header and body
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(d.wp.chunked)
boost::asio::async_write(d.s,
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
buffer_cat(d.wp.b.data(),
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
chunk_encode(false, buffers)),
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
std::move(self_));
else
boost::asio::async_write(d.s,
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
buffer_cat(d.wp.b.data(),
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
buffers), std::move(self_));
}
};
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
class writef_lambda
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
write_op& self_;
public:
explicit
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
writef_lambda(write_op& self)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
: self_(self)
{
}
template<class ConstBufferSequence>
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
void operator()(ConstBufferSequence const& buffers) const
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
auto& d = *self_.d_;
// write body
if(d.wp.chunked)
boost::asio::async_write(d.s,
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
chunk_encode(false, buffers),
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
std::move(self_));
else
boost::asio::async_write(d.s,
buffers, std::move(self_));
}
};
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
handler_ptr<data, Handler> d_;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
public:
write_op(write_op&&) = default;
write_op(write_op const&) = default;
template<class DeducedHandler, class... Args>
write_op(DeducedHandler&& h, Stream& s, Args&&... args)
Better handler_ptr (API Change): 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
2017-01-29 19:46:17 -05:00
: d_(std::forward<DeducedHandler>(h),
s, std::forward<Args>(args)...)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
(*this)(error_code{}, 0, false);
}
void
operator()(error_code ec,
std::size_t bytes_transferred, bool again = true);
friend
void* asio_handler_allocate(
std::size_t size, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
friend
bool asio_handler_is_continuation(write_op* op)
{
return op->d_->cont;
}
Restyle sources
2016-08-26 08:01:44 -04:00
template<class Function>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
friend
void asio_handler_invoke(Function&& f, write_op* op)
{
Remove handler helpers, tidy up hook invocations (API Change)
2017-05-14 09:25:43 -07:00
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
};
template<class Stream, class Handler,
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
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
write_op<Stream, Handler, isRequest, Body, Fields>::
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
operator()(error_code ec, std::size_t, bool again)
{
auto& d = *d_;
d.cont = d.cont || again;
while(! ec && d.state != 99)
{
switch(d.state)
{
case 0:
{
d.wp.init(ec);
if(ec)
{
// call handler
d.state = 99;
d.s.get_io_service().post(bind_handler(
std::move(*this), ec, 0, false));
return;
}
d.state = 1;
break;
}
case 1:
{
Remove http Writer suspend and resume feature (API Change): fix #154 The resume_context parameter passed to instances of Writer during HTTP serialization is removed.
2017-03-31 11:15:27 -04:00
auto const result =
d.wp.w.write(ec,
writef0_lambda{*this});
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(ec)
{
// call handler
d.state = 99;
d.s.get_io_service().post(bind_handler(
std::move(*this), ec, false));
return;
}
if(result)
d.state = d.wp.chunked ? 4 : 5;
else
d.state = 2;
return;
}
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
// sent header and body
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
case 2:
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
d.wp.b.consume(d.wp.b.size());
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
d.state = 3;
break;
case 3:
{
Remove http Writer suspend and resume feature (API Change): fix #154 The resume_context parameter passed to instances of Writer during HTTP serialization is removed.
2017-03-31 11:15:27 -04:00
auto const result =
d.wp.w.write(ec,
writef_lambda{*this});
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(ec)
{
// call handler
d.state = 99;
break;
}
if(result)
d.state = d.wp.chunked ? 4 : 5;
else
d.state = 2;
return;
}
case 4:
// VFALCO Unfortunately the current interface to the
// Writer concept prevents us from coalescing the
// final body chunk with the final chunk delimiter.
//
// write final chunk
d.state = 5;
boost::asio::async_write(d.s,
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
chunk_encode_final(), std::move(*this));
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
return;
case 5:
if(d.wp.close)
{
// VFALCO TODO Decide on an error code
ec = boost::asio::error::eof;
}
d.state = 99;
break;
}
}
Implement asio dealloc-before-invoke guarantee: 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.
2017-01-02 13:29:48 -05:00
d_.invoke(ec);
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
template<class SyncWriteStream, class DynamicBuffer>
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
class writef0_lambda
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
DynamicBuffer const& sb_;
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
SyncWriteStream& stream_;
bool chunked_;
error_code& ec_;
public:
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
writef0_lambda(SyncWriteStream& stream,
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
DynamicBuffer const& b, bool chunked, error_code& ec)
: sb_(b)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
, stream_(stream)
, chunked_(chunked)
, ec_(ec)
{
}
template<class ConstBufferSequence>
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
void operator()(ConstBufferSequence const& buffers) const
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
// write header and body
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(chunked_)
boost::asio::write(stream_, buffer_cat(
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
sb_.data(), chunk_encode(false, buffers)), ec_);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
else
boost::asio::write(stream_, buffer_cat(
sb_.data(), buffers), ec_);
}
};
template<class SyncWriteStream>
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
class writef_lambda
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
SyncWriteStream& stream_;
bool chunked_;
error_code& ec_;
public:
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
writef_lambda(SyncWriteStream& stream,
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
bool chunked, error_code& ec)
: stream_(stream)
, chunked_(chunked)
, ec_(ec)
{
}
template<class ConstBufferSequence>
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
void operator()(ConstBufferSequence const& buffers) const
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
// write body
if(chunked_)
boost::asio::write(stream_,
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
chunk_encode(false, buffers), ec_);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
else
boost::asio::write(stream_, buffers, ec_);
}
};
} // detail
template<class SyncWriteStream,
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
write(SyncWriteStream& stream,
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> const& msg)
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
"SyncWriteStream requirements not met");
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
static_assert(is_Body<Body>::value,
"Body requirements not met");
static_assert(has_writer<Body>::value,
"Body has no writer");
static_assert(is_Writer<typename Body::writer,
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>>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Writer requirements not met");
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
error_code ec;
write(stream, msg, ec);
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
}
template<class SyncWriteStream,
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>
Distinguish HTTP/1 messages from general HTTP messages: The version field is moved into message_v1, all public interfaces are reworked to identify HTTP/1 wire format operations (suffix "_v1") versus general HTTP.
2016-05-01 11:14:10 -04:00
void
write(SyncWriteStream& stream,
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> const& msg,
Tidy up error types: * Restructure header material * Clean up namespace type injections * Remove extraneous 'success' constants
2016-10-04 18:00:11 -04:00
error_code& ec)
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_sync_write_stream<SyncWriteStream>::value,
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
"SyncWriteStream requirements not met");
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
static_assert(is_Body<Body>::value,
"Body requirements not met");
static_assert(has_writer<Body>::value,
"Body has no writer");
static_assert(is_Writer<typename Body::writer,
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>>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Writer requirements not met");
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
detail::write_preparation<isRequest, Body, Fields> wp(msg);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
wp.init(ec);
if(ec)
return;
Remove http Writer suspend and resume feature (API Change): fix #154 The resume_context parameter passed to instances of Writer during HTTP serialization is removed.
2017-03-31 11:15:27 -04:00
auto result = wp.w.write(
ec, detail::writef0_lambda<
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
SyncWriteStream, decltype(wp.b)>{
stream, wp.b, wp.chunked, ec});
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
if(ec)
return;
Rename to multi_buffer, basic_multi_buffer (API Change): These classes are renamed: * streambuf to multi_buffer * basic_streambuf to basic_multi_buffer
2017-05-04 15:40:07 -07:00
wp.b.consume(wp.b.size());
Fixes, fail testing: Core: * Test buffer_cat iterator move members HTTP: * Fixed yield / resume in writer * Fixed message serialization with chunked encoding * Test yield / resume in writer * Test all conditional branches during message serialization * Test chunked encoding * Increase coverage on parse_error * Add parse_error::general WebSocket: * Add error::general * Increase coverage in error
2016-05-07 17:06:46 -04:00
if(! result)
{
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
detail::writef_lambda<SyncWriteStream> wf{
stream, wp.chunked, ec};
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
for(;;)
{
Remove http Writer suspend and resume feature (API Change): fix #154 The resume_context parameter passed to instances of Writer during HTTP serialization is removed.
2017-03-31 11:15:27 -04:00
result = wp.w.write(ec, wf);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(ec)
return;
if(result)
break;
}
}
if(wp.chunked)
{
// VFALCO Unfortunately the current interface to the
// Writer concept prevents us from using coalescing the
// final body chunk with the final chunk delimiter.
//
// write final chunk
Make chunk_encode public: 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.
2016-11-07 16:57:41 -05:00
boost::asio::write(stream, chunk_encode_final(), ec);
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
if(ec)
return;
}
if(wp.close)
{
// VFALCO TODO Decide on an error code
ec = boost::asio::error::eof;
}
}
template<class AsyncWriteStream,
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
class WriteHandler>
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
async_return_type<
WriteHandler, void(error_code)>
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
async_write(AsyncWriteStream& stream,
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> const& msg,
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
WriteHandler&& handler)
{
Concept revision and documentation (API Change): 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.
2017-05-10 12:03:00 -07:00
static_assert(is_async_write_stream<AsyncWriteStream>::value,
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
"AsyncWriteStream requirements not met");
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
static_assert(is_Body<Body>::value,
"Body requirements not met");
static_assert(has_writer<Body>::value,
"Body has no writer");
static_assert(is_Writer<typename Body::writer,
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>>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Writer requirements not met");
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
async_completion<WriteHandler,
void(error_code)> init{handler};
Replace asynchronous helper macros with template aliases (API Change)
2017-05-12 17:13:03 -07:00
detail::write_op<AsyncWriteStream, handler_type<
WriteHandler, void(error_code)>, isRequest,
Harmonize concepts and identifiers with net-ts (API Change): fix #321 This synchronizes identifier names and some implementation details with the Networking-TS document and reference implementation. The following interfaces have changed: * async_completion * is_buffer_sequence (removed) * is_const_buffer_sequence (was is_ConstBufferSequence) * is_dynamic_buffer (was is_DynamicBuffer) * is_mutable_buffer_sequence (was is_MutableBufferSequence) * async_result (new) * BEAST_HANDLER_TYPE macro (new) * BEAST_INITFN_RESULT_TYPE macro (new) Filename changes: * async_result.hpp (was async_completion.hpp)
2017-05-06 12:36:40 -07:00
Body, Fields>{init.completion_handler, stream, msg};
return init.result.get();
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
}
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05: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
template<bool isRequest, class Fields>
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
std::ostream&
operator<<(std::ostream& os,
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
header<isRequest, Fields> const& msg)
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
{
beast::detail::sync_ostream oss{os};
error_code ec;
write(oss, msg, ec);
if(ec)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Add write, async_write, operator<< for message_headers: fix #155 This adds overloads of write, async_write, and operator<< for message_headers.
2016-11-07 13:51:10 -05:00
return os;
}
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
template<bool isRequest, class Body, class Fields>
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
std::ostream&
operator<<(std::ostream& os,
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> const& msg)
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
{
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
static_assert(is_Body<Body>::value,
"Body requirements not met");
static_assert(has_writer<Body>::value,
"Body has no writer");
static_assert(is_Writer<typename Body::writer,
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>>::value,
Rework HTTP concepts (API Change): fix #139, fix #140 * Writer uses write instead of operator() * Refactor traits to use void_t * Remove is_ReadableBody, is_WritableBody * Add has_reader, has_writer, is_Reader, is_Writer * More friendly compile errors on failed concept checks
2016-10-15 13:40:17 -04:00
"Writer requirements not met");
Move sync_ostream to core/detail
2016-11-07 06:33:03 -05:00
beast::detail::sync_ostream oss{os};
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
error_code ec;
write(oss, msg, ec);
if(ec && ec != boost::asio::error::eof)
Use BOOST_THROW_EXCEPTION fix #370
2017-05-22 15:30:12 -07:00
BOOST_THROW_EXCEPTION(system_error{ec});
Refactor beast core, http, tests, and examples: * Fix warnings * Port cmake scripts to linux * Add command line options for running test suites * Add examples to CMakeLists * Return std::uint64_t from writer::content_length * basic_parser::write takes asio::const_buffer instead of pointer and size * Turn message test back on now that it passes * Rename to http::headers, use std::allocator, remove http_headers * http::message::method is now a string * Refactor to_string for ConstBufferSequence * Remove chunk_encode from the public interface * Initialize members for default constructed iterators * Disallow default construction for dependent buffer sequences Refactor http::message serialization: * Serialization no longer creates a copy of the headers and modifies them * New function prepare(), sets Connection, Transfer-Encoding, Content-Length based on the body attributes and caller options. Callers can use prepare() to have the fields set automatically, or they can set the fields manually. * Use write for operator<< * Tests for serialization
2016-04-29 06:04:40 -04:00
return os;
}
Truncate history, version 1.0.0-b2
2017-07-20 08:01:46 -07:00
} // http
} // beast
#endif
Copy Permalink