From 6d2bdc1e90f22f3be05f73057ce8eabc8d790733 Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sat, 8 Jun 2024 09:43:20 +0000
Subject: [PATCH 1/7] Remove sync get_info from Response

---
 curlio/basic_response.hpp | 2 --
 curlio/basic_response.inl | 7 -------
 2 files changed, 9 deletions(-)

diff --git a/curlio/basic_response.hpp b/curlio/basic_response.hpp
index 4063583..2b25a76 100644
--- a/curlio/basic_response.hpp
+++ b/curlio/basic_response.hpp
@@ -21,8 +21,6 @@ class Basic_response : public std::enable_shared_from_this<Basic_response<Execut
 
 	Basic_response(const Basic_response& copy) = delete;
 
-	template<CURLINFO Option>
-	auto get_info() const;
 	template<CURLINFO Option>
 	auto async_get_info(auto&& token) const;
 	auto async_read_some(const auto& buffers, auto&& token);
diff --git a/curlio/basic_response.inl b/curlio/basic_response.inl
index b1a0343..e4d827d 100644
--- a/curlio/basic_response.inl
+++ b/curlio/basic_response.inl
@@ -8,13 +8,6 @@
 
 namespace curlio {
 
-template<typename Executor>
-template<CURLINFO Option>
-inline auto Basic_response<Executor>::get_info() const
-{
-	return async_get_info<Option>(CURLIO_ASIO_NS::use_future).get();
-}
-
 template<typename Executor>
 template<CURLINFO Option>
 inline auto Basic_response<Executor>::async_get_info(auto&& token) const

From 0bf9414d8e26debdd5360c30a95acd3bf83a68fc Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sat, 8 Jun 2024 17:16:41 +0000
Subject: [PATCH 2/7] Fix header callback unregistering

---
 curlio/basic_response.hpp          |  4 +-
 curlio/basic_response.inl          |  5 +-
 curlio/basic_session.hpp           |  4 +-
 curlio/basic_session.inl           | 27 +++++----
 curlio/detail/header_collector.hpp | 37 ++++++++-----
 curlio/detail/socket_data.hpp      |  4 +-
 examples/CMakeLists.txt            | 10 ++--
 examples/playground.cpp            | 89 +++++++++++-------------------
 8 files changed, 82 insertions(+), 98 deletions(-)

diff --git a/curlio/basic_response.hpp b/curlio/basic_response.hpp
index 2b25a76..1a510d2 100644
--- a/curlio/basic_response.hpp
+++ b/curlio/basic_response.hpp
@@ -17,7 +17,7 @@ template<typename Executor>
 class Basic_response : public std::enable_shared_from_this<Basic_response<Executor>> {
 public:
 	using executor_type = Executor;
-	using headers_type  = detail::Header_collector::fields_type;
+	using headers_type  = detail::HeaderCollector::fields_type;
 
 	Basic_response(const Basic_response& copy) = delete;
 
@@ -35,7 +35,7 @@ class Basic_response : public std::enable_shared_from_this<Basic_response<Execut
 	std::shared_ptr<Basic_request<Executor>> _request;
 	CURLIO_ASIO_NS::streambuf _input_buffer;
 	detail::Function<std::size_t(detail::asio_error_code, const char*, std::size_t)> _receive_handler;
-	detail::Header_collector _header_collector;
+	detail::HeaderCollector _header_collector;
 	bool _finished = false;
 
 	Basic_response(std::shared_ptr<Basic_session<Executor>>&& session,
diff --git a/curlio/basic_response.inl b/curlio/basic_response.inl
index e4d827d..cd2aa54 100644
--- a/curlio/basic_response.inl
+++ b/curlio/basic_response.inl
@@ -92,9 +92,8 @@ inline Basic_response<Executor>::executor_type Basic_response<Executor>::get_exe
 template<typename Executor>
 inline Basic_response<Executor>::Basic_response(std::shared_ptr<Basic_session<Executor>>&& session,
                                                 std::shared_ptr<Basic_request<Executor>>&& request)
-    : _session{ std::move(session) }, _request{ std::move(request) }, _header_collector{
-	      _request->native_handle()
-      }
+    : _session{ std::move(session) }, _request{ std::move(request) },
+      _header_collector{ _request->native_handle() }
 {
 	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEFUNCTION, &Basic_response::_write_callback);
 	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEDATA, this);
diff --git a/curlio/basic_session.hpp b/curlio/basic_session.hpp
index 4b1a066..909e908 100644
--- a/curlio/basic_session.hpp
+++ b/curlio/basic_session.hpp
@@ -33,11 +33,11 @@ class Basic_session : public std::enable_shared_from_this<Basic_session<Executor
 	CURLM* _multi_handle;
 	CURLIO_ASIO_NS::strand<Executor> _strand;
 	std::map<CURL*, response_pointer> _active_requests;
-	std::map<curl_socket_t, std::shared_ptr<detail::Socket_data>> _sockets;
+	std::map<curl_socket_t, std::shared_ptr<detail::SocketData>> _sockets;
 	CURLIO_ASIO_NS::steady_timer _timer{ _strand };
 
 	Basic_session(Executor executor);
-	void _monitor(const std::shared_ptr<detail::Socket_data>& data, detail::Socket_data::Wait_flag type);
+	void _monitor(const std::shared_ptr<detail::SocketData>& data, detail::SocketData::WaitFlag type);
 	void _clean_finished();
 	void _perform(curl_socket_t socket, int bitmask);
 	static int _socket_callback(CURL* easy_handle, curl_socket_t socket, int what, void* self_ptr,
diff --git a/curlio/basic_session.inl b/curlio/basic_session.inl
index 1563f0f..3eed098 100644
--- a/curlio/basic_session.inl
+++ b/curlio/basic_session.inl
@@ -75,18 +75,19 @@ inline Basic_session<Executor>::Basic_session(Executor executor) : _strand{ std:
 }
 
 template<typename Executor>
-inline void Basic_session<Executor>::_monitor(const std::shared_ptr<detail::Socket_data>& data,
-                                              detail::Socket_data::Wait_flag type)
+inline void Basic_session<Executor>::_monitor(const std::shared_ptr<detail::SocketData>& data,
+                                              detail::SocketData::WaitFlag type)
 {
+	CURLIO_TRACE("Monitoring on socket flags=" << data->wait_flags << " type=" << static_cast<int>(type));
 	if (data->wait_flags & type) {
 		data->socket.async_wait(
-		  type == detail::Socket_data::wait_flag_write ? CURLIO_ASIO_NS::socket_base::wait_write
-		                                               : CURLIO_ASIO_NS::socket_base::wait_read,
+		  type == detail::SocketData::wait_flag_write ? CURLIO_ASIO_NS::socket_base::wait_write
+		                                              : CURLIO_ASIO_NS::socket_base::wait_read,
 		  [this, type, data](const detail::asio_error_code& ec) {
-			  CURLIO_TRACE("Socket action occurred: " << ec.what());
+			  CURLIO_TRACE("Socket action occurred (flags=" << data->wait_flags << "): " << ec.what());
 			  if (!ec && data->wait_flags & type) {
 				  _perform(data->socket.native_handle(),
-				           type == detail::Socket_data::wait_flag_write ? CURL_CSELECT_OUT : CURL_CSELECT_IN);
+				           type == detail::SocketData::wait_flag_write ? CURL_CSELECT_OUT : CURL_CSELECT_IN);
 				  _monitor(data, type);
 			  }
 		  });
@@ -114,6 +115,8 @@ inline void Basic_session<Executor>::_clean_finished()
 			}
 
 			curl_multi_remove_handle(_multi_handle, message->easy_handle);
+		} else {
+			CURLIO_WARN("Got unknown message during cleaning: " << message->msg);
 		}
 	}
 }
@@ -137,7 +140,7 @@ inline int Basic_session<Executor>::_socket_callback(CURL* easy_handle, curl_soc
 {
 	constexpr const char* what_names[] = { "IN", "OUT", "IN/OUT", "REMOVE" };
 	CURLIO_TRACE("Socket action callback on " << socket << ": "
-	                                          << (what >= 1 && what <= 4 ? what_names[what - 1] : "unknwon"));
+	                                          << (what >= 1 && what <= 4 ? what_names[what - 1] : "unknown"));
 
 	const auto self = static_cast<Basic_session*>(self_ptr);
 
@@ -156,12 +159,12 @@ inline int Basic_session<Executor>::_socket_callback(CURL* easy_handle, curl_soc
 	}
 
 	if (what == CURL_POLL_IN || what == CURL_POLL_INOUT) {
-		data->wait_flags |= detail::Socket_data::wait_flag_read;
-		self->_monitor(data, detail::Socket_data::wait_flag_read);
+		data->wait_flags |= detail::SocketData::wait_flag_read;
+		self->_monitor(data, detail::SocketData::wait_flag_read);
 	}
 	if (what == CURL_POLL_OUT || what == CURL_POLL_INOUT) {
-		data->wait_flags |= detail::Socket_data::wait_flag_write;
-		self->_monitor(data, detail::Socket_data::wait_flag_write);
+		data->wait_flags |= detail::SocketData::wait_flag_write;
+		self->_monitor(data, detail::SocketData::wait_flag_write);
 	}
 
 	return CURLM_OK;
@@ -205,7 +208,7 @@ inline curl_socket_t Basic_session<Executor>::_open_socket_callback(void* self_p
 
 	if (protocol.has_value()) {
 		detail::asio_error_code ec{};
-		auto data = std::make_shared<detail::Socket_data>(CURLIO_ASIO_NS::ip::tcp::socket{ self->_strand });
+		auto data = std::make_shared<detail::SocketData>(CURLIO_ASIO_NS::ip::tcp::socket{ self->_strand });
 		data->socket.open(protocol.value(), ec);
 		if (!ec) {
 			const auto fd = data->socket.native_handle();
diff --git a/curlio/detail/header_collector.hpp b/curlio/detail/header_collector.hpp
index 641e5c8..54328af 100644
--- a/curlio/detail/header_collector.hpp
+++ b/curlio/detail/header_collector.hpp
@@ -1,8 +1,10 @@
 #pragma once
 
 #include "../error.hpp"
+#include "../log.hpp"
 #include "asio_include.hpp"
 #include "case_insensitive_less.hpp"
+#include "function.hpp"
 
 #include <curl/curl.h>
 #include <locale>
@@ -31,27 +33,27 @@ constexpr std::string_view trim(std::string_view str, const std::locale& locale
 
 /// Hooks into the header callbacks of cURL and parses the header fields. Hook management must be done
 /// separately.
-class Header_collector {
+class HeaderCollector {
 public:
 	using fields_type = std::map<std::string, std::string, Case_insensitive_less>;
 
-	Header_collector(CURL* handle) : _handle{ handle }
+	HeaderCollector(CURL* handle) : _handle{ handle }
 	{
-		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, &Header_collector::_header_callback);
+		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, &HeaderCollector::_header_callback);
 		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, this);
 	}
-	Header_collector(const Header_collector& copy) = delete;
-	~Header_collector() noexcept
-	{
-		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, nullptr);
-		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, nullptr);
-	}
+	HeaderCollector(const HeaderCollector& copy) = delete;
+	HeaderCollector(HeaderCollector&& move)      = delete;
+	~HeaderCollector()                           = default;
+
 	void finish()
 	{
 		if (_headers_received_handler) {
 			_headers_received_handler(CURLIO_ASIO_NS::error::eof);
 			_headers_received_handler.reset();
 		}
+		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, nullptr);
+		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, nullptr);
 	}
 	auto async_wait(auto&& fallback_executor, auto&& token)
 	{
@@ -82,6 +84,9 @@ class Header_collector {
 		  token, std::forward<decltype(fallback_executor)>(fallback_executor));
 	}
 
+	HeaderCollector& operator=(const HeaderCollector& copy) = delete;
+	HeaderCollector& operator=(HeaderCollector&& move)      = delete;
+
 private:
 	fields_type _fields;
 	CURL* _handle;
