ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-12-06 17:27:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Squashed 'src/beast/' changes from 6d5547a..3bcd986

Browse Source 
3bcd986 Set version to 79
4f42f8c Remove spurious fallthrough guidance
fa1ac16 Set version to 78
0cb9b63 Fix warning in root ca declaration
f78c73a Tidy up file_posix unused variable
72ce9ef Tidy up dstream for existing Boost versions
efe8e58 Add Boost.Locale utf8 benchmark comparison
f7c745e Remove string_view_body
7a79efa Tidy up FieldsReader doc
e51aefd Header file tidying
69898f4 Fix warning in zlib
53723c0 Add message keep_alive, chunked, content_length members
d7af73b Fix spurious uninitialized warning
ca42cc0 Tidy up invalid characters in test vector
48d3e60 Use make_unique_noinit
a1ff804 span, string, vector bodies are public
feab6a0 Documentation work
116c0b0 Add span_body
7fb901d Tidy up includes and javadocs
f0f58be Add span
7a8982b Add vector_body
524f73a Tidy up basic_string_body
a8ad67b Set version to 77
d555859 file_posix works without large file support
1bc30cb Set version to 76
9a1e7a8 Disable SSE4.2 optimizations
09af312 Fix parse illegal characters in obs-fold
7dd684c Add file_body_win32:
1bbc71c serializing file_body is not const
9a4b55e BodyReader, BodyWriter use two-phase init (API Change):
dc400ce Serializer members are not const
1a33c37 Rename to serializer::keep_alive (API Change):
55935c5 Add serializer::chunked
63ace37 Add serializer::get
2c4047b BodyReader may construct from a non-const message
0a0a225 Use Boost.Config
6f83d07 Always go through write_some:
0e23066 Set version to 75
28f3ece Doc tidying
3495331 Using SSE4.2 intrinsics in basic_parser if available
bc1f0ac file_body tests
4e03d7e Add serializer::limit
85e3ee8 Shrink serializer buffers using buffers_ref
78bcdb1 Tidy up BEAST_NO_BIG_VARIANTS
3ea6cf2 Construct buffer_prefix_view in-place
69f9f7a Use file_body for valid requests, string_body otherwise.
6f88f01 Set version to 74
93fed8e remove redundant flush() from example:
e0f56da Fix Beast include directories for cmake targets
5ff9e0a Add file_posix
1bb5705 Remove common/file_body.hpp
5c89d87 Add file_body
67a55c8 Add file_win32
647d3b0 Add file_stdio and File concept
89c416c Set version to 73
0efc32f Fixes for gcc-4.8
c8910ab Initialize local variable in basic_parser
8a28193 Adjust benchmarks
81e51d8 Verify certificates in SSL clients
a43f6d4 Jamroot tweak
8c85ee8 Put more... links on overload reference pages
ff1104e Documentation tidy
826ff0e serializer::next replaces serializer::get (API Change):
8d67775 Refactor header and message constructors:
6c79f19 Add basic_parser tests
25127d9 basic_parser optimizations:
9d082fd Set version to 72
c88e2b9 Various improvements to http_server_fast.cpp:
20b0fdb Documentation tidying
afd1fa7 Add websocket-server-async example
954b597 Add http-server-threaded example
df8f253 Refactor file_body for best practices
11c1037 Newly constructed responses have a 200 OK result
a648817 Refine Body::size specification
40aad37 Tidy up set payload in http-server-fast
52cefbc Set version to 71
8c51c77 Tidy up Jamroot /permissive-
5efecea Update README.md
5a47acd Tidy up http_sync_port error check
a2af2b5 Concept check in basic_dynamic_body
8b80a6f Fix buffer overflow handling for string_body and mutable_body
ec3b4fd Return std::size_t from Body::writer::put (API Change)
effbb37 Check trailers in test
f5368cf Call prepare_payload in HTTP example
a3e5e01 Fix spurious on_chunk invocation
96d94eb Add options for building examples and tests. Move zlib test sources to test/zlib
e0efdc7 Allow close, ping, and write to happen concurrently
9c1a419 Refactor websocket composed ops
d5659a4 Fine tune websocket asserts
b8e8943 std::pair "last" -> "first" in http_message.qbk
c691bf4 Fix can/cannot thinko in FAQ.
6dd006b Documentation revision
6d2e315 Fix extra ; warning
78a065b Set version to 70
00c7e9d Fix HEAD response in file_service
67d70d2 Fix BEAST_FALLTHROUGH in config
4f33655 Add parser::on_header to set a callback
9c16b21 Add basic_parser header and body limits:
b64d1f7 Rename to message::base (API Change):
436c66a Serialize in one step when possible
3e1061b Set version to 69
f709273 Add /permissive- to msvc toolchain
0dae464 Use BEAST_FALLTHROUGH to silence warnings
a70d386 basic_parser optimizations
4269f35 Set version to 68
544327f Link statically on cmake MSVC
e213ffe Add const_body, mutable_body to examples
0568763 Optimize field lookups
8fc3001 Use string_ref in older Boost versions
8af77da bad_target replaces bad_path (API Change):
325dd62 Adjust buffer size in fast server
be59785 Doc erratum
d9b44f3 Small speed up in fields comparisons
3e6ce38 Use Boost master on Appveyor
09f3d64 Split common tests to a new project
adfd22a Remove BodyReader::is_deferred (API Change):
582d28d Change BodyReader, BodyWriter requirements (API Change):
8982e14 Set version to 67
daa58a2 Group common example headers
afd8f1a Rename to http-server-fast
07cb9f7 control_callback replaces ping_callback (API Change):
91e83ed Use boost::string_view
067db87 Merge stream_base to stream and tidy
d61241a Add http-server-small example
eb08e92 Fix doc example link
7fb75d0 Set version to 66
df86723 Respect debug flag for marked output
c08565a Squelch spurious warning on gcc
188ef7c Documentation work
1c62d3a Add http-server example
3f54582 basic_fields optimizations
a8b05b8 Add header aliases
b94eac3 Tidy up message piecewise ctors
9c48b52 Handle bad_alloc in parser
1b57c54 Fix costly potential value-init in parser
1edc41e Make consuming_buffers smaller
72ac918 Add serializer request/response aliases
18f7606 string_param optimizations
c675252 Set version to 65
c398cdd Enable msvc warnings in Jamfile
380cceb Fix unused variable warnings
4172e7e Enable unused variable warning on msvc cmake
f04d227 Fix integer warnings
ca975b3 Fix narrowing in deflate_stream
2fab796 Fix narrowing in inflate_stream
cff87f6 Fix narrowing in ostream
1956886 Fix narrowing in static_ostream
69cdc4b Fix integer types in deflate_stream::bi_reverse
3e3dd21 Enable narrowing warning on msvc cmake
e11a294 Set version to 64
a00e070 Remove make_serializer (API Change):
8449697 Add link_directories to cmake
7b2b066 Doc tidying
158d3e8 async_write requires a non-const message:
d13328b Better User-Agent in examples
ebcb2c0 Exemplars are compiled code
b9054d3 Simplify websocket write_op
c2571fe Simplify ssl teardown composed op
d8ad3d1 Simplify buffered_read_stream composed op
f68dc34 Set version to 63
a99f7ef Control running with valgrind explicitly
4eb7af4 Tidy up Jamfiles
49b42a5 Tidy up CMakeLists.txt
dadb54f Only run the tests under ubasan
d1c7696 Move benchmarks to a separate project
a4aada8 Only build and run tests in variant=coverage
f835b9a Don't use cached Boost
a0edd82 Put num_jobs back up on Travis
a8d5823 Use std::to_string instead of lexical_cast
45d8b81 Set version to 62
09e07ce Put slow tests back for coverage builds
295b1d7 Doc tidy
f58425c Squelch harmless not_connected errors
9b537f7 Add http::is_fields trait
d43701b message::prepare_payload replaces message::prepare (API Change):
42ba289 Refine FieldsReader concept (API Change)
bde90a1 Narrow the use of Fields parameters:
5f47526 parser requires basic_fields (API Change):
60f58e4 Avoid explicit operator bool for error
352f8de Clear the error faster
34befd8 Tidy up namespaces in examples
9e0b4b5 Doc fixes and tidy
c003a2a Tidy up test build scripts and projects
b929130 Add server-framework tests
03d4301 Increase detail::static_ostream coverage
80d7cbc Remove libssl-dev from a Travis matrix item
4c15db4 Set version to 61
1dfbd0b Don't run slow tests on certain targets
6bb1109 Use one job less on CI
6f58342 Tidy up resolver calls
530b044 Add multi_port to server-framework
bfef5d1 Tidy up http-crawl example
e2f2f33 Reorganize SSL examples
adc301b Fix shadowing warnings
c60185e Add server-framework SSL HTTP and WebSocket ports
7912fb8 Refactor WebSocket, HTTP examples:
cd4b9e0 Flush the output stream in the example
d046b20 Tidy up names in error categories
9d4a422 status-codes is unsigned (API Change)
e3599b0 header::version is unsigned (API Change)
a26b043 Add message::header_part()
fc8d2e9 Tidy up some integer conversion warnings
c91732e Reorganize SSL examples
9907b31 Documentation work
4b2e78e Use generic_cateogry for errno
38c46cd Remove Spirit dependency
c111d6f Set version to 60
d78dc12 Documentation work
141a524 New server-framework, full featured server example:
3f7ffd9 Fix response message type in async websocket accept
13f3750 String comparisons are public interfaces
4e4bcf8 Set version to 59
5015cdb Remove obsolete doc/README.md
71c3f0a Fix base64 alphabet
aa2b843 Change Body::size signature (API Change):
80a599a Documentation work
9c19449 Integrated Beast interface.
3f8097b Set version to 58
4581777 Better message formal parameter names
5879cd8 Fix parsing chunk size with leading zeroes
56bd228 Remove redundant code
534ca63 Use static string in basic_fields::reader
a7b3810 basic_parser::put doc
1e4413f basic_fields::set optimization:
9b244c1 Fix basic_fields insert ordering
4f854d0 Avoid std::string in websocket
dc8f146 Renamed to basic_fields::set (API Change):
660c465 Specification for http read
981285b Documentation tidy
983d676 Reorganize examples:
a2a5c57 Qualify size_t in message template
d86769c Fix unaligned reads in utf8-checker
8ba182c Set version to 57
42e2791 Update doc/ for docca
1ee0afd Merge commit '101d7dbfb9725674cb9ce5a4196f19aa1d4bb801' as 'doc/docca'
101d7db Squashed 'doc/docca/' content from commit c50b3ba5
900c04e Documentation work
8eee932 Fix warning in basic_parser.cpp
437a616 Fix message.hpp javadocs
18c68ce Set version to 56
b058e90 Convert buffer in range loops
cbc9212 Add Beast INTERFACE CMake target
2914b59 More basic_parser tests
ed5c317 Reset error codes
ba14251 Test error code handling
e45e50b Tidy up README.md build instructions
16efb9b Try harder to find Boost (cmake)
e281d91 HTTP/1 is the default version
916fe4a Call on_chunk when the extension is empty
9855598 Add string_view_body
19d4520 Tidy up
6e59f9b Add provisional IANA header field names
84722f2 Revert "Add a Beast CMake interface target:"
fde6929 Set version to 55
01f6cc4 Documentation work
a7a388c read_size replaces read_size_helper:
ed8f0bb Tidy up type_traits
c2f6268 Avoid a parser allocation using non-flat buffer:
906db45 Add a Beast CMake interface target:
47f2541 Don't allocate memory to handle obs-fold
6a8912a Set version to 54
296ef3b Documentation work
e3e9b61 Fix incorrect use of [[fallthrough]]
3c44398 Retain ownership when reading using a message
a71bb2b basic_fields refactor (API Change):
d8d3562 Add string_param
83b2558 basic_fields members and coverage
c4f5fa5 consuming_buffers members and coverage
e10507c multi_buffer members and coverage
0e6bd3f flat_buffer coverage
7351d6e static_buffer coverage
18a8ef5 Set version to 53
452df59 Remove extraneous doc file
3ef0359 Fix read_size_helper usage:
b64e6d3 Fix basic_parser::maybe_flatten (#462)
76402f7 Set version to 52
b0ceb2a Add drain_buffer class
4c6735a flat_buffer is an AllocatorAwareContainer
9d5d4d5 Documentation work
d4ec693 finish(error_code&) is a BodyReader requirement (API Change)
7b24cad opcode is private (API Change):
068c2ac Documentation work
a1ff89b Disable std::future snippet for libstdc++ bug
b5ef664 read_frame returns `bool` fin (API Change):
7911847 Remove opcode from read, async_read (API Change):
c72d70f ping_callback is a member of stream (API Change):
720a309 write_buffer_size is a member of stream (API Change):
7ff0178 read_message_max is a member of stream (API Change):
cd40964 read_buffer_size is a member of stream (API Change):
a58e5e1 binary, text are members of stream (API Change):
ad35846 auto_fragment is a member of stream (API Change):
ccee139 Documentation work
13c64e3 Set version to 51
cafc8e2 Fix infinite loop in basic_parser
dc4b69d Add construct, destroy to handler_alloc
58c2739 multi_buffer implementation change (API Change):
dd7f5c0 DynamicBuffer benchmarks
1c4811b Use BOOST_STRINGIZE
31051ac Use BOOST_FALLTHROUGH
8f2430b Documentation work
eb35b92 Fix file_body::get() not setting the more flag correctly
566244a Tidy up file_body
53cbeea Tune up static_buffer (API Change):
20c59b7 Fix operator<< for header
a2c1117 Set version to 50
6045b74 http read_some, async_read_some don't return bytes (API Change):
4df6885 Fix chunk header parsing
36bf32b Fix test::pipe read_size
bf69ce1 Fix chunk delimiter parsing
0c6b6b1 Add missing handler_alloc nested types
a06b8f9 Tidy up message javadoc
3bd8260 Remove obsolete serializer allocator (API Change)
001c979 Remove message free functions (API Change)
745876b Remove message connection settings (API Change)
bcf2c33 Body documentation work
1e303b0 Fields concept work
9d0464a Tidy up basic_fields, header, and concepts
3ba81b5 Use field in basic_parser
b5f6cc1 Use field in basic_fields and call sites
cfd6d14 Documentation reference tidy
2adc80a Protect basic_fields special members (API Change)
d55b079 Fix basic_fields allocator awareness
d8febda Documentation work
485a6e5 Refactor prepare (API Change)
9fd3071 Derive header from Fields (API Change)
8ad26b8 Use allocator more in basic_fields
0071039 Add verb to on_request for parsers (API Change)
74f6cbb Add field enumeration
be0d74f Documentation fixes
054ac40 Remove header_parser (API Change)
a007eba parser is constructible from other body types
d89809f Documentation work (buffer_body)
ac5bc4f Set version to 49
af47128 Documentation work
a1848f0 Add HEAD request example
ddfbfbf Use <iosfwd> instead of <ostream>
e67c0ab Refactor header status, reason, and target (API Change):
60f044a Tidy up empty_body writer error
7d267f4 Canonicalize string_view parameter types
ac175cb Refactor method and verb (API Change):
e18efed Documentation work
d77e423 Set version to 48
d3a5a05 Documentation work
acf18fb Tidy up traits
6cb188e Remove detail::sync_ostream
d6092bc Documentation work
4707b21 Rename to parser (API Change):
3cb385d Consolidate parsers to parser.hpp
290bdf1 Documentation work
7cb442c Make buffer_prefix_view public
ef0b121 Rename to buffer_cat_view (API Change)
b9df187 Tidy up chunk decorator (API Change):
458fa7e Set version to 47
fc83a03 Documentation work
1ee3013 Fix leak in basic_flat_buffer
55fbf76 Fix undefined behavior in pausation
fe75a7c Refactor HTTP serialization and parsing (API Change):
50cba32 buffer_size overload for basic_multi_buffer::const_buffers_type
d977bf2 Disable operator<< for buffer_body
5db707a Refactor treatment of status code and obsolete reason (API Change):
9a585a8 Refactor treatment of request-method (API Change):
3ae76d0 Set version to 46
6004712 Documentation work
34ea0b3 Refactor serialization algorithms:
407b046 Rename to make_serializer
c29451a Refactor type_traits (API Change):
8578419 Refactor HTTP serialization (API Change):
f8612aa Remove HTTP header aliases (API Change):
b0054e3 Add test::pipe
dfba72b Set version to 45
6ba3697 Disable reverse_iterator buffer_view test
266ebac buffer_view skips empty buffer sequences
96b9892 Documentation work
c23f1e2 Fix header::reason
9796106 Better test::enable_yield_to
9a8bcb7 Fix message doc image
7a5e87e Workaround for boost::asio::basic_streambuf type check
663c275 Set version to 44
f205976 Make buffers_adapter meet requirements
8e39c60 Tidy up is_dynamic_buffer traits test
0088f7c Add buffers_adapter regression test
8a23de1 Fix README websocket example
949504a Fix async return values in docs
cd9f41b Use BOOST_STATIC_ASSERT
1b616fa Tidy up and make get_lowest_layer public
612e616 Require Boost 1.58 or later
1b1daa7 Tidy up read_size_helper and dynamic buffers
bf0145d Use BOOST_THROW_EXCEPTION
e762818 Add GitHub issue template
dab679c Set version to 43
386b817 Reformat README.md QR code
50e5123 Additional constructors for consuming_buffers
f7289b9 Add write limit to test::string_ostream
3aa87e0 Tidy up buffer_prefix overloads and test
bee583c Fix strict aliasing warnings in buffers_view
6b54d3a Require Boost 1.64.0
76f1084 Set version to 42
0bdb148 Make buffers_view a public interface
338fc81 Add formal review notes
784f965 Fix javadoc typo
823aee2 Set version to v41
88adbdd Remove handler helpers, tidy up hook invocations (API Change)
4974af2 Rename prepare_buffer(s) to buffer_prefix (API Change)
ebd459b Tidy up websocket::close_code enum and constructors
c3fd6f9 Tidy up formal parameter names
210cd70 Remove coveralls integration
d811962 Concept revision and documentation (API Change):
bdae92a Replace asynchronous helper macros with template aliases (API Change)
df95a09 Move prepare_buffers to prepare_buffer.hpp (API Change)
787de21 Remove placeholders (API Change)
c59b544 Trim Appveyor matrix rows
b7184f3 Return http::error::end_of_stream on HTTP read eof (API Change)
f2d8255 Set version to 40
40b9194 Tidy up .travis.yml:
9b240c7 Fix basic_streambuf movable trait
76a2617 Consolidate get_lowest_layer in type_traits.hpp
6d00321 Add to_static_string:
f888136 Set version to 39
47c82b5 Better travis deps
4ed7865 Squelch openssl spurious leak and memory errors
b6bc26f Fixed braced-init error with older gcc
59b2f8f ostream workaround for gcc 4.8.4
8363d86 Increase ostream test coverage
5631936 Tidy up HTTP reason_string (API Change):
2bf5150 Harmonize concepts and identifiers with net-ts (API Change):
728e9d8 Tidy up basic_parser javadocs
1c9067b Use beast::string_view alias
771c5ca Doc fixes and tidying
e2b5c31 Rename to buffered_read_stream (API Change):
a753f1c Rename to static_buffer, static_buffer_n (API Change):
24b6686 Rename to flat_buffer, basic_flat_buffer (API Change):
69259ef Rename to multi_buffer, basic_multi_buffer (API Change):
bef9ae1 New buffers() replaces to_string() (API Change):
a7ef4f5 New ostream() returns dynamic buffer output stream (API Change):
87fd60c Fix eof error on ssl::stream shutdown
606fc9d Add websocket async echo ssl server test:
ff5e659 Refactor http::header contents (API Change):
dd02097 Set version to 1.0.0-b38
5596e97 Prevent basic_fields operator[] assignment
c2b32dc Remove websocket::keep_alive option (API Change):
32dbfb2 Refactor WebSocket error codes (API Change):
dd6b500 WebSocket doc work
0b4d87c More flat_streambuf tests
aacefb4 Add test_allocator to extras/test
931a5fb Simplify get_lowest_layer test
ba4228a Use static_string for WebSocket handshakes:
6df3ff3 Refactor base64:
19b124d Refactor static_string:
30e8d16 Set version to 1.0.0-b37
b141020 Fix narrowing warning in table constants
d554b81 Add -funsigned-char to asan build target
bcc6ad8 Add ub sanitizer blacklist
e1f08e9 Fix flat_streambuf:
7d08f59 Fix typo in documentation example
21ef97d Rename to http::dynamic_body, consolidate header:
45a2d73 Rename project to http-bench
c86fee9 Move everything in basic_fields.hpp to fields.hpp (API Change)
a14a5d6 Rename to detail::is_invocable
540d037 Rename to websocket::detail::pausation
84e1739 Document websocket::stream thread safety
dc274af Add is_upgrade() free function:
2c17d04 Refactor websocket decorators (API Change):
235fe68 Provide websocket::stream accept() overloads (API Change):
a715825 CMake hide command lines in .vcxproj Output windows
32024d8 Set version to 1.0.0-b36
f48b95f Update README.md
d8db5f1 Set version to 1.0.0-b35
dd2a514 Tidy up doc declarations
2c50aba Fix README.md CMake instructions
4ffdce2 Update .gitignore for VS2017
403011f Remove http::empty_body (API Change)
f47b661 New HTTP interfaces (API Change):
f6835b8 Rename to BEAST_DOXYGEN
7e37723 Add flat_streambuf:
5b68faa Doc XSL support for list and table markdown
3de46de Make websocket::close_code a proper enum:
0128743 Tidy up MSVC CMake configuration
ccd188e Add appveyor build script

git-subtree-dir: src/beast
git-subtree-split: 3bcd9865f80f12ba5faad35c564918f85b02e271
This commit is contained in:
Miguel Portilla
2017-07-11 12:17:02 -04:00
parent d8dea963fa
commit f0f96bd1da
487 changed files with 60952 additions and 23793 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
include/beast/websocket/detail/debug.hpp
View File

@@ -1,75 +0,0 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_DETAIL_DEBUG_HPP
#define BEAST_WEBSOCKET_DETAIL_DEBUG_HPP
#include <boost/asio/buffer.hpp>
#include <iomanip>
#include <sstream>
#include <string>
namespace beast {
namespace websocket {
namespace detail {
template<class = void>
std::string
to_hex(boost::asio::const_buffer b)
{
using namespace boost::asio;
std::stringstream ss;
auto p = buffer_cast<std::uint8_t const*>(b);
auto n = buffer_size(b);
while(n--)
{
ss <<
std::setfill('0') <<
std::setw(2) <<
std::hex << int(*p++) << " ";
}
return ss.str();
}
template<class Buffers>
std::string
to_hex(Buffers const& bs)
{
std::string s;
for(auto const& b : bs)
s.append(to_hex(boost::asio::const_buffer(b)));
return s;
}
template<class Buffers>
std::string
buffers_to_string(Buffers const& bs)
{
using namespace boost::asio;
std::string s;
s.reserve(buffer_size(bs));
for(auto const& b : bs)
s.append(buffer_cast<char const*>(b),
buffer_size(b));
return s;
}
template<class = void>
std::string
format(std::string s)
{
auto const w = 84;
for(int n = w*(s.size()/w); n>0; n-=w)
s.insert(n, 1, '\n');
return s;
}
} // detail
} // websocket
} // beast
#endif

167
include/beast/websocket/detail/decorator.hpp
View File

@@ -1,167 +0,0 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_DETAIL_DECORATOR_HPP
#define BEAST_WEBSOCKET_DETAIL_DECORATOR_HPP
#include <beast/http/empty_body.hpp>
#include <beast/http/message.hpp>
#include <beast/http/string_body.hpp>
#include <beast/version.hpp>
#include <type_traits>
#include <utility>
namespace beast {
namespace websocket {
namespace detail {
using request_type = http::request<http::empty_body>;
using response_type = http::response<http::string_body>;
struct abstract_decorator
{
virtual
~abstract_decorator() = default;
virtual
void
operator()(request_type& req) const = 0;
virtual
void
operator()(response_type& res) const = 0;
};
template<class F>
class decorator : public abstract_decorator
{
F f_;
class call_req_possible
{
template<class U, class R = decltype(
std::declval<U const>().operator()(
std::declval<request_type&>()),
std::true_type{})>
static R check(int);
template<class>
static std::false_type check(...);
public:
using type = decltype(check<F>(0));
};
class call_res_possible
{
template<class U, class R = decltype(
std::declval<U const>().operator()(
std::declval<response_type&>()),
std::true_type{})>
static R check(int);
template<class>
static std::false_type check(...);
public:
using type = decltype(check<F>(0));
};
public:
decorator(F&& t)
: f_(std::move(t))
{
}
decorator(F const& t)
: f_(t)
{
}
void
operator()(request_type& req) const override
{
(*this)(req, typename call_req_possible::type{});
}
void
operator()(response_type& res) const override
{
(*this)(res, typename call_res_possible::type{});
}
private:
void
operator()(request_type& req, std::true_type) const
{
f_(req);
}
void
operator()(request_type& req, std::false_type) const
{
req.fields.replace("User-Agent",
std::string{"Beast/"} + BEAST_VERSION_STRING);
}
void
operator()(response_type& res, std::true_type) const
{
f_(res);
}
void
operator()(response_type& res, std::false_type) const
{
res.fields.replace("Server",
std::string{"Beast/"} + BEAST_VERSION_STRING);
}
};
class decorator_type
{
std::shared_ptr<abstract_decorator> p_;
public:
decorator_type() = delete;
decorator_type(decorator_type&&) = default;
decorator_type(decorator_type const&) = default;
decorator_type& operator=(decorator_type&&) = default;
decorator_type& operator=(decorator_type const&) = default;
template<class F, class =
typename std::enable_if<! std::is_same<
typename std::decay<F>::type,
decorator_type>::value>>
decorator_type(F&& f)
: p_(std::make_shared<decorator<F>>(
std::forward<F>(f)))
{
BOOST_ASSERT(p_);
}
void
operator()(request_type& req)
{
(*p_)(req);
BOOST_ASSERT(p_);
}
void
operator()(response_type& res)
{
(*p_)(res);
BOOST_ASSERT(p_);
}
};
struct default_decorator
{
};
} // detail
} // websocket
} // beast
#endif

71
include/beast/websocket/detail/endian.hpp
View File

@@ -1,71 +0,0 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_DETAIL_ENDIAN_HPP
#define BEAST_WEBSOCKET_DETAIL_ENDIAN_HPP
#include <cstdint>
namespace beast {
namespace websocket {
namespace detail {
inline
std::uint16_t
big_uint16_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return (p[0]<<8) + p[1];
}
inline
std::uint64_t
big_uint64_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return
(static_cast<std::uint64_t>(p[0])<<56) +
(static_cast<std::uint64_t>(p[1])<<48) +
(static_cast<std::uint64_t>(p[2])<<40) +
(static_cast<std::uint64_t>(p[3])<<32) +
(static_cast<std::uint64_t>(p[4])<<24) +
(static_cast<std::uint64_t>(p[5])<<16) +
(static_cast<std::uint64_t>(p[6])<< 8) +
p[7];
}
inline
std::uint32_t
little_uint32_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return
p[0] +
(static_cast<std::uint32_t>(p[1])<< 8) +
(static_cast<std::uint32_t>(p[2])<<16) +
(static_cast<std::uint32_t>(p[3])<<24);
}
inline
void
native_to_little_uint32(std::uint32_t v, void* buf)
{
auto p = reinterpret_cast<std::uint8_t*>(buf);
p[0] = v & 0xff;
p[1] = (v >> 8) & 0xff;
p[2] = (v >> 16) & 0xff;
p[3] = (v >> 24) & 0xff;
}
} // detail
} // websocket
} // beast
#endif

