boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-08-03 14:54:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Partial support for BOOST_NO_EXCEPTIONS:

Browse Source 
Some stream operations are modified to use a
helper function which supports BOOST_NO_EXCEPTIONS.
This commit is contained in:
Vinnie Falco
2018-10-30 17:30:48 -07:00
parent 335f5c2333
commit 65434a0cba
6 changed files with 71 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -3,6 +3,7 @@ Version 187:
* Add experimental timeout_socket
* Fix warning in file tests
* Fix uninitialized comparison in buffers iterator
* Partial support for BOOST_NO_EXCEPTIONS
--------------------------------------------------------------------------------

2
doc/qbk/09_releases.qbk
View File

@@ -35,6 +35,8 @@
* Workaround for http-server-fast and libstdc++
* Partial support for `BOOST_NO_EXCEPTIONS`
[*Experimental]
* Add [link beast.ref.boost__beast__timeout_socket `timeout_socket`]

21
include/boost/beast/http/basic_dynamic_body.hpp
View File

@@ -12,6 +12,7 @@
#include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/http/error.hpp>
#include <boost/beast/http/message.hpp>
#include <boost/optional.hpp>
@@ -95,21 +96,15 @@ struct basic_dynamic_body
ec = error::buffer_overflow;
return 0;
}
boost::optional<typename
DynamicBuffer::mutable_buffers_type> b;
try
{
b.emplace(body_.prepare((std::min)(n,
body_.max_size() - body_.size())));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
auto const mb =
beast::detail::dynamic_buffer_prepare(
body_, (std::min)(n,
body_.max_size() - body_.size()),
ec, error::buffer_overflow);
if(ec)
return 0;
}
ec.assign(0, ec.category());
auto const bytes_transferred =
buffer_copy(*b, buffers);
buffer_copy(*mb, buffers);
body_.commit(bytes_transferred);
return bytes_transferred;
}

48
include/boost/beast/http/impl/read.ipp
View File

