beast support per-op cancellation

- websocket supports cancellation.
 - Iterating test for ws cancellation.
 - Only terminal cancellation is forwarded by default.
 - basic_stream supports cancellation.
 - supported cancellation is documented.
 - http cancellation additions.
 - Added cancellation_slot tests to http, utils and saved_handler.
 - Added post to write.cpp, to avoid SIGSEV in test.
 - Refresher describes cancellation in more detail.

include/boost/beast/websocket/impl/accept.hpp

@@ -266,6 +266,9 @@ public:
 
 // read and respond to an upgrade request
 //
+// Cancellation: the async_accept cancellation can be terminal
+// because it will just interrupt the reading of the header.
+//
 template<class NextLayer, bool deflateSupported>
 template<class Handler, class Decorator>
 class stream<NextLayer, deflateSupported>::accept_op

include/boost/beast/websocket/impl/close.hpp

@@ -90,9 +90,15 @@ public:
                     BOOST_ASIO_HANDLER_LOCATION((
                         __FILE__, __LINE__,
                         "websocket::async_close"));
-
-                    impl.op_close.emplace(std::move(*this));
+                    this->set_allowed_cancellation(net::cancellation_type::all);
+                    impl.op_close.emplace(std::move(*this),
+                                          net::cancellation_type::all);
                 }
+                // cancel fired before we could do anything.
+                if (ec == net::error::operation_aborted)
+                    return this->complete(cont, ec);
+                this->set_allowed_cancellation(net::cancellation_type::terminal);
+
                 impl.wr_block.lock(this);
                 BOOST_ASIO_CORO_YIELD
                 {
@@ -143,9 +149,17 @@ public:
                     BOOST_ASIO_HANDLER_LOCATION((
                         __FILE__, __LINE__,
                         "websocket::async_close"));
-
+                    // terminal only, that's the default
                     impl.op_r_close.emplace(std::move(*this));
                 }
+                if (ec == net::error::operation_aborted)
+                {
+                    // if a cancellation fires here, we do a dirty shutdown
+                    impl.change_status(status::closed);
+                    close_socket(get_lowest_layer(impl.stream()));
+                    return this->complete(cont, ec);
+                }
+
                 impl.rd_block.lock(this);
                 BOOST_ASIO_CORO_YIELD
                 {
@@ -185,7 +199,7 @@ public:
                             beast::detail::bind_continuation(std::move(*this)));
                     }
                     impl.rd_buf.commit(bytes_transferred);
-                    if(impl.check_stop_now(ec))
+                    if(impl.check_stop_now(ec)) //< this catches cancellation
                         goto upcall;
                 }
                 if(detail::is_control(impl.rd_fh.op))

include/boost/beast/websocket/impl/ping.hpp

@@ -86,9 +86,12 @@ public:
                     BOOST_ASIO_HANDLER_LOCATION((
                         __FILE__, __LINE__,
                         "websocket::async_ping"));
-
-                    impl.op_ping.emplace(std::move(*this));
+                    this->set_allowed_cancellation(net::cancellation_type::all);
+                    impl.op_ping.emplace(std::move(*this), net::cancellation_type::all);
                 }
+                if (ec)
+                    return this->complete(cont, ec);
+                this->set_allowed_cancellation(net::cancellation_type::terminal);
                 impl.wr_block.lock(this);
                 BOOST_ASIO_CORO_YIELD
                 {

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

@@ -107,8 +107,14 @@ public:
                         __FILE__, __LINE__,
                         "websocket::async_read_some"));
 
-                    impl.op_r_rd.emplace(std::move(*this));
+                    this->set_allowed_cancellation(net::cancellation_type::all);
+                    impl.op_r_rd.emplace(std::move(*this), net::cancellation_type::all);
                 }
+                if (ec)
+                    return this->complete(cont, ec, bytes_written_);
+
+                this->set_allowed_cancellation(net::cancellation_type::terminal);
+
                 impl.rd_block.lock(this);
                 BOOST_ASIO_CORO_YIELD
                 {
@@ -275,6 +281,9 @@ public:
 
                                 impl.op_rd.emplace(std::move(*this));
                             }
+                            if (ec)
+                                return this->complete(cont, ec, bytes_written_);
+
                             impl.wr_block.lock(this);
                             BOOST_ASIO_CORO_YIELD
                             {
@@ -629,6 +638,9 @@ public:
 
                     impl.op_rd.emplace(std::move(*this));
                 }
+                if (ec)
+                    return this->complete(cont, ec, bytes_written_);
+
                 impl.wr_block.lock(this);
                 BOOST_ASIO_CORO_YIELD
                 {

include/boost/beast/websocket/impl/ssl.hpp

@@ -66,6 +66,8 @@ struct ssl_shutdown_op
     {
         BOOST_ASIO_CORO_REENTER(*this)
         {
+            self.reset_cancellation_state(net::enable_total_cancellation());
+
             BOOST_ASIO_CORO_YIELD
                 s_.async_shutdown(std::move(self));
             ec_ = ec;

include/boost/beast/websocket/impl/teardown.hpp

@@ -59,6 +59,7 @@ public:
         , nb_(false)
     {
         (*this)({}, 0, false);
+        this->set_allowed_cancellation(net::cancellation_type::all);
     }
 
     void

include/boost/beast/websocket/impl/write.hpp

@@ -181,9 +181,14 @@ operator()(
                         "websocket::async_write" :
                         "websocket::async_write_some"
                     ));
-
-                impl.op_wr.emplace(std::move(*this));
+                this->set_allowed_cancellation(net::cancellation_type::all);
+                impl.op_wr.emplace(std::move(*this),
+                                   net::cancellation_type::all);
             }
+            if (ec)
+                return this->complete(cont, ec, bytes_transferred_);
+
+            this->set_allowed_cancellation(net::cancellation_type::terminal);
             impl.wr_block.lock(this);
             BOOST_ASIO_CORO_YIELD
             {