Fix lifetime issues

src/asio_server_connection.h

@@ -69,10 +69,13 @@ public:
       const boost::posix_time::time_duration &tls_handshake_timeout,
       const boost::posix_time::time_duration &read_timeout,
       SocketArgs &&... args)
-      : socket_(std::forward<SocketArgs>(args)...), mux_(mux),
+      : socket_(std::forward<SocketArgs>(args)...),
+        mux_(mux),
         deadline_(socket_.get_io_service()),
         tls_handshake_timeout_(tls_handshake_timeout),
-        read_timeout_(read_timeout), writing_(false), stopped_(false) {}
+        read_timeout_(read_timeout),
+        writing_(false),
+        stopped_(false) {}
 
   /// Start the first asynchronous operation for the connection.
   void start() {
@@ -80,11 +83,12 @@ public:
 
     handler_ = std::make_shared<http2_handler>(
         socket_.get_io_service(), socket_.lowest_layer().remote_endpoint(ec),
-        [ this, self = this->shared_from_this() ]() {
+        [self = this->shared_from_this()]() {
-          if (!std::weak_ptr<connection>{self}.lock()) {
+          auto ptr = std::weak_ptr<connection>{self}.lock();
+          if (!ptr) {
             return;
           }
-          do_write();
+          ptr->do_write();
         },
         mux_);
     if (handler_->start() != 0) {
@@ -100,9 +104,11 @@ public:
     deadline_.expires_from_now(tls_handshake_timeout_);
     deadline_.async_wait([self = this->shared_from_this()](
         const boost::system::error_code &) {
-      if (!std::weak_ptr<connection>{self}.lock())
+      auto ptr = std::weak_ptr<connection>{self}.lock();
+      if (!ptr) {
         return;
-      return self->handle_deadline();
+      }
+      return ptr->handle_deadline();
     });
   }
 
@@ -110,9 +116,11 @@ public:
     deadline_.expires_from_now(read_timeout_);
     deadline_.async_wait([self = this->shared_from_this()](
         const boost::system::error_code &) {
-      if (!std::weak_ptr<connection>{self}.lock())
+      auto ptr = std::weak_ptr<connection>{self}.lock();
+      if (!ptr) {
         return;
-      return self->handle_deadline();
+      }
+      return ptr->handle_deadline();
     });
   }
 
@@ -130,39 +138,43 @@ public:
 
     deadline_.async_wait([self = this->shared_from_this()](
         const boost::system::error_code &) {
-      if (!std::weak_ptr<connection>{self}.lock())
+      auto ptr = std::weak_ptr<connection>{self}.lock();
+      if (!ptr) {
         return;
-      return self->handle_deadline();
+      }
+      return ptr->handle_deadline();
     });
   }
 
   void do_read() {
     deadline_.expires_from_now(read_timeout_);
 
-    socket_.async_read_some(boost::asio::buffer(buffer_), [
+    socket_.async_read_some(
-      this, self = this->shared_from_this()
+        boost::asio::buffer(buffer_),
-    ](const boost::system::error_code &e, std::size_t bytes_transferred) {
+        [this, self=this->shared_from_this()](const boost::system::error_code &e,
-      if (!std::weak_ptr<connection>{self}.lock()) {
+                     std::size_t bytes_transferred) {
+          auto ptr = std::weak_ptr<connection>{self}.lock();
+          if (!ptr) {
             return;
           }
           if (e) {
-        stop();
+            ptr->stop();
             return;
           }
 
           if (handler_->on_read(buffer_, bytes_transferred) != 0) {
-        stop();
+            ptr->stop();
             return;
           }
 
-      do_write();
+          ptr->do_write();
 
           if (!writing_ && handler_->should_stop()) {
             stop();
             return;
           }
 
-      do_read();
+          ptr->do_read();
 
           // If an error occurs then no new asynchronous operations are
           // started. This means that all shared_ptr references to the
@@ -203,17 +215,18 @@ public:
     boost::asio::async_write(socket_, boost::asio::buffer(outbuf_, nwrite), [
       this, self = this->shared_from_this()
     ](const boost::system::error_code &e, std::size_t) {
-      if (!std::weak_ptr<connection>{self}.lock()) {
+      auto ptr = std::weak_ptr<connection>{self}.lock();
+      if (!ptr) {
         return;
       }
       if (e) {
-        stop();
+        ptr->stop();
         return;
       }
 
       writing_ = false;
 
-      do_write();
+      ptr->do_write();
     });
 
     // No new asynchronous operations are started. This means that all