@@ -18,6 +18,7 @@
#include <boost/beast/core/handler_ptr.hpp>
#include <boost/beast/core/read_size.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp>
#include <boost/asio/associated_allocator.hpp>
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/coroutine.hpp>
@@ -121,8 +122,6 @@ operator()(
bool cont)
{
cont_ = cont;
boost::optional<typename
DynamicBuffer::mutable_buffers_type> mb;
BOOST_ASIO_CORO_REENTER(*this)
{
if(b_.size() == 0)
@@ -139,18 +138,22 @@ operator()(
break;
do_read:
try
{
mb.emplace(b_.prepare(
read_size_or_throw(b_, 65536)));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
break;
}
BOOST_ASIO_CORO_YIELD
s_.async_read_some(*mb, std::move(*this));
{
// VFALCO This was read_size_or_throw
auto const size = read_size(b_, 65536);
if(size == 0)
{
ec = error::buffer_overflow;
goto upcall;
}
auto const mb =
beast::detail::dynamic_buffer_prepare(
b_, size, ec, error::buffer_overflow);
if(ec)
goto upcall;
s_.async_read_some(*mb, std::move(*this));
}
if(ec == boost::asio::error::eof)
{
BOOST_ASSERT(bytes_transferred == 0);
@@ -513,19 +516,18 @@ read_some(
break;
}
do_read:
boost::optional<typename
DynamicBuffer::mutable_buffers_type> b;
try
{
b.emplace(buffer.prepare(
read_size_or_throw(buffer, 65536)));
}
catch(std::length_error const&)
auto const size = read_size(buffer, 65536);
if(size == 0)
{
ec = error::buffer_overflow;
return bytes_transferred;
break;
}
auto const n = stream.read_some(*b, ec);
auto const mb =
beast::detail::dynamic_buffer_prepare(
buffer, size, ec, error::buffer_overflow);
if(ec)
break;
auto const n = stream.read_some(*mb, ec);
if(ec == boost::asio::error::eof)
{
BOOST_ASSERT(n == 0);

52
include/boost/beast/websocket/impl/accept.ipp
View File

@@ -18,6 +18,7 @@
#include <boost/beast/http/write.hpp>
#include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/handler_ptr.hpp>
#include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/core/detail/type_traits.hpp>
#include <boost/asio/coroutine.hpp>
#include <boost/asio/associated_allocator.hpp>
@@ -244,20 +245,12 @@ run(Buffers const& buffers)
using boost::asio::buffer_size;
auto& d = *d_;
error_code ec;
boost::optional<typename
static_buffer_base::mutable_buffers_type> mb;
auto const len = buffer_size(buffers);
try
{
mb.emplace(d.ws.rd_buf_.prepare(len));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
auto const mb = beast::detail::dynamic_buffer_prepare(
d.ws.rd_buf_, buffer_size(buffers), ec,
error::buffer_overflow);
if(ec)
return (*this)(ec);
}
d.ws.rd_buf_.commit(
buffer_copy(*mb, buffers));
d.ws.rd_buf_.commit(buffer_copy(*mb, buffers));
(*this)(ec);
}
@@ -432,20 +425,12 @@ accept(
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
reset();
boost::optional<typename
static_buffer_base::mutable_buffers_type> mb;
try
{
mb.emplace(rd_buf_.prepare(
buffer_size(buffers)));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
auto const mb = beast::detail::dynamic_buffer_prepare(
rd_buf_, buffer_size(buffers), ec,
error::buffer_overflow);
if(ec)
return;
}
rd_buf_.commit(
buffer_copy(*mb, buffers));
rd_buf_.commit(buffer_copy(*mb, buffers));
do_accept(&default_decorate_res, ec);
}
@@ -472,18 +457,11 @@ accept_ex(
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
reset();
boost::optional<typename
static_buffer_base::mutable_buffers_type> mb;
try
{
mb.emplace(rd_buf_.prepare(
buffer_size(buffers)));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
auto const mb = beast::detail::dynamic_buffer_prepare(
rd_buf_, buffer_size(buffers), ec,
error::buffer_overflow);
if(ec)
return;
}
rd_buf_.commit(buffer_copy(*mb, buffers));
do_accept(decorator, ec);
}

54
include/boost/beast/websocket/impl/read.ipp
View File

@@ -16,6 +16,7 @@
#include <boost/beast/core/buffers_suffix.hpp>
#include <boost/beast/core/flat_static_buffer.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/core/detail/clamp.hpp>
#include <boost/beast/core/detail/config.hpp>
#include <boost/asio/associated_allocator.hpp>
@@ -800,35 +801,27 @@ operator()(
std::size_t bytes_transferred)
{
using beast::detail::clamp;
using buffers_type = typename
DynamicBuffer::mutable_buffers_type;
boost::optional<buffers_type> mb;
BOOST_ASIO_CORO_REENTER(*this)
{
do
{
try
{
mb.emplace(b_.prepare(clamp(
ws_.read_size_hint(b_), limit_)));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
}
if(ec)
{
BOOST_ASIO_CORO_YIELD
boost::asio::post(
ws_.get_executor(),
bind_handler(std::move(*this),
error::buffer_overflow, 0));
break;
}
BOOST_ASIO_CORO_YIELD
read_some_op<buffers_type, read_op>{
std::move(*this), ws_, *mb}(
{}, 0, false);
{
auto mb = beast::detail::dynamic_buffer_prepare(b_,
clamp(ws_.read_size_hint(b_), limit_),
ec, error::buffer_overflow);
if(ec)
boost::asio::post(
ws_.get_executor(),
bind_handler(
std::move(*this), ec, 0));
else
read_some_op<typename
DynamicBuffer::mutable_buffers_type,
read_op>(std::move(*this), ws_, *mb)(
{}, 0, false);
return;
}
if(ec)
break;
b_.commit(bytes_transferred);
@@ -950,17 +943,10 @@ read_some(
auto const size =
clamp(read_size_hint(buffer), limit);
BOOST_ASSERT(size > 0);
boost::optional<typename
DynamicBuffer::mutable_buffers_type> mb;
try
{
mb.emplace(buffer.prepare(size));
}
catch(std::length_error const&)
{
ec = error::buffer_overflow;
auto mb = beast::detail::dynamic_buffer_prepare(
buffer, size, ec, error::buffer_overflow);
if(ec)
return 0;
}
auto const bytes_written = read_some(*mb, ec);
buffer.commit(bytes_written);
return bytes_written;