net integartion

Author: Garcia6l20

.github/workflows/cmake.yml

@@ -1,6 +1,8 @@
 name: CMake
 
-on: [push, pull_request]
+on:
+- push
+- pull_request
 
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)

include/cppcoro/detail/win32.hpp

@@ -164,16 +164,18 @@ namespace cppcoro
 
 				bool operator!=(handle_t handle) const
 				{
-					return m_handle != handle;
-				}
+					return m_handle != handle; }
 
 			private:
-
 				handle_t m_handle;
-
 			};
-		}
-	}
+		}  // namespace win32
+
+		using dword_t = win32::dword_t;
+		using handle_t = win32::handle_t;
+		using sock_buf = win32::wsabuf;
+		using safe_handle = win32::safe_handle;
+	}  // namespace detail
 }
 
 #endif

include/cppcoro/detail/win32_overlapped_operation.hpp

@@ -100,7 +100,7 @@ namespace cppcoro
 			bool await_ready() const noexcept { return false; }
 
 			CPPCORO_NOINLINE
-			bool await_suspend(cppcoro::coroutine_handle<> awaitingCoroutine)
+			bool await_suspend(coroutine_handle<> awaitingCoroutine)
 			{
 				static_assert(std::is_base_of_v<win32_overlapped_operation, OPERATION>);
 
@@ -127,7 +127,7 @@ namespace cppcoro
 				operation->m_awaitingCoroutine.resume();
 			}
 
-			cppcoro::coroutine_handle<> m_awaitingCoroutine;
+			coroutine_handle<> m_awaitingCoroutine;
 
 		};
 
@@ -186,7 +186,7 @@ namespace cppcoro
 			}
 
 			CPPCORO_NOINLINE
-			bool await_suspend(cppcoro::coroutine_handle<> awaitingCoroutine)
+			bool await_suspend(coroutine_handle<> awaitingCoroutine)
 			{
 				static_assert(std::is_base_of_v<win32_overlapped_operation_cancellable, OPERATION>);
 
@@ -367,10 +367,17 @@ namespace cppcoro
 			std::atomic<state> m_state;
 			cppcoro::cancellation_token m_cancellationToken;
 			std::optional<cppcoro::cancellation_registration> m_cancellationCallback;
-			cppcoro::coroutine_handle<> m_awaitingCoroutine;
-
+			coroutine_handle<> m_awaitingCoroutine;
 		};
-	}
+
+		using io_operation_base = win32_overlapped_operation_base;
+
+		template<typename OPERATION>
+		using io_operation = win32_overlapped_operation<OPERATION>;
+
+		template<typename OPERATION>
+		using io_operation_cancellable = win32_overlapped_operation_cancellable<OPERATION>;
+	}  // namespace detail
 }
 
 #endif

include/cppcoro/file.hpp

@@ -47,7 +47,7 @@ namespace cppcoro
 			file_buffering_mode bufferingMode);
 
 		detail::safe_handle m_fileHandle;
-#ifdef CPPCORO_OS_LINUX
+#if CPPCORO_OS_LINUX
 		io_service *m_ioService;
 #endif
 	};

include/cppcoro/net/socket.hpp

@@ -92,10 +92,10 @@ namespace cppcoro
 
 			socket& operator=(socket&& other) noexcept;
 
-#if CPPCORO_OS_WINNT
-			/// Get the Win32 socket handle assocaited with this socket.
-			cppcoro::detail::win32::socket_t native_handle() noexcept { return m_handle; }
+            /// Get the socket handle associated with this socket.
+            auto native_handle() noexcept { return m_handle; }
 
+#if CPPCORO_OS_WINNT
 			/// Query whether I/O operations that complete synchronously will skip posting
 			/// an I/O completion event to the I/O completion port.
 			///
@@ -246,16 +246,26 @@ namespace cppcoro
 
 			friend class socket_accept_operation_impl;
 			friend class socket_connect_operation_impl;
+            friend class socket_recv_from_operation_impl;
+            friend class socket_recv_operation_impl;
+            friend class socket_send_to_operation_impl;
 
 #if CPPCORO_OS_WINNT
 			explicit socket(
 				cppcoro::detail::win32::socket_t handle,
 				bool skipCompletionOnSuccess) noexcept;
+#elif CPPCORO_OS_LINUX
+			explicit socket(detail::lnx::io_queue& ioQueue,
+							cppcoro::detail::lnx::fd_t fd) noexcept;
 #endif
 
 #if CPPCORO_OS_WINNT
 			cppcoro::detail::win32::socket_t m_handle;
 			bool m_skipCompletionOnSuccess;
