Autobahn|Testsuite fixes

CHANGELOG.md

@@ -14,6 +14,7 @@ WebSocket:
 * Refactor close_op
 * Refactor read_op + fail_op
 * Websocket close will automatically drain
+* Autobahn|Testsuite fixes
 
 --------------------------------------------------------------------------------
 

example/websocket/server/fast/websocket_server_fast.cpp

@@ -104,7 +104,6 @@ do_sync_session(tcp::socket& socket)
             break;
         if(ec)
             return fail(ec, "read");
-
         ws.text(ws.got_text());
         ws.write(buffer.data(), ec);
         if(ec)

include/boost/beast/websocket/impl/read.ipp

@@ -210,17 +210,21 @@ operator()(
                             ws_.rd_.key);
             if(detail::is_control(ws_.rd_.fh.op))
             {
+                // Clear this otherwise the next
+                // frame will be considered final.
+                ws_.rd_.fh.fin = false;
+
                 // Handle ping frame
                 if(ws_.rd_.fh.op == detail::opcode::ping)
                 {
                     {
-                        auto const cb = buffer_prefix(
+                        auto const b = buffer_prefix(
                             clamp(ws_.rd_.fh.len),
                                 ws_.rd_.buf.data());
-                        auto const len = buffer_size(cb);
+                        auto const len = buffer_size(b);
                         BOOST_ASSERT(len == ws_.rd_.fh.len);
                         ping_data payload;
-                        detail::read_ping(payload, cb);
+                        detail::read_ping(payload, b);
                         ws_.rd_.buf.consume(len);
                         // Ignore ping when closing
                         if(ws_.wr_close_)
@@ -356,11 +360,9 @@ operator()(
                 // get fewer bytes at the cost of one I/O.
                 BOOST_ASIO_CORO_YIELD
                 ws_.stream_.async_read_some(
-                    ws_.rd_.buf.prepare(
+                    ws_.rd_.buf.prepare(read_size(
-                        read_size(
+                        ws_.rd_.buf, ws_.rd_.buf.max_size())),
-                            ws_.rd_.buf,
+                            std::move(*this));
-                            ws_.rd_.buf.max_size())),
-                    std::move(*this));
                 dispatched_ = true;
                 ws_.failed_ = !!ec;
                 if(ws_.failed_)
@@ -954,15 +956,20 @@ loop:
         if(detail::is_control(rd_.fh.op))
         {
             // Get control frame payload
-            auto const cb = buffer_prefix(
+            auto const b = buffer_prefix(
                 clamp(rd_.fh.len), rd_.buf.data());
-            auto const len = buffer_size(cb);
+            auto const len = buffer_size(b);
             BOOST_ASSERT(len == rd_.fh.len);
-            // Process control frame
+
+            // Clear this otherwise the next
+            // frame will be considered final.
+            rd_.fh.fin = false;
+
+            // Handle ping frame
             if(rd_.fh.op == detail::opcode::ping)
             {
                 ping_data payload;
-                detail::read_ping(payload, cb);
+                detail::read_ping(payload, b);
                 rd_.buf.consume(len);
                 if(wr_close_)
                 {
@@ -980,21 +987,23 @@ loop:
                     return bytes_written;
                 goto loop;
             }
-            else if(rd_.fh.op == detail::opcode::pong)
+            // Handle pong frame
+            if(rd_.fh.op == detail::opcode::pong)
             {
                 ping_data payload;
-                detail::read_ping(payload, cb);
+                detail::read_ping(payload, b);
                 rd_.buf.consume(len);
                 if(ctrl_cb_)
                     ctrl_cb_(frame_type::pong, payload);
                 goto loop;
             }
+            // Handle close frame
             BOOST_ASSERT(rd_.fh.op == detail::opcode::close);
             {
                 BOOST_ASSERT(! rd_close_);
                 rd_close_ = true;
                 close_reason cr;
-                detail::read_close(cr, cb, code);
+                detail::read_close(cr, b, code);
                 if(code != close_code::none)
                 {
                     // _Fail the WebSocket Connection_
@@ -1040,18 +1049,16 @@ loop:
             {
                 // Fill the read buffer first, otherwise we
                 // get fewer bytes at the cost of one I/O.
-                auto const mb = rd_.buf.prepare(
+                rd_.buf.commit(stream_.read_some(
-                    read_size(rd_.buf, rd_.buf.max_size()));
+                    rd_.buf.prepare(read_size(rd_.buf,
-                auto const bytes_transferred =
+                        rd_.buf.max_size())), ec));
-                    stream_.read_some(mb, ec);
                 failed_ = !!ec;
                 if(failed_)
                     return bytes_written;
                 if(rd_.fh.mask)
-                    detail::mask_inplace(buffer_prefix(
+                    detail::mask_inplace(
-                        clamp(rd_.remain), mb), rd_.key);
+                        buffer_prefix(clamp(rd_.remain),
-                // VFALCO Do this before masking  for symmetry with the async version
+                            rd_.buf.data()), rd_.key);
-                rd_.buf.commit(bytes_transferred);
             }
             if(rd_.buf.size() > 0)
             {

include/boost/beast/websocket/impl/stream.ipp

@@ -304,10 +304,10 @@ parse_fh(
     consuming_buffers<typename
         DynamicBuffer::const_buffers_type> cb{
             b.data()};
+    std::size_t need;
     {
         std::uint8_t tmp[2];
         cb.consume(buffer_copy(buffer(tmp), cb));
-        std::size_t need;
         fh.len = tmp[1] & 0x7f;
         switch(fh.len)
         {
@@ -393,7 +393,7 @@ parse_fh(
     if(role_ == role_type::client && fh.mask)
         return err(close_code::protocol_error);
     if(detail::is_control(fh.op) &&
-        buffer_size(cb) < fh.len)
+        buffer_size(cb) < need + fh.len)
     {
         // Make the entire control frame payload
         // get read in before we return `true`
@@ -489,24 +489,24 @@ write_close(DynamicBuffer& db, close_reason const& cr)
         if(fh.mask)
             detail::prepare_key(key, fh.key);
         {
-            std::uint8_t b[2];
+            std::uint8_t tmp[2];
-            ::new(&b[0]) big_uint16_buf_t{
+            ::new(&tmp[0]) big_uint16_buf_t{
                 (std::uint16_t)cr.code};
-            auto d = db.prepare(2);
+            auto mb = db.prepare(2);
-            boost::asio::buffer_copy(d,
+            boost::asio::buffer_copy(mb,
-                boost::asio::buffer(b));
+                boost::asio::buffer(tmp));
             if(fh.mask)
-                detail::mask_inplace(d, key);
+                detail::mask_inplace(mb, key);
             db.commit(2);
         }
         if(! cr.reason.empty())
         {
-            auto d = db.prepare(cr.reason.size());
+            auto mb = db.prepare(cr.reason.size());
-            boost::asio::buffer_copy(d,
+            boost::asio::buffer_copy(mb,
                 boost::asio::const_buffer(
                     cr.reason.data(), cr.reason.size()));
             if(fh.mask)
-                detail::mask_inplace(d, key);
+                detail::mask_inplace(mb, key);
             db.commit(cr.reason.size());
         }
     }
@@ -535,12 +535,12 @@ write_ping(DynamicBuffer& db,
     detail::prepared_key key;
     if(fh.mask)
         detail::prepare_key(key, fh.key);
-    auto d = db.prepare(data.size());
+    auto mb = db.prepare(data.size());
-    boost::asio::buffer_copy(d,
+    boost::asio::buffer_copy(mb,
         boost::asio::const_buffers_1(
             data.data(), data.size()));
     if(fh.mask)
-        detail::mask_inplace(d, key);
+        detail::mask_inplace(mb, key);
     db.commit(data.size());
 }
 

include/boost/beast/websocket/stream.hpp

@@ -3766,11 +3766,11 @@ private:
 
     template<class DynamicBuffer>
     void
-    write_close(DynamicBuffer& db, close_reason const& rc);
+    write_close(DynamicBuffer& b, close_reason const& rc);
 
     template<class DynamicBuffer>
     void
-    write_ping(DynamicBuffer& db,
+    write_ping(DynamicBuffer& b,
         detail::opcode op, ping_data const& data);
 
     template<class Decorator>