WebSocket ping, fixes, coverage:

* Improve test coverage
* tests for invokable in composed ops

* Update documentation
* Add License badge to README
* Target Windows 7 SDK and later
* Make role_type private
* Remove extra unused masking functions
* Allow stream reuse / reconnect after failure
* Restructure logic of composed operations
* Allow 0 for read_message_max meaning no limit
* Respect keep alive when building HTTP responses
* Check version in upgrade request
* Response with 426 status on unsupported WebSocket version
* Remove unnecessary Sec-WebSocket-Key in HTTP responses
* Rename to mask_buffer_size

* Remove maybe_throw
* Add ping, async_ping, async_on_pong
* Add ping_op
* Add pong_op
* Fix crash in accept_op
* Fix suspend in close_op
* Fix read_frame_op logic
* Fix crash in read_op
* Fix races in echo sync and async echo servers

test/websocket/websocket_sync_echo_peer.hpp

@@ -101,15 +101,17 @@ private:
     {
         int id;
         sync_echo_peer& self;
-        socket_type sock;
         boost::asio::io_service::work work;
+        // Must be destroyed before work otherwise the
+        // io_service could be destroyed before the socket.
+        socket_type sock;
 
         lambda(int id_, sync_echo_peer& self_,
                 socket_type&& sock_)
             : id(id_)
             , self(self_)
+            , work(sock_.get_io_service())
             , sock(std::move(sock_))
-            , work(sock.get_io_service())
         {
         }
 
@@ -149,10 +151,31 @@ private:
         }
     };
 
+    template<class Streambuf, std::size_t N>
+    static
+    bool
+    match(Streambuf& sb, char const(&s)[N])
+    {
+        using boost::asio::buffer;
+        using boost::asio::buffer_copy;
+        if(sb.size() < N-1)
+            return false;
+        static_string<N-1> t;
+        t.resize(N-1);
+        buffer_copy(buffer(t.data(), t.size()),
+            sb.data());
+        if(t != s)
+            return false;
+        sb.consume(N-1);
+        return true;
+    }
+
     void
     do_peer(int id, socket_type&& sock)
     {
-        websocket::stream<socket_type> ws(std::move(sock));
+        using boost::asio::buffer;
+        using boost::asio::buffer_copy;
+        stream<socket_type> ws(std::move(sock));
         ws.set_option(decorate(identity{}));
         ws.set_option(read_message_max(64 * 1024 * 1024));
         error_code ec;
@@ -164,17 +187,45 @@ private:
         }
         for(;;)
         {
-            websocket::opcode op;
+            opcode op;
             beast::streambuf sb;
             ws.read(op, sb, ec);
             if(ec)
+            {
+                auto const s = ec.message();
                 break;
-            ws.set_option(websocket::message_type(op));
-            ws.write(sb.data(), ec);
+            }
+            ws.set_option(message_type(op));
+            if(match(sb, "RAW"))
+            {
+                boost::asio::write(
+                    ws.next_layer(), sb.data(), ec);
+            }
+            else if(match(sb, "TEXT"))
+            {
+                ws.set_option(message_type{opcode::text});
+                ws.write(sb.data(), ec);
+            }
+            else if(match(sb, "PING"))
+            {
+                ping_data payload;
+                sb.consume(buffer_copy(
+                    buffer(payload.data(), payload.size()),
+                        sb.data()));
+                ws.ping(payload, ec);
+            }
+            else if(match(sb, "CLOSE"))
+            {
+                ws.close({}, ec);
+            }
+            else
+            {
+                ws.write(sb.data(), ec);
+            }
             if(ec)
                 break;
         }
-        if(ec && ec != websocket::error::closed)
+        if(ec && ec != error::closed)
         {
             fail(id, ec, "read");
         }