+#elif CPPCORO_OS_LINUX
+			cppcoro::detail::lnx::fd_t m_handle = -1;
+            cppcoro::detail::lnx::io_queue& m_ioQueue;
+			int m_recvFlags = 0;
 #endif
 
 			ip_endpoint m_localEndPoint;

include/cppcoro/net/socket_accept_operation.hpp

@@ -12,9 +12,13 @@
 #if CPPCORO_OS_WINNT
 # include <cppcoro/detail/win32.hpp>
 # include <cppcoro/detail/win32_overlapped_operation.hpp>
+#elif CPPCORO_OS_LINUX
+# include <cppcoro/detail/linux_io_operation.hpp>
+#endif
 
-# include <atomic>
-# include <optional>
+#include <cppcoro/coroutine.hpp>
+#include <atomic>
+#include <optional>
 
 namespace cppcoro
 {
@@ -33,41 +37,53 @@ namespace cppcoro
 				, m_acceptingSocket(acceptingSocket)
 			{}
 
-			bool try_start(cppcoro::detail::win32_overlapped_operation_base& operation) noexcept;
-			void cancel(cppcoro::detail::win32_overlapped_operation_base& operation) noexcept;
-			void get_result(cppcoro::detail::win32_overlapped_operation_base& operation);
+			bool try_start(cppcoro::detail::io_operation_base& operation) noexcept;
+			void cancel(cppcoro::detail::io_operation_base& operation) noexcept;
+			void get_result(cppcoro::detail::io_operation_base& operation);
 
 		private:
 
 #if CPPCORO_COMPILER_MSVC
 # pragma warning(push)
-# pragma warning(disable : 4324) // Structure padded due to alignment
+# pragma warning(disable : 4324)  // Structure padded due to alignment
 #endif
 
 			socket& m_listeningSocket;
 			socket& m_acceptingSocket;
 			alignas(8) std::uint8_t m_addressBuffer[88];
 
+#if CPPCORO_OS_LINUX
+			socklen_t m_addressBufferLength = sizeof(m_addressBuffer);
+#endif
+
 #if CPPCORO_COMPILER_MSVC
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 		};
 
 		class socket_accept_operation
-			: public cppcoro::detail::win32_overlapped_operation<socket_accept_operation>
+			: public cppcoro::detail::io_operation<socket_accept_operation>
 		{
 		public:
 
 			socket_accept_operation(
+#if CPPCORO_OS_LINUX
+				detail::lnx::io_queue& ioQueue,
+#endif
 				socket& listeningSocket,
 				socket& acceptingSocket) noexcept
-				: m_impl(listeningSocket, acceptingSocket)
+				: cppcoro::detail::io_operation<socket_accept_operation>{
+#if CPPCORO_OS_LINUX
+                    ioQueue,
+#endif
+			    }
+				, m_impl(listeningSocket, acceptingSocket)
 			{}
 
 		private:
 
-			friend class cppcoro::detail::win32_overlapped_operation<socket_accept_operation>;
+			friend cppcoro::detail::io_operation<socket_accept_operation>;
 
 			bool try_start() noexcept { return m_impl.try_start(*this); }
 			void get_result() { m_impl.get_result(*this); }
@@ -77,21 +93,28 @@ namespace cppcoro
 		};
 
 		class socket_accept_operation_cancellable
-			: public cppcoro::detail::win32_overlapped_operation_cancellable<socket_accept_operation_cancellable>
+			: public cppcoro::detail::io_operation_cancellable<socket_accept_operation_cancellable>
 		{
 		public:
 
 			socket_accept_operation_cancellable(
+#if CPPCORO_OS_LINUX
+                detail::lnx::io_queue& ioQueue,
+#endif
 				socket& listeningSocket,
 				socket& acceptingSocket,
 				cancellation_token&& ct) noexcept
-				: cppcoro::detail::win32_overlapped_operation_cancellable<socket_accept_operation_cancellable>(std::move(ct))
+				: cppcoro::detail::io_operation_cancellable<socket_accept_operation_cancellable>(
+#if CPPCORO_OS_LINUX
+                    ioQueue,
+#endif
+					  std::move(ct))
 				, m_impl(listeningSocket, acceptingSocket)
 			{}
 
 		private:
 
-			friend class cppcoro::detail::win32_overlapped_operation_cancellable<socket_accept_operation_cancellable>;
+			friend cppcoro::detail::io_operation_cancellable<socket_accept_operation_cancellable>;
 
 			bool try_start() noexcept { return m_impl.try_start(*this); }
 			void cancel() noexcept { m_impl.cancel(*this); }
@@ -100,9 +123,7 @@ namespace cppcoro
 			socket_accept_operation_impl m_impl;
 
 		};