@@ -94,26 +99,30 @@ class Header_collector {
 	                                    void* self_ptr) noexcept
 	{
 		static std::locale locale{};
-		const auto self                = static_cast<Header_collector*>(self_ptr);
+		const auto self                = static_cast<HeaderCollector*>(self_ptr);
 		const std::size_t total_length = size * count;
 
+		CURLIO_TRACE("Received " << total_length << " bytes of headers");
+
 		// New header segment -> clear old fields.
 		if (self->_last_clear < self->_headers_received) {
+			CURLIO_TRACE("Cleaning headers because of new segment");
 			self->_fields.clear();
 			self->_last_clear++;
 		}
 
 		// Add header to map.
 		const auto end       = buffer + total_length;
-		const auto seperator = std::find(buffer, end, ':');
-		if (seperator != end) {
-			std::string key{ buffer, static_cast<std::size_t>(seperator - buffer) };
-			std::string value{ trim({ seperator + 1, static_cast<std::size_t>(end - seperator - 1) }, locale) };
+		const auto separator = std::find(buffer, end, ':');
+		if (separator != end) {
+			std::string key{ buffer, static_cast<std::size_t>(separator - buffer) };
+			std::string value{ trim({ separator + 1, static_cast<std::size_t>(end - separator - 1) }, locale) };
 			self->_fields.insert({ std::move(key), std::move(value) });
 		}
 
 		// End of header.
 		if (total_length == 2) {
+			CURLIO_TRACE("End of header: waiter=" << static_cast<bool>(self->_headers_received_handler));
 			self->_headers_received++;
 			self->_ready_to_await = true;
 			if (self->_headers_received_handler) {
diff --git a/curlio/detail/socket_data.hpp b/curlio/detail/socket_data.hpp
index 023caf9..2a73b7e 100644
--- a/curlio/detail/socket_data.hpp
+++ b/curlio/detail/socket_data.hpp
@@ -4,8 +4,8 @@
 
 namespace curlio::detail {
 
-struct Socket_data {
-	enum Wait_flag {
+struct SocketData {
+	enum WaitFlag {
 		wait_flag_write = 0x1,
 		wait_flag_read  = 0x2,
 	};
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 1df9c1d..5929d7a 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -4,10 +4,10 @@ file(GLOB examples "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
 foreach(example ${examples})
   get_filename_component(name "${example}" NAME_WE)
 
-  add_executable(${name} "${example}")
-  target_link_libraries(${name} PRIVATE curlio::curlio Threads::Threads)
-  set_target_properties(${name} PROPERTIES CXX_STANDARD 20)
+  add_executable(curlio_example_${name} "${example}")
+  target_link_libraries(curlio_example_${name} PRIVATE cURLio::cURLio Threads::Threads)
+  set_target_properties(curlio_example_${name} PROPERTIES CXX_STANDARD 20)
 
-  # target_compile_options(${name} PUBLIC -fsanitize=address -fno-omit-frame-pointer -O1
-  # -fno-optimize-sibling-calls) target_link_options(${name} PUBLIC -fsanitize=address)
+  # target_compile_options(curlio_example_${name} PUBLIC -fsanitize=address -fno-omit-frame-pointer -O1
+  # -fno-optimize-sibling-calls) target_link_options(curlio_example_${name} PUBLIC -fsanitize=address)
 endforeach()
diff --git a/examples/playground.cpp b/examples/playground.cpp
index fac6a55..047b2bc 100644
--- a/examples/playground.cpp
+++ b/examples/playground.cpp
@@ -1,79 +1,52 @@
 // #define CURLIO_ENABLE_LOGGING
 // #define BOOST_ASIO_ENABLE_HANDLER_TRACKING
 
-#include <boost/asio/experimental/as_tuple.hpp>
-#include <boost/crc.hpp>
-#include <boost/json/src.hpp>
 #include <curlio/curlio.hpp>
-#include <fstream>
 #include <iostream>
-#include <random>
-#include <thread>
+#include <numeric>
 #include <tuple>
 
 using namespace boost::asio;
 
-constexpr auto use_nothrow_awaitable = experimental::as_tuple(use_awaitable);
-
-std::tuple<std::string, unsigned int, std::size_t> map[] = {
-	std::make_tuple("HUAWEI_MateBook_D_16_WDT_1.0.3.11.zip", 2454097580, 162351),
-	std::make_tuple("ml.remawmom.2022_cmx1100a_d_owner_s_manual.pdf", 3038542098, 5534135),
-	std::make_tuple("virtio-win-guest-tools.exe", 1758795416, 31137536),
-};
+awaitable<void> async_main()
+try {
+	auto session = curlio::make_session(co_await this_coro::executor);
+	auto request = curlio::make_request(session);
+
+	std::shared_ptr<curlio::Response> response{};
+	for (const auto url : { "http://example.com", "http://google.de" }) {
+		request->set_option<CURLOPT_URL>(url);
+		response = co_await session->async_start(request, use_awaitable);
+		co_await response->async_wait_headers(use_awaitable);
+
+		std::uint64_t checksum = 0;
+		std::uint8_t data[4096]{};
+		while (true) {
+			const auto [ec, bytes_transferred] =
+			  co_await response->async_read_some(buffer(data), as_tuple(use_awaitable));
+			if (ec) {
+				std::cout << "Error: " << ec.message() << "\n";
+				break;
+			}
+			std::cout.write(reinterpret_cast<const char*>(data), bytes_transferred);
+			checksum = std::accumulate(data, data + bytes_transferred, checksum);
+		}
+		std::cout << "Checksum for '" << url << "' is " << checksum << "\n";
+	}
+} catch (const std::exception& e) {
+	std::cerr << "Failed with: " << e.what() << "\n";
+}
 
 int main(int argc, char** argv)
 {
 	curl_global_init(CURL_GLOBAL_ALL);
-	io_service service;
+	io_service service{};
 
 	auto session = curlio::make_session<boost::asio::any_io_executor>(service.get_executor());
 
-	std::default_random_engine engine{ 12223 };
-	std::uniform_int_distribution<int> dist{ 0, 2 };
-	for (int j = 0; j < 2000; ++j) {
-		co_spawn(
-		  service,
-		  [&, i = dist(engine)]() -> awaitable<void> {
-			  int k        = j % 3;
-			  auto request = curlio::make_request(session);
-
-			  const auto& [name, checksum, size] = map[i];
-			  curl_easy_setopt(request->native_handle(), CURLOPT_URL, ("http://localhost:8088/" + name).c_str());
-
-			  auto response = co_await session->async_start(request, use_awaitable);
-
-			  co_await response->async_wait_headers(use_awaitable);
-
-			  char data[1024 * 16];
-			  boost::crc_32_type crc{};
-			  std::size_t total = 0;
-			  while (true) {
-				  const auto [ec, read] = co_await response->async_read_some(buffer(data), use_nothrow_awaitable);
-				  if (ec) {
-					  if (ec != error::eof) {
-						  puts(ec.message().c_str());
-					  }
-					  break;
-				  }
-				  total += read;
-				  crc.process_bytes(data, read);
-			  }
-			  if (crc.checksum() != checksum) {
-				  std::cout << "Checksum not identical for " << name << " (" << total << "/" << size << ")"
-				            << "\n";
-			  }
-			  co_return;
-		  },
-		  detached);
-	}
+	co_spawn(service, async_main(), detached);
 
 	std::cout << "Service running with cURL version: " << curl_version() << "\n";
-	std::thread t{ [&] { service.run(); } };
-	// boost::asio::signal_set sig{service, SIGINT};
-	// sig.async_wait([&](auto, auto) {
-	// 	service.stop();
-	// });
 	service.run();
-	t.join();
 	curl_global_cleanup();
 }

From fbc3822d540eb31d666a32979800ed3066f7ad8e Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sun, 16 Jun 2024 16:24:45 +0000
Subject: [PATCH 3/7] Fix correct registering and unregistering of callbacks

---
 curlio/basic_request.hpp           |  2 +-
 curlio/basic_request.inl           |  2 +-
 curlio/basic_response.hpp          |  9 ++++++---
 curlio/basic_response.inl          | 18 +++++++++++++----
 curlio/basic_session.inl           | 26 ++++++++++++++++++++-----
 curlio/detail/header_collector.hpp | 17 ++++++++--------
 examples/playground.cpp            | 31 ++++++++++++------------------
 7 files changed, 64 insertions(+), 41 deletions(-)

diff --git a/curlio/basic_request.hpp b/curlio/basic_request.hpp
index cd08f24..d429a8a 100644
--- a/curlio/basic_request.hpp
+++ b/curlio/basic_request.hpp
@@ -41,7 +41,7 @@ class Basic_request : public std::enable_shared_from_this<Basic_request<Executor
 	detail::Function<std::size_t(detail::asio_error_code, char*, std::size_t)> _send_handler;
 
 	Basic_request(std::shared_ptr<Basic_session<Executor>>&& session);
-	void _mark_finished();
+	void _mark_finished() noexcept;
 	static std::size_t _read_callback(char* data, std::size_t size, std::size_t count, void* self_ptr) noexcept;
 };
 
diff --git a/curlio/basic_request.inl b/curlio/basic_request.inl
index 3e2bbb3..ab658b5 100644
--- a/curlio/basic_request.inl
+++ b/curlio/basic_request.inl
@@ -119,7 +119,7 @@ inline Basic_request<Executor>::Basic_request(std::shared_ptr<Basic_session<Exec
 }
 
 template<typename Executor>
-inline void Basic_request<Executor>::_mark_finished()
+inline void Basic_request<Executor>::_mark_finished() noexcept
 {
 	CURLIO_INFO("Request marked as finished");
 	if (_send_handler) {
diff --git a/curlio/basic_response.hpp b/curlio/basic_response.hpp
index 1a510d2..c8184b8 100644
--- a/curlio/basic_response.hpp
+++ b/curlio/basic_response.hpp
@@ -13,6 +13,8 @@
 
 namespace curlio {
 
+using Headers = detail::HeaderCollector::fields_type;
+
 template<typename Executor>
 class Basic_response : public std::enable_shared_from_this<Basic_response<Executor>> {
 public:
@@ -38,9 +40,10 @@ class Basic_response : public std::enable_shared_from_this<Basic_response<Execut
 	detail::HeaderCollector _header_collector;
 	bool _finished = false;
 
-	Basic_response(std::shared_ptr<Basic_session<Executor>>&& session,
-	               std::shared_ptr<Basic_request<Executor>>&& request);
-	void _mark_finished();
+	Basic_response(std::shared_ptr<Basic_session<Executor>> session,
+	               std::shared_ptr<Basic_request<Executor>> request);
+	void _start() noexcept;
+	void _stop() noexcept;
 	static std::size_t _write_callback(char* data, std::size_t size, std::size_t count,
 	                                   void* self_ptr) noexcept;
 };
diff --git a/curlio/basic_response.inl b/curlio/basic_response.inl
index cd2aa54..0b500da 100644
--- a/curlio/basic_response.inl
+++ b/curlio/basic_response.inl
@@ -90,25 +90,35 @@ inline Basic_response<Executor>::executor_type Basic_response<Executor>::get_exe
 }
 
 template<typename Executor>
-inline Basic_response<Executor>::Basic_response(std::shared_ptr<Basic_session<Executor>>&& session,
-                                                std::shared_ptr<Basic_request<Executor>>&& request)
+inline Basic_response<Executor>::Basic_response(std::shared_ptr<Basic_session<Executor>> session,
+                                                std::shared_ptr<Basic_request<Executor>> request)
     : _session{ std::move(session) }, _request{ std::move(request) },
       _header_collector{ _request->native_handle() }
+{}
+
+template<typename Executor>
+inline void Basic_response<Executor>::_start() noexcept
 {
 	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEFUNCTION, &Basic_response::_write_callback);
 	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEDATA, this);
+	_header_collector.start();
 }
 
 template<typename Executor>
-inline void Basic_response<Executor>::_mark_finished()
+inline void Basic_response<Executor>::_stop() noexcept
 {
 	CURLIO_INFO("Response marked as finished");
+
+	_header_collector.stop();
+	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEFUNCTION, nullptr);
+	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEDATA, nullptr);
+
 	_finished = true;
-	_header_collector.finish();
 	if (_receive_handler) {
 		_receive_handler(CURLIO_ASIO_NS::error::eof, nullptr, 0);
 		_receive_handler.reset();
 	}
+
 	_request->_mark_finished();
 }
 
diff --git a/curlio/basic_session.inl b/curlio/basic_session.inl
index 3eed098..889c415 100644
--- a/curlio/basic_session.inl
+++ b/curlio/basic_session.inl
@@ -3,6 +3,7 @@
 #include "basic_request.hpp"
 #include "basic_response.hpp"
 #include "basic_session.hpp"
+#include "detail/final_action.hpp"
 #include "log.hpp"
 
 #include <functional>
@@ -33,18 +34,33 @@ inline auto Basic_session<Executor>::async_start(request_pointer request, auto&&
 			    request->template set_option<CURLOPT_OPENSOCKETDATA>(this);
 			    request->template set_option<CURLOPT_CLOSESOCKETFUNCTION>(&Basic_session::_close_socket_callback);
 			    request->template set_option<CURLOPT_CLOSESOCKETDATA>(this);
+			    auto unregister_request = detail::finally([&] {
+				    request->template set_option<CURLOPT_OPENSOCKETFUNCTION>(nullptr);
+				    request->template set_option<CURLOPT_OPENSOCKETDATA>(nullptr);
+				    request->template set_option<CURLOPT_CLOSESOCKETFUNCTION>(nullptr);
+				    request->template set_option<CURLOPT_CLOSESOCKETDATA>(nullptr);
+			    });
 
 			    // Kick start.
 			    CURLIO_TRACE("Starting handle " << easy_handle);
 			    curl_multi_add_handle(_multi_handle, easy_handle);
 			    _perform(CURL_SOCKET_TIMEOUT, 0);
 
-			    std::shared_ptr<Response> response{ new Response{ this->shared_from_this(), std::move(request) } };
+			    const std::shared_ptr<Response> response{ new Response{ this->shared_from_this(), request } };
+			    response->_start();
+			    auto unregister_response = detail::finally([&] {
+				    response->_stop();
+				    _active_requests.erase(easy_handle);
+			    });
 			    _active_requests.insert({ easy_handle, response });
 
 			    auto executor = CURLIO_ASIO_NS::get_associated_executor(handler, get_executor());
 			    CURLIO_ASIO_NS::post(std::move(executor),
-			                         std::bind(std::move(handler), detail::asio_error_code{}, std::move(response)));
+			                         std::bind(std::move(handler), detail::asio_error_code{}, response));
+
+			    // Everything went without exceptions.
+			    unregister_response.cancel();
+			    unregister_request.cancel();
 		    });
 	  },
 	  token);
@@ -105,13 +121,13 @@ inline void Basic_session<Executor>::_clean_finished()
 
 			const auto it = _active_requests.find(message->easy_handle);
 			if (it != _active_requests.end()) {
-				it->second->_mark_finished();
-				_active_requests.erase(it);
-
 				curl_easy_setopt(message->easy_handle, CURLOPT_OPENSOCKETFUNCTION, nullptr);
 				curl_easy_setopt(message->easy_handle, CURLOPT_OPENSOCKETDATA, nullptr);
 				curl_easy_setopt(message->easy_handle, CURLOPT_CLOSESOCKETFUNCTION, nullptr);
 				curl_easy_setopt(message->easy_handle, CURLOPT_CLOSESOCKETDATA, nullptr);
+
+				it->second->_stop();
+				_active_requests.erase(it);
 			}
 
 			curl_multi_remove_handle(_multi_handle, message->easy_handle);
diff --git a/curlio/detail/header_collector.hpp b/curlio/detail/header_collector.hpp
index 54328af..2d326be 100644
--- a/curlio/detail/header_collector.hpp
+++ b/curlio/detail/header_collector.hpp
@@ -37,23 +37,24 @@ class HeaderCollector {
 public:
 	using fields_type = std::map<std::string, std::string, Case_insensitive_less>;
 
-	HeaderCollector(CURL* handle) : _handle{ handle }
-	{
-		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, &HeaderCollector::_header_callback);
-		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, this);
-	}
+	HeaderCollector(CURL* handle) noexcept : _handle{ handle } {}
 	HeaderCollector(const HeaderCollector& copy) = delete;
 	HeaderCollector(HeaderCollector&& move)      = delete;
 	~HeaderCollector()                           = default;
 
-	void finish()
+	void start() noexcept
+	{
+		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, &HeaderCollector::_header_callback);
+		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, this);
+	}
+	void stop() noexcept
 	{
+		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, nullptr);
+		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, nullptr);
 		if (_headers_received_handler) {
 			_headers_received_handler(CURLIO_ASIO_NS::error::eof);
 			_headers_received_handler.reset();
 		}
