boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-30 12:57:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove obsolete frame tests

Browse Source
This commit is contained in:
Vinnie Falco
2017-08-01 20:31:01 -07:00
parent 387d68f336
commit e9d01fe79f
4 changed files with 4 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -6,6 +6,10 @@ Version 100:
* Rename test macros * Rename test macros
* Reorder define test macro params * Reorder define test macro params
WebSocket:
* Remove obsolete frame tests
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
Version 99: Version 99:

188
include/boost/beast/websocket/impl/stream.ipp
View File

@ -424,194 +424,6 @@ parse_fh(
return true; return true;
} }
// 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(! detail::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> template<class NextLayer>
template<class DynamicBuffer> template<class DynamicBuffer>
void void

10
include/boost/beast/websocket/stream.hpp
View File

@ -3768,16 +3768,6 @@ private:
parse_fh(detail::frame_header& fh, parse_fh(detail::frame_header& fh,
DynamicBuffer& b, close_code& code); DynamicBuffer& b, close_code& code);
template<class DynamicBuffer>
std::size_t
read_fh1(detail::frame_header& fh,
DynamicBuffer& db, close_code& code);
template<class DynamicBuffer>
void
read_fh2(detail::frame_header& fh,
DynamicBuffer& db, close_code& code);
template<class DynamicBuffer> template<class DynamicBuffer>
void void
write_close(DynamicBuffer& db, close_reason const& rc); write_close(DynamicBuffer& db, close_reason const& rc);

185
test/beast/websocket/frame.cpp
View File

@ -20,21 +20,6 @@ namespace beast {
namespace websocket { namespace websocket {
namespace detail { namespace detail {
static
bool
operator==(frame_header const& lhs, frame_header const& rhs)
{
return
lhs.op == rhs.op &&
lhs.fin == rhs.fin &&
lhs.mask == rhs.mask &&
lhs.rsv1 == rhs.rsv1 &&
lhs.rsv2 == rhs.rsv2 &&
lhs.rsv3 == rhs.rsv3 &&
lhs.len == rhs.len &&
lhs.key == rhs.key;
}
class frame_test class frame_test
: public beast::unit_test::suite : public beast::unit_test::suite
, public test::enable_yield_to , public test::enable_yield_to
@ -73,179 +58,9 @@ public:
} }
}; };
void testFrameHeader()
{
using stream_type =
beast::websocket::stream<test::pipe::stream&>;
test::pipe p{ios_};
// good frame fields
{
stream_type::role_type role =
stream_type::role_type::client;
auto check =
[&](frame_header const& fh)
{
fh_streambuf b;
write(b, fh);
close_code code;
stream_type stream{p.server};
stream.open(role);
detail::frame_header fh1;
auto const n =
stream.read_fh1(fh1, b, code);
if(! BEAST_EXPECT(! code))
return;
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh1, b, code);
if(! BEAST_EXPECT(! code))
return;
if(! BEAST_EXPECT(b.size() == 0))
return;
BEAST_EXPECT(fh1 == fh);
};
test_fh fh;
check(fh);
role = stream_type::role_type::server;
fh.mask = true;
fh.key = 1;
check(fh);
fh.len = 1;
check(fh);
fh.len = 126;
check(fh);
fh.len = 65535;
check(fh);
fh.len = 65536;
check(fh);
fh.len = 65537;
check(fh);
}
// bad frame fields
{
stream_type::role_type role = stream_type::role_type::client;
auto check =
[&](frame_header const& fh)
{
fh_streambuf b;
write(b, fh);
close_code code;
stream_type stream{p.server};
stream.open(role);
frame_header fh1;
auto const n =
stream.read_fh1(fh1, b, code);
if(code)
{
pass();
return;
}
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh1, b, code);
if(! BEAST_EXPECT(code))
return;
if(! BEAST_EXPECT(b.size() == 0))
return;
};
test_fh fh;
fh.op = detail::opcode::close;
fh.fin = true;
fh.len = 126;
check(fh);
fh.len = 0;
fh.rsv1 = true;
check(fh);
fh.rsv1 = false;
fh.rsv2 = true;
check(fh);
fh.rsv2 = false;
fh.rsv3 = true;
check(fh);
fh.rsv3 = false;
fh.op = detail::opcode::rsv3;
check(fh);
fh.op = detail::opcode::text;
fh.op = detail::opcode::ping;
fh.fin = false;
check(fh);
fh.fin = true;
fh.mask = true;
check(fh);
role = stream_type::role_type::server;
fh.mask = false;
check(fh);
}
}
void bad(std::initializer_list<std::uint8_t> bs)
{
using stream_type =
beast::websocket::stream<test::pipe::stream&>;
using boost::asio::buffer;
using boost::asio::buffer_copy;
test::pipe p{ios_};
static stream_type::role_type constexpr role = stream_type::role_type::client;
std::vector<std::uint8_t> v{bs};
fh_streambuf b;
b.commit(buffer_copy(b.prepare(v.size()), buffer(v)));
stream_type stream{p.server};
stream.open(role);
close_code code;
detail::frame_header fh;
auto const n =
stream.read_fh1(fh, b, code);
if(code)
{
pass();
return;
}
if(! BEAST_EXPECT(b.size() == n))
return;
stream.read_fh2(fh, b, code);
if(! BEAST_EXPECT(code))
return;
if(! BEAST_EXPECT(b.size() == 0))
return;
}
void testBadFrameHeaders()
{
// bad frame fields
//
// can't be created by the library
// so we produce them manually.
bad({0, 126, 0, 125});
bad({0, 127, 0, 0, 0, 0, 0, 0, 255, 255});
}
void run() override void run() override
{ {
testCloseCodes(); testCloseCodes();
testFrameHeader();
testBadFrameHeaders();
} }
}; };