118
include/beast/websocket/detail/frame.hpp
View File

@@ -9,10 +9,9 @@
#define BEAST_WEBSOCKET_DETAIL_FRAME_HPP
#include <beast/websocket/rfc6455.hpp>
#include <beast/websocket/detail/endian.hpp>
#include <beast/websocket/detail/utf8_checker.hpp>
#include <beast/core/consuming_buffers.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/static_buffer.hpp>
#include <beast/core/static_string.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/assert.hpp>
@@ -23,6 +22,77 @@ namespace beast {
namespace websocket {
namespace detail {
inline
std::uint16_t
big_uint16_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return (p[0]<<8) + p[1];
}
inline
std::uint64_t
big_uint64_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return
(static_cast<std::uint64_t>(p[0])<<56) +
(static_cast<std::uint64_t>(p[1])<<48) +
(static_cast<std::uint64_t>(p[2])<<40) +
(static_cast<std::uint64_t>(p[3])<<32) +
(static_cast<std::uint64_t>(p[4])<<24) +
(static_cast<std::uint64_t>(p[5])<<16) +
(static_cast<std::uint64_t>(p[6])<< 8) +
p[7];
}
inline
std::uint32_t
little_uint32_to_native(void const* buf)
{
auto const p = reinterpret_cast<
std::uint8_t const*>(buf);
return
p[0] +
(static_cast<std::uint32_t>(p[1])<< 8) +
(static_cast<std::uint32_t>(p[2])<<16) +
(static_cast<std::uint32_t>(p[3])<<24);
}
inline
void
native_to_little_uint32(std::uint32_t v, void* buf)
{
auto p = reinterpret_cast<std::uint8_t*>(buf);
p[0] = v & 0xff;
p[1] = (v >> 8) & 0xff;
p[2] = (v >> 16) & 0xff;
p[3] = (v >> 24) & 0xff;
}
/** WebSocket frame header opcodes. */
enum class opcode : std::uint8_t
{
cont = 0,
text = 1,
binary = 2,
rsv3 = 3,
rsv4 = 4,
rsv5 = 5,
rsv6 = 6,
rsv7 = 7,
close = 8,
ping = 9,
pong = 10,
crsvb = 11,
crsvc = 12,
crsvd = 13,
crsve = 14,
crsvf = 15
};
// Contents of a WebSocket frame header
struct frame_header
{
@@ -38,11 +108,11 @@ struct frame_header
// holds the largest possible frame header
using fh_streambuf =
static_streambuf_n<14>;
static_buffer_n<14>;
// holds the largest possible control frame
using frame_streambuf =
static_streambuf_n< 2 + 8 + 4 + 125 >;
static_buffer_n< 2 + 8 + 4 + 125 >;
inline
bool constexpr
@@ -67,33 +137,31 @@ is_control(opcode op)
return op >= opcode::close;
}
// Returns `true` if a close code is valid
inline
bool
is_valid(close_code::value code)
is_valid_close_code(std::uint16_t v)
{
auto const v = code;
switch(v)
{
case 1000:
case 1001:
case 1002:
case 1003:
case 1007:
case 1008:
case 1009:
case 1010:
case 1011:
case 1012:
case 1013:
case close_code::normal: // 1000
case close_code::going_away: // 1001
case close_code::protocol_error: // 1002
case close_code::unknown_data: // 1003
case close_code::bad_payload: // 1007
case close_code::policy_error: // 1008
case close_code::too_big: // 1009
case close_code::needs_extension: // 1010
case close_code::internal_error: // 1011
case close_code::service_restart: // 1012
case close_code::try_again_later: // 1013
return true;
// explicitly reserved
case 1004:
case 1005:
case 1006:
case 1014:
case 1015:
case close_code::reserved1: // 1004
case close_code::no_status: // 1005
case close_code::abnormal: // 1006
case close_code::reserved2: // 1014
case close_code::reserved3: // 1015
return false;
}
// reserved
@@ -175,7 +243,7 @@ read(ping_data& data, Buffers const& bs)
template<class Buffers>
void
read(close_reason& cr,
Buffers const& bs, close_code::value& code)
Buffers const& bs, close_code& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
@@ -201,7 +269,7 @@ read(close_reason& cr,
cr.code = big_uint16_to_native(&b[0]);
cb.consume(2);
n -= 2;
if(! is_valid(cr.code))
if(! is_valid_close_code(cr.code))
{
code = close_code::protocol_error;
return;

43
include/beast/websocket/detail/hybi13.hpp
View File

@@ -8,9 +8,11 @@
#ifndef BEAST_WEBSOCKET_DETAIL_HYBI13_HPP
#define BEAST_WEBSOCKET_DETAIL_HYBI13_HPP
#include <beast/core/static_string.hpp>
#include <beast/core/string.hpp>
#include <beast/core/detail/base64.hpp>
#include <beast/core/detail/sha1.hpp>
#include <boost/utility/string_ref.hpp>
#include <boost/assert.hpp>
#include <array>
#include <cstdint>
#include <string>
@@ -20,11 +22,17 @@ namespace beast {
namespace websocket {
namespace detail {
using sec_ws_key_type = static_string<
beast::detail::base64::encoded_size(16)>;
using sec_ws_accept_type = static_string<
beast::detail::base64::encoded_size(20)>;
template<class Gen>
std::string
make_sec_ws_key(Gen& g)
void
make_sec_ws_key(sec_ws_key_type& key, Gen& g)
{
std::array<std::uint8_t, 16> a;
char a[16];
for(int i = 0; i < 16; i += 4)
{
auto const v = g();
@@ -33,24 +41,27 @@ make_sec_ws_key(Gen& g)
a[i+2] = (v >> 16) & 0xff;
a[i+3] = (v >> 24) & 0xff;
}
return beast::detail::base64_encode(
a.data(), a.size());
key.resize(key.max_size());
key.resize(beast::detail::base64::encode(
key.data(), &a[0], 16));
}
template<class = void>
std::string
make_sec_ws_accept(boost::string_ref const& key)
void
make_sec_ws_accept(sec_ws_accept_type& accept,
string_view key)
{
std::string s(key.data(), key.size());
s += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
BOOST_ASSERT(key.size() <= sec_ws_key_type::max_size_n);
static_string<sec_ws_key_type::max_size_n + 36> m(key);
m.append("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
beast::detail::sha1_context ctx;
beast::detail::init(ctx);
beast::detail::update(ctx, s.data(), s.size());
std::array<std::uint8_t,
beast::detail::sha1_context::digest_size> digest;
beast::detail::finish(ctx, digest.data());
return beast::detail::base64_encode(
digest.data(), digest.size());
beast::detail::update(ctx, m.data(), m.size());
char digest[beast::detail::sha1_context::digest_size];
beast::detail::finish(ctx, &digest[0]);
accept.resize(accept.max_size());
accept.resize(beast::detail::base64::encode(
accept.data(), &digest[0], sizeof(digest)));
}
} // detail

2
include/beast/websocket/detail/mask.hpp
View File

@@ -254,7 +254,7 @@ void
mask_inplace(
MutableBuffers const& bs, KeyType& key)
{
for(auto const& b : bs)
for(boost::asio::mutable_buffer b : bs)
mask_inplace(b, key);
}

47
include/beast/websocket/detail/invokable.hpp → include/beast/websocket/detail/pausation.hpp
View File

@@ -5,8 +5,8 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BEAST_WEBSOCKET_DETAIL_INVOKABLE_HPP
#define BEAST_WEBSOCKET_DETAIL_INVOKABLE_HPP
#ifndef BEAST_WEBSOCKET_DETAIL_PAUSATION_HPP
#define BEAST_WEBSOCKET_DETAIL_PAUSATION_HPP
#include <beast/core/handler_ptr.hpp>
#include <boost/assert.hpp>
@@ -19,16 +19,18 @@ namespace beast {
namespace websocket {
namespace detail {
// "Parks" a composed operation, to invoke later
// A container that holds a suspended, asynchronous composed
// operation. The contained object may be invoked later to
// resume the operation, or the container may be destroyed.
//
class invokable
class pausation
{
struct base
{
base() = default;
base(base &&) = default;
virtual ~base() = default;
virtual void move(void* p) = 0;
virtual base* move(void* p) = 0;
virtual void operator()() = 0;
};
@@ -46,10 +48,10 @@ class invokable
{
}
void
base*
move(void* p) override
{
::new(p) holder(std::move(*this));
return ::new(p) holder(std::move(*this));
}
void
@@ -58,7 +60,7 @@ class invokable
F f_(std::move(f));
this->~holder();
// invocation of f_() can
// assign a new invokable.
// assign a new object to *this.
f_();
}
};
@@ -86,38 +88,34 @@ class invokable
alignas(holder<exemplar>) buf_type buf_;
public:
~invokable()
~pausation()
{
if(base_)
base_->~base();
}
invokable() = default;
pausation() = default;
invokable(invokable&& other)
pausation(pausation&& other)
{
if(other.base_)
{
// type-pun
base_ = reinterpret_cast<base*>(&buf_[0]);
other.base_->move(buf_);
base_ = other.base_->move(buf_);
other.base_ = nullptr;
}
}
invokable&
operator=(invokable&& other)
pausation&
operator=(pausation&& other)
{
// Engaged invokables must be invoked before
// Engaged pausations must be invoked before
// assignment otherwise the io_service
// completion invariants are broken.
BOOST_ASSERT(! base_);
if(other.base_)
{
// type-pun
base_ = reinterpret_cast<base*>(&buf_[0]);
other.base_->move(buf_);
base_ = other.base_->move(buf_);
other.base_ = nullptr;
}
return *this;
@@ -143,14 +141,13 @@ public:
template<class F>
void
invokable::emplace(F&& f)
pausation::emplace(F&& f)
{
static_assert(sizeof(buf_type) >= sizeof(holder<F>),
using type = holder<typename std::decay<F>::type>;
static_assert(sizeof(buf_type) >= sizeof(type),
"buffer too small");
BOOST_ASSERT(! base_);
::new(buf_) holder<F>(std::forward<F>(f));
// type-pun
base_ = reinterpret_cast<base*>(&buf_[0]);
base_ = ::new(buf_) type{std::forward<F>(f)};
}
} // detail

64
include/beast/websocket/detail/pmd_extension.hpp
View File

@@ -10,7 +10,7 @@
#include <beast/core/error.hpp>
#include <beast/core/consuming_buffers.hpp>
#include <beast/core/detail/ci_char_traits.hpp>
#include <beast/core/read_size.hpp>
#include <beast/zlib/deflate_stream.hpp>
#include <beast/zlib/inflate_stream.hpp>
#include <beast/websocket/option.hpp>
@@ -46,7 +46,7 @@ struct pmd_offer
template<class = void>
int
parse_bits(boost::string_ref const& s)
parse_bits(string_view s)
{
if(s.size() == 0)
return -1;
@@ -66,9 +66,10 @@ parse_bits(boost::string_ref const& s)
// Parse permessage-deflate request fields
//
template<class Fields>
template<class Allocator>
void
pmd_read(pmd_offer& offer, Fields const& fields)
pmd_read(pmd_offer& offer,
http::basic_fields<Allocator> const& fields)
{
offer.accept = false;
offer.server_max_window_bits= 0;
@@ -76,16 +77,15 @@ pmd_read(pmd_offer& offer, Fields const& fields)
offer.server_no_context_takeover = false;
offer.client_no_context_takeover = false;
using beast::detail::ci_equal;
http::ext_list list{
fields["Sec-WebSocket-Extensions"]};
for(auto const& ext : list)
{
if(ci_equal(ext.first, "permessage-deflate"))
if(iequals(ext.first, "permessage-deflate"))
{
for(auto const& param : ext.second)
{
if(ci_equal(param.first,
if(iequals(param.first,
"server_max_window_bits"))
{
if(offer.server_max_window_bits != 0)
@@ -113,7 +113,7 @@ pmd_read(pmd_offer& offer, Fields const& fields)
return; // MUST decline
}
}
else if(ci_equal(param.first,
else if(iequals(param.first,
"client_max_window_bits"))
{
if(offer.client_max_window_bits != 0)
@@ -141,7 +141,7 @@ pmd_read(pmd_offer& offer, Fields const& fields)
offer.client_max_window_bits = -1;
}
}
else if(ci_equal(param.first,
else if(iequals(param.first,
"server_no_context_takeover"))
{
if(offer.server_no_context_takeover)
@@ -160,7 +160,7 @@ pmd_read(pmd_offer& offer, Fields const& fields)
}
offer.server_no_context_takeover = true;
}
else if(ci_equal(param.first,
else if(iequals(param.first,
"client_no_context_takeover"))
{
if(offer.client_no_context_takeover)
@@ -195,18 +195,19 @@ pmd_read(pmd_offer& offer, Fields const& fields)
// Set permessage-deflate fields for a client offer
//
template<class Fields>
template<class Allocator>
void
pmd_write(Fields& fields, pmd_offer const& offer)
pmd_write(http::basic_fields<Allocator>& fields,
pmd_offer const& offer)
{
std::string s;
static_string<512> s;
s = "permessage-deflate";
if(offer.server_max_window_bits != 0)
{
if(offer.server_max_window_bits != -1)
{
s += "; server_max_window_bits=";
s += std::to_string(
s += to_static_string(
offer.server_max_window_bits);
}
else
@@ -219,7 +220,7 @@ pmd_write(Fields& fields, pmd_offer const& offer)
if(offer.client_max_window_bits != -1)
{
s += "; client_max_window_bits=";
s += std::to_string(
s += to_static_string(
offer.client_max_window_bits);
}
else
@@ -235,15 +236,15 @@ pmd_write(Fields& fields, pmd_offer const& offer)
{
s += "; client_no_context_takeover";
}
fields.replace("Sec-WebSocket-Extensions", s);
fields.set(http::field::sec_websocket_extensions, s);
}
// Negotiate a permessage-deflate client offer
//
template<class Fields>
template<class Allocator>
void
pmd_negotiate(
Fields& fields,
http::basic_fields<Allocator>& fields,
pmd_offer& config,
pmd_offer const& offer,
permessage_deflate const& o)
@@ -255,7 +256,7 @@ pmd_negotiate(
}
config.accept = true;
std::string s = "permessage-deflate";
static_string<512> s = "permessage-deflate";
config.server_no_context_takeover =
offer.server_no_context_takeover ||
@@ -285,7 +286,7 @@ pmd_negotiate(
config.server_max_window_bits = 9;
s += "; server_max_window_bits=";
s += std::to_string(
s += to_static_string(
config.server_max_window_bits);
}
@@ -298,7 +299,7 @@ pmd_negotiate(
if(config.client_max_window_bits < 15)
{
s += "; client_max_window_bits=";
s += std::to_string(
s += to_static_string(
config.client_max_window_bits);
}
break;
@@ -323,12 +324,12 @@ pmd_negotiate(
o.client_max_window_bits,
offer.client_max_window_bits);
s += "; client_max_window_bits=";
s += std::to_string(
s += to_static_string(
config.client_max_window_bits);
break;
}
if(config.accept)
fields.replace("Sec-WebSocket-Extensions", s);
fields.set(http::field::sec_websocket_extensions, s);
}
// Normalize the server's response
@@ -356,7 +357,7 @@ template<class InflateStream, class DynamicBuffer>
void
inflate(
InflateStream& zi,
DynamicBuffer& dynabuf,
DynamicBuffer& buffer,
boost::asio::const_buffer const& in,
error_code& ec)
{
@@ -368,18 +369,18 @@ inflate(
for(;;)
{
// VFALCO we could be smarter about the size
auto const bs = dynabuf.prepare(
read_size_helper(dynabuf, 65536));
auto const bs = buffer.prepare(
read_size_or_throw(buffer, 65536));
auto const out = *bs.begin();
zs.avail_out = buffer_size(out);
zs.next_out = buffer_cast<void*>(out);
zi.write(zs, zlib::Flush::sync, ec);
dynabuf.commit(zs.total_out);
buffer.commit(zs.total_out);
zs.total_out = 0;
if( ec == zlib::error::need_buffers ||
ec == zlib::error::end_of_stream)
{
ec = {};
ec.assign(0, ec.category());
break;
}
if(ec)
@@ -408,7 +409,7 @@ deflate(
zs.next_in = nullptr;
zs.avail_out = buffer_size(out);
zs.next_out = buffer_cast<void*>(out);
for(auto const& in : cb)
for(boost::asio::const_buffer in : cb)
{
zs.avail_in = buffer_size(in);
if(zs.avail_in == 0)
@@ -421,7 +422,7 @@ deflate(
return false;
BOOST_ASSERT(zs.avail_out == 0);
BOOST_ASSERT(zs.total_out == buffer_size(out));
ec = {};
ec.assign(0, ec.category());
break;
}
if(zs.avail_out == 0)
@@ -445,7 +446,7 @@ deflate(
zo.write(zs, zlib::Flush::block, ec);
BOOST_ASSERT(! ec || ec == zlib::error::need_buffers);
if(ec == zlib::error::need_buffers)
ec = {};
ec.assign(0, ec.category());
if(ec)
return false;
if(zs.avail_out >= 6)
@@ -460,6 +461,7 @@ deflate(
}
}
}
ec.assign(0, ec.category());
out = buffer(
buffer_cast<void*>(out), zs.total_out);
return true;

568
include/beast/websocket/detail/stream_base.hpp
View File

@@ -1,568 +0,0 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_DETAIL_STREAM_BASE_HPP
#define BEAST_WEBSOCKET_DETAIL_STREAM_BASE_HPP
#include <beast/websocket/error.hpp>
#include <beast/websocket/option.hpp>
#include <beast/websocket/rfc6455.hpp>
#include <beast/websocket/detail/decorator.hpp>
#include <beast/websocket/detail/frame.hpp>
#include <beast/websocket/detail/invokable.hpp>
#include <beast/websocket/detail/mask.hpp>
#include <beast/websocket/detail/pmd_extension.hpp>
#include <beast/websocket/detail/utf8_checker.hpp>
#include <beast/http/empty_body.hpp>
#include <beast/http/message.hpp>
#include <beast/http/string_body.hpp>
#include <beast/zlib/deflate_stream.hpp>
#include <beast/zlib/inflate_stream.hpp>
#include <boost/asio/error.hpp>
#include <boost/assert.hpp>
#include <cstdint>
#include <memory>
namespace beast {
namespace websocket {
namespace detail {
/// Identifies the role of a WebSockets stream.
enum class role_type
{
/// Stream is operating as a client.
client,
/// Stream is operating as a server.
server
};
//------------------------------------------------------------------------------
struct stream_base
{
protected:
friend class frame_test;
struct op {};
detail::maskgen maskgen_; // source of mask keys
decorator_type d_; // adorns http messages
bool keep_alive_ = false; // close on failed upgrade
std::size_t rd_msg_max_ =
16 * 1024 * 1024; // max message size
bool wr_autofrag_ = true; // auto fragment
std::size_t wr_buf_size_ = 4096; // write buffer size
std::size_t rd_buf_size_ = 4096; // read buffer size
opcode wr_opcode_ = opcode::text; // outgoing message type
ping_cb ping_cb_; // ping callback
role_type role_; // server or client
bool failed_; // the connection failed
bool wr_close_; // sent close frame
op* wr_block_; // op currenly writing
ping_data* ping_data_; // where to put the payload
invokable rd_op_; // read parking
invokable wr_op_; // write parking
invokable ping_op_; // ping parking
close_reason cr_; // set from received close frame
// State information for the message being received
//
struct rd_t
{
// opcode of current message being read
opcode op;
// `true` if the next frame is a continuation.
bool cont;
// Checks that test messages are valid utf8
detail::utf8_checker utf8;
// Size of the current message so far.
std::uint64_t size;
// Size of the read buffer.
// This gets set to the read buffer size option at the
// beginning of sending a message, so that the option can be
// changed mid-send without affecting the current message.
std::size_t buf_size;
// The read buffer. Used for compression and masking.
std::unique_ptr<std::uint8_t[]> buf;
};
rd_t rd_;
// State information for the message being sent
//
struct wr_t
{
// `true` if next frame is a continuation,
// `false` if next frame starts a new message
bool cont;
// `true` if this message should be auto-fragmented
// This gets set to the auto-fragment option at the beginning
// of sending a message, so that the option can be changed
// mid-send without affecting the current message.
bool autofrag;
// `true` if this message should be compressed.
// This gets set to the compress option at the beginning of
// of sending a message, so that the option can be changed
// mid-send without affecting the current message.
bool compress;
// Size of the write buffer.
// This gets set to the write buffer size option at the
// beginning of sending a message, so that the option can be
// changed mid-send without affecting the current message.
std::size_t buf_size;
// The write buffer. Used for compression and masking.
// The buffer is allocated or reallocated at the beginning of
// sending a message.
std::unique_ptr<std::uint8_t[]> buf;
};
wr_t wr_;
// State information for the permessage-deflate extension
struct pmd_t
{
// `true` if current read message is compressed
bool rd_set;
zlib::deflate_stream zo;
zlib::inflate_stream zi;
};
// If not engaged, then permessage-deflate is not
// enabled for the currently active session.
std::unique_ptr<pmd_t> pmd_;
// Local options for permessage-deflate
permessage_deflate pmd_opts_;
// Offer for clients, negotiated result for servers
pmd_offer pmd_config_;
stream_base(stream_base&&) = default;
stream_base(stream_base const&) = delete;
stream_base& operator=(stream_base&&) = default;
stream_base& operator=(stream_base const&) = delete;
stream_base()
: d_(detail::default_decorator{})
{
}
template<class = void>
void
open(role_type role);
template<class = void>
void
close();
template<class DynamicBuffer>
std::size_t
read_fh1(detail::frame_header& fh,
DynamicBuffer& db, close_code::value& code);
template<class DynamicBuffer>
void
read_fh2(detail::frame_header& fh,
DynamicBuffer& db, close_code::value& code);
// Called before receiving the first frame of each message
template<class = void>
void
rd_begin();
// Called before sending the first frame of each message
//
template<class = void>
void
wr_begin();
template<class DynamicBuffer>
void
write_close(DynamicBuffer& db, close_reason const& rc);
template<class DynamicBuffer>
void
write_ping(DynamicBuffer& db, opcode op, ping_data const& data);
};
template<class>
void
stream_base::
open(role_type role)
{
// VFALCO TODO analyze and remove dupe code in reset()
role_ = role;
failed_ = false;
rd_.cont = false;
wr_close_ = false;
wr_block_ = nullptr; // should be nullptr on close anyway
ping_data_ = nullptr; // should be nullptr on close anyway
wr_.cont = false;
wr_.buf_size = 0;
if(((role_ == role_type::client && pmd_opts_.client_enable) ||
(role_ == role_type::server && pmd_opts_.server_enable)) &&
pmd_config_.accept)
{
pmd_normalize(pmd_config_);
pmd_.reset(new pmd_t);
if(role_ == role_type::client)
{
pmd_->zi.reset(
pmd_config_.server_max_window_bits);
pmd_->zo.reset(
pmd_opts_.compLevel,
pmd_config_.client_max_window_bits,
pmd_opts_.memLevel,
zlib::Strategy::normal);
}
else
{
pmd_->zi.reset(
pmd_config_.client_max_window_bits);
pmd_->zo.reset(
pmd_opts_.compLevel,
pmd_config_.server_max_window_bits,
pmd_opts_.memLevel,
zlib::Strategy::normal);
}
}
}
template<class>
void
stream_base::
close()
{
rd_.buf.reset();
wr_.buf.reset();
pmd_.reset();
}
// Read fixed frame header from buffer
// Requires at least 2 bytes
//
template<class DynamicBuffer>
std::size_t
stream_base::
read_fh1(detail::frame_header& fh,
DynamicBuffer& db, close_code::value& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
auto const err =
[&](close_code::value cv)
{
code = cv;
return 0;
};
std::uint8_t b[2];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
std::size_t need;
fh.len = b[1] & 0x7f;
switch(fh.len)
{
case 126: need = 2; break;
case 127: need = 8; break;
default:
need = 0;
}
fh.mask = (b[1] & 0x80) != 0;
if(fh.mask)
need += 4;
fh.op = static_cast<opcode>(b[0] & 0x0f);
fh.fin = (b[0] & 0x80) != 0;
fh.rsv1 = (b[0] & 0x40) != 0;
fh.rsv2 = (b[0] & 0x20) != 0;
fh.rsv3 = (b[0] & 0x10) != 0;
switch(fh.op)
{
case opcode::binary:
case opcode::text:
if(rd_.cont)
{
// new data frame when continuation expected
return err(close_code::protocol_error);
}
if((fh.rsv1 && ! pmd_) ||
fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
if(pmd_)
pmd_->rd_set = fh.rsv1;
break;
case opcode::cont:
if(! rd_.cont)
{
// continuation without an active message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
default:
if(is_reserved(fh.op))
{
// reserved opcode
return err(close_code::protocol_error);
}
if(! fh.fin)
{
// fragmented control message
return err(close_code::protocol_error);
}
if(fh.len > 125)
{
// invalid length for control message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
}
// unmasked frame from client
if(role_ == role_type::server && ! fh.mask)
{
code = close_code::protocol_error;
return 0;
}
// masked frame from server
if(role_ == role_type::client && fh.mask)
{
code = close_code::protocol_error;
return 0;
}
code = close_code::none;
return need;
}
// Decode variable frame header from buffer
//
template<class DynamicBuffer>
void
stream_base::
read_fh2(detail::frame_header& fh,
DynamicBuffer& db, close_code::value& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
using namespace boost::endian;
switch(fh.len)
{
case 126:
{
std::uint8_t b[2];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.len = big_uint16_to_native(&b[0]);
// length not canonical
if(fh.len < 126)
{
code = close_code::protocol_error;
return;
}
break;
}
case 127:
{
std::uint8_t b[8];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.len = big_uint64_to_native(&b[0]);
// length not canonical
if(fh.len < 65536)
{
code = close_code::protocol_error;
return;
}
break;
}
}
if(fh.mask)
{
std::uint8_t b[4];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.key = little_uint32_to_native(&b[0]);
}
else
{
// initialize this otherwise operator== breaks
fh.key = 0;
}
if(! is_control(fh.op))
{
if(fh.op != opcode::cont)
{
rd_.size = 0;
rd_.op = fh.op;
}
else
{
if(rd_.size > (std::numeric_limits<
std::uint64_t>::max)() - fh.len)
{
code = close_code::too_big;
return;
}
}
rd_.cont = ! fh.fin;
}
code = close_code::none;
}
template<class>
void
stream_base::
rd_begin()
{
// Maintain the read buffer
if(pmd_)
{
if(! rd_.buf || rd_.buf_size != rd_buf_size_)
{
rd_.buf_size = rd_buf_size_;
rd_.buf.reset(new std::uint8_t[rd_.buf_size]);
}
}
}
template<class>
void
stream_base::
wr_begin()
{
wr_.autofrag = wr_autofrag_;
wr_.compress = static_cast<bool>(pmd_);
// Maintain the write buffer
if( wr_.compress ||
role_ == detail::role_type::client)
{
if(! wr_.buf || wr_.buf_size != wr_buf_size_)
{
wr_.buf_size = wr_buf_size_;
wr_.buf.reset(new std::uint8_t[wr_.buf_size]);
}
}
else
{
wr_.buf_size = wr_buf_size_;
wr_.buf.reset();
}
}
template<class DynamicBuffer>
void
stream_base::
write_close(DynamicBuffer& db, close_reason const& cr)
{
using namespace boost::endian;
frame_header fh;
fh.op = opcode::close;
fh.fin = true;
fh.rsv1 = false;
fh.rsv2 = false;
fh.rsv3 = false;
fh.len = cr.code == close_code::none ?
0 : 2 + cr.reason.size();
fh.mask = role_ == detail::role_type::client;
if(fh.mask)
fh.key = maskgen_();
detail::write(db, fh);
if(cr.code != close_code::none)
{
detail::prepared_key key;
if(fh.mask)
detail::prepare_key(key, fh.key);
{
std::uint8_t b[2];
::new(&b[0]) big_uint16_buf_t{
(std::uint16_t)cr.code};
auto d = db.prepare(2);
boost::asio::buffer_copy(d,
boost::asio::buffer(b));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(2);
}
if(! cr.reason.empty())
{
auto d = db.prepare(cr.reason.size());
boost::asio::buffer_copy(d,
boost::asio::const_buffer(
cr.reason.data(), cr.reason.size()));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(cr.reason.size());
}
}
}
template<class DynamicBuffer>
void
stream_base::
write_ping(
DynamicBuffer& db, opcode op, ping_data const& data)
{
frame_header fh;
fh.op = op;
fh.fin = true;
fh.rsv1 = false;
fh.rsv2 = false;
fh.rsv3 = false;
fh.len = data.size();
fh.mask = role_ == role_type::client;
if(fh.mask)
fh.key = maskgen_();
detail::write(db, fh);
if(data.empty())
return;
detail::prepared_key key;
if(fh.mask)
detail::prepare_key(key, fh.key);
auto d = db.prepare(data.size());
boost::asio::buffer_copy(d,
boost::asio::const_buffers_1(
data.data(), data.size()));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(data.size());
}
} // detail
} // websocket
} // beast
#endif

32
include/beast/websocket/detail/type_traits.hpp Normal file
View File

@@ -0,0 +1,32 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_DETAIL_TYPE_TRAITS_HPP
#define BEAST_WEBSOCKET_DETAIL_TYPE_TRAITS_HPP
#include <beast/websocket/rfc6455.hpp>
#include <beast/core/detail/type_traits.hpp>
namespace beast {
namespace websocket {
namespace detail {
template<class F>
using is_RequestDecorator =
typename beast::detail::is_invocable<F,
void(request_type&)>::type;
template<class F>
using is_ResponseDecorator =
typename beast::detail::is_invocable<F,
void(response_type&)>::type;
} // detail
} // websocket
} // beast
#endif

167
include/beast/websocket/detail/utf8_checker.hpp
View File

@@ -8,9 +8,9 @@
#ifndef BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_HPP
#define BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_HPP
#include <beast/core/type_traits.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/assert.hpp>
#include <beast/core/buffer_concepts.hpp>
#include <algorithm>
#include <cstdint>
@@ -105,7 +105,8 @@ public:
template<class _>
void
utf8_checker_t<_>::reset()
utf8_checker_t<_>::
reset()
{
need_ = 0;
p_ = have_;
@@ -113,7 +114,8 @@ utf8_checker_t<_>::reset()
template<class _>
bool
utf8_checker_t<_>::finish()
utf8_checker_t<_>::
finish()
{
auto const success = need_ == 0;
reset();
@@ -123,13 +125,14 @@ utf8_checker_t<_>::finish()
template<class _>
template<class ConstBufferSequence>
bool
utf8_checker_t<_>::write(ConstBufferSequence const& bs)
utf8_checker_t<_>::
write(ConstBufferSequence const& bs)
{
static_assert(is_ConstBufferSequence<ConstBufferSequence>::value,
static_assert(is_const_buffer_sequence<ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
for(auto const& b : bs)
for(boost::asio::const_buffer b : bs)
if(! write(buffer_cast<std::uint8_t const*>(b),
buffer_size(b)))
return false;
@@ -138,43 +141,44 @@ utf8_checker_t<_>::write(ConstBufferSequence const& bs)
template<class _>
bool
utf8_checker_t<_>::write(std::uint8_t const* in, std::size_t size)
utf8_checker_t<_>::
write(std::uint8_t const* in, std::size_t size)
{
auto const valid =
[](std::uint8_t const*& in)
[](std::uint8_t const*& p)
{
if (in[0] < 128)
if (p[0] < 128)
{
++in;
++p;
return true;
}
if ((in[0] & 0x60) == 0x40)
if ((p[0] & 0x60) == 0x40)
{
if ((in[1] & 0xc0) != 0x80)
if ((p[1] & 0xc0) != 0x80)
return false;
in += 2;
p += 2;
return true;
}
if ((in[0] & 0xf0) == 0xe0)
if ((p[0] & 0xf0) == 0xe0)
{
if ((in[1] & 0xc0) != 0x80 ||
(in[2] & 0xc0) != 0x80 ||
(in[0] == 224 && in[1] < 160) ||
(in[0] == 237 && in[1] > 159))
if ((p[1] & 0xc0) != 0x80 ||
(p[2] & 0xc0) != 0x80 ||
(p[0] == 224 && p[1] < 160) ||
(p[0] == 237 && p[1] > 159))
return false;
in += 3;
p += 3;
return true;
}
if ((in[0] & 0xf8) == 0xf0)
if ((p[0] & 0xf8) == 0xf0)
{
if (in[0] > 244 ||
(in[1] & 0xc0) != 0x80 ||
(in[2] & 0xc0) != 0x80 ||
(in[3] & 0xc0) != 0x80 ||
(in[0] == 240 && in[1] < 144) ||
(in[0] == 244 && in[1] > 143))
if (p[0] > 244 ||
(p[1] & 0xc0) != 0x80 ||
(p[2] & 0xc0) != 0x80 ||
(p[3] & 0xc0) != 0x80 ||
(p[0] == 240 && p[1] < 144) ||
(p[0] == 244 && p[1] > 143))
return false;
in += 4;
p += 4;
return true;
}
return false;
@@ -195,10 +199,10 @@ utf8_checker_t<_>::write(std::uint8_t const* in, std::size_t size)
}
if ((have_[0] & 0xf8) == 0xf0)
{
auto const size = p_ - have_;
if (size > 2 && (have_[2] & 0xc0) != 0x80)
auto const n = p_ - have_;
if (n > 2 && (have_[2] & 0xc0) != 0x80)
return false;
if (size > 1 &&
if (n > 1 &&
((have_[1] & 0xc0) != 0x80 ||
(have_[0] == 240 && have_[1] < 144) ||
(have_[0] == 244 && have_[1] > 143)))
@@ -207,17 +211,17 @@ utf8_checker_t<_>::write(std::uint8_t const* in, std::size_t size)
return true;
};
auto const needed =
[](std::uint8_t const in)
[](std::uint8_t const v)
{
if (in < 128)
if (v < 128)
return 1;
if (in < 194)
if (v < 194)
return 0;
if (in < 224)
if (v < 224)
return 2;
if (in < 240)
if (v < 240)
return 3;
if (in < 245)
if (v < 245)
return 4;
return 0;
};
@@ -241,39 +245,66 @@ utf8_checker_t<_>::write(std::uint8_t const* in, std::size_t size)
p_ = have_;
}
auto last = in + size - 7;
while(in < last)
{
#if BEAST_WEBSOCKET_NO_UNALIGNED_READ
auto constexpr align = sizeof(std::size_t) - 1;
auto constexpr mask = static_cast<
std::size_t>(0x8080808080808080 &
~std::size_t{0});
if(
((reinterpret_cast<
std::uintptr_t>(in) & align) == 0) &&
(*reinterpret_cast<
std::size_t const*>(in) & mask) == 0)
in += sizeof(std::size_t);
else if(! valid(in))
return false;
#else
auto constexpr mask = static_cast<
std::size_t>(0x8080808080808080 &
~std::size_t{0});
if(
(*reinterpret_cast<
std::size_t const*>(in) & mask) == 0)
in += sizeof(std::size_t);
else if(! valid(in))
return false;
#endif
}
last += 4;
while(in < last)
if(! valid(in))
return false;
if(size <= sizeof(std::size_t))
goto slow;
// align in to sizeof(std::size_t) boundary
{
auto const in0 = in;
auto last = reinterpret_cast<std::uint8_t const*>(
((reinterpret_cast<std::uintptr_t>(in) + sizeof(std::size_t) - 1) /
sizeof(std::size_t)) * sizeof(std::size_t));
while(in < last)
{
if(*in & 0x80)
{
size = size - (in - in0);
goto slow;
}
++in;
}
size = size - (in - in0);
}
// fast loop
{
auto const in0 = in;
auto last = in + size - 7;
auto constexpr mask = static_cast<
std::size_t>(0x8080808080808080 & ~std::size_t{0});
while(in < last)
{
#if 0
std::size_t temp;
std::memcpy(&temp, in, sizeof(temp));
if((temp & mask) != 0)
#else
// Technically UB but works on all known platforms
if((*reinterpret_cast<std::size_t const*>(in) & mask) != 0)
#endif
{
size = size - (in - in0);
goto slow;
}
in += sizeof(std::size_t);
}
last += 4;
while(in < last)
if(! valid(in))
return false;
goto tail;
}
// slow loop: one code point at a time
slow:
{
auto last = in + size - 3;
while(in < last)
if(! valid(in))
return false;
}
tail:
for(;;)
{
auto n = end - in;

28
include/beast/websocket/error.hpp
View File

@@ -23,32 +23,8 @@ enum class error
/// WebSocket connection failed, protocol violation
failed,
/// Upgrade request failed, connection is closed
handshake_failed,
/// Upgrade request failed, but connection is still open
keep_alive,
/// HTTP response is malformed
response_malformed,
/// HTTP response failed the upgrade
response_failed,
/// Upgrade request denied for invalid fields.
response_denied,
/// Upgrade request is malformed
request_malformed,
/// Upgrade request fields incorrect
request_invalid,
/// Upgrade request denied
request_denied,
/// General WebSocket error
general
/// Upgrade handshake failed
handshake_failed
};
} // websocket

724
include/beast/websocket/impl/accept.ipp
View File

@@ -8,16 +8,20 @@
#ifndef BEAST_WEBSOCKET_IMPL_ACCEPT_IPP
#define BEAST_WEBSOCKET_IMPL_ACCEPT_IPP
#include <beast/http/message.hpp>
#include <beast/http/parser_v1.hpp>
#include <beast/websocket/detail/type_traits.hpp>
#include <beast/http/empty_body.hpp>
#include <beast/http/parser.hpp>
#include <beast/http/read.hpp>
#include <beast/http/string_body.hpp>
#include <beast/http/write.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/buffer_prefix.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/assert.hpp>
#include <boost/throw_exception.hpp>
#include <memory>
#include <type_traits>
@@ -35,23 +39,37 @@ class stream<NextLayer>::response_op
{
bool cont;
stream<NextLayer>& ws;
http::response<http::string_body> res;
error_code final_ec;
response_type res;
int state = 0;
template<class Body, class Fields>
data(Handler&, stream<NextLayer>& ws_,
http::request<Body, Fields> const& req,
bool cont_)
template<class Allocator, class Decorator>
data(Handler&, stream<NextLayer>& ws_, http::header<
true, http::basic_fields<Allocator>> const& req,
Decorator const& decorator,
bool cont_)
: cont(cont_)
, ws(ws_)
, res(ws_.build_response(req))
, res(ws_.build_response(req, decorator))
{
// can't call stream::reset() here
// otherwise accept_op will malfunction
//
if(res.status != 101)
final_ec = error::handshake_failed;
}
template<class Allocator,
class Buffers, class Decorator>
data(Handler&, stream<NextLayer>& ws_, http::header<
true, http::basic_fields<Allocator>> const& req,
Buffers const& buffers,
Decorator const& decorator,
bool cont_)
: cont(cont_)
, ws(ws_)
, res(ws_.build_response(req, decorator))
{
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
// VFALCO What about catch(std::length_error const&)?
ws.stream_.buffer().commit(buffer_copy(
ws.stream_.buffer().prepare(
buffer_size(buffers)), buffers));
}
};
@@ -77,16 +95,18 @@ public:
void* asio_handler_allocate(
std::size_t size, response_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, response_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
@@ -99,8 +119,9 @@ public:
friend
void asio_handler_invoke(Function&& f, response_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
@@ -126,12 +147,13 @@ operator()(error_code ec, bool again)
// sent response
case 1:
d.state = 99;
ec = d.final_ec;
if(d.res.result() !=
http::status::switching_protocols)
ec = error::handshake_failed;
if(! ec)
{
pmd_read(
d.ws.pmd_config_, d.res.fields);
d.ws.open(detail::role_type::server);
pmd_read(d.ws.pmd_config_, d.res);
d.ws.open(role_type::server);
}
break;
}
@@ -144,26 +166,32 @@ operator()(error_code ec, bool again)
// read and respond to an upgrade request
//
template<class NextLayer>
template<class Handler>
template<class Decorator, class Handler>
class stream<NextLayer>::accept_op
{
struct data
{
bool cont;
stream<NextLayer>& ws;
http::request<http::string_body> req;
int state = 0;
Decorator decorator;
http::request_parser<http::empty_body> p;
data(Handler&, stream<NextLayer>& ws_,
Decorator const& decorator_)
: ws(ws_)
, decorator(decorator_)
{
}
template<class Buffers>
data(Handler& handler, stream<NextLayer>& ws_,
Buffers const& buffers)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
data(Handler&, stream<NextLayer>& ws_,
Buffers const& buffers,
Decorator const& decorator_)
: ws(ws_)
, decorator(decorator_)
{
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
ws.reset();
// VFALCO What about catch(std::length_error const&)?
ws.stream_.buffer().commit(buffer_copy(
ws.stream_.buffer().prepare(
buffer_size(buffers)), buffers));
@@ -182,150 +210,122 @@ public:
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
{
(*this)(error_code{}, 0, false);
}
void operator()(error_code const& ec)
{
(*this)(ec, 0);
}
void operator()();
void operator()(error_code const& ec,
std::size_t bytes_transferred, bool again = true);
void operator()(error_code ec);
friend
void* asio_handler_allocate(
std::size_t size, accept_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, accept_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
bool asio_handler_is_continuation(accept_op* op)
{
return op->d_->cont;
using boost::asio::asio_handler_is_continuation;
return asio_handler_is_continuation(
std::addressof(op->d_.handler()));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, accept_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
template<class NextLayer>
template<class Handler>
template<class Decorator, class Handler>
void
stream<NextLayer>::accept_op<Handler>::
operator()(error_code const& ec,
std::size_t bytes_transferred, bool again)
stream<NextLayer>::accept_op<Decorator, Handler>::
operator()()
{
beast::detail::ignore_unused(bytes_transferred);
auto& d = *d_;
d.cont = d.cont || again;
while(! ec && d.state != 99)
{
switch(d.state)
{
case 0:
// read message
d.state = 1;
http::async_read(d.ws.next_layer(),
d.ws.stream_.buffer(), d.req,
std::move(*this));
return;
http::async_read_header(d.ws.next_layer(),
d.ws.stream_.buffer(), d.p,
std::move(*this));
}
// got message
case 1:
{
// respond to request
auto& ws = d.ws;
auto req = std::move(d.req);
response_op<Handler>{
d_.release_handler(), ws, req, true};
return;
}
}
template<class NextLayer>
template<class Decorator, class Handler>
void
stream<NextLayer>::accept_op<Decorator, Handler>::
operator()(error_code ec)
{
auto& d = *d_;
if(! ec)
{
BOOST_ASSERT(d.p.is_header_done());
// Arguments from our state must be
// moved to the stack before releasing
// the handler.
auto& ws = d.ws;
auto const req = d.p.release();
auto const decorator = d.decorator;
#if 1
response_op<Handler>{
d_.release_handler(),
ws, req, decorator, true};
#else
// VFALCO This *should* work but breaks
// coroutine invariants in the unit test.
// Also it calls reset() when it shouldn't.
ws.async_accept_ex(
req, decorator, d_.release_handler());
#endif
return;
}
d_.invoke(ec);
}
template<class NextLayer>
template<class AcceptHandler>
typename async_completion<
AcceptHandler, void(error_code)>::result_type
stream<NextLayer>::
async_accept(AcceptHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
return async_accept(boost::asio::null_buffers{},
std::forward<AcceptHandler>(handler));
}
template<class NextLayer>
template<class ConstBufferSequence, class AcceptHandler>
typename async_completion<
AcceptHandler, void(error_code)>::result_type
stream<NextLayer>::
async_accept(ConstBufferSequence const& bs, AcceptHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(beast::is_ConstBufferSequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
beast::async_completion<
AcceptHandler, void(error_code)
> completion{handler};
accept_op<decltype(completion.handler)>{
completion.handler, *this, bs};
return completion.result.get();
}
template<class NextLayer>
template<class Body, class Fields, class AcceptHandler>
typename async_completion<
AcceptHandler, void(error_code)>::result_type
stream<NextLayer>::
async_accept(http::request<Body, Fields> const& req,
AcceptHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
beast::async_completion<
AcceptHandler, void(error_code)
> completion{handler};
reset();
response_op<decltype(completion.handler)>{
completion.handler, *this, req,
beast_asio_helpers::
is_continuation(completion.handler)};
return completion.result.get();
}
//------------------------------------------------------------------------------
template<class NextLayer>
void
stream<NextLayer>::
accept()
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
error_code ec;
accept(boost::asio::null_buffers{}, ec);
accept(ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class ResponseDecorator>
void
stream<NextLayer>::
accept_ex(ResponseDecorator const& decorator)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
@@ -333,93 +333,477 @@ void
stream<NextLayer>::
accept(error_code& ec)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
accept(boost::asio::null_buffers{}, ec);
reset();
do_accept(&default_decorate_res, ec);
}
template<class NextLayer>
template<class ResponseDecorator>
void
stream<NextLayer>::
accept_ex(ResponseDecorator const& decorator, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
reset();
do_accept(decorator, ec);
}
template<class NextLayer>
template<class ConstBufferSequence>
void
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer>::
accept(ConstBufferSequence const& buffers)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_ConstBufferSequence<
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
error_code ec;
accept(buffers, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<
class ConstBufferSequence, class ResponseDecorator>
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer>::
accept_ex(ConstBufferSequence const& buffers,
ResponseDecorator const &decorator)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(buffers, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class ConstBufferSequence>
void
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer>::
accept(ConstBufferSequence const& buffers, error_code& ec)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(beast::is_ConstBufferSequence<
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
reset();
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
reset();
stream_.buffer().commit(buffer_copy(
stream_.buffer().prepare(
buffer_size(buffers)), buffers));
http::request<http::string_body> m;
http::read(next_layer(), stream_.buffer(), m, ec);
if(ec)
return;
accept(m, ec);
do_accept(&default_decorate_res, ec);
}
template<class NextLayer>
template<class Body, class Fields>
template<
class ConstBufferSequence, class ResponseDecorator>
typename std::enable_if<! http::detail::is_header<
ConstBufferSequence>::value>::type
stream<NextLayer>::
accept_ex(ConstBufferSequence const& buffers,
ResponseDecorator const& decorator, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
reset();
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
stream_.buffer().commit(buffer_copy(
stream_.buffer().prepare(
buffer_size(buffers)), buffers));
do_accept(decorator, ec);
}
template<class NextLayer>
template<class Allocator>
void
stream<NextLayer>::
accept(http::request<Body, Fields> const& request)
accept(http::header<true,
http::basic_fields<Allocator>> const& req)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
error_code ec;
accept(request, ec);
accept(req, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class Body, class Fields>
template<class Allocator, class ResponseDecorator>
void
stream<NextLayer>::
accept(http::request<Body, Fields> const& req,
error_code& ec)
accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(req, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class Allocator>
void
stream<NextLayer>::
accept(http::header<true,
http::basic_fields<Allocator>> const& req,
error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
reset();
auto const res = build_response(req);
http::write(stream_, res, ec);
do_accept(req, &default_decorate_res, ec);
}
template<class NextLayer>
template<class Allocator, class ResponseDecorator>
void
stream<NextLayer>::
accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
reset();
do_accept(req, decorator, ec);
}
template<class NextLayer>
template<class Allocator, class ConstBufferSequence>
void
stream<NextLayer>::
accept(http::header<true,
http::basic_fields<Allocator>> const& req,
ConstBufferSequence const& buffers)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
error_code ec;
accept(req, buffers, ec);
if(ec)
return;
if(res.status != 101)
{
ec = error::handshake_failed;
// VFALCO TODO Respect keep alive setting, perform
// teardown if Connection: close.
return;
}
pmd_read(pmd_config_, req.fields);
open(detail::role_type::server);
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class Allocator,
class ConstBufferSequence, class ResponseDecorator>
void
stream<NextLayer>::
accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ConstBufferSequence const& buffers,
ResponseDecorator const& decorator)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
error_code ec;
accept_ex(req, buffers, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class Allocator, class ConstBufferSequence>
void
stream<NextLayer>::
accept(http::header<true,
Allocator> const& req,
ConstBufferSequence const& buffers, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
reset();
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
stream_.buffer().commit(buffer_copy(
stream_.buffer().prepare(
buffer_size(buffers)), buffers));
do_accept(req, &default_decorate_res, ec);
}
template<class NextLayer>
template<class Allocator,
class ConstBufferSequence, class ResponseDecorator>
void
stream<NextLayer>::
accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ConstBufferSequence const& buffers,
ResponseDecorator const& decorator,
error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
reset();
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
stream_.buffer().commit(buffer_copy(
stream_.buffer().prepare(
buffer_size(buffers)), buffers));
do_accept(req, decorator, ec);
}
//------------------------------------------------------------------------------
template<class NextLayer>
template<class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept(AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
accept_op<decltype(&default_decorate_res),
handler_type<AcceptHandler, void(error_code)>>{
init.completion_handler, *this, &default_decorate_res}();
return init.result.get();
}
template<class NextLayer>
template<class ResponseDecorator, class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept_ex(ResponseDecorator const& decorator,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
accept_op<ResponseDecorator, handler_type<
AcceptHandler, void(error_code)>>{
init.completion_handler, *this, decorator}();
return init.result.get();
}
template<class NextLayer>
template<class ConstBufferSequence, class AcceptHandler>
typename std::enable_if<
! http::detail::is_header<ConstBufferSequence>::value,
async_return_type<AcceptHandler, void(error_code)>>::type
stream<NextLayer>::
async_accept(ConstBufferSequence const& buffers,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
accept_op<decltype(&default_decorate_res),
handler_type<AcceptHandler, void(error_code)>>{
init.completion_handler, *this, buffers,
&default_decorate_res}();
return init.result.get();
}
template<class NextLayer>
template<class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler>
typename std::enable_if<
! http::detail::is_header<ConstBufferSequence>::value,
async_return_type<AcceptHandler, void(error_code)>>::type
stream<NextLayer>::
async_accept_ex(ConstBufferSequence const& buffers,
ResponseDecorator const& decorator,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
accept_op<ResponseDecorator, handler_type<
AcceptHandler, void(error_code)>>{
init.completion_handler, *this, buffers,
decorator}();
return init.result.get();
}
template<class NextLayer>
template<class Allocator, class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept(http::header<true,
http::basic_fields<Allocator>> const& req,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
using boost::asio::asio_handler_is_continuation;
response_op<handler_type<
AcceptHandler, void(error_code)>>{init.completion_handler,
*this, req, &default_decorate_res,
asio_handler_is_continuation(
std::addressof(init.completion_handler))};
return init.result.get();
}
template<class NextLayer>
template<class Allocator,
class ResponseDecorator, class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ResponseDecorator const& decorator, AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
using boost::asio::asio_handler_is_continuation;
response_op<handler_type<
AcceptHandler, void(error_code)>>{
init.completion_handler, *this, req, decorator,
asio_handler_is_continuation(
std::addressof(init.completion_handler))};
return init.result.get();
}
template<class NextLayer>
template<class Allocator,
class ConstBufferSequence, class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept(http::header<true,
http::basic_fields<Allocator>> const& req,
ConstBufferSequence const& buffers,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
using boost::asio::asio_handler_is_continuation;
response_op<handler_type<
AcceptHandler, void(error_code)>>{
init.completion_handler, *this, req, buffers,
&default_decorate_res, asio_handler_is_continuation(
std::addressof(init.completion_handler))};
return init.result.get();
}
template<class NextLayer>
template<class Allocator, class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler>
async_return_type<
AcceptHandler, void(error_code)>
stream<NextLayer>::
async_accept_ex(http::header<true,
http::basic_fields<Allocator>> const& req,
ConstBufferSequence const& buffers,
ResponseDecorator const& decorator,
AcceptHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(detail::is_ResponseDecorator<
ResponseDecorator>::value,
"ResponseDecorator requirements not met");
async_completion<AcceptHandler,
void(error_code)> init{handler};
reset();
using boost::asio::asio_handler_is_continuation;
response_op<handler_type<
AcceptHandler, void(error_code)>>{init.completion_handler,
*this, req, buffers, decorator, asio_handler_is_continuation(
std::addressof(init.completion_handler))};
return init.result.get();
}
} // websocket
} // beast

212
include/beast/websocket/impl/close.ipp
View File

@@ -8,10 +8,14 @@
#ifndef BEAST_WEBSOCKET_IMPL_CLOSE_IPP
#define BEAST_WEBSOCKET_IMPL_CLOSE_IPP
#include <beast/core/handler_helpers.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/static_buffer.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/config.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/throw_exception.hpp>
#include <memory>
namespace beast {
@@ -25,25 +29,20 @@ template<class NextLayer>
template<class Handler>
class stream<NextLayer>::close_op
{
using fb_type = detail::frame_streambuf;
struct data : op
{
bool cont;
stream<NextLayer>& ws;
close_reason cr;
fb_type fb;
detail::frame_streambuf fb;
int state = 0;
data(Handler& handler, stream<NextLayer>& ws_,
data(Handler&, stream<NextLayer>& ws_,
close_reason const& cr_)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
: ws(ws_)
, cr(cr_)
{
ws.template write_close<
static_streambuf>(fb, cr);
static_buffer>(fb, cr);
}
};
@@ -59,48 +58,50 @@ public:
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
{
(*this)(error_code{}, false);
}
void operator()()
{
(*this)(error_code{});
(*this)({});
}
void
operator()(error_code ec, std::size_t);
void
operator()(error_code ec, bool again = true);
operator()(error_code ec,
std::size_t bytes_transferred = 0);
friend
void* asio_handler_allocate(
std::size_t size, close_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, close_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
bool asio_handler_is_continuation(close_op* op)
{
return op->d_->cont;
using boost::asio::asio_handler_is_continuation;
return asio_handler_is_continuation(
std::addressof(op->d_.handler()));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, close_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
@@ -112,104 +113,90 @@ operator()(error_code ec, std::size_t)
{
auto& d = *d_;
if(ec)
d.ws.failed_ = true;
(*this)(ec);
}
template<class NextLayer>
template<class Handler>
void
stream<NextLayer>::close_op<Handler>::
operator()(error_code ec, bool again)
{
auto& d = *d_;
d.cont = d.cont || again;
if(ec)
goto upcall;
for(;;)
{
switch(d.state)
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.failed_ = true;
goto upcall;
}
switch(d.state)
{
case 0:
if(d.ws.wr_block_)
{
case 0:
if(d.ws.wr_block_)
{
// suspend
d.state = 2;
d.ws.wr_op_.template emplace<
close_op>(std::move(*this));
return;
}
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
d.ws.get_io_service().post(
bind_handler(std::move(*this),
boost::asio::error::operation_aborted));
return;
}
d.ws.wr_block_ = &d;
// [[fallthrough]]
case 1:
// send close frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = 99;
d.ws.wr_close_ = true;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case 2:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = 3;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(
bind_handler(std::move(*this), ec));
return;
case 3:
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
ec = boost::asio::error::operation_aborted;
goto upcall;
}
// suspend
d.state = 1;
break;
d.ws.close_op_.emplace(std::move(*this));
return;
}
d.ws.wr_block_ = &d;
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
d.ws.get_io_service().post(
bind_handler(std::move(*this),
boost::asio::error::operation_aborted));
return;
}
case 99:
do_write:
// send close frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = 3;
d.ws.wr_close_ = true;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case 1:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = 2;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(
bind_handler(std::move(*this), ec));
return;
case 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
ec = boost::asio::error::operation_aborted;
goto upcall;
}
goto do_write;
case 3:
break;
}
upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
d.ws.rd_op_.maybe_invoke() ||
d.ws.ping_op_.maybe_invoke();
d.ws.ping_op_.maybe_invoke() ||
d.ws.wr_op_.maybe_invoke();
d_.invoke(ec);
}
template<class NextLayer>
template<class CloseHandler>
typename async_completion<
CloseHandler, void(error_code)>::result_type
async_return_type<
CloseHandler, void(error_code)>
stream<NextLayer>::
async_close(close_reason const& cr, CloseHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
beast::async_completion<
CloseHandler, void(error_code)
> completion{handler};
close_op<decltype(completion.handler)>{
completion.handler, *this, cr};
return completion.result.get();
async_completion<CloseHandler,
void(error_code)> init{handler};
close_op<handler_type<
CloseHandler, void(error_code)>>{
init.completion_handler, *this, cr}({});
return init.result.get();
}
template<class NextLayer>
@@ -217,12 +204,12 @@ void
stream<NextLayer>::
close(close_reason const& cr)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
error_code ec;
close(cr, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
@@ -230,14 +217,19 @@ void
stream<NextLayer>::
close(close_reason const& cr, error_code& ec)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
BOOST_ASSERT(! wr_close_);
if(wr_close_)
{
ec = boost::asio::error::operation_aborted;
return;
}
wr_close_ = true;
detail::frame_streambuf fb;
write_close<static_streambuf>(fb, cr);
write_close<static_buffer>(fb, cr);
boost::asio::write(stream_, fb.data(), ec);
failed_ = ec != 0;
failed_ = !!ec;
}
//------------------------------------------------------------------------------

11
include/beast/websocket/impl/error.ipp
View File

@@ -28,7 +28,7 @@ public:
const char*
name() const noexcept override
{
return "websocket";
return "beast.websocket";
}
std::string
@@ -39,16 +39,9 @@ public:
case error::closed: return "WebSocket connection closed normally";
case error::failed: return "WebSocket connection failed due to a protocol violation";
case error::handshake_failed: return "WebSocket Upgrade handshake failed";
case error::keep_alive: return "WebSocket Upgrade handshake failed but connection is still open";
case error::response_malformed: return "malformed HTTP response";
case error::response_failed: return "upgrade request failed";
case error::response_denied: return "upgrade request denied";
case error::request_malformed: return "malformed HTTP request";
case error::request_invalid: return "upgrade request invalid";
case error::request_denied: return "upgrade request denied";
default:
return "websocket error";
return "beast.websocket error";
}
}

287
include/beast/websocket/impl/handshake.ipp
View File

@@ -8,14 +8,18 @@
#ifndef BEAST_WEBSOCKET_IMPL_HANDSHAKE_IPP
#define BEAST_WEBSOCKET_IMPL_HANDSHAKE_IPP
#include <beast/websocket/detail/type_traits.hpp>
#include <beast/http/empty_body.hpp>
#include <beast/http/message.hpp>
#include <beast/http/read.hpp>
#include <beast/http/write.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/type_traits.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/assert.hpp>
#include <boost/throw_exception.hpp>
#include <memory>
namespace beast {
@@ -33,19 +37,25 @@ class stream<NextLayer>::handshake_op
{
bool cont;
stream<NextLayer>& ws;
std::string key;
response_type* res_p;
detail::sec_ws_key_type key;
http::request<http::empty_body> req;
http::response<http::string_body> resp;
response_type res;
int state = 0;
template<class Decorator>
data(Handler& handler, stream<NextLayer>& ws_,
boost::string_ref const& host,
boost::string_ref const& resource)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
, req(ws.build_request(host, resource, key))
response_type* res_p_,
string_view host,
string_view target,
Decorator const& decorator)
: ws(ws_)
, res_p(res_p_)
, req(ws.build_request(key,
host, target, decorator))
{
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
ws.reset();
}
};
@@ -72,16 +82,18 @@ public:
void* asio_handler_allocate(
std::size_t size, handshake_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, handshake_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
@@ -94,8 +106,9 @@ public:
friend
void asio_handler_invoke(Function&& f, handshake_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
@@ -117,10 +130,13 @@ operator()(error_code ec, bool again)
d.state = 1;
// VFALCO Do we need the ability to move
// a message on the async_write?
pmd_read(
d.ws.pmd_config_, d.req.fields);
//
pmd_read(d.ws.pmd_config_, d.req);
http::async_write(d.ws.stream_,
d.req, std::move(*this));
// TODO We don't need d.req now. Figure
// out a way to make it a parameter instead
// of a state variable to reduce footprint.
return;
}
@@ -129,78 +145,245 @@ operator()(error_code ec, bool again)
// read http response
d.state = 2;
http::async_read(d.ws.next_layer(),
d.ws.stream_.buffer(), d.resp,
d.ws.stream_.buffer(), d.res,
std::move(*this));
return;
// got response
case 2:
{
d.ws.do_response(d.resp, d.key, ec);
d.ws.do_response(d.res, d.key, ec);
// call handler
d.state = 99;
break;
}
}
}
if(d.res_p)
swap(d.res, *d.res_p);
d_.invoke(ec);
}
template<class NextLayer>
template<class HandshakeHandler>
typename async_completion<
HandshakeHandler, void(error_code)>::result_type
async_return_type<
HandshakeHandler, void(error_code)>
stream<NextLayer>::
async_handshake(boost::string_ref const& host,
boost::string_ref const& resource, HandshakeHandler&& handler)
async_handshake(string_view host,
string_view target,
HandshakeHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
beast::async_completion<
HandshakeHandler, void(error_code)
> completion{handler};
handshake_op<decltype(completion.handler)>{
completion.handler, *this, host, resource};
return completion.result.get();
async_completion<HandshakeHandler,
void(error_code)> init{handler};
handshake_op<handler_type<
HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, nullptr, host,
target, &default_decorate_req};
return init.result.get();
}
template<class NextLayer>
template<class HandshakeHandler>
async_return_type<
HandshakeHandler, void(error_code)>
stream<NextLayer>::
async_handshake(response_type& res,
string_view host,
string_view target,
HandshakeHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
async_completion<HandshakeHandler,
void(error_code)> init{handler};
handshake_op<handler_type<
HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, &res, host,
target, &default_decorate_req};
return init.result.get();
}
template<class NextLayer>
template<class RequestDecorator, class HandshakeHandler>
async_return_type<
HandshakeHandler, void(error_code)>
stream<NextLayer>::
async_handshake_ex(string_view host,
string_view target,
RequestDecorator const& decorator,
HandshakeHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
async_completion<HandshakeHandler,
void(error_code)> init{handler};
handshake_op<handler_type<
HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, nullptr, host,
target, decorator};
return init.result.get();
}
template<class NextLayer>
template<class RequestDecorator, class HandshakeHandler>
async_return_type<
HandshakeHandler, void(error_code)>
stream<NextLayer>::
async_handshake_ex(response_type& res,
string_view host,
string_view target,
RequestDecorator const& decorator,
HandshakeHandler&& handler)
{
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
async_completion<HandshakeHandler,
void(error_code)> init{handler};
handshake_op<handler_type<
HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, &res, host,
target, decorator};
return init.result.get();
}
template<class NextLayer>
void
stream<NextLayer>::
handshake(boost::string_ref const& host,
boost::string_ref const& resource)
handshake(string_view host,
string_view target)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
error_code ec;
handshake(host, resource, ec);
handshake(
host, target, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
void
stream<NextLayer>::
handshake(boost::string_ref const& host,
boost::string_ref const& resource, error_code& ec)
handshake(response_type& res,
string_view host,
string_view target)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
reset();
std::string key;
{
auto const req =
build_request(host, resource, key);
pmd_read(pmd_config_, req.fields);
http::write(stream_, req, ec);
}
error_code ec;
handshake(res, host, target, ec);
if(ec)
return;
http::response<http::string_body> res;
http::read(next_layer(), stream_.buffer(), res, ec);
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class RequestDecorator>
void
stream<NextLayer>::
handshake_ex(string_view host,
string_view target,
RequestDecorator const& decorator)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
error_code ec;
handshake_ex(host, target, decorator, ec);
if(ec)
return;
do_response(res, key, ec);
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class RequestDecorator>
void
stream<NextLayer>::
handshake_ex(response_type& res,
string_view host,
string_view target,
RequestDecorator const& decorator)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
error_code ec;
handshake_ex(res, host, target, decorator, ec);
if(ec)
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
void
stream<NextLayer>::
handshake(string_view host,
string_view target, error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
do_handshake(nullptr,
host, target, &default_decorate_req, ec);
}
template<class NextLayer>
void
stream<NextLayer>::
handshake(response_type& res,
string_view host,
string_view target,
error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
do_handshake(&res,
host, target, &default_decorate_req, ec);
}
template<class NextLayer>
template<class RequestDecorator>
void
stream<NextLayer>::
handshake_ex(string_view host,
string_view target,
RequestDecorator const& decorator,
error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
do_handshake(nullptr,
host, target, decorator, ec);
}
template<class NextLayer>
template<class RequestDecorator>
void
stream<NextLayer>::
handshake_ex(response_type& res,
string_view host,
string_view target,
RequestDecorator const& decorator,
error_code& ec)
{
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(detail::is_RequestDecorator<
RequestDecorator>::value,
"RequestDecorator requirements not met");
do_handshake(&res,
host, target, decorator, ec);
}
//------------------------------------------------------------------------------

228
include/beast/websocket/impl/ping.ipp
View File

@@ -9,10 +9,14 @@
#define BEAST_WEBSOCKET_IMPL_PING_IPP
#include <beast/core/bind_handler.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/config.hpp>
#include <beast/websocket/detail/frame.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/throw_exception.hpp>
#include <memory>
namespace beast {
@@ -28,21 +32,18 @@ class stream<NextLayer>::ping_op
{
struct data : op
{
bool cont;
stream<NextLayer>& ws;
detail::frame_streambuf fb;
int state = 0;
data(Handler& handler, stream<NextLayer>& ws_,
opcode op_, ping_data const& payload)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
data(Handler&, stream<NextLayer>& ws_,
detail::opcode op_, ping_data const& payload)
: ws(ws_)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
ws.template write_ping<
static_streambuf>(fb, op_, payload);
static_buffer>(fb, op_, payload);
}
};
@@ -58,175 +59,162 @@ public:
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
{
(*this)(error_code{}, false);
}
void operator()()
{
(*this)(error_code{});
(*this)({});
}
void operator()(error_code ec, std::size_t);
void operator()(error_code ec, bool again = true);
void operator()(error_code ec,
std::size_t bytes_transferred = 0);
friend
void* asio_handler_allocate(
std::size_t size, ping_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, ping_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
bool asio_handler_is_continuation(ping_op* op)
{
return op->d_->cont;
using boost::asio::asio_handler_is_continuation;
return asio_handler_is_continuation(
std::addressof(op->d_.handler()));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, ping_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
template<class NextLayer>
template<class Handler>
void
stream<NextLayer>::ping_op<Handler>::
stream<NextLayer>::
ping_op<Handler>::
operator()(error_code ec, std::size_t)
{
auto& d = *d_;
if(ec)
d.ws.failed_ = true;
(*this)(ec);
}
template<class NextLayer>
template<class Handler>
void
stream<NextLayer>::
ping_op<Handler>::
operator()(error_code ec, bool again)
{
auto& d = *d_;
d.cont = d.cont || again;
if(ec)
goto upcall;
for(;;)
{
switch(d.state)
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.failed_ = true;
goto upcall;
}
switch(d.state)
{
case 0:
if(d.ws.wr_block_)
{
case 0:
if(d.ws.wr_block_)
{
// suspend
d.state = 2;
d.ws.ping_op_.template emplace<
ping_op>(std::move(*this));
return;
}
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
d.state = 99;
d.ws.get_io_service().post(
bind_handler(std::move(*this),
boost::asio::error::operation_aborted));
return;
}
d.ws.wr_block_ = &d;
// [[fallthrough]]
case 1:
// send ping frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = 99;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case 2:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = 3;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(
bind_handler(std::move(*this), ec));
return;
case 3:
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
ec = boost::asio::error::operation_aborted;
goto upcall;
}
// suspend
d.state = 1;
break;
d.ws.ping_op_.emplace(std::move(*this));
return;
}
d.ws.wr_block_ = &d;
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
return d.ws.get_io_service().post(
bind_handler(std::move(*this),
boost::asio::error::operation_aborted));
}
case 99:
do_write:
// send ping frame
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = 3;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case 1:
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = 2;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(
bind_handler(std::move(*this), ec));
return;
case 2:
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_ || d.ws.wr_close_)
{
// call handler
ec = boost::asio::error::operation_aborted;
goto upcall;
}
goto do_write;
case 3:
break;
}
upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.rd_op_.maybe_invoke() ||
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
d.ws.close_op_.maybe_invoke() ||
d.ws.rd_op_.maybe_invoke() ||
d.ws.wr_op_.maybe_invoke();
d_.invoke(ec);
}
template<class NextLayer>
template<class WriteHandler>
typename async_completion<
WriteHandler, void(error_code)>::result_type
async_return_type<
WriteHandler, void(error_code)>
stream<NextLayer>::
async_ping(ping_data const& payload, WriteHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
beast::async_completion<
WriteHandler, void(error_code)
> completion{handler};
ping_op<decltype(completion.handler)>{
completion.handler, *this,
opcode::ping, payload};
return completion.result.get();
async_completion<WriteHandler,
void(error_code)> init{handler};
ping_op<handler_type<
WriteHandler, void(error_code)>>{
init.completion_handler, *this,
detail::opcode::ping, payload}({});
return init.result.get();
}
template<class NextLayer>
template<class WriteHandler>
typename async_completion<
WriteHandler, void(error_code)>::result_type
async_return_type<
WriteHandler, void(error_code)>
stream<NextLayer>::
async_pong(ping_data const& payload, WriteHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
beast::async_completion<
WriteHandler, void(error_code)
> completion{handler};
ping_op<decltype(completion.handler)>{
completion.handler, *this,
opcode::pong, payload};
return completion.result.get();
async_completion<WriteHandler,
void(error_code)> init{handler};
ping_op<handler_type<
WriteHandler, void(error_code)>>{
init.completion_handler, *this,
detail::opcode::pong, payload}({});
return init.result.get();
}
template<class NextLayer>
@@ -237,7 +225,7 @@ ping(ping_data const& payload)
error_code ec;
ping(payload, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
@@ -246,8 +234,8 @@ stream<NextLayer>::
ping(ping_data const& payload, error_code& ec)
{
detail::frame_streambuf db;
write_ping<static_streambuf>(
db, opcode::ping, payload);
write_ping<static_buffer>(
db, detail::opcode::ping, payload);
boost::asio::write(stream_, db.data(), ec);
}
@@ -259,7 +247,7 @@ pong(ping_data const& payload)
error_code ec;
pong(payload, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
@@ -268,8 +256,8 @@ stream<NextLayer>::
pong(ping_data const& payload, error_code& ec)
{
detail::frame_streambuf db;
write_ping<static_streambuf>(
db, opcode::pong, payload);
write_ping<static_buffer>(
db, detail::opcode::pong, payload);
boost::asio::write(stream_, db.data(), ec);
}

507
include/beast/websocket/impl/read.ipp
View File

@@ -9,15 +9,19 @@
#define BEAST_WEBSOCKET_IMPL_READ_IPP
#include <beast/websocket/teardown.hpp>
#include <beast/core/buffer_concepts.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/buffer_prefix.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/static_buffer.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/clamp.hpp>
#include <beast/core/detail/config.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/optional.hpp>
#include <boost/throw_exception.hpp>
#include <limits>
#include <memory>
@@ -46,7 +50,6 @@ class stream<NextLayer>::read_frame_op
{
bool cont;
stream<NextLayer>& ws;
frame_info& fi;
DynamicBuffer& db;
fb_type fb;
std::uint64_t remain;
@@ -57,13 +60,12 @@ class stream<NextLayer>::read_frame_op
int state = 0;
data(Handler& handler, stream<NextLayer>& ws_,
frame_info& fi_, DynamicBuffer& sb_)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
, fi(fi_)
DynamicBuffer& sb_)
: ws(ws_)
, db(sb_)
{
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
}
};
@@ -79,7 +81,6 @@ public:
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
{
(*this)(error_code{}, 0, false);
}
void operator()()
@@ -102,16 +103,18 @@ public:
void* asio_handler_allocate(
std::size_t size, read_frame_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, read_frame_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
@@ -124,8 +127,9 @@ public:
friend
void asio_handler_invoke(Function&& f, read_frame_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
@@ -160,9 +164,8 @@ operator()(error_code ec,
do_control_payload = 8,
do_control = 9,
do_pong_resume = 10,
do_pong = 12,
do_ponged = 12,
do_close_resume = 14,
do_close = 16,
do_teardown = 17,
do_fail = 19,
@@ -170,10 +173,16 @@ operator()(error_code ec,
};
auto& d = *d_;
if(d.state == do_teardown + 1 && ec == boost::asio::error::eof)
{
// Rationale:
// http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error
ec.assign(0, ec.category());
}
if(! ec)
{
d.cont = d.cont || again;
close_code::value code = close_code::none;
close_code code = close_code::none;
do
{
switch(d.state)
@@ -210,7 +219,7 @@ operator()(error_code ec,
d.remain = d.fh.len;
if(d.fh.mask)
detail::prepare_key(d.key, d.fh.key);
// fall through
BEAST_FALLTHROUGH;
case do_read_payload + 1:
d.state = do_read_payload + 2;
@@ -223,11 +232,11 @@ operator()(error_code ec,
case do_read_payload + 2:
{
d.remain -= bytes_transferred;
auto const pb = prepare_buffers(
auto const pb = buffer_prefix(
bytes_transferred, *d.dmb);
if(d.fh.mask)
detail::mask_inplace(pb, d.key);
if(d.ws.rd_.op == opcode::text)
if(d.ws.rd_.op == detail::opcode::text)
{
if(! d.ws.rd_.utf8.write(pb) ||
(d.remain == 0 && d.fh.fin &&
@@ -285,7 +294,7 @@ operator()(error_code ec,
detail::mask_inplace(in, d.key);
auto const prev = d.db.size();
detail::inflate(d.ws.pmd_->zi, d.db, in, ec);
d.ws.failed_ = ec != 0;
d.ws.failed_ = !!ec;
if(d.ws.failed_)
break;
if(d.remain == 0 && d.fh.fin)
@@ -295,11 +304,11 @@ operator()(error_code ec,
0x00, 0x00, 0xff, 0xff };
detail::inflate(d.ws.pmd_->zi, d.db,
buffer(&empty_block[0], 4), ec);
d.ws.failed_ = ec != 0;
d.ws.failed_ = !!ec;
if(d.ws.failed_)
break;
}
if(d.ws.rd_.op == opcode::text)
if(d.ws.rd_.op == detail::opcode::text)
{
consuming_buffers<typename
DynamicBuffer::const_buffers_type
@@ -321,9 +330,9 @@ operator()(error_code ec,
break;
}
if(d.fh.fin && (
(d.ws.role_ == detail::role_type::client &&
(d.ws.role_ == role_type::client &&
d.ws.pmd_config_.server_no_context_takeover) ||
(d.ws.role_ == detail::role_type::server &&
(d.ws.role_ == role_type::server &&
d.ws.pmd_config_.client_no_context_takeover)))
d.ws.pmd_->zi.reset();
d.state = do_frame_done;
@@ -333,9 +342,6 @@ operator()(error_code ec,
//------------------------------------------------------------------
case do_frame_done:
// call handler
d.fi.op = d.ws.rd_.op;
d.fi.fin = d.fh.fin;
goto upcall;
//------------------------------------------------------------------
@@ -395,8 +401,8 @@ operator()(error_code ec,
d.state = do_control;
break;
}
if(d.fh.op == opcode::text ||
d.fh.op == opcode::binary)
if(d.fh.op == detail::opcode::text ||
d.fh.op == detail::opcode::binary)
d.ws.rd_begin();
if(d.fh.len == 0 && ! d.fh.fin)
{
@@ -425,45 +431,46 @@ operator()(error_code ec,
//------------------------------------------------------------------
case do_control:
if(d.fh.op == opcode::ping)
if(d.fh.op == detail::opcode::ping)
{
ping_data payload;
detail::read(payload, d.fb.data());
d.fb.reset();
if(d.ws.ping_cb_)
d.ws.ping_cb_(false, payload);
d.fb.consume(d.fb.size());
if(d.ws.ctrl_cb_)
d.ws.ctrl_cb_(
frame_type::ping, payload);
if(d.ws.wr_close_)
{
// ignore ping when closing
d.state = do_read_fh;
break;
}
d.ws.template write_ping<static_streambuf>(
d.fb, opcode::pong, payload);
d.ws.template write_ping<static_buffer>(
d.fb, detail::opcode::pong, payload);
if(d.ws.wr_block_)
{
// suspend
d.state = do_pong_resume;
BOOST_ASSERT(d.ws.wr_block_ != &d);
d.ws.rd_op_.template emplace<
read_frame_op>(std::move(*this));
d.state = do_pong_resume;
d.ws.rd_op_.emplace(std::move(*this));
return;
}
d.state = do_pong;
break;
d.ws.wr_block_ = &d;
goto go_pong;
}
else if(d.fh.op == opcode::pong)
if(d.fh.op == detail::opcode::pong)
{
code = close_code::none;
ping_data payload;
detail::read(payload, d.fb.data());
if(d.ws.ping_cb_)
d.ws.ping_cb_(true, payload);
d.fb.reset();
if(d.ws.ctrl_cb_)
d.ws.ctrl_cb_(
frame_type::pong, payload);
d.fb.consume(d.fb.size());
d.state = do_read_fh;
break;
}
BOOST_ASSERT(d.fh.op == opcode::close);
BOOST_ASSERT(d.fh.op == detail::opcode::close);
{
detail::read(d.ws.cr_, d.fb.data(), code);
if(code != close_code::none)
@@ -472,25 +479,28 @@ operator()(error_code ec,
d.state = do_fail;
break;
}
if(d.ws.ctrl_cb_)
d.ws.ctrl_cb_(frame_type::close,
d.ws.cr_.reason);
if(! d.ws.wr_close_)
{
auto cr = d.ws.cr_;
if(cr.code == close_code::none)
cr.code = close_code::normal;
cr.reason = "";
d.fb.reset();
d.fb.consume(d.fb.size());
d.ws.template write_close<
static_streambuf>(d.fb, cr);
static_buffer>(d.fb, cr);
if(d.ws.wr_block_)
{
// suspend
BOOST_ASSERT(d.ws.wr_block_ != &d);
d.state = do_close_resume;
d.ws.rd_op_.template emplace<
read_frame_op>(std::move(*this));
d.ws.rd_op_.emplace(std::move(*this));
return;
}
d.state = do_close;
break;
d.ws.wr_block_ = &d;
goto go_close;
}
d.state = do_teardown;
break;
@@ -502,48 +512,46 @@ operator()(error_code ec,
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = do_pong_resume + 1;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(bind_handler(
std::move(*this), ec, bytes_transferred));
std::move(*this), ec, 0));
return;
case do_pong_resume + 1:
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_)
{
// call handler
ec = boost::asio::error::operation_aborted;
goto upcall;
}
// [[fallthrough]]
//------------------------------------------------------------------
case do_pong:
if(d.ws.wr_close_)
{
// ignore ping when closing
if(d.ws.wr_block_)
{
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.wr_block_ = nullptr;
}
d.fb.reset();
d.ws.wr_block_ = nullptr;
d.fb.consume(d.fb.size());
d.state = do_read_fh;
break;
}
//------------------------------------------------------------------
go_pong:
// send pong
if(! d.ws.wr_block_)
d.ws.wr_block_ = &d;
else
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = do_pong + 1;
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = do_ponged;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case do_pong + 1:
d.fb.reset();
d.state = do_read_fh;
case do_ponged:
d.ws.wr_block_ = nullptr;
d.fb.consume(d.fb.size());
d.state = do_read_fh;
break;
//------------------------------------------------------------------
@@ -571,20 +579,15 @@ operator()(error_code ec,
}
if(d.ws.wr_close_)
{
// call handler
// already sent a close frame
ec = error::closed;
goto upcall;
}
d.state = do_close;
break;
//------------------------------------------------------------------
case do_close:
if(! d.ws.wr_block_)
d.ws.wr_block_ = &d;
else
BOOST_ASSERT(d.ws.wr_block_ == &d);
go_close:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.state = do_teardown;
d.ws.wr_close_ = true;
boost::asio::async_write(d.ws.stream_,
@@ -612,41 +615,51 @@ operator()(error_code ec,
d.state = do_fail + 4;
break;
}
d.fb.reset();
d.fb.consume(d.fb.size());
d.ws.template write_close<
static_streambuf>(d.fb, code);
static_buffer>(d.fb, code);
if(d.ws.wr_block_)
{
// suspend
BOOST_ASSERT(d.ws.wr_block_ != &d);
d.state = do_fail + 2;
d.ws.rd_op_.template emplace<
read_frame_op>(std::move(*this));
d.ws.rd_op_.emplace(std::move(*this));
return;
}
// fall through
d.ws.wr_block_ = &d;
BEAST_FALLTHROUGH;
case do_fail + 1:
BOOST_ASSERT(d.ws.wr_block_ == &d);
d.ws.failed_ = true;
// send close frame
d.state = do_fail + 4;
d.ws.wr_close_ = true;
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
boost::asio::async_write(d.ws.stream_,
d.fb.data(), std::move(*this));
return;
case do_fail + 2:
// resume
BOOST_ASSERT(! d.ws.wr_block_);
d.ws.wr_block_ = &d;
d.state = do_fail + 3;
// The current context is safe but might not be
// the same as the one for this operation (since
// we are being called from a write operation).
// Call post to make sure we are invoked the same
// way as the final handler for this operation.
d.ws.get_io_service().post(bind_handler(
std::move(*this), ec, bytes_transferred));
return;
case do_fail + 3:
if(d.ws.failed_)
BOOST_ASSERT(d.ws.wr_block_ == &d);
if(d.ws.failed_ || d.ws.wr_close_)
{
d.state = do_fail + 5;
break;
// call handler
ec = error::failed;
goto upcall;
}
d.state = do_fail + 1;
break;
@@ -673,61 +686,65 @@ operator()(error_code ec,
upcall:
if(d.ws.wr_block_ == &d)
d.ws.wr_block_ = nullptr;
d.ws.ping_op_.maybe_invoke() ||
d.ws.close_op_.maybe_invoke() ||
d.ws.ping_op_.maybe_invoke() ||
d.ws.wr_op_.maybe_invoke();
d_.invoke(ec);
bool const fin = (! ec) ? d.fh.fin : false;
d_.invoke(ec, fin);
}
template<class NextLayer>
template<class DynamicBuffer, class ReadHandler>
typename async_completion<
ReadHandler, void(error_code)>::result_type
async_return_type<
ReadHandler, void(error_code, bool)>
stream<NextLayer>::
async_read_frame(frame_info& fi,
DynamicBuffer& dynabuf, ReadHandler&& handler)
async_read_frame(DynamicBuffer& buffer, ReadHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
beast::async_completion<
ReadHandler, void(error_code)> completion{handler};
read_frame_op<DynamicBuffer, decltype(completion.handler)>{
completion.handler, *this, fi, dynabuf};
return completion.result.get();
async_completion<ReadHandler,
void(error_code, bool)> init{handler};
read_frame_op<DynamicBuffer, handler_type<
ReadHandler, void(error_code, bool)>>{
init.completion_handler,*this, buffer}(
{}, 0, false);
return init.result.get();
}
template<class NextLayer>
template<class DynamicBuffer>
void
bool
stream<NextLayer>::
read_frame(frame_info& fi, DynamicBuffer& dynabuf)
read_frame(DynamicBuffer& buffer)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
error_code ec;
read_frame(fi, dynabuf, ec);
auto const fin = read_frame(buffer, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
return fin;
}
template<class NextLayer>
template<class DynamicBuffer>
void
bool
stream<NextLayer>::
read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
read_frame(DynamicBuffer& dynabuf, error_code& ec)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
using beast::detail::clamp;
using boost::asio::buffer;
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
close_code::value code{};
close_code code{};
for(;;)
{
// Read frame header
@@ -736,9 +753,9 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
{
fb.commit(boost::asio::read(
stream_, fb.prepare(2), ec));
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
{
auto const n = read_fh1(fh, fb, code);
if(code != close_code::none)
@@ -747,16 +764,16 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
{
fb.commit(boost::asio::read(
stream_, fb.prepare(n), ec));
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
}
}
read_fh2(fh, fb, code);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
if(code != close_code::none)
goto do_close;
}
@@ -768,9 +785,9 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
auto const mb = fb.prepare(
static_cast<std::size_t>(fh.len));
fb.commit(boost::asio::read(stream_, mb, ec));
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
if(fh.mask)
{
detail::prepared_key key;
@@ -780,52 +797,54 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
fb.commit(static_cast<std::size_t>(fh.len));
}
// Process control frame
if(fh.op == opcode::ping)
if(fh.op == detail::opcode::ping)
{
ping_data payload;
detail::read(payload, fb.data());
fb.reset();
if(ping_cb_)
ping_cb_(false, payload);
write_ping<static_streambuf>(
fb, opcode::pong, payload);
fb.consume(fb.size());
if(ctrl_cb_)
ctrl_cb_(frame_type::ping, payload);
write_ping<static_buffer>(fb,
detail::opcode::pong, payload);
boost::asio::write(stream_, fb.data(), ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
continue;
}
else if(fh.op == opcode::pong)
else if(fh.op == detail::opcode::pong)
{
ping_data payload;
detail::read(payload, fb.data());
if(ping_cb_)
ping_cb_(true, payload);
if(ctrl_cb_)
ctrl_cb_(frame_type::pong, payload);
continue;
}
BOOST_ASSERT(fh.op == opcode::close);
BOOST_ASSERT(fh.op == detail::opcode::close);
{
detail::read(cr_, fb.data(), code);
if(code != close_code::none)
goto do_close;
if(ctrl_cb_)
ctrl_cb_(frame_type::close, cr_.reason);
if(! wr_close_)
{
auto cr = cr_;
if(cr.code == close_code::none)
cr.code = close_code::normal;
cr.reason = "";
fb.reset();
fb.consume(fb.size());
wr_close_ = true;
write_close<static_streambuf>(fb, cr);
write_close<static_buffer>(fb, cr);
boost::asio::write(stream_, fb.data(), ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
}
goto do_close;
}
}
if(fh.op != opcode::cont)
if(fh.op != detail::opcode::cont)
rd_begin();
if(fh.len == 0 && ! fh.fin)
{
@@ -853,16 +872,16 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
dynabuf.prepare(clamp(remain));
auto const bytes_transferred =
stream_.read_some(b, ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
BOOST_ASSERT(bytes_transferred > 0);
remain -= bytes_transferred;
auto const pb = prepare_buffers(
auto const pb = buffer_prefix(
bytes_transferred, b);
if(fh.mask)
detail::mask_inplace(pb, key);
if(rd_.op == opcode::text)
if(rd_.op == detail::opcode::text)
{
if(! rd_.utf8.write(pb) ||
(remain == 0 && fh.fin &&
@@ -885,9 +904,9 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
auto const bytes_transferred =
stream_.read_some(buffer(rd_.buf.get(),
clamp(remain, rd_.buf_size)), ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
remain -= bytes_transferred;
auto const in = buffer(
rd_.buf.get(), bytes_transferred);
@@ -895,9 +914,9 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
detail::mask_inplace(in, key);
auto const prev = dynabuf.size();
detail::inflate(pmd_->zi, dynabuf, in, ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
if(remain == 0 && fh.fin)
{
static std::uint8_t constexpr
@@ -905,11 +924,11 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
0x00, 0x00, 0xff, 0xff };
detail::inflate(pmd_->zi, dynabuf,
buffer(&empty_block[0], 4), ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
}
if(rd_.op == opcode::text)
if(rd_.op == detail::opcode::text)
{
consuming_buffers<typename
DynamicBuffer::const_buffers_type
@@ -927,15 +946,13 @@ read_frame(frame_info& fi, DynamicBuffer& dynabuf, error_code& ec)
break;
}
if(fh.fin && (
(role_ == detail::role_type::client &&
(role_ == role_type::client &&
pmd_config_.server_no_context_takeover) ||
(role_ == detail::role_type::server &&
(role_ == role_type::server &&
pmd_config_.client_no_context_takeover)))
pmd_->zi.reset();
}
fi.op = rd_.op;
fi.fin = fh.fin;
return;
return fh.fin;
}
do_close:
if(code != close_code::none)
@@ -945,25 +962,41 @@ do_close:
{
wr_close_ = true;
detail::frame_streambuf fb;
write_close<static_streambuf>(fb, code);
write_close<static_buffer>(fb, code);
boost::asio::write(stream_, fb.data(), ec);
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return;
return false;
}
websocket_helpers::call_teardown(next_layer(), ec);
failed_ = ec != 0;
if(ec == boost::asio::error::eof)
{
// Rationale:
// http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error
ec.assign(0, ec.category());
}
failed_ = !!ec;
if(failed_)
return;
return false;
ec = error::failed;
failed_ = true;
return;
return false;
}
if(! ec)
{
websocket_helpers::call_teardown(next_layer(), ec);
if(ec == boost::asio::error::eof)
{
// (See above)
ec.assign(0, ec.category());
}
}
if(! ec)
ec = error::closed;
failed_ = ec != 0;
failed_ = !!ec;
if(failed_)
return false;
return true;
}
//------------------------------------------------------------------------------
@@ -974,73 +1007,58 @@ template<class NextLayer>
template<class DynamicBuffer, class Handler>
class stream<NextLayer>::read_op
{
struct data
{
bool cont;
stream<NextLayer>& ws;
opcode& op;
DynamicBuffer& db;
frame_info fi;
int state = 0;
data(Handler& handler,
stream<NextLayer>& ws_, opcode& op_,
DynamicBuffer& sb_)
: cont(beast_asio_helpers::
is_continuation(handler))
, ws(ws_)
, op(op_)
, db(sb_)
{
}
};
handler_ptr<data, Handler> d_;
int state_ = 0;
stream<NextLayer>& ws_;
DynamicBuffer& b_;
Handler h_;
public:
read_op(read_op&&) = default;
read_op(read_op const&) = default;
template<class DeducedHandler, class... Args>
template<class DeducedHandler>
read_op(DeducedHandler&& h,
stream<NextLayer>& ws, Args&&... args)
: d_(std::forward<DeducedHandler>(h),
ws, std::forward<Args>(args)...)
stream<NextLayer>& ws, DynamicBuffer& b)
: ws_(ws)
, b_(b)
, h_(std::forward<DeducedHandler>(h))
{
(*this)(error_code{}, false);
}
void operator()(
error_code const& ec, bool again = true);
void operator()(error_code const& ec, bool fin);
friend
void* asio_handler_allocate(
std::size_t size, read_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->h_));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, read_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->h_));
}
friend
bool asio_handler_is_continuation(read_op* op)
{
return op->d_->cont;
using boost::asio::asio_handler_is_continuation;
return op->state_ >= 2 ? true:
asio_handler_is_continuation(std::addressof(op->h_));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, read_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(f, std::addressof(op->h_));
}
};
@@ -1048,88 +1066,83 @@ template<class NextLayer>
template<class DynamicBuffer, class Handler>
void
stream<NextLayer>::read_op<DynamicBuffer, Handler>::
operator()(error_code const& ec, bool again)
operator()(error_code const& ec, bool fin)
{
auto& d = *d_;
d.cont = d.cont || again;
while(! ec)
switch(state_)
{
switch(d.state)
{
case 0:
// read payload
d.state = 1;
d.ws.async_read_frame(
d.fi, d.db, std::move(*this));
return;
case 0:
state_ = 1;
goto do_read;
// got payload
case 1:
d.op = d.fi.op;
if(d.fi.fin)
goto upcall;
d.state = 0;
break;
}
case 1:
state_ = 2;
BEAST_FALLTHROUGH;
case 2:
if(ec)
goto upcall;
if(fin)
goto upcall;
do_read:
return ws_.async_read_frame(
b_, std::move(*this));
}
upcall:
d_.invoke(ec);
h_(ec);
}
template<class NextLayer>
template<class DynamicBuffer, class ReadHandler>
typename async_completion<
ReadHandler, void(error_code)>::result_type
async_return_type<
ReadHandler, void(error_code)>
stream<NextLayer>::
async_read(opcode& op,
DynamicBuffer& dynabuf, ReadHandler&& handler)
async_read(DynamicBuffer& buffer, ReadHandler&& handler)
{
static_assert(is_AsyncStream<next_layer_type>::value,
static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
beast::async_completion<
ReadHandler, void(error_code)
> completion{handler};
read_op<DynamicBuffer, decltype(completion.handler)>{
completion.handler, *this, op, dynabuf};
return completion.result.get();
async_completion<ReadHandler,
void(error_code)> init{handler};
read_op<DynamicBuffer, handler_type<
ReadHandler, void(error_code)>>{
init.completion_handler, *this, buffer}(
{}, false);
return init.result.get();
}
template<class NextLayer>
template<class DynamicBuffer>
void
stream<NextLayer>::
read(opcode& op, DynamicBuffer& dynabuf)
read(DynamicBuffer& buffer)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
error_code ec;
read(op, dynabuf, ec);
read(buffer, ec);
if(ec)
throw system_error{ec};
BOOST_THROW_EXCEPTION(system_error{ec});
}
template<class NextLayer>
template<class DynamicBuffer>
void
stream<NextLayer>::
read(opcode& op, DynamicBuffer& dynabuf, error_code& ec)
read(DynamicBuffer& buffer, error_code& ec)
{
static_assert(is_SyncStream<next_layer_type>::value,
static_assert(is_sync_stream<next_layer_type>::value,
"SyncStream requirements not met");
static_assert(beast::is_DynamicBuffer<DynamicBuffer>::value,
static_assert(beast::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
frame_info fi;
for(;;)
{
read_frame(fi, dynabuf, ec);
auto const fin = read_frame(buffer, ec);
if(ec)
break;
op = fi.op;
if(fi.fin)
if(fin)
break;
}
}

38
include/beast/websocket/impl/rfc6455.ipp Normal file
View File

@@ -0,0 +1,38 @@
//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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_WEBSOCKET_IMPL_RFC6455_IPP
#define BEAST_WEBSOCKET_IMPL_RFC6455_IPP
#include <beast/http/fields.hpp>
#include <beast/http/rfc7230.hpp>
namespace beast {
namespace websocket {
template<class Allocator>
bool
is_upgrade(http::header<true,
http::basic_fields<Allocator>> const& req)
{
if(req.version < 11)
return false;
if(req.method() != http::verb::get)
return false;
if(! http::token_list{req["Connection"]}.exists("upgrade"))
return false;
if(! http::token_list{req["Upgrade"]}.exists("websocket"))
return false;
if(! req.count(http::field::sec_websocket_version))
return false;
return true;
}
} // websocket
} // beast
#endif

105
include/beast/websocket/impl/ssl.ipp
View File

@@ -8,16 +8,11 @@
#ifndef BEAST_WEBSOCKET_IMPL_SSL_IPP_INCLUDED
#define BEAST_WEBSOCKET_IMPL_SSL_IPP_INCLUDED
#include <beast/core/async_completion.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_ptr.hpp>
#include <utility>
namespace beast {
namespace websocket {
namespace detail {
/*
See
@@ -32,97 +27,6 @@ Behavior of ssl::stream regarding close_
to async_shutdown will complete with eof.
*/
template<class AsyncStream, class Handler>
class teardown_ssl_op
{
using stream_type =
boost::asio::ssl::stream<AsyncStream>;
struct data
{
bool cont;
stream_type& stream;
int state = 0;
data(Handler& handler, stream_type& stream_)
: cont(beast_asio_helpers::
is_continuation(handler))
, stream(stream_)
{
}
};
handler_ptr<data, Handler> d_;
public:
template<class DeducedHandler>
explicit
teardown_ssl_op(
DeducedHandler&& h, stream_type& stream)
: d_(std::forward<DeducedHandler>(h), stream)
{
(*this)(error_code{}, false);
}
void
operator()(error_code ec, bool again = true);
friend
void* asio_handler_allocate(std::size_t size,
teardown_ssl_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
}
friend
void asio_handler_deallocate(void* p,
std::size_t size, teardown_ssl_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
}
friend
bool asio_handler_is_continuation(
teardown_ssl_op* op)
{
return op->d_->cont;
}
template<class Function>
friend
void asio_handler_invoke(Function&& f,
teardown_ssl_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
}
};
template<class AsyncStream, class Handler>
void
teardown_ssl_op<AsyncStream, Handler>::
operator()(error_code ec, bool again)
{
auto& d = *d_;
d.cont = d.cont || again;
while(!ec && d.state != 99)
{
switch(d.state)
{
case 0:
d.state = 99;
d.stream.async_shutdown(*this);
return;
}
}
d_.invoke(ec);
}
} // detail
//------------------------------------------------------------------------------
template<class AsyncStream>
void
@@ -139,12 +43,7 @@ async_teardown(teardown_tag,
boost::asio::ssl::stream<AsyncStream>& stream,
TeardownHandler&& handler)
{
static_assert(beast::is_CompletionHandler<
TeardownHandler, void(error_code)>::value,
"TeardownHandler requirements not met");
detail::teardown_ssl_op<AsyncStream, typename std::decay<
TeardownHandler>::type>{std::forward<TeardownHandler>(
handler), stream};
stream.async_shutdown(std::forward<TeardownHandler>(handler));
}
} // websocket

632
include/beast/websocket/impl/stream.ipp
View File

@@ -8,27 +8,31 @@
#ifndef BEAST_WEBSOCKET_IMPL_STREAM_IPP
#define BEAST_WEBSOCKET_IMPL_STREAM_IPP
#include <beast/websocket/rfc6455.hpp>
#include <beast/websocket/teardown.hpp>
#include <beast/websocket/detail/hybi13.hpp>
#include <beast/websocket/detail/pmd_extension.hpp>
#include <beast/version.hpp>
#include <beast/http/read.hpp>
#include <beast/http/write.hpp>
#include <beast/http/reason.hpp>
#include <beast/http/rfc7230.hpp>
#include <beast/core/buffer_cat.hpp>
#include <beast/core/buffer_concepts.hpp>
#include <beast/core/buffer_prefix.hpp>
#include <beast/core/consuming_buffers.hpp>
#include <beast/core/prepare_buffers.hpp>
#include <beast/core/static_streambuf.hpp>
#include <beast/core/stream_concepts.hpp>
#include <beast/core/static_buffer.hpp>
#include <beast/core/type_traits.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/assert.hpp>
#include <boost/endian/buffers.hpp>
#include <boost/make_unique.hpp>
#include <boost/throw_exception.hpp>
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <utility>
#include <iostream>
namespace beast {
namespace websocket {
@@ -47,20 +51,20 @@ set_option(permessage_deflate const& o)
{
if( o.server_max_window_bits > 15 ||
o.server_max_window_bits < 9)
throw std::invalid_argument{
"invalid server_max_window_bits"};
BOOST_THROW_EXCEPTION(std::invalid_argument{
"invalid server_max_window_bits"});
if( o.client_max_window_bits > 15 ||
o.client_max_window_bits < 9)
throw std::invalid_argument{
"invalid client_max_window_bits"};
BOOST_THROW_EXCEPTION(std::invalid_argument{
"invalid client_max_window_bits"});
if( o.compLevel < 0 ||
o.compLevel > 9)
throw std::invalid_argument{
"invalid compLevel"};
BOOST_THROW_EXCEPTION(std::invalid_argument{
"invalid compLevel"});
if( o.memLevel < 1 ||
o.memLevel > 9)
throw std::invalid_argument{
"invalid memLevel"};
BOOST_THROW_EXCEPTION(std::invalid_argument{
"invalid memLevel"});
pmd_opts_ = o;
}
@@ -83,20 +87,91 @@ reset()
}
template<class NextLayer>
http::request<http::empty_body>
template<class Decorator>
void
stream<NextLayer>::
build_request(boost::string_ref const& host,
boost::string_ref const& resource, std::string& key)
do_accept(
Decorator const& decorator, error_code& ec)
{
http::request<http::empty_body> req;
req.url = { resource.data(), resource.size() };
http::request_parser<http::empty_body> p;
http::read_header(next_layer(),
stream_.buffer(), p, ec);
if(ec)
return;
do_accept(p.get(), decorator, ec);
}
template<class NextLayer>
template<class Allocator, class Decorator>
void
stream<NextLayer>::
do_accept(http::header<true,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator, error_code& ec)
{
auto const res = build_response(req, decorator);
http::write(stream_, res, ec);
if(ec)
return;
if(res.result() != http::status::switching_protocols)
{
ec = error::handshake_failed;
// VFALCO TODO Respect keep alive setting, perform
// teardown if Connection: close.
return;
}
pmd_read(pmd_config_, req);
open(role_type::server);
}
template<class NextLayer>
template<class RequestDecorator>
void
stream<NextLayer>::
do_handshake(response_type* res_p,
string_view host,
string_view target,
RequestDecorator const& decorator,
error_code& ec)
{
response_type res;
reset();
detail::sec_ws_key_type key;
{
auto const req = build_request(
key, host, target, decorator);
pmd_read(pmd_config_, req);
http::write(stream_, req, ec);
}
if(ec)
return;
http::read(next_layer(), stream_.buffer(), res, ec);
if(ec)
return;
do_response(res, key, ec);
if(res_p)
*res_p = std::move(res);
}
template<class NextLayer>
template<class Decorator>
request_type
stream<NextLayer>::
build_request(detail::sec_ws_key_type& key,
string_view host,
string_view target,
Decorator const& decorator)
{
request_type req;
req.target(target);
req.version = 11;
req.method = "GET";
req.fields.insert("Host", host);
req.fields.insert("Upgrade", "websocket");
key = detail::make_sec_ws_key(maskgen_);
req.fields.insert("Sec-WebSocket-Key", key);
req.fields.insert("Sec-WebSocket-Version", "13");
req.method(http::verb::get);
req.set(http::field::host, host);
req.set(http::field::upgrade, "websocket");
req.set(http::field::connection, "upgrade");
detail::make_sec_ws_key(key, maskgen_);
req.set(http::field::sec_websocket_key, key);
req.set(http::field::sec_websocket_version, "13");
if(pmd_opts_.client_enable)
{
detail::pmd_offer config;
@@ -109,119 +184,502 @@ build_request(boost::string_ref const& host,
pmd_opts_.server_no_context_takeover;
config.client_no_context_takeover =
pmd_opts_.client_no_context_takeover;
detail::pmd_write(
req.fields, config);
detail::pmd_write(req, config);
}
d_(req);
http::prepare(req, http::connection::upgrade);
decorator(req);
if(! req.count(http::field::user_agent))
req.set(http::field::user_agent,
BEAST_VERSION_STRING);
return req;
}
template<class NextLayer>
template<class Body, class Fields>
http::response<http::string_body>
template<class Allocator, class Decorator>
response_type
stream<NextLayer>::
build_response(http::request<Body, Fields> const& req)
build_response(http::header<true,
http::basic_fields<Allocator>> const& req,
Decorator const& decorator)
{
auto const decorate =
[&decorator](response_type& res)
{
decorator(res);
if(! res.count(http::field::server))
{
BOOST_STATIC_ASSERT(sizeof(BEAST_VERSION_STRING) < 20);
static_string<20> s(BEAST_VERSION_STRING);
res.set(http::field::server, s);
}
};
auto err =
[&](std::string const& text)
{
http::response<http::string_body> res;
res.status = 400;
res.reason = http::reason_string(res.status);
response_type res;
res.version = req.version;
res.result(http::status::bad_request);
res.body = text;
d_(res);
prepare(res,
(is_keep_alive(req) && keep_alive_) ?
http::connection::keep_alive :
http::connection::close);
res.prepare_payload();
decorate(res);
return res;
};
if(req.version < 11)
return err("HTTP version 1.1 required");
if(req.method != "GET")
if(req.method() != http::verb::get)
return err("Wrong method");
if(! is_upgrade(req))
return err("Expected Upgrade request");
if(! req.fields.exists("Host"))
if(! req.count(http::field::host))
return err("Missing Host");
if(! req.fields.exists("Sec-WebSocket-Key"))
if(! req.count(http::field::sec_websocket_key))
return err("Missing Sec-WebSocket-Key");
if(! http::token_list{req.fields["Upgrade"]}.exists("websocket"))
if(! http::token_list{req[http::field::upgrade]}.exists("websocket"))
return err("Missing websocket Upgrade token");
auto const key = req[http::field::sec_websocket_key];
if(key.size() > detail::sec_ws_key_type::max_size_n)
return err("Invalid Sec-WebSocket-Key");
{
auto const version =
req.fields["Sec-WebSocket-Version"];
req[http::field::sec_websocket_version];
if(version.empty())
return err("Missing Sec-WebSocket-Version");
if(version != "13")
{
http::response<http::string_body> res;
res.status = 426;
res.reason = http::reason_string(res.status);
response_type res;
res.result(http::status::upgrade_required);
res.version = req.version;
res.fields.insert("Sec-WebSocket-Version", "13");
d_(res);
prepare(res,
(is_keep_alive(req) && keep_alive_) ?
http::connection::keep_alive :
http::connection::close);
res.set(http::field::sec_websocket_version, "13");
res.prepare_payload();
decorate(res);
return res;
}
}
http::response<http::string_body> res;
response_type res;
{
detail::pmd_offer offer;
detail::pmd_offer unused;
pmd_read(offer, req.fields);
pmd_negotiate(
res.fields, unused, offer, pmd_opts_);
pmd_read(offer, req);
pmd_negotiate(res, unused, offer, pmd_opts_);
}
res.status = 101;
res.reason = http::reason_string(res.status);
res.result(http::status::switching_protocols);
res.version = req.version;
res.fields.insert("Upgrade", "websocket");
res.set(http::field::upgrade, "websocket");
res.set(http::field::connection, "upgrade");
{
auto const key =
req.fields["Sec-WebSocket-Key"];
res.fields.insert("Sec-WebSocket-Accept",
detail::make_sec_ws_accept(key));
detail::sec_ws_accept_type acc;
detail::make_sec_ws_accept(acc, key);
res.set(http::field::sec_websocket_accept, acc);
}
res.fields.replace("Server", "Beast.WSProto");
d_(res);
http::prepare(res, http::connection::upgrade);
decorate(res);
return res;
}
template<class NextLayer>
template<class Body, class Fields>
void
stream<NextLayer>::
do_response(http::response<Body, Fields> const& res,
boost::string_ref const& key, error_code& ec)
do_response(http::header<false> const& res,
detail::sec_ws_key_type const& key, error_code& ec)
{
// VFALCO Review these error codes
auto fail = [&]{ ec = error::response_failed; };
if(res.version < 11)
return fail();
if(res.status != 101)
return fail();
if(! is_upgrade(res))
return fail();
if(! http::token_list{res.fields["Upgrade"]}.exists("websocket"))
return fail();
if(! res.fields.exists("Sec-WebSocket-Accept"))
return fail();
if(res.fields["Sec-WebSocket-Accept"] !=
detail::make_sec_ws_accept(key))
return fail();
bool const success = [&]()
{
if(res.version < 11)
return false;
if(res.result() != http::status::switching_protocols)
return false;
if(! http::token_list{res[http::field::connection]}.exists("upgrade"))
return false;
if(! http::token_list{res[http::field::upgrade]}.exists("websocket"))
return false;
if(res.count(http::field::sec_websocket_accept) != 1)
return false;
detail::sec_ws_accept_type acc;
detail::make_sec_ws_accept(acc, key);
if(acc.compare(
res[http::field::sec_websocket_accept]) != 0)
return false;
return true;
}();
if(! success)
{
ec = error::handshake_failed;
return;
}
ec.assign(0, ec.category());
detail::pmd_offer offer;
pmd_read(offer, res.fields);
pmd_read(offer, res);
// VFALCO see if offer satisfies pmd_config_,
// return an error if not.
pmd_config_ = offer; // overwrite for now
open(detail::role_type::client);
open(role_type::client);
}
//------------------------------------------------------------------------------
template<class NextLayer>
void
stream<NextLayer>::
open(role_type role)
{
// VFALCO TODO analyze and remove dupe code in reset()
role_ = role;
failed_ = false;
rd_.cont = false;
wr_close_ = false;
wr_block_ = nullptr; // should be nullptr on close anyway
ping_data_ = nullptr; // should be nullptr on close anyway
wr_.cont = false;
wr_.buf_size = 0;
if(((role_ == role_type::client && pmd_opts_.client_enable) ||
(role_ == role_type::server && pmd_opts_.server_enable)) &&
pmd_config_.accept)
{
pmd_normalize(pmd_config_);
pmd_.reset(new pmd_t);
if(role_ == role_type::client)
{
pmd_->zi.reset(
pmd_config_.server_max_window_bits);
pmd_->zo.reset(
pmd_opts_.compLevel,
pmd_config_.client_max_window_bits,
pmd_opts_.memLevel,
zlib::Strategy::normal);
}
else
{
pmd_->zi.reset(
pmd_config_.client_max_window_bits);
pmd_->zo.reset(
pmd_opts_.compLevel,
pmd_config_.server_max_window_bits,
pmd_opts_.memLevel,
zlib::Strategy::normal);
}
}
}
template<class NextLayer>
void
stream<NextLayer>::
close()
{
rd_.buf.reset();
wr_.buf.reset();
pmd_.reset();
}
// Read fixed frame header from buffer
// Requires at least 2 bytes
//
template<class NextLayer>
template<class DynamicBuffer>
std::size_t
stream<NextLayer>::
read_fh1(detail::frame_header& fh,
DynamicBuffer& db, close_code& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
auto const err =
[&](close_code cv)
{
code = cv;
return 0;
};
std::uint8_t b[2];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
std::size_t need;
fh.len = b[1] & 0x7f;
switch(fh.len)
{
case 126: need = 2; break;
case 127: need = 8; break;
default:
need = 0;
}
fh.mask = (b[1] & 0x80) != 0;
if(fh.mask)
need += 4;
fh.op = static_cast<
detail::opcode>(b[0] & 0x0f);
fh.fin = (b[0] & 0x80) != 0;
fh.rsv1 = (b[0] & 0x40) != 0;
fh.rsv2 = (b[0] & 0x20) != 0;
fh.rsv3 = (b[0] & 0x10) != 0;
switch(fh.op)
{
case detail::opcode::binary:
case detail::opcode::text:
if(rd_.cont)
{
// new data frame when continuation expected
return err(close_code::protocol_error);
}
if((fh.rsv1 && ! pmd_) ||
fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
if(pmd_)
pmd_->rd_set = fh.rsv1;
break;
case detail::opcode::cont:
if(! rd_.cont)
{
// continuation without an active message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
default:
if(is_reserved(fh.op))
{
// reserved opcode
return err(close_code::protocol_error);
}
if(! fh.fin)
{
// fragmented control message
return err(close_code::protocol_error);
}
if(fh.len > 125)
{
// invalid length for control message
return err(close_code::protocol_error);
}
if(fh.rsv1 || fh.rsv2 || fh.rsv3)
{
// reserved bits not cleared
return err(close_code::protocol_error);
}
break;
}
// unmasked frame from client
if(role_ == role_type::server && ! fh.mask)
{
code = close_code::protocol_error;
return 0;
}
// masked frame from server
if(role_ == role_type::client && fh.mask)
{
code = close_code::protocol_error;
return 0;
}
code = close_code::none;
return need;
}
// Decode variable frame header from buffer
//
template<class NextLayer>
template<class DynamicBuffer>
void
stream<NextLayer>::
read_fh2(detail::frame_header& fh,
DynamicBuffer& db, close_code& code)
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
using boost::asio::buffer_size;
using namespace boost::endian;
switch(fh.len)
{
case 126:
{
std::uint8_t b[2];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.len = detail::big_uint16_to_native(&b[0]);
// length not canonical
if(fh.len < 126)
{
code = close_code::protocol_error;
return;
}
break;
}
case 127:
{
std::uint8_t b[8];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.len = detail::big_uint64_to_native(&b[0]);
// length not canonical
if(fh.len < 65536)
{
code = close_code::protocol_error;
return;
}
break;
}
}
if(fh.mask)
{
std::uint8_t b[4];
BOOST_ASSERT(buffer_size(db.data()) >= sizeof(b));
db.consume(buffer_copy(buffer(b), db.data()));
fh.key = detail::little_uint32_to_native(&b[0]);
}
else
{
// initialize this otherwise operator== breaks
fh.key = 0;
}
if(! is_control(fh.op))
{
if(fh.op != detail::opcode::cont)
{
rd_.size = 0;
rd_.op = fh.op;
}
else
{
if(rd_.size > (std::numeric_limits<
std::uint64_t>::max)() - fh.len)
{
code = close_code::too_big;
return;
}
}
rd_.cont = ! fh.fin;
}
code = close_code::none;
}
template<class NextLayer>
void
stream<NextLayer>::
rd_begin()
{
// Maintain the read buffer
if(pmd_)
{
if(! rd_.buf || rd_.buf_size != rd_buf_size_)
{
rd_.buf_size = rd_buf_size_;
rd_.buf = boost::make_unique_noinit<
std::uint8_t[]>(rd_.buf_size);
}
}
}
template<class NextLayer>
void
stream<NextLayer>::
wr_begin()
{
wr_.autofrag = wr_autofrag_;
wr_.compress = static_cast<bool>(pmd_);
// Maintain the write buffer
if( wr_.compress ||
role_ == role_type::client)
{
if(! wr_.buf || wr_.buf_size != wr_buf_size_)
{
wr_.buf_size = wr_buf_size_;
wr_.buf = boost::make_unique_noinit<
std::uint8_t[]>(wr_.buf_size);
}
}
else
{
wr_.buf_size = wr_buf_size_;
wr_.buf.reset();
}
}
template<class NextLayer>
template<class DynamicBuffer>
void
stream<NextLayer>::
write_close(DynamicBuffer& db, close_reason const& cr)
{
using namespace boost::endian;
detail::frame_header fh;
fh.op = detail::opcode::close;
fh.fin = true;
fh.rsv1 = false;
fh.rsv2 = false;
fh.rsv3 = false;
fh.len = cr.code == close_code::none ?
0 : 2 + cr.reason.size();
fh.mask = role_ == role_type::client;
if(fh.mask)
fh.key = maskgen_();
detail::write(db, fh);
if(cr.code != close_code::none)
{
detail::prepared_key key;
if(fh.mask)
detail::prepare_key(key, fh.key);
{
std::uint8_t b[2];
::new(&b[0]) big_uint16_buf_t{
(std::uint16_t)cr.code};
auto d = db.prepare(2);
boost::asio::buffer_copy(d,
boost::asio::buffer(b));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(2);
}
if(! cr.reason.empty())
{
auto d = db.prepare(cr.reason.size());
boost::asio::buffer_copy(d,
boost::asio::const_buffer(
cr.reason.data(), cr.reason.size()));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(cr.reason.size());
}
}
}
template<class NextLayer>
template<class DynamicBuffer>
void
stream<NextLayer>::
write_ping(DynamicBuffer& db,
detail::opcode code, ping_data const& data)
{
detail::frame_header fh;
fh.op = code;
fh.fin = true;
fh.rsv1 = false;
fh.rsv2 = false;
fh.rsv3 = false;
fh.len = data.size();
fh.mask = role_ == role_type::client;
if(fh.mask)
fh.key = maskgen_();
detail::write(db, fh);
if(data.empty())
return;
detail::prepared_key key;
if(fh.mask)
detail::prepare_key(key, fh.key);
auto d = db.prepare(data.size());
boost::asio::buffer_copy(d,
boost::asio::const_buffers_1(
data.data(), data.size()));
if(fh.mask)
detail::mask_inplace(d, key);
db.commit(data.size());
}
} // websocket

31
include/beast/websocket/impl/teardown.ipp
View File

@@ -8,10 +8,12 @@
#ifndef BEAST_WEBSOCKET_IMPL_TEARDOWN_IPP
#define BEAST_WEBSOCKET_IMPL_TEARDOWN_IPP
#include <beast/core/async_completion.hpp>
#include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_helpers.hpp>
#include <beast/core/async_result.hpp>
#include <beast/core/handler_ptr.hpp>
#include <beast/core/type_traits.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <memory>
namespace beast {
@@ -33,10 +35,10 @@ class teardown_tcp_op
int state = 0;
data(Handler& handler, socket_type& socket_)
: cont(beast_asio_helpers::
is_continuation(handler))
, socket(socket_)
: socket(socket_)
{
using boost::asio::asio_handler_is_continuation;
cont = asio_handler_is_continuation(std::addressof(handler));
}
};
@@ -59,16 +61,18 @@ public:
void* asio_handler_allocate(std::size_t size,
teardown_tcp_op* op)
{
return beast_asio_helpers::
allocate(size, op->d_.handler());
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->d_.handler()));
}
friend
void asio_handler_deallocate(void* p,
std::size_t size, teardown_tcp_op* op)
{
return beast_asio_helpers::
deallocate(p, size, op->d_.handler());
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->d_.handler()));
}
friend
@@ -82,8 +86,9 @@ public:
void asio_handler_invoke(Function&& f,
teardown_tcp_op* op)
{
return beast_asio_helpers::
invoke(f, op->d_.handler());
using boost::asio::asio_handler_invoke;
asio_handler_invoke(
f, std::addressof(op->d_.handler()));
}
};
@@ -152,7 +157,7 @@ async_teardown(teardown_tag,
boost::asio::ip::tcp::socket& socket,
TeardownHandler&& handler)
{
static_assert(beast::is_CompletionHandler<
static_assert(beast::is_completion_handler<
TeardownHandler, void(error_code)>::value,
"TeardownHandler requirements not met");
detail::teardown_tcp_op<typename std::decay<

1113
include/beast/websocket/impl/write.ipp
View File

File diff suppressed because it is too large Load Diff

350
include/beast/websocket/option.hpp
View File

@@ -10,8 +10,8 @@
#include <beast/config.hpp>
#include <beast/websocket/rfc6455.hpp>
#include <beast/websocket/detail/decorator.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/throw_exception.hpp>
#include <algorithm>
#include <cstdint>
#include <functional>
@@ -22,177 +22,6 @@
namespace beast {
namespace websocket {
/** Automatic fragmentation option.
Determines if outgoing message payloads are broken up into
multiple pieces.
When the automatic fragmentation size is turned on, outgoing
message payloads are broken up into multiple frames no larger
than the write buffer size.
The default setting is to fragment messages.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the automatic fragmentation option:
@code
...
websocket::stream<ip::tcp::socket> stream(ios);
stream.set_option(auto_fragment{true});
@endcode
*/
#if GENERATING_DOCS
using auto_fragment = implementation_defined;
#else
struct auto_fragment
{
bool value;
explicit
auto_fragment(bool v)
: value(v)
{
}
};
#endif
/** HTTP decorator option.
The decorator transforms the HTTP requests and responses used
when requesting or responding to the WebSocket Upgrade. This may
be used to set or change header fields. For example to set the
Server or User-Agent fields. The default setting applies no
transformation to the HTTP message.
The context in which the decorator is called depends on the
type of operation performed:
@li For synchronous operations, the implementation will call the
decorator before the operation unblocks.
@li For asynchronous operations, the implementation guarantees
that calls to the decorator will be made from the same implicit
or explicit strand used to call the asynchronous initiation
function.
The default setting is no decorator.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the decorator.
@code
struct identity
{
template<bool isRequest, class Body, class Fields>
void
operator()(http::message<isRequest, Body, Fields>& m)
{
if(isRequest)
m.fields.replace("User-Agent", "MyClient");
else
m.fields.replace("Server", "MyServer");
}
};
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(decorate(identity{}));
@endcode
*/
#if GENERATING_DOCS
using decorate = implementation_defined;
#else
using decorate = detail::decorator_type;
#endif
/** Keep-alive option.
Determines if the connection is closed after a failed upgrade
request.
This setting only affects the behavior of HTTP requests that
implicitly or explicitly ask for a keepalive. For HTTP requests
that indicate the connection should be closed, the connection is
closed as per rfc7230.
The default setting is to close connections after a failed
upgrade request.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the keep alive option.
@code
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(keep_alive{8192});
@endcode
*/
#if GENERATING_DOCS
using keep_alive = implementation_defined;
#else
struct keep_alive
{
bool value;
explicit
keep_alive(bool v)
: value(v)
{
}
};
#endif
/** Message type option.
This controls the opcode set for outgoing messages. Valid
choices are opcode::binary or opcode::text. The setting is
only applied at the start when a caller begins a new message.
Changing the opcode after a message is started will only
take effect after the current message being sent is complete.
The default setting is opcode::text.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the message type to binary.
@code
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(message_type{opcode::binary});
@endcode
*/
#if GENERATING_DOCS
using message_type = implementation_defined;
#else
struct message_type
{
opcode value;
explicit
message_type(opcode op)
{
if(op != opcode::binary && op != opcode::text)
throw beast::detail::make_exception<std::invalid_argument>(
"bad opcode", __FILE__, __LINE__);
value = op;
}
};
#endif
namespace detail {
using ping_cb = std::function<void(bool, ping_data const&)>;
} // detail
/** permessage-deflate extension options.
These settings control the permessage-deflate extension,
@@ -234,183 +63,6 @@ struct permessage_deflate
int memLevel = 4;
};
/** Ping callback option.
Sets the callback to be invoked whenever a ping or pong is
received during a call to one of the following functions:
@li @ref beast::websocket::stream::read
@li @ref beast::websocket::stream::read_frame
@li @ref beast::websocket::stream::async_read
@li @ref beast::websocket::stream::async_read_frame
Unlike completion handlers, the callback will be invoked
for each received ping and pong during a call to any
synchronous or asynchronous read function. The operation is
passive, with no associated error code, and triggered by reads.
The signature of the callback must be:
@code
void
callback(
bool is_pong, // `true` if this is a pong
ping_data const& payload // Payload of the pong frame
);
@endcode
The value of `is_pong` will be `true` if a pong control frame
is received, and `false` if a ping control frame is received.
If the read operation receiving a ping or pong frame is an
asynchronous operation, the callback will be invoked using
the same method as that used to invoke the final handler.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
To remove the ping callback, construct the option with
no parameters: `set_option(ping_callback{})`
*/
#if GENERATING_DOCS
using ping_callback = implementation_defined;
#else
struct ping_callback
{
detail::ping_cb value;
ping_callback() = default;
ping_callback(ping_callback&&) = default;
ping_callback(ping_callback const&) = default;
explicit
ping_callback(detail::ping_cb f)
: value(std::move(f))
{
}
};
#endif
/** Read buffer size option.
Sets the size of the read buffer used by the implementation to
receive frames. The read buffer is needed when permessage-deflate
is used.
Lowering the size of the buffer can decrease the memory requirements
for each connection, while increasing the size of the buffer can reduce
the number of calls made to the next layer to read data.
The default setting is 4096. The minimum value is 8.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the read buffer size.
@code
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(read_buffer_size{16 * 1024});
@endcode
*/
#if GENERATING_DOCS
using read_buffer_size = implementation_defined;
#else
struct read_buffer_size
{
std::size_t value;
explicit
read_buffer_size(std::size_t n)
: value(n)
{
if(n < 8)
throw beast::detail::make_exception<std::invalid_argument>(
"read buffer size is too small", __FILE__, __LINE__);
}
};
#endif
/** Maximum incoming message size option.
Sets the largest permissible incoming message size. Message
frame fields indicating a size that would bring the total
message size over this limit will cause a protocol failure.
The default setting is 16 megabytes. A value of zero indicates
a limit of the maximum value of a `std::uint64_t`.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the maximum read message size.
@code
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(read_message_max{65536});
@endcode
*/
#if GENERATING_DOCS
using read_message_max = implementation_defined;
#else
struct read_message_max
{
std::size_t value;
explicit
read_message_max(std::size_t n)
: value(n)
{
}
};
#endif
/** Write buffer size option.
Sets the size of the write buffer used by the implementation to
send frames. The write buffer is needed when masking payload data
in the client role, compressing frames, or auto-fragmenting message
data.
Lowering the size of the buffer can decrease the memory requirements
for each connection, while increasing the size of the buffer can reduce
the number of calls made to the next layer to write data.
The default setting is 4096. The minimum value is 8.
The write buffer size can only be changed when the stream is not
open. Undefined behavior results if the option is modified after a
successful WebSocket handshake.
@note Objects of this type are used with
@ref beast::websocket::stream::set_option.
@par Example
Setting the write buffer size.
@code
...
websocket::stream<ip::tcp::socket> ws(ios);
ws.set_option(write_buffer_size{8192});
@endcode
*/
#if GENERATING_DOCS
using write_buffer_size = implementation_defined;
#else
struct write_buffer_size
{
std::size_t value;
explicit
write_buffer_size(std::size_t n)
: value(n)
{
if(n < 8)
throw beast::detail::make_exception<std::invalid_argument>(
"write buffer size is too small", __FILE__, __LINE__);
}
};
#endif
} // websocket
} // beast

175
include/beast/websocket/rfc6455.hpp
View File

@@ -10,83 +10,138 @@
#include <beast/config.hpp>
#include <beast/core/static_string.hpp>
#include <boost/optional.hpp>
#include <beast/core/string.hpp>
#include <beast/http/message.hpp>
#include <array>
#include <cstdint>
namespace beast {
namespace websocket {
/** WebSocket frame header opcodes. */
enum class opcode : std::uint8_t
{
cont = 0,
text = 1,
binary = 2,
rsv3 = 3,
rsv4 = 4,
rsv5 = 5,
rsv6 = 6,
rsv7 = 7,
close = 8,
ping = 9,
pong = 10,
crsvb = 11,
crsvc = 12,
crsvd = 13,
crsve = 14,
crsvf = 15
};
/** Returns `true` if the specified HTTP request is a WebSocket Upgrade.
This function returns `true` when the passed HTTP Request
indicates a WebSocket Upgrade. It does not validate the
contents of the fields: it just trivially accepts requests
which could only possibly be a valid or invalid WebSocket
Upgrade message.
Callers who wish to manually read HTTP requests in their
server implementation can use this function to determine if
the request should be routed to an instance of
@ref websocket::stream.
@par Example
@code
void handle_connection(boost::asio::ip::tcp::socket& sock)
{
beast::flat_buffer buffer;
beast::http::request<beast::http::string_body> req;
beast::http::read(sock, buffer, req);
if(beast::websocket::is_upgrade(req))
{
beast::websocket::stream<decltype(sock)> ws{std::move(sock)};
ws.accept(req);
}
}
@endcode
@param req The HTTP Request object to check.
@return `true` if the request is a WebSocket Upgrade.
*/
template<class Allocator>
bool
is_upgrade(beast::http::header<true,
http::basic_fields<Allocator>> const& req);
/** Close status codes.
These codes accompany close frames.
@see <a href="https://tools.ietf.org/html/rfc6455#section-7.4.1">RFC 6455 7.4.1 Defined Status Codes</a>
*/
#if GENERATING_DOCS
enum close_code
#else
namespace close_code {
using value = std::uint16_t;
enum
#endif
enum close_code : std::uint16_t
{
/// used internally to mean "no error"
none = 0,
/// Normal closure; the connection successfully completed whatever purpose for which it was created.
normal = 1000,
/// The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.
going_away = 1001,
/// The endpoint is terminating the connection due to a protocol error.
protocol_error = 1002,
/// The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data).
unknown_data = 1003,
/// Indicates a received close frame has no close code
//no_code = 1005, // TODO
/// Indicates the connection was closed without receiving a close frame
no_close = 1006,
/// The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message).
bad_payload = 1007,
/// The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable.
policy_error = 1008,
/// The endpoint is terminating the connection because a data frame was received that is too large.
too_big = 1009,
/// The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn't.
needs_extension = 1010,
/// The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
internal_error = 1011,
/// The server is terminating the connection because it is restarting.
service_restart = 1012,
/// The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients.
try_again_later = 1013,
reserved1 = 1004,
no_status = 1005, // illegal on wire
abnormal = 1006, // illegal on wire
reserved2 = 1015,
//----
//
// The following are illegal on the wire
//
last = 5000 // satisfy warnings
/** Used internally to mean "no error"
This code is reserved and may not be sent.
*/
none = 0,
/** Reserved for future use by the WebSocket standard.
This code is reserved and may not be sent.
*/
reserved1 = 1004,
/** No status code was provided even though one was expected.
This code is reserved and may not be sent.
*/
no_status = 1005,
/** Connection was closed without receiving a close frame
This code is reserved and may not be sent.
*/
abnormal = 1006,
/** Reserved for future use by the WebSocket standard.
This code is reserved and may not be sent.
*/
reserved2 = 1014,
/** Reserved for future use by the WebSocket standard.
This code is reserved and may not be sent.
*/
reserved3 = 1015
//
//----
//last = 5000 // satisfy warnings
};
#if ! GENERATING_DOCS
} // close_code
#endif
/// The type representing the reason string in a close frame.
using reason_string = static_string<123, char>;
@@ -102,7 +157,7 @@ using ping_data = static_string<125, char>;
struct close_reason
{
/// The close code.
close_code::value code = close_code::none;
std::uint16_t code = close_code::none;
/// The optional utf8-encoded reason string.
reason_string reason;
@@ -115,25 +170,29 @@ struct close_reason
close_reason() = default;
/// Construct from a code.
close_reason(close_code::value code_)
close_reason(std::uint16_t code_)
: code(code_)
{
}
/// Construct from a reason. code is close_code::normal.
template<std::size_t N>
close_reason(char const (&reason_)[N])
/// Construct from a reason string. code is @ref close_code::normal.
close_reason(string_view s)
: code(close_code::normal)
, reason(reason_)
, reason(s)
{
}
/// Construct from a code and reason.
template<std::size_t N>
close_reason(close_code::value code_,
char const (&reason_)[N])
/// Construct from a reason string literal. code is @ref close_code::normal.
close_reason(char const* s)
: code(close_code::normal)
, reason(s)
{
}
/// Construct from a close code and reason string.
close_reason(close_code code_, string_view s)
: code(code_)
, reason(reason_)
, reason(s)
{
}
@@ -147,4 +206,6 @@ struct close_reason
} // websocket
} // beast
#include <beast/websocket/impl/rfc6455.ipp>
#endif

1
include/beast/websocket/ssl.hpp
View File

@@ -12,7 +12,6 @@
#include <beast/websocket/teardown.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <memory>
namespace beast {
namespace websocket {

2744
include/beast/websocket/stream.hpp
View File

File diff suppressed because it is too large Load Diff