-		curl_easy_setopt(_handle, CURLOPT_HEADERFUNCTION, nullptr);
-		curl_easy_setopt(_handle, CURLOPT_HEADERDATA, nullptr);
 	}
 	auto async_wait(auto&& fallback_executor, auto&& token)
 	{
diff --git a/examples/playground.cpp b/examples/playground.cpp
index 047b2bc..c67f7c4 100644
--- a/examples/playground.cpp
+++ b/examples/playground.cpp
@@ -5,6 +5,7 @@
 #include <iostream>
 #include <numeric>
 #include <tuple>
+#include <fstream>
 
 using namespace boost::asio;
 
@@ -13,25 +14,17 @@ try {
 	auto session = curlio::make_session(co_await this_coro::executor);
 	auto request = curlio::make_request(session);
 
-	std::shared_ptr<curlio::Response> response{};
-	for (const auto url : { "http://example.com", "http://google.de" }) {
-		request->set_option<CURLOPT_URL>(url);
-		response = co_await session->async_start(request, use_awaitable);
-		co_await response->async_wait_headers(use_awaitable);
-
-		std::uint64_t checksum = 0;
-		std::uint8_t data[4096]{};
-		while (true) {
-			const auto [ec, bytes_transferred] =
-			  co_await response->async_read_some(buffer(data), as_tuple(use_awaitable));
-			if (ec) {
-				std::cout << "Error: " << ec.message() << "\n";
-				break;
-			}
-			std::cout.write(reinterpret_cast<const char*>(data), bytes_transferred);
-			checksum = std::accumulate(data, data + bytes_transferred, checksum);
-		}
-		std::cout << "Checksum for '" << url << "' is " << checksum << "\n";
+	request->set_option<CURLOPT_URL>("http://127.0.0.1:8088/");
+	request->set_option<CURLOPT_MAXREDIRS>(3);
+	request->set_option<CURLOPT_FOLLOWLOCATION>(1);
+
+	auto response = co_await session->async_start(request, use_awaitable);
+
+	std::ofstream file{"/workspaces/downer/backend/asd", std::ios::out|std::ios::binary};
+	char data[10*1024];
+	while (true) {
+		const std::size_t bytes_transferred = co_await response->async_read_some(buffer(data), use_awaitable);
+		file.write(data, bytes_transferred);
 	}
 } catch (const std::exception& e) {
 	std::cerr << "Failed with: " << e.what() << "\n";

From f7bfd244192f904aa79f60ea6cf26b178e1dba9f Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Mon, 17 Jun 2024 16:12:13 +0000
Subject: [PATCH 4/7] Fix potential use-after-free

---
 curlio/basic_session.inl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/curlio/basic_session.inl b/curlio/basic_session.inl
index 889c415..0684c1b 100644
--- a/curlio/basic_session.inl
+++ b/curlio/basic_session.inl
@@ -119,6 +119,8 @@ inline void Basic_session<Executor>::_clean_finished()
 		if (message->msg == CURLMSG_DONE) {
 			CURLIO_INFO("Removing handle: " << message->easy_handle);
 
+			curl_multi_remove_handle(_multi_handle, message->easy_handle);
+
 			const auto it = _active_requests.find(message->easy_handle);
 			if (it != _active_requests.end()) {
 				curl_easy_setopt(message->easy_handle, CURLOPT_OPENSOCKETFUNCTION, nullptr);
@@ -129,8 +131,6 @@ inline void Basic_session<Executor>::_clean_finished()
 				it->second->_stop();
 				_active_requests.erase(it);
 			}
-
-			curl_multi_remove_handle(_multi_handle, message->easy_handle);
 		} else {
 			CURLIO_WARN("Got unknown message during cleaning: " << message->msg);
 		}

From 0ee2494ea1160a43ef95f861af6ca0939fac48c3 Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sat, 22 Jun 2024 17:17:09 +0000
Subject: [PATCH 5/7] Change owning strategy

---
 curlio/basic_request.hpp                |  33 ++++---
 curlio/basic_request.inl                |  98 ++++++++++---------
 curlio/basic_response.hpp               |  33 ++++---
 curlio/basic_response.inl               | 110 +++++++++++----------
 curlio/basic_session.hpp                |  29 +++---
 curlio/basic_session.inl                | 122 +++++++++++++-----------
 curlio/detail/case_insensitive_less.hpp |   2 +-
 curlio/detail/final_action.hpp          |  12 +--
 curlio/detail/header_collector.hpp      |   2 +-
 curlio/fwd.hpp                          |   6 +-
 curlio/quick/reader.hpp                 |   2 +-
 11 files changed, 235 insertions(+), 214 deletions(-)

diff --git a/curlio/basic_request.hpp b/curlio/basic_request.hpp
index d429a8a..6fbf16d 100644
--- a/curlio/basic_request.hpp
+++ b/curlio/basic_request.hpp
@@ -3,20 +3,23 @@
 #include "config.hpp"
 #include "detail/asio_include.hpp"
 #include "detail/function.hpp"
-#include "fwd.hpp"
 #include "detail/option_type.hpp"
+#include "fwd.hpp"
 
 #include <curl/curl.h>
 
 namespace curlio {
 
 template<typename Executor>
-class Basic_request : public std::enable_shared_from_this<Basic_request<Executor>> {
+class BasicRequest {
 public:
 	using executor_type = Executor;
+	using strand_type   = CURLIO_ASIO_NS::strand<executor_type>;
 
-	Basic_request(const Basic_request& copy);
-	~Basic_request() noexcept;
+	BasicRequest(BasicSession<Executor>& session) noexcept;
+	BasicRequest(const BasicRequest& copy) noexcept;
+	BasicRequest(BasicRequest&& move) = delete;
+	~BasicRequest();
 
 	template<CURLoption Option>
 	void set_option(detail::option_type<Option> value);
@@ -25,26 +28,28 @@ class Basic_request : public std::enable_shared_from_this<Basic_request<Executor
 	auto async_abort(auto&& token);
 	CURLIO_NO_DISCARD CURL* native_handle() const noexcept;
 	CURLIO_NO_DISCARD executor_type get_executor() const noexcept;
-	Basic_request& operator=(const Basic_request& copy) = delete;
+	CURLIO_NO_DISCARD strand_type& get_strand() noexcept;
+
+	BasicRequest& operator=(const BasicRequest& copy) = delete;
+	BasicRequest& operator=(BasicRequest&& move)      = delete;
 
-	template<typename Executor_>
-	friend std::shared_ptr<Basic_request<Executor_>>
-	  make_request(std::shared_ptr<Basic_session<Executor_>> session);
+	static std::shared_ptr<BasicRequest> make_request(BasicSession<Executor>& session);
 
 private:
-	friend class Basic_session<Executor>;
-	friend class Basic_response<Executor>;
+	friend class BasicSession<Executor>;
+	friend class BasicResponse<Executor>;
 
-	std::shared_ptr<Basic_session<Executor>> _session;
+	std::shared_ptr<strand_type> _strand;
+	// The CURL easy handle. The response owns this instance.
 	CURL* _handle;
 	curl_slist* _additional_headers = nullptr;
-	detail::Function<std::size_t(detail::asio_error_code, char*, std::size_t)> _send_handler;
+	detail::Function<std::size_t(detail::asio_error_code, char*, std::size_t)> _send_handler{};
 
-	Basic_request(std::shared_ptr<Basic_session<Executor>>&& session);
+	BasicRequest(std::shared_ptr<BasicSession<Executor>>&& session);
 	void _mark_finished() noexcept;
 	static std::size_t _read_callback(char* data, std::size_t size, std::size_t count, void* self_ptr) noexcept;
 };
 
-using Request = Basic_request<CURLIO_ASIO_NS::any_io_executor>;
+using Request = BasicRequest<CURLIO_ASIO_NS::any_io_executor>;
 
 } // namespace curlio
diff --git a/curlio/basic_request.inl b/curlio/basic_request.inl
index ab658b5..203ba2e 100644
--- a/curlio/basic_request.inl
+++ b/curlio/basic_request.inl
@@ -8,16 +8,26 @@
 namespace curlio {
 
 template<typename Executor>
-inline Basic_request<Executor>::Basic_request(const Basic_request& copy) : _session{ copy._session }
+inline BasicRequest<Executor>::BasicRequest(BasicSession<Executor>& session) noexcept
+    : _strand{ session._strand }
+{
+	_handle = curl_easy_init();
+
+	curl_easy_setopt(_handle, CURLOPT_READFUNCTION, &BasicRequest::_read_callback);
+	curl_easy_setopt(_handle, CURLOPT_READDATA, this);
+}
+
+template<typename Executor>
+inline BasicRequest<Executor>::BasicRequest(const BasicRequest& copy) noexcept : _strand{ copy._strand }
 {
 	_handle = curl_easy_duphandle(copy._handle);
 
-	curl_easy_setopt(_handle, CURLOPT_READFUNCTION, &Basic_request::_read_callback);
+	curl_easy_setopt(_handle, CURLOPT_READFUNCTION, &BasicRequest::_read_callback);
 	curl_easy_setopt(_handle, CURLOPT_READDATA, this);
 }
 
 template<typename Executor>
-inline Basic_request<Executor>::~Basic_request() noexcept
+inline BasicRequest<Executor>::~BasicRequest()
 {
 	curl_easy_cleanup(_handle);
 	curl_slist_free_all(_additional_headers);
@@ -25,7 +35,7 @@ inline Basic_request<Executor>::~Basic_request() noexcept
 
 template<typename Executor>
 template<CURLoption Option>
-inline void Basic_request<Executor>::set_option(detail::option_type<Option> value)
+inline void BasicRequest<Executor>::set_option(detail::option_type<Option> value)
 {
 	if (const auto status = curl_easy_setopt(_handle, Option, value); status != CURLE_OK) {
 		throw std::system_error{ Code::bad_option, curl_easy_strerror(status) };
@@ -33,49 +43,48 @@ inline void Basic_request<Executor>::set_option(detail::option_type<Option> valu
 }
 
 template<typename Executor>
-inline void Basic_request<Executor>::append_header(const char* header)
+inline void BasicRequest<Executor>::append_header(const char* header)
 {
 	_additional_headers = curl_slist_append(_additional_headers, header);
 	set_option<CURLOPT_HTTPHEADER>(_additional_headers);
 }
 
 template<typename Executor>
-inline auto Basic_request<Executor>::async_write_some(const auto& buffers, auto&& token)
+inline auto BasicRequest<Executor>::async_write_some(const auto& buffers, auto&& token)
 {
 	return CURLIO_ASIO_NS::async_initiate<decltype(token), void(detail::asio_error_code, std::size_t)>(
 	  [this](auto handler, const auto& buffers) {
-		  CURLIO_ASIO_NS::dispatch(
-		    _session->get_strand(), [this, buffers, handler = std::move(handler)]() mutable {
-			    auto executor = CURLIO_ASIO_NS::get_associated_executor(handler, get_executor());
-
-			    if (_send_handler) {
-				    CURLIO_ASIO_NS::post(
-				      std::move(executor),
-				      std::bind(std::move(handler), make_error_code(Code::multiple_writes), std::size_t{ 0 }));
-			    } else {
-				    _send_handler = [this, buffers = std::move(buffers), handler = std::move(handler),
-				                     executor = std::move(executor)](detail::asio_error_code ec, char* data,
-				                                                     std::size_t size) mutable {
-					    const std::size_t copied =
-					      CURLIO_ASIO_NS::buffer_copy(CURLIO_ASIO_NS::buffer(data, size), buffers);
-					    CURLIO_ASIO_NS::post(std::move(executor), std::bind(std::move(handler), ec, copied));
-					    return copied;
-				    };
-
-				    // Resume.
-				    curl_easy_pause(_handle, CURLPAUSE_CONT);
-			    }
-		    });
+		  CURLIO_ASIO_NS::dispatch(*_strand, [this, buffers, handler = std::move(handler)]() mutable {
+			  auto executor = CURLIO_ASIO_NS::get_associated_executor(handler, get_executor());
+
+			  if (_send_handler) {
+				  CURLIO_ASIO_NS::post(
+				    std::move(executor),
+				    std::bind(std::move(handler), make_error_code(Code::multiple_writes), std::size_t{ 0 }));
+			  } else {
+				  _send_handler = [this, buffers = std::move(buffers), handler = std::move(handler),
+				                   executor = std::move(executor)](detail::asio_error_code ec, char* data,
+				                                                   std::size_t size) mutable {
+					  const std::size_t copied =
+					    CURLIO_ASIO_NS::buffer_copy(CURLIO_ASIO_NS::buffer(data, size), buffers);
+					  CURLIO_ASIO_NS::post(std::move(executor), std::bind(std::move(handler), ec, copied));
+					  return copied;
+				  };
+
+				  // Resume.
+				  curl_easy_pause(_handle, CURLPAUSE_CONT);
+			  }
+		  });
 	  },
 	  token, buffers);
 }
 
 template<typename Executor>
-inline auto Basic_request<Executor>::async_abort(auto&& token)
+inline auto BasicRequest<Executor>::async_abort(auto&& token)
 {
 	return CURLIO_ASIO_NS::async_initiate<decltype(token), void(detail::asio_error_code)>(
 	  [this](auto handler) {
-		  CURLIO_ASIO_NS::dispatch(_session->get_strand(), [this, handler = std::move(handler)]() mutable {
+		  CURLIO_ASIO_NS::dispatch(*_strand, [this, handler = std::move(handler)]() mutable {
 			  if (_send_handler) {
 				  _send_handler(CURLIO_ASIO_NS::error::operation_aborted, nullptr, 0);
 				  _send_handler.reset();
@@ -97,29 +106,25 @@ inline auto Basic_request<Executor>::async_abort(auto&& token)
 }
 
 template<typename Executor>
-inline CURL* Basic_request<Executor>::native_handle() const noexcept
+inline CURL* BasicRequest<Executor>::native_handle() const noexcept
 {
 	return _handle;
 }
 
 template<typename Executor>
-inline Basic_request<Executor>::executor_type Basic_request<Executor>::get_executor() const noexcept
+inline BasicRequest<Executor>::executor_type BasicRequest<Executor>::get_executor() const noexcept
 {
-	return _session->get_executor();
+	return _strand->get_inner_executor();
 }
 
 template<typename Executor>
-inline Basic_request<Executor>::Basic_request(std::shared_ptr<Basic_session<Executor>>&& session)
-    : _session{ std::move(session) }
+inline BasicRequest<Executor>::strand_type& BasicRequest<Executor>::get_strand() noexcept
 {
-	_handle = curl_easy_init();
-
-	curl_easy_setopt(_handle, CURLOPT_READFUNCTION, &Basic_request::_read_callback);
-	curl_easy_setopt(_handle, CURLOPT_READDATA, this);
+	return *_strand;
 }
 
 template<typename Executor>
-inline void Basic_request<Executor>::_mark_finished() noexcept
+inline void BasicRequest<Executor>::_mark_finished() noexcept
 {
 	CURLIO_INFO("Request marked as finished");
 	if (_send_handler) {
@@ -129,10 +134,10 @@ inline void Basic_request<Executor>::_mark_finished() noexcept
 }
 
 template<typename Executor>
-inline std::size_t Basic_request<Executor>::_read_callback(char* data, std::size_t size, std::size_t count,
-                                                           void* self_ptr) noexcept
+inline std::size_t BasicRequest<Executor>::_read_callback(char* data, std::size_t size, std::size_t count,
+                                                          void* self_ptr) noexcept
 {
-	const auto self                = static_cast<Basic_request*>(self_ptr);
+	const auto self                = static_cast<BasicRequest*>(self_ptr);
 	const std::size_t total_length = size * count;
 
 	if (total_length == 0) {
@@ -149,11 +154,4 @@ inline std::size_t Basic_request<Executor>::_read_callback(char* data, std::size
 	return CURL_READFUNC_PAUSE;
 }
 
-template<typename Executor>
-CURLIO_NO_DISCARD inline std::shared_ptr<Basic_request<Executor>>
-  make_request(std::shared_ptr<Basic_session<Executor>> session)
-{
-	return std::shared_ptr<Basic_request<Executor>>{ new Basic_request<Executor>{ std::move(session) } };
-}
-
 } // namespace curlio
diff --git a/curlio/basic_response.hpp b/curlio/basic_response.hpp
index c8184b8..7124fc5 100644
--- a/curlio/basic_response.hpp
+++ b/curlio/basic_response.hpp
@@ -4,11 +4,9 @@
 #include "detail/asio_include.hpp"
 #include "detail/function.hpp"
 #include "detail/header_collector.hpp"
-#include "detail/option_type.hpp"
 #include "fwd.hpp"
 
 #include <curl/curl.h>
-#include <map>
 #include <memory>
 
 namespace curlio {
@@ -16,32 +14,37 @@ namespace curlio {
 using Headers = detail::HeaderCollector::fields_type;
 
 template<typename Executor>
-class Basic_response : public std::enable_shared_from_this<Basic_response<Executor>> {
+class BasicResponse : public std::enable_shared_from_this<BasicResponse<Executor>> {
 public:
 	using executor_type = Executor;
-	using headers_type  = detail::HeaderCollector::fields_type;
+	using strand_type   = CURLIO_ASIO_NS::strand<executor_type>;
 
-	Basic_response(const Basic_response& copy) = delete;
+	BasicResponse(const BasicResponse& copy) = delete;
+	BasicResponse(BasicResponse&& move)      = delete;
 
 	template<CURLINFO Option>
 	auto async_get_info(auto&& token) const;
 	auto async_read_some(const auto& buffers, auto&& token);
 	auto async_wait_headers(auto&& token);
 	CURLIO_NO_DISCARD executor_type get_executor() const noexcept;
-	Basic_response& operator=(const Basic_response& copy) = delete;
+	CURLIO_NO_DISCARD strand_type& get_strand() noexcept;
+
+	BasicResponse& operator=(const BasicResponse& copy) = delete;
+	BasicResponse& operator=(BasicResponse&& move)      = delete;
 
 private:
-	friend class Basic_session<Executor>;
+	// Only the session may construct a response and call `_start()` / `_stop()`.
+	friend class BasicSession<Executor>;
 
-	std::shared_ptr<Basic_session<Executor>> _session;
-	std::shared_ptr<Basic_request<Executor>> _request;
-	CURLIO_ASIO_NS::streambuf _input_buffer;
-	detail::Function<std::size_t(detail::asio_error_code, const char*, std::size_t)> _receive_handler;
+	std::shared_ptr<strand_type> _strand;
+	std::shared_ptr<BasicRequest<Executor>> _request;
+	CURLIO_ASIO_NS::streambuf _input_buffer{};
+	detail::Function<std::size_t(detail::asio_error_code, const char*, std::size_t)> _receive_handler{};
 	detail::HeaderCollector _header_collector;
 	bool _finished = false;
 
-	Basic_response(std::shared_ptr<Basic_session<Executor>> session,
-	               std::shared_ptr<Basic_request<Executor>> request);
+	BasicResponse(std::shared_ptr<strand_type> strand,
+	              std::shared_ptr<BasicRequest<Executor>> request) noexcept;
 	void _start() noexcept;
 	void _stop() noexcept;
 	static std::size_t _write_callback(char* data, std::size_t size, std::size_t count,
@@ -49,8 +52,8 @@ class Basic_response : public std::enable_shared_from_this<Basic_response<Execut
 };
 
 template<typename Executor>
-auto async_wait_last_headers(std::shared_ptr<Basic_response<Executor>> response, auto&& token);
+auto async_wait_last_headers(std::shared_ptr<BasicResponse<Executor>> response, auto&& token);
 
-using Response = Basic_response<CURLIO_ASIO_NS::any_io_executor>;
+using Response = BasicResponse<CURLIO_ASIO_NS::any_io_executor>;
 
 } // namespace curlio
diff --git a/curlio/basic_response.inl b/curlio/basic_response.inl
index 0b500da..6580ea3 100644
--- a/curlio/basic_response.inl
+++ b/curlio/basic_response.inl
@@ -2,7 +2,6 @@
 
 #include "basic_request.hpp"
 #include "basic_response.hpp"
-#include "basic_session.hpp"
 #include "error.hpp"
 #include "log.hpp"
 
@@ -10,12 +9,12 @@ namespace curlio {
 
 template<typename Executor>
 template<CURLINFO Option>
-inline auto Basic_response<Executor>::async_get_info(auto&& token) const
+inline auto BasicResponse<Executor>::async_get_info(auto&& token) const
 {
 	return CURLIO_ASIO_NS::async_initiate<decltype(token),
 	                                      void(detail::asio_error_code, detail::info_type<Option>)>(
 	  [this](auto handler) {
-		  CURLIO_ASIO_NS::dispatch(_session->get_strand(), [this, handler = std::move(handler)]() mutable {
+		  CURLIO_ASIO_NS::dispatch(*_strand, [this, handler = std::move(handler)]() mutable {
 			  detail::info_type<Option> value{};
 			  detail::asio_error_code ec{};
 
@@ -30,53 +29,52 @@ inline auto Basic_response<Executor>::async_get_info(auto&& token) const
 }
 
 template<typename Executor>
-inline auto Basic_response<Executor>::async_read_some(const auto& buffers, auto&& token)
+inline auto BasicResponse<Executor>::async_read_some(const auto& buffers, auto&& token)
 {
 	return CURLIO_ASIO_NS::async_initiate<decltype(token), void(detail::asio_error_code, std::size_t)>(
 	  [this](auto handler, const auto& buffers) {
-		  CURLIO_ASIO_NS::dispatch(
-		    _session->get_strand(), [this, buffers, handler = std::move(handler)]() mutable {
-			    auto executor = CURLIO_ASIO_NS::get_associated_executor(handler, get_executor());
-			    // Can immediately finish.
-			    if (_input_buffer.size() > 0) {
-				    const std::size_t copied = CURLIO_ASIO_NS::buffer_copy(buffers, _input_buffer.data());
-				    _input_buffer.consume(copied);
-				    CURLIO_ASIO_NS::post(std::move(executor),
-				                         std::bind(std::move(handler), detail::asio_error_code{}, copied));
-			    } else if (_finished) {
-				    CURLIO_ASIO_NS::post(std::move(executor),
-				                         std::bind(std::move(handler),
-				                                   detail::asio_error_code{ CURLIO_ASIO_NS::error::eof },
-				                                   std::size_t{ 0 }));
-			    } else if (_receive_handler) {
-				    CURLIO_ASIO_NS::post(
-				      std::move(executor),
-				      std::bind(std::move(handler), make_error_code(Code::multiple_reads), std::size_t{ 0 }));
-			    } // Wait for more data.
-			    else {
-				    _receive_handler = [this, buffers = std::move(buffers), executor = std::move(executor),
-				                        handler = std::move(handler)](detail::asio_error_code ec, const char* data,
-				                                                      std::size_t size) mutable {
-					    const std::size_t copied =
-					      CURLIO_ASIO_NS::buffer_copy(buffers, CURLIO_ASIO_NS::buffer(data, size));
-					    CURLIO_ASIO_NS::post(std::move(executor), std::bind(std::move(handler), ec, copied));
-					    return copied;
-				    };
-
-				    // Resume.
-				    curl_easy_pause(_request->native_handle(), CURLPAUSE_CONT);
-			    }
-		    });
+		  CURLIO_ASIO_NS::dispatch(*_strand, [this, buffers, handler = std::move(handler)]() mutable {
+			  auto executor = CURLIO_ASIO_NS::get_associated_executor(handler, get_executor());
+			  // Can immediately finish.
+			  if (_input_buffer.size() > 0) {
+				  const std::size_t copied = CURLIO_ASIO_NS::buffer_copy(buffers, _input_buffer.data());
+				  _input_buffer.consume(copied);
+				  CURLIO_ASIO_NS::post(std::move(executor),
+				                       std::bind(std::move(handler), detail::asio_error_code{}, copied));
+			  } else if (_finished) {
+				  CURLIO_ASIO_NS::post(std::move(executor),
+				                       std::bind(std::move(handler),
+				                                 detail::asio_error_code{ CURLIO_ASIO_NS::error::eof },
+				                                 std::size_t{ 0 }));
+			  } else if (_receive_handler) {
+				  CURLIO_ASIO_NS::post(
+				    std::move(executor),
+				    std::bind(std::move(handler), make_error_code(Code::multiple_reads), std::size_t{ 0 }));
+			  } // Wait for more data.
+			  else {
+				  _receive_handler = [this, buffers = std::move(buffers), executor = std::move(executor),
+				                      handler = std::move(handler)](detail::asio_error_code ec, const char* data,
+				                                                    std::size_t size) mutable {
+					  const std::size_t copied =
+					    CURLIO_ASIO_NS::buffer_copy(buffers, CURLIO_ASIO_NS::buffer(data, size));
+					  CURLIO_ASIO_NS::post(std::move(executor), std::bind(std::move(handler), ec, copied));
+					  return copied;
+				  };
+
+				  // Resume.
+				  curl_easy_pause(_request->native_handle(), CURLPAUSE_CONT);
+			  }
+		  });
 	  },
 	  token, buffers);
 }
 
 template<typename Executor>
-inline auto Basic_response<Executor>::async_wait_headers(auto&& token)
+inline auto BasicResponse<Executor>::async_wait_headers(auto&& token)
 {
-	return CURLIO_ASIO_NS::async_initiate<decltype(token), void(detail::asio_error_code, headers_type)>(
+	return CURLIO_ASIO_NS::async_initiate<decltype(token), void(detail::asio_error_code, Headers)>(
 	  [this](auto handler) {
-		  CURLIO_ASIO_NS::dispatch(_session->get_strand(), [this, handler = std::move(handler)]() mutable {
+		  CURLIO_ASIO_NS::dispatch(*_strand, [this, handler = std::move(handler)]() mutable {
 			  _header_collector.async_wait(get_executor(), std::move(handler));
 		  });
 	  },
@@ -84,28 +82,34 @@ inline auto Basic_response<Executor>::async_wait_headers(auto&& token)
 }
 
 template<typename Executor>
-inline Basic_response<Executor>::executor_type Basic_response<Executor>::get_executor() const noexcept
+inline BasicResponse<Executor>::executor_type BasicResponse<Executor>::get_executor() const noexcept
+{
+	return _strand->get_inner_executor();
+}
+
+template<typename Executor>
+inline BasicResponse<Executor>::strand_type& BasicResponse<Executor>::get_strand() noexcept
 {
-	return _session->get_executor();
+	return *_strand;
 }
 
 template<typename Executor>
-inline Basic_response<Executor>::Basic_response(std::shared_ptr<Basic_session<Executor>> session,
-                                                std::shared_ptr<Basic_request<Executor>> request)
-    : _session{ std::move(session) }, _request{ std::move(request) },
+inline BasicResponse<Executor>::BasicResponse(std::shared_ptr<CURLIO_ASIO_NS::strand<Executor>> strand,
+                                              std::shared_ptr<BasicRequest<Executor>> request) noexcept
+    : _strand{ std::move(strand) }, _request{ std::move(request) },
       _header_collector{ _request->native_handle() }
 {}
 
 template<typename Executor>
-inline void Basic_response<Executor>::_start() noexcept
+inline void BasicResponse<Executor>::_start() noexcept
 {
-	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEFUNCTION, &Basic_response::_write_callback);
+	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEFUNCTION, &BasicResponse::_write_callback);
 	curl_easy_setopt(_request->native_handle(), CURLOPT_WRITEDATA, this);
 	_header_collector.start();
 }
 
 template<typename Executor>
-inline void Basic_response<Executor>::_stop() noexcept
+inline void BasicResponse<Executor>::_stop() noexcept
 {
 	CURLIO_INFO("Response marked as finished");
 
@@ -123,10 +127,10 @@ inline void Basic_response<Executor>::_stop() noexcept
 }
 
 template<typename Executor>
-inline std::size_t Basic_response<Executor>::_write_callback(char* data, std::size_t size, std::size_t count,
-                                                             void* self_ptr) noexcept
+inline std::size_t BasicResponse<Executor>::_write_callback(char* data, std::size_t size, std::size_t count,
+                                                            void* self_ptr) noexcept
 {
-	const auto self                = static_cast<Basic_response*>(self_ptr);
+	const auto self                = static_cast<BasicResponse*>(self_ptr);
 	const std::size_t total_length = size * count;
 
 	if (total_length == 0) {
@@ -151,9 +155,9 @@ inline std::size_t Basic_response<Executor>::_write_callback(char* data, std::si
 }
 
 template<typename Executor>
-inline auto async_wait_last_headers(std::shared_ptr<Basic_response<Executor>> response, auto&& token)
+inline auto async_wait_last_headers(std::shared_ptr<BasicResponse<Executor>> response, auto&& token)
 {
-	using headers_type = Basic_response<Executor>::headers_type;
+	using headers_type = BasicResponse<Executor>::headers_type;
 	return CURLIO_ASIO_NS::async_compose<decltype(token), void(detail::asio_error_code, headers_type)>(
 	  [response = std::move(response), started = false](auto& self, detail::asio_error_code ec = {},
 	                                                    headers_type headers = {}) mutable {
diff --git a/curlio/basic_session.hpp b/curlio/basic_session.hpp
index 909e908..daa8e0c 100644
--- a/curlio/basic_session.hpp
+++ b/curlio/basic_session.hpp
@@ -12,31 +12,34 @@
 namespace curlio {
 
 template<typename Executor>
-class Basic_session : public std::enable_shared_from_this<Basic_session<Executor>> {
+class BasicSession {
 public:
 	using executor_type    = Executor;
-	using request_pointer  = std::shared_ptr<Basic_request<Executor>>;
-	using response_pointer = std::shared_ptr<Basic_response<Executor>>;
+	using strand_type      = CURLIO_ASIO_NS::strand<executor_type>;
+	using request_pointer  = std::shared_ptr<BasicRequest<Executor>>;
+	using response_pointer = std::shared_ptr<BasicResponse<Executor>>;
 
-	Basic_session(const Basic_session& copy) = delete;
-	~Basic_session() noexcept;
+	BasicSession(Executor executor);
+	BasicSession(const BasicSession& copy) = delete;
+	BasicSession(BasicSession&& move)      = delete;
+	~BasicSession();
 
 	auto async_start(request_pointer request, auto&& token);
 	CURLIO_NO_DISCARD executor_type get_executor() const noexcept;
-	CURLIO_NO_DISCARD CURLIO_ASIO_NS::strand<Executor>& get_strand() noexcept;
-	Basic_session& operator=(const Basic_session& copy) = delete;
+	CURLIO_NO_DISCARD strand_type& get_strand() noexcept;
 
-	template<typename Executor_>
-	friend std::shared_ptr<Basic_session<Executor_>> make_session(Executor_ executor);
+	BasicSession& operator=(const BasicSession& copy) = delete;
+	BasicSession& operator=(BasicSession&& move)      = delete;
 
 private:
+	friend class BasicRequest<Executor>;
+
 	CURLM* _multi_handle;
-	CURLIO_ASIO_NS::strand<Executor> _strand;
+	std::shared_ptr<strand_type> _strand;
 	std::map<CURL*, response_pointer> _active_requests;
 	std::map<curl_socket_t, std::shared_ptr<detail::SocketData>> _sockets;
-	CURLIO_ASIO_NS::steady_timer _timer{ _strand };
+	CURLIO_ASIO_NS::steady_timer _timer{ *_strand };
 
-	Basic_session(Executor executor);
 	void _monitor(const std::shared_ptr<detail::SocketData>& data, detail::SocketData::WaitFlag type);
 	void _clean_finished();
 	void _perform(curl_socket_t socket, int bitmask);
@@ -48,6 +51,6 @@ class Basic_session : public std::enable_shared_from_this<Basic_session<Executor
 	static int _close_socket_callback(void* self_ptr, curl_socket_t socket) noexcept;
 };
 
-using Session = Basic_session<CURLIO_ASIO_NS::any_io_executor>;
+using Session = BasicSession<CURLIO_ASIO_NS::any_io_executor>;
 
 } // namespace curlio
diff --git a/curlio/basic_session.inl b/curlio/basic_session.inl
index 0684c1b..577ef5f 100644
--- a/curlio/basic_session.inl
+++ b/curlio/basic_session.inl
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "basic_request.hpp"
 #include "basic_response.hpp"
 #include "basic_session.hpp"
 #include "detail/final_action.hpp"
@@ -12,27 +11,42 @@
 namespace curlio {
 
 template<typename Executor>
-inline Basic_session<Executor>::~Basic_session() noexcept
+inline BasicSession<Executor>::BasicSession(Executor executor)
+    : _strand{ std::make_shared<strand_type>(CURLIO_ASIO_NS::make_strand(std::move(executor))) }
+{
+	_multi_handle = curl_multi_init();
+
+	curl_multi_setopt(_multi_handle, CURLMOPT_SOCKETFUNCTION, &BasicSession::_socket_callback);
+	curl_multi_setopt(_multi_handle, CURLMOPT_SOCKETDATA, this);
+
+	curl_multi_setopt(_multi_handle, CURLMOPT_TIMERFUNCTION, &BasicSession::_timer_callback);
+	curl_multi_setopt(_multi_handle, CURLMOPT_TIMERDATA, this);
+}
+
+template<typename Executor>
+inline BasicSession<Executor>::~BasicSession()
 {
 	_timer.cancel();
 
+	// TODO remove all active easy handles
+
 	curl_multi_cleanup(_multi_handle);
 }
 
 template<typename Executor>
-inline auto Basic_session<Executor>::async_start(request_pointer request, auto&& token)
+inline auto BasicSession<Executor>::async_start(request_pointer request, auto&& token)
 {
 	return CURLIO_ASIO_NS::async_initiate<decltype(token),
 	                                      void(detail::asio_error_code, std::shared_ptr<Response>)>(
 	  [this, request = std::move(request)](auto handler) mutable {
 		  CURLIO_ASIO_NS::dispatch(
-		    _strand, [this, request = std::move(request), handler = std::move(handler)]() mutable {
+		    *_strand, [this, request = std::move(request), handler = std::move(handler)]() mutable {
 			    const auto easy_handle = request->native_handle();
 
 			    // TODO error
-			    request->template set_option<CURLOPT_OPENSOCKETFUNCTION>(&Basic_session::_open_socket_callback);
+			    request->template set_option<CURLOPT_OPENSOCKETFUNCTION>(&BasicSession::_open_socket_callback);
 			    request->template set_option<CURLOPT_OPENSOCKETDATA>(this);
-			    request->template set_option<CURLOPT_CLOSESOCKETFUNCTION>(&Basic_session::_close_socket_callback);
+			    request->template set_option<CURLOPT_CLOSESOCKETFUNCTION>(&BasicSession::_close_socket_callback);
 			    request->template set_option<CURLOPT_CLOSESOCKETDATA>(this);
 			    auto unregister_request = detail::finally([&] {
 				    request->template set_option<CURLOPT_OPENSOCKETFUNCTION>(nullptr);
@@ -46,7 +60,7 @@ inline auto Basic_session<Executor>::async_start(request_pointer request, auto&&
 			    curl_multi_add_handle(_multi_handle, easy_handle);
 			    _perform(CURL_SOCKET_TIMEOUT, 0);
 
-			    const std::shared_ptr<Response> response{ new Response{ this->shared_from_this(), request } };
+			    const std::shared_ptr<Response> response{ new Response{ _strand, request } };
 			    response->_start();
 			    auto unregister_response = detail::finally([&] {
 				    response->_stop();
@@ -67,32 +81,20 @@ inline auto Basic_session<Executor>::async_start(request_pointer request, auto&&
 }
 
 template<typename Executor>
-inline Basic_session<Executor>::executor_type Basic_session<Executor>::get_executor() const noexcept
-{
-	return _strand.get_inner_executor();
-}
-
-template<typename Executor>
-inline CURLIO_ASIO_NS::strand<Executor>& Basic_session<Executor>::get_strand() noexcept
+inline BasicSession<Executor>::executor_type BasicSession<Executor>::get_executor() const noexcept
 {
-	return _strand;
+	return _strand->get_inner_executor();
 }
 
 template<typename Executor>
-inline Basic_session<Executor>::Basic_session(Executor executor) : _strand{ std::move(executor) }
+inline BasicSession<Executor>::strand_type& BasicSession<Executor>::get_strand() noexcept
 {
-	_multi_handle = curl_multi_init();
-
-	curl_multi_setopt(_multi_handle, CURLMOPT_SOCKETFUNCTION, &Basic_session::_socket_callback);
-	curl_multi_setopt(_multi_handle, CURLMOPT_SOCKETDATA, this);
-
-	curl_multi_setopt(_multi_handle, CURLMOPT_TIMERFUNCTION, &Basic_session::_timer_callback);
-	curl_multi_setopt(_multi_handle, CURLMOPT_TIMERDATA, this);
+	return *_strand;
 }
 
 template<typename Executor>
-inline void Basic_session<Executor>::_monitor(const std::shared_ptr<detail::SocketData>& data,
-                                              detail::SocketData::WaitFlag type)
+inline void BasicSession<Executor>::_monitor(const std::shared_ptr<detail::SocketData>& data,
+                                             detail::SocketData::WaitFlag type)
 {
 	CURLIO_TRACE("Monitoring on socket flags=" << data->wait_flags << " type=" << static_cast<int>(type));
 	if (data->wait_flags & type) {
@@ -111,34 +113,46 @@ inline void Basic_session<Executor>::_monitor(const std::shared_ptr<detail::Sock
 }
 
 template<typename Executor>
-inline void Basic_session<Executor>::_clean_finished()
+inline void BasicSession<Executor>::_clean_finished()
 {
+	const auto unregister = [&](typename decltype(_active_requests)::iterator it) {
+		assert(it != _active_requests.end());
+
+		curl_multi_remove_handle(_multi_handle, it->first);
+
+		curl_easy_setopt(it->first, CURLOPT_OPENSOCKETFUNCTION, nullptr);
+		curl_easy_setopt(it->first, CURLOPT_OPENSOCKETDATA, nullptr);
+		curl_easy_setopt(it->first, CURLOPT_CLOSESOCKETFUNCTION, nullptr);
+		curl_easy_setopt(it->first, CURLOPT_CLOSESOCKETDATA, nullptr);
+
+		it->second->_stop();
+		return _active_requests.erase(it);
+	};
+
 	CURLMsg* message = nullptr;
 	int left         = 0;
 	while ((message = curl_multi_info_read(_multi_handle, &left))) {
 		if (message->msg == CURLMSG_DONE) {
 			CURLIO_INFO("Removing handle: " << message->easy_handle);
 
-			curl_multi_remove_handle(_multi_handle, message->easy_handle);
-
-			const auto it = _active_requests.find(message->easy_handle);
-			if (it != _active_requests.end()) {
-				curl_easy_setopt(message->easy_handle, CURLOPT_OPENSOCKETFUNCTION, nullptr);
-				curl_easy_setopt(message->easy_handle, CURLOPT_OPENSOCKETDATA, nullptr);
-				curl_easy_setopt(message->easy_handle, CURLOPT_CLOSESOCKETFUNCTION, nullptr);
-				curl_easy_setopt(message->easy_handle, CURLOPT_CLOSESOCKETDATA, nullptr);
-
-				it->second->_stop();
-				_active_requests.erase(it);
-			}
+			unregister(_active_requests.find(message->easy_handle));
 		} else {
 			CURLIO_WARN("Got unknown message during cleaning: " << message->msg);
 		}
 	}
+
+	// Unregister all active request that have no other owner.
+	for (auto it = _active_requests.begin(); it != _active_requests.end();) {
+		if (it->second.use_count() == 1) {
+			it = unregister(it);
+		} else {
+			++it;
+		}
+	}
 }
 
 template<typename Executor>
-inline void Basic_session<Executor>::_perform(curl_socket_t socket, int bitmask)
+inline void BasicSession<Executor>::_perform(curl_socket_t socket, int bitmask)
 {
 	int running = 0;
 	if (const auto code = curl_multi_socket_action(_multi_handle, socket, bitmask, &running);
@@ -151,14 +165,14 @@ inline void Basic_session<Executor>::_perform(curl_socket_t socket, int bitmask)
 }
 
 template<typename Executor>
-inline int Basic_session<Executor>::_socket_callback(CURL* easy_handle, curl_socket_t socket, int what,
-                                                     void* self_ptr, void* socket_data_ptr) noexcept
+inline int BasicSession<Executor>::_socket_callback(CURL* easy_handle, curl_socket_t socket, int what,
+                                                    void* self_ptr, void* socket_data_ptr) noexcept
 {
 	constexpr const char* what_names[] = { "IN", "OUT", "IN/OUT", "REMOVE" };
 	CURLIO_TRACE("Socket action callback on " << socket << ": "
 	                                          << (what >= 1 && what <= 4 ? what_names[what - 1] : "unknown"));
 
-	const auto self = static_cast<Basic_session*>(self_ptr);
+	const auto self = static_cast<BasicSession*>(self_ptr);
 
 	const auto it = self->_sockets.find(socket);
 	if (it == self->_sockets.end()) {
@@ -187,12 +201,12 @@ inline int Basic_session<Executor>::_socket_callback(CURL* easy_handle, curl_soc
 }
 
 template<typename Executor>
-inline int Basic_session<Executor>::_timer_callback(CURLM* multi_handle, long timeout_ms,
-                                                    void* self_ptr) noexcept
+inline int BasicSession<Executor>::_timer_callback(CURLM* multi_handle, long timeout_ms,
+                                                   void* self_ptr) noexcept
 {
 	CURLIO_DEBUG("Adding timer with timeout of " << timeout_ms << " ms");
 
-	const auto self = static_cast<Basic_session*>(self_ptr)->shared_from_this();
+	const auto self = static_cast<BasicSession*>(self_ptr);
 	if (timeout_ms == -1) {
 		self->_timer.cancel();
 	} else {
@@ -209,11 +223,11 @@ inline int Basic_session<Executor>::_timer_callback(CURLM* multi_handle, long ti
 }
 
 template<typename Executor>
-inline curl_socket_t Basic_session<Executor>::_open_socket_callback(void* self_ptr, curlsocktype purpose,
-                                                                    curl_sockaddr* address) noexcept
+inline curl_socket_t BasicSession<Executor>::_open_socket_callback(void* self_ptr, curlsocktype purpose,
+                                                                   curl_sockaddr* address) noexcept
 {
 	CURLIO_TRACE("Trying to open new socket with family=" << address->family);
-	const auto self = static_cast<Basic_session*>(self_ptr);
+	const auto self = static_cast<BasicSession*>(self_ptr);
 
 	std::optional<CURLIO_ASIO_NS::ip::tcp> protocol{};
 	if (address->family == AF_INET) {
@@ -224,7 +238,7 @@ inline curl_socket_t Basic_session<Executor>::_open_socket_callback(void* self_p
 
 	if (protocol.has_value()) {
 		detail::asio_error_code ec{};
-		auto data = std::make_shared<detail::SocketData>(CURLIO_ASIO_NS::ip::tcp::socket{ self->_strand });
+		auto data = std::make_shared<detail::SocketData>(CURLIO_ASIO_NS::ip::tcp::socket{ self->get_strand() });
 		data->socket.open(protocol.value(), ec);
 		if (!ec) {
 			const auto fd = data->socket.native_handle();
@@ -239,9 +253,9 @@ inline curl_socket_t Basic_session<Executor>::_open_socket_callback(void* self_p
 }
 
 template<typename Executor>
-inline int Basic_session<Executor>::_close_socket_callback(void* self_ptr, curl_socket_t socket) noexcept
+inline int BasicSession<Executor>::_close_socket_callback(void* self_ptr, curl_socket_t socket) noexcept
 {
-	const auto self = static_cast<Basic_session*>(self_ptr);
+	const auto self = static_cast<BasicSession*>(self_ptr);
 
 	CURLIO_INFO("Closing socket: " << socket);
 	if (const auto it = self->_sockets.find(socket); it != self->_sockets.end()) {
@@ -258,10 +272,4 @@ inline int Basic_session<Executor>::_close_socket_callback(void* self_ptr, curl_
 	return CURLE_OK;
 }
 
-template<typename Executor>
-CURLIO_NO_DISCARD inline std::shared_ptr<Basic_session<Executor>> make_session(Executor executor)
-{
-	return std::shared_ptr<Basic_session<Executor>>{ new Basic_session<Executor>{ std::move(executor) } };
-}
-
 } // namespace curlio
diff --git a/curlio/detail/case_insensitive_less.hpp b/curlio/detail/case_insensitive_less.hpp
index 99dc9a1..fc83666 100644
--- a/curlio/detail/case_insensitive_less.hpp
+++ b/curlio/detail/case_insensitive_less.hpp
@@ -5,7 +5,7 @@
 
 namespace curlio::detail {
 
-struct Case_insensitive_less {
+struct CaseInsensitiveLess {
 	std::locale locale{};
 
 	bool operator()(const std::string& lhs, const std::string& rhs) const noexcept
diff --git a/curlio/detail/final_action.hpp b/curlio/detail/final_action.hpp
index 5004217..5d1ce95 100644
--- a/curlio/detail/final_action.hpp
+++ b/curlio/detail/final_action.hpp
@@ -6,14 +6,14 @@
 namespace curlio::detail {
 
 template<typename Action>
-class [[nodiscard]] Final_action {
+class [[nodiscard]] FinalAction {
 public:
-	constexpr Final_action(auto&& action) : _run{ true }, _action{ std::forward<decltype(action)>(action) } {}
-	constexpr Final_action(Final_action&& move) : _action{ std::move(move._action) }
+	constexpr FinalAction(auto&& action) : _run{ true }, _action{ std::forward<decltype(action)>(action) } {}
+	constexpr FinalAction(FinalAction&& move) : _action{ std::move(move._action) }
 	{
 		std::swap(_run, move._run);
 	}
-	~Final_action() noexcept
+	~FinalAction() noexcept
 	{
 		if (_run) {
 			_action();
@@ -21,7 +21,7 @@ class [[nodiscard]] Final_action {
 	}
 
 	constexpr void cancel() noexcept { _run = false; }
-	constexpr Final_action& operator=(Final_action&& move)
+	constexpr FinalAction& operator=(FinalAction&& move)
 	{
 		_action = std::move(move._action);
 		_run    = std::exchange(move._run, false);
@@ -35,7 +35,7 @@ class [[nodiscard]] Final_action {
 
 [[nodiscard]] constexpr auto finally(auto&& action)
 {
-	return Final_action<std::decay_t<decltype(action)>>{ std::forward<decltype(action)>(action) };
+	return FinalAction<std::decay_t<decltype(action)>>{ std::forward<decltype(action)>(action) };
 }
 
 } // namespace curlio::detail
diff --git a/curlio/detail/header_collector.hpp b/curlio/detail/header_collector.hpp
index 2d326be..c1e93bb 100644
--- a/curlio/detail/header_collector.hpp
+++ b/curlio/detail/header_collector.hpp
@@ -35,7 +35,7 @@ constexpr std::string_view trim(std::string_view str, const std::locale& locale
 /// separately.
 class HeaderCollector {
 public:
-	using fields_type = std::map<std::string, std::string, Case_insensitive_less>;
+	using fields_type = std::map<std::string, std::string, CaseInsensitiveLess>;
 
 	HeaderCollector(CURL* handle) noexcept : _handle{ handle } {}
 	HeaderCollector(const HeaderCollector& copy) = delete;
diff --git a/curlio/fwd.hpp b/curlio/fwd.hpp
index f4d8346..faa86c7 100644
--- a/curlio/fwd.hpp
+++ b/curlio/fwd.hpp
@@ -4,12 +4,12 @@ namespace curlio
 {
 
 template<typename Executor>
-class Basic_session;
+class BasicSession;
 
 template<typename Executor>
-class Basic_request;
+class BasicRequest;
 
 template<typename Executor>
-class Basic_response;
+class BasicResponse;
 
 }
diff --git a/curlio/quick/reader.hpp b/curlio/quick/reader.hpp
index 2ad1708..a9d37f3 100644
--- a/curlio/quick/reader.hpp
+++ b/curlio/quick/reader.hpp
@@ -14,7 +14,7 @@
 namespace curlio::quick {
 
 template<typename Executor>
-inline auto async_read_all(std::shared_ptr<Basic_response<Executor>> response, auto&& token,
+inline auto async_read_all(std::shared_ptr<BasicResponse<Executor>> response, auto&& token,
                            std::size_t buffer_increment = 4096)
 {
 	auto executor = response->get_executor();

From 30803aa07c2c13d0db45ea48d8dcec2aeaddffa7 Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sun, 4 Aug 2024 19:52:05 +0200
Subject: [PATCH 6/7] Fix segfault on kick-starting

---
 curlio/basic_request.hpp  |  1 +
 curlio/basic_request.inl  | 10 +++++-
 curlio/basic_response.inl |  5 +--
 curlio/basic_session.inl  | 64 ++++++++++++++++++++++++---------------
 curlio/log.hpp            | 16 +++++++---
 5 files changed, 64 insertions(+), 32 deletions(-)

diff --git a/curlio/basic_request.hpp b/curlio/basic_request.hpp
index 6fbf16d..5c54f6c 100644
--- a/curlio/basic_request.hpp
+++ b/curlio/basic_request.hpp
@@ -24,6 +24,7 @@ class BasicRequest {
 	template<CURLoption Option>
 	void set_option(detail::option_type<Option> value);
 	void append_header(const char* header);
+	void free_headers();
 	auto async_write_some(const auto& buffers, auto&& token);
 	auto async_abort(auto&& token);
 	CURLIO_NO_DISCARD CURL* native_handle() const noexcept;
diff --git a/curlio/basic_request.inl b/curlio/basic_request.inl
index 203ba2e..aaa2588 100644
--- a/curlio/basic_request.inl
+++ b/curlio/basic_request.inl
@@ -29,8 +29,9 @@ inline BasicRequest<Executor>::BasicRequest(const BasicRequest& copy) noexcept :
 template<typename Executor>
 inline BasicRequest<Executor>::~BasicRequest()
 {
+	CURLIO_DEBUG("Freeing handle @" << _handle);
 	curl_easy_cleanup(_handle);
-	curl_slist_free_all(_additional_headers);
+	free_headers();
 }
 
 template<typename Executor>
@@ -49,6 +50,13 @@ inline void BasicRequest<Executor>::append_header(const char* header)
 	set_option<CURLOPT_HTTPHEADER>(_additional_headers);
 }
 
+template<typename Executor>
+inline void BasicRequest<Executor>::free_headers()
+{
+	curl_slist_free_all(_additional_headers);
+	_additional_headers = nullptr;
+}
+
 template<typename Executor>
 inline auto BasicRequest<Executor>::async_write_some(const auto& buffers, auto&& token)
 {
diff --git a/curlio/basic_response.inl b/curlio/basic_response.inl
index 6580ea3..7475e89 100644
--- a/curlio/basic_response.inl
+++ b/curlio/basic_response.inl
@@ -141,7 +141,8 @@ inline std::size_t BasicResponse<Executor>::_write_callback(char* data, std::siz
 	if (self->_receive_handler) {
 		const std::size_t immediately_consumed = self->_receive_handler({}, data, total_length);
 		self->_receive_handler.reset();
-		CURLIO_TRACE("Received " << total_length << " bytes and consumed " << immediately_consumed);
+		CURLIO_TRACE("Received " << total_length << " bytes and consumed " << immediately_consumed
+		                         << " for handle @" << self->_request->_handle);
 
 		const std::size_t copied = CURLIO_ASIO_NS::buffer_copy(
 		  self->_input_buffer.prepare(total_length - immediately_consumed),
@@ -150,7 +151,7 @@ inline std::size_t BasicResponse<Executor>::_write_callback(char* data, std::siz
 		return immediately_consumed + copied;
 	}
 
-	CURLIO_TRACE("Received " << total_length << " bytes but pausing");
+	CURLIO_TRACE("Received " << total_length << " bytes but pausing handle @" << self->_request->_handle);
 	return CURL_WRITEFUNC_PAUSE;
 }
 
diff --git a/curlio/basic_session.inl b/curlio/basic_session.inl
index 577ef5f..cd3ad47 100644
--- a/curlio/basic_session.inl
+++ b/curlio/basic_session.inl
@@ -56,13 +56,14 @@ inline auto BasicSession<Executor>::async_start(request_pointer request, auto&&
 			    });
 
 			    // Kick start.
-			    CURLIO_TRACE("Starting handle " << easy_handle);
+			    CURLIO_TRACE("Kick-starting handle @" << easy_handle);
 			    curl_multi_add_handle(_multi_handle, easy_handle);
-			    _perform(CURL_SOCKET_TIMEOUT, 0);
+			    CURLIO_ASIO_NS::post(*_strand, [this] { _perform(CURL_SOCKET_TIMEOUT, 0); });
 
 			    const std::shared_ptr<Response> response{ new Response{ _strand, request } };
 			    response->_start();
 			    auto unregister_response = detail::finally([&] {
+				    CURLIO_ERROR("Something prevented lift-off @" << easy_handle);
 				    response->_stop();
 				    _active_requests.erase(easy_handle);
 			    });
@@ -96,13 +97,15 @@ template<typename Executor>
 inline void BasicSession<Executor>::_monitor(const std::shared_ptr<detail::SocketData>& data,
                                              detail::SocketData::WaitFlag type)
 {
-	CURLIO_TRACE("Monitoring on socket flags=" << data->wait_flags << " type=" << static_cast<int>(type));
+	CURLIO_TRACE("Monitoring on socket #" << data->socket.native_handle() << " flags=" << data->wait_flags
+	                                      << " type=" << static_cast<int>(type));
 	if (data->wait_flags & type) {
 		data->socket.async_wait(
 		  type == detail::SocketData::wait_flag_write ? CURLIO_ASIO_NS::socket_base::wait_write
 		                                              : CURLIO_ASIO_NS::socket_base::wait_read,
 		  [this, type, data](const detail::asio_error_code& ec) {
-			  CURLIO_TRACE("Socket action occurred (flags=" << data->wait_flags << "): " << ec.what());
+			  CURLIO_TRACE("Socket #" << data->socket.native_handle()
+			                          << " action occurred (flags=" << data->wait_flags << "): " << ec.what());
 			  if (!ec && data->wait_flags & type) {
 				  _perform(data->socket.native_handle(),
 				           type == detail::SocketData::wait_flag_write ? CURL_CSELECT_OUT : CURL_CSELECT_IN);
@@ -116,7 +119,7 @@ template<typename Executor>
 inline void BasicSession<Executor>::_clean_finished()
 {
 	const auto unregister = [&](typename decltype(_active_requests)::iterator it) {
-		assert(it != _active_requests.end());
+		CURLIO_ASSERT(it != _active_requests.end());
 
 		curl_multi_remove_handle(_multi_handle, it->first);
 
@@ -129,26 +132,33 @@ inline void BasicSession<Executor>::_clean_finished()
 		return _active_requests.erase(it);
 	};
 
-	CURLMsg* message = nullptr;
-	int left         = 0;
+	const std::size_t active_count = _active_requests.size();
+	CURLMsg* message               = nullptr;
+	int left                       = 0;
 	while ((message = curl_multi_info_read(_multi_handle, &left))) {
 		if (message->msg == CURLMSG_DONE) {
-			CURLIO_INFO("Removing handle: " << message->easy_handle);
-
+			CURLIO_INFO("Removing handle @" << message->easy_handle);
 			unregister(_active_requests.find(message->easy_handle));
 		} else {
-			CURLIO_WARN("Got unknown message during cleaning: " << message->msg);
+			CURLIO_WARN("Got unknown message '" << message->msg << "' during cleaning for @"
+			                                    << message->easy_handle);
 		}
 	}
 
 	// Unregister all active request that have no other owner.
 	for (auto it = _active_requests.begin(); it != _active_requests.end();) {
 		if (it->second.use_count() == 1) {
+			CURLIO_INFO("Stale handle @" << it->first << " found in active requests");
 			it = unregister(it);
 		} else {
 			++it;
 		}
 	}
+
+	if (active_count != _active_requests.size()) {
+		CURLIO_INFO("Cleaned " << active_count - _active_requests.size() << " handles and left with "
+		                       << _active_requests.size() << " active ones");
+	}
 }
 
 template<typename Executor>
@@ -157,10 +167,10 @@ inline void BasicSession<Executor>::_perform(curl_socket_t socket, int bitmask)
 	int running = 0;
 	if (const auto code = curl_multi_socket_action(_multi_handle, socket, bitmask, &running);
 	    code != CURLM_OK) {
-		CURLIO_ERROR("Action failed: " << curl_multi_strerror(code));
+		CURLIO_ERROR("Action failed on socket #" << socket << ": " << curl_multi_strerror(code));
 	}
-	CURLIO_TRACE("Action performed for " << socket << " with bitmask " << bitmask << " and remaining handles "
-	                                     << running);
+	CURLIO_TRACE("Action performed for socket #" << socket << " with bitmask " << bitmask
+	                                             << " and running handles " << running);
 	_clean_finished();
 }
 
@@ -169,14 +179,14 @@ inline int BasicSession<Executor>::_socket_callback(CURL* easy_handle, curl_sock
                                                     void* self_ptr, void* socket_data_ptr) noexcept
 {
 	constexpr const char* what_names[] = { "IN", "OUT", "IN/OUT", "REMOVE" };
-	CURLIO_TRACE("Socket action callback on " << socket << ": "
-	                                          << (what >= 1 && what <= 4 ? what_names[what - 1] : "unknown"));
+	CURLIO_TRACE("Action callback on socket #" << socket << " in handle @" << easy_handle << ": "
+	                                           << (what >= 1 && what <= 4 ? what_names[what - 1] : "unknown"));
 
 	const auto self = static_cast<BasicSession*>(self_ptr);
 
 	const auto it = self->_sockets.find(socket);
 	if (it == self->_sockets.end()) {
-		CURLIO_WARN("Socket " << socket << " not found");
+		CURLIO_WARN("Socket #" << socket << " in handle @" << easy_handle << " was not found");
 		return CURLM_OK;
 	}
 
@@ -204,15 +214,20 @@ template<typename Executor>
 inline int BasicSession<Executor>::_timer_callback(CURLM* multi_handle, long timeout_ms,
                                                    void* self_ptr) noexcept
 {
-	CURLIO_DEBUG("Adding timer with timeout of " << timeout_ms << " ms");
-
 	const auto self = static_cast<BasicSession*>(self_ptr);
 	if (timeout_ms == -1) {
+		CURLIO_DEBUG("Removing timer");
 		self->_timer.cancel();
 	} else {
+		if (timeout_ms == 0) {
+			CURLIO_DEBUG("Adding immediate timer");
+		} else {
+			CURLIO_DEBUG("Adding timer with timeout of " << timeout_ms << " ms");
+		}
+
 		self->_timer.expires_after(std::chrono::milliseconds{ timeout_ms });
 		self->_timer.async_wait([self](const detail::asio_error_code& ec) {
-			CURLIO_DEBUG("Timeout with ec=" << ec.message());
+			CURLIO_DEBUG("Timeout occurred ec=" << ec.message());
 			if (!ec) {
 				self->_perform(CURL_SOCKET_TIMEOUT, 0);
 			}
@@ -226,7 +241,7 @@ template<typename Executor>
 inline curl_socket_t BasicSession<Executor>::_open_socket_callback(void* self_ptr, curlsocktype purpose,
                                                                    curl_sockaddr* address) noexcept
 {
-	CURLIO_TRACE("Trying to open new socket with family=" << address->family);
+	CURLIO_TRACE("Trying to open new socket with family=" << address->family << " purpose=" << purpose);
 	const auto self = static_cast<BasicSession*>(self_ptr);
 
 	std::optional<CURLIO_ASIO_NS::ip::tcp> protocol{};
@@ -239,16 +254,16 @@ inline curl_socket_t BasicSession<Executor>::_open_socket_callback(void* self_pt
 	if (protocol.has_value()) {
 		detail::asio_error_code ec{};
 		auto data = std::make_shared<detail::SocketData>(CURLIO_ASIO_NS::ip::tcp::socket{ self->get_strand() });
-		data->socket.open(protocol.value(), ec);
+		static_cast<void>(data->socket.open(protocol.value(), ec));
 		if (!ec) {
 			const auto fd = data->socket.native_handle();
-			CURLIO_INFO("New socket opened: " << fd);
+			CURLIO_INFO("New socket #" << fd << " opened");
 			self->_sockets.insert({ fd, std::move(data) });
 			return fd;
 		}
 	}
 
-	CURLIO_ERROR("Failed to open socket. Purpose=" << purpose << ", family=" << address->family);
+	CURLIO_ERROR("Failed to open socket");
 	return CURL_SOCKET_BAD;
 }
 
@@ -257,7 +272,7 @@ inline int BasicSession<Executor>::_close_socket_callback(void* self_ptr, curl_s
 {
 	const auto self = static_cast<BasicSession*>(self_ptr);
 
-	CURLIO_INFO("Closing socket: " << socket);
+	CURLIO_INFO("Closing socket #" << socket);
 	if (const auto it = self->_sockets.find(socket); it != self->_sockets.end()) {
 		detail::asio_error_code ec{};
 		it->second->socket.close(ec);
@@ -266,6 +281,7 @@ inline int BasicSession<Executor>::_close_socket_callback(void* self_ptr, curl_s
 			return CURLE_UNKNOWN_OPTION;
 		}
 	} else {
+		CURLIO_WARN("Socket #" << socket << " is unkown in socket map");
 		return close(socket);
 	}
 
diff --git a/curlio/log.hpp b/curlio/log.hpp
index 6f59604..759eeab 100644
--- a/curlio/log.hpp
+++ b/curlio/log.hpp
@@ -1,16 +1,22 @@
 #pragma once
 
+#include <cassert>
+
 #if defined(CURLIO_ENABLE_LOGGING)
 #	include <iostream>
 #	include <thread>
 
 // #	define CURLIO_TRACE(stream) static_cast<void>(0)
-#	define CURLIO_TRACE(stream) std::cout << "TRACE " << std::this_thread::get_id() << ": " << stream << "\n"
-#	define CURLIO_DEBUG(stream) std::cout << "DEBUG " << std::this_thread::get_id() << ": " << stream << "\n"
-#	define CURLIO_INFO(stream) std::cout << "INFO  " << std::this_thread::get_id() << ": " << stream << "\n"
-#	define CURLIO_WARN(stream) std::cout << "WARN  " << std::this_thread::get_id() << ": " << stream << "\n"
-#	define CURLIO_ERROR(stream) std::cout << "ERROR " << std::this_thread::get_id() << ": " << stream << "\n"
+#	define CURLIO_ASSERT(stmt)                                                                                \
+		std::cout << "ASSERT " << std::this_thread::get_id() << "  (" #stmt "): " << (stmt) << "\n";             \
+		assert(stmt)
+#	define CURLIO_TRACE(stream) std::cout << "TRACE  " << std::this_thread::get_id() << ": " << stream << "\n"
+#	define CURLIO_DEBUG(stream) std::cout << "DEBUG  " << std::this_thread::get_id() << ": " << stream << "\n"
+#	define CURLIO_INFO(stream) std::cout << "INFO   " << std::this_thread::get_id() << ": " << stream << "\n"
+#	define CURLIO_WARN(stream) std::cout << "WARN   " << std::this_thread::get_id() << ": " << stream << "\n"
+#	define CURLIO_ERROR(stream) std::cout << "ERROR  " << std::this_thread::get_id() << ": " << stream << "\n"
 #else
+#	define CURLIO_ASSERT(stmt) assert(stmt)
 #	define CURLIO_TRACE(stream) static_cast<void>(0)
 #	define CURLIO_DEBUG(stream) static_cast<void>(0)
 #	define CURLIO_INFO(stream) static_cast<void>(0)

From 152bf27f232b870ee7bfe79d63f21ff99a2082a5 Mon Sep 17 00:00:00 2001
From: terrakuh <greybley@yahoo.de>
Date: Sun, 4 Aug 2024 20:50:31 +0200
Subject: [PATCH 7/7] Fix repo information

---
 CHANGELOG.md            | 11 +++++++++++
 CMakeLists.txt          |  2 +-
 README.md               | 10 +++++-----
 curlio/CMakeLists.txt   |  1 +
 examples/playground.cpp | 16 ++++++----------
 examples/simple.cpp     |  8 ++++----
 6 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a9289d..478640c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Change Log
 
+<h2><a href="https://github.com/terrakuh/curlio/compare/v0.4..v0.5.0">v0.5.0</a> - 2024-08-04</h2>
+
+### Changed
+- Less relying on pointers
+- CMake target name `cURLio::cURLio`
+
+### Fixed
+- Fix segfaults on kick-starting new requests
+- Fix CURL deprecation warnings
+- Various bugs
+
 <h2><a href="https://github.com/terrakuh/curlio/compare/v0.3.3..v0.4">v0.4</a> - 2022-11-27</h2>
 
 ### Changed
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 09c30a4..b768bb3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.16)
 
 project(
   cURLio
-  VERSION 0.4.0
+  VERSION 0.5.0
   DESCRIPTION "The simple glue for cURL and Boost.ASIO"
   HOMEPAGE_URL "https://github.com/terrakuh/curlio"
   LANGUAGES CXX
diff --git a/README.md b/README.md
index fba2c93..b4f727e 100644
--- a/README.md
+++ b/README.md
@@ -11,15 +11,15 @@ The following examples uses the [coroutines](https://en.cppreference.com/w/cpp/l
 ```cpp
 asio::io_service service{};
 
-auto session = curlio::make_session<boost::asio::any_io_executor>(service.get_executor());
+curlio::Session session{ service.get_executor() };
 
 // Create request and set options.
-auto request = curlio::make_request(session);
+auto request = std::make_shared<curlio::Request>(session);
 request->set_option<CURLOPT_URL>("http://example.com");
 request->set_option<CURLOPT_USERAGENT>("cURLio");
 
 // Launches the request which will then run in the background.
-auto response = co_await session->async_start(request, asio::use_awaitable);
+auto response = co_await session.async_start(request, asio::use_awaitable);
 
 // Read all and do something with the data.
 char data[4096];
@@ -52,8 +52,8 @@ cmake --install curlio/build
 And then in your `CMakeLists.txt`:
 
 ```cmake
-find_package(curlio 0.4 REQUIRED)
-target_link_libraries(my-target PRIVATE curlio::curlio)
+find_package(cURLio 0.5 REQUIRED)
+target_link_libraries(my-target PRIVATE cURLio::cURLio)
 ```
 
 ## Debugging
diff --git a/curlio/CMakeLists.txt b/curlio/CMakeLists.txt
index 90f7c0b..d29e071 100644
--- a/curlio/CMakeLists.txt
+++ b/curlio/CMakeLists.txt
@@ -6,6 +6,7 @@ target_link_libraries(cURLio INTERFACE CURL::libcurl Threads::Threads Boost::boo
 target_include_directories(
   cURLio INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>" $<INSTALL_INTERFACE:include>
 )
+target_compile_features(cURLio INTERFACE cxx_std_17)
 
 if(CURLIO_ENABLE_LOGGING)
   target_compile_definitions(cURLio INTERFACE CURLIO_ENABLE_LOGGING)
diff --git a/examples/playground.cpp b/examples/playground.cpp
index c67f7c4..a4cd075 100644
--- a/examples/playground.cpp
+++ b/examples/playground.cpp
@@ -2,26 +2,24 @@
 // #define BOOST_ASIO_ENABLE_HANDLER_TRACKING
 
 #include <curlio/curlio.hpp>
-#include <iostream>
-#include <numeric>
-#include <tuple>
 #include <fstream>
+#include <iostream>
 
 using namespace boost::asio;
 
 awaitable<void> async_main()
 try {
-	auto session = curlio::make_session(co_await this_coro::executor);
-	auto request = curlio::make_request(session);
+	curlio::Session session{ co_await this_coro::executor };
+	auto request = std::make_shared<curlio::Request>(session);
 
 	request->set_option<CURLOPT_URL>("http://127.0.0.1:8088/");
 	request->set_option<CURLOPT_MAXREDIRS>(3);
 	request->set_option<CURLOPT_FOLLOWLOCATION>(1);
 
-	auto response = co_await session->async_start(request, use_awaitable);
+	auto response = co_await session.async_start(request, use_awaitable);
 
-	std::ofstream file{"/workspaces/downer/backend/asd", std::ios::out|std::ios::binary};
-	char data[10*1024];
+	std::ofstream file{ "/workspaces/downer/backend/asd", std::ios::out | std::ios::binary };
+	char data[10 * 1024];
 	while (true) {
 		const std::size_t bytes_transferred = co_await response->async_read_some(buffer(data), use_awaitable);
 		file.write(data, bytes_transferred);
@@ -35,8 +33,6 @@ int main(int argc, char** argv)
 	curl_global_init(CURL_GLOBAL_ALL);
 	io_service service{};
 
-	auto session = curlio::make_session<boost::asio::any_io_executor>(service.get_executor());
-
 	co_spawn(service, async_main(), detached);
 
 	std::cout << "Service running with cURL version: " << curl_version() << "\n";
diff --git a/examples/simple.cpp b/examples/simple.cpp
index 0b0b681..6b72173 100644
--- a/examples/simple.cpp
+++ b/examples/simple.cpp
@@ -14,17 +14,17 @@ int main(int argc, char** argv)
 	curl_global_init(CURL_GLOBAL_ALL);
 	io_service service;
 
-	auto session = curlio::make_session<any_io_executor>(service.get_executor());
+	curlio::Session session{ service.get_executor() };
 	co_spawn(
 	  service,
 	  [&]() -> awaitable<void> {
 		  // Create request and set options.
-		  auto request = curlio::make_request(session);
+		  auto request = std::make_shared<curlio::Request>(session);
 		  curl_easy_setopt(request->native_handle(), CURLOPT_URL, "http://example.com");
 		  curl_easy_setopt(request->native_handle(), CURLOPT_USERAGENT, "cURLio");
 
 		  // Launches the request which will then run in the background.
-		  auto response = co_await session->async_start(request, use_awaitable);
+		  auto response = co_await session.async_start(request, use_awaitable);
 
 		  co_await response->async_wait_headers(use_awaitable);
 
@@ -42,7 +42,7 @@ int main(int argc, char** argv)
 
 		  // When all data was read and the `response->async_read_some()` returned `asio::error::eof`
 		  // the request is removed from the session and can be used again.
-			std::cout << "All transfers done\n";
+		  std::cout << "All transfers done\n";
 	  },
 	  detached);