-	}
-}
-
-#endif // CPPCORO_OS_WINNT
+	}  // namespace net
+}  // namespace cppcoro
 
 #endif

include/cppcoro/net/socket_connect_operation.hpp

@@ -12,6 +12,9 @@
 #if CPPCORO_OS_WINNT
 # include <cppcoro/detail/win32.hpp>
 # include <cppcoro/detail/win32_overlapped_operation.hpp>
+#elif CPPCORO_OS_LINUX
+# include <cppcoro/detail/linux_io_operation.hpp>
+#endif
 
 namespace cppcoro
 {
@@ -30,31 +33,38 @@ namespace cppcoro
 				, m_remoteEndPoint(remoteEndPoint)
 			{}
 
-			bool try_start(cppcoro::detail::win32_overlapped_operation_base& operation) noexcept;
-			void cancel(cppcoro::detail::win32_overlapped_operation_base& operation) noexcept;
-			void get_result(cppcoro::detail::win32_overlapped_operation_base& operation);
+			bool try_start(cppcoro::detail::io_operation_base& operation) noexcept;
+			void cancel(cppcoro::detail::io_operation_base& operation) noexcept;
+			void get_result(cppcoro::detail::io_operation_base& operation);
 
 		private:
 
 			socket& m_socket;
 			ip_endpoint m_remoteEndPoint;
-
 		};
 
 		class socket_connect_operation
-			: public cppcoro::detail::win32_overlapped_operation<socket_connect_operation>
+			: public cppcoro::detail::io_operation<socket_connect_operation>
 		{
 		public:
 
 			socket_connect_operation(
+#if CPPCORO_OS_LINUX
+                detail::lnx::io_queue &ioQueue,
+#endif
 				socket& socket,
 				const ip_endpoint& remoteEndPoint) noexcept
-				: m_impl(socket, remoteEndPoint)
+                : cppcoro::detail::io_operation<socket_connect_operation> {
+#if CPPCORO_OS_LINUX
+                    ioQueue,
+#endif
+                }
+				, m_impl(socket, remoteEndPoint)
 			{}
 
 		private:
 
-			friend class cppcoro::detail::win32_overlapped_operation<socket_connect_operation>;
+			friend cppcoro::detail::io_operation<socket_connect_operation>;
 
 			bool try_start() noexcept { return m_impl.try_start(*this); }
 			decltype(auto) get_result() { return m_impl.get_result(*this); }
@@ -64,21 +74,28 @@ namespace cppcoro
 		};
 
 		class socket_connect_operation_cancellable
-			: public cppcoro::detail::win32_overlapped_operation_cancellable<socket_connect_operation_cancellable>
+			: public cppcoro::detail::io_operation_cancellable<socket_connect_operation_cancellable>
 		{
 		public:
 
 			socket_connect_operation_cancellable(
+#if CPPCORO_OS_LINUX
+                detail::lnx::io_queue &ioQueue,
+#endif
 				socket& socket,
 				const ip_endpoint& remoteEndPoint,
 				cancellation_token&& ct) noexcept
-				: cppcoro::detail::win32_overlapped_operation_cancellable<socket_connect_operation_cancellable>(std::move(ct))
+				: cppcoro::detail::io_operation_cancellable<socket_connect_operation_cancellable> {
+#if CPPCORO_OS_LINUX
+                    ioQueue,
+#endif
+                    std::move(ct)}
 				, m_impl(socket, remoteEndPoint)
 			{}
 
 		private:
 
-			friend class cppcoro::detail::win32_overlapped_operation_cancellable<socket_connect_operation_cancellable>;
+			friend cppcoro::detail::io_operation_cancellable<socket_connect_operation_cancellable>;
 
 			bool try_start() noexcept { return m_impl.try_start(*this); }
 			void cancel() noexcept { m_impl.cancel(*this); }
@@ -90,6 +107,4 @@ namespace cppcoro
 	}
 }
 
-#endif // CPPCORO_OS_WINNT
-
 #endif