work

network/manager.cpp

@@ -2,6 +2,11 @@
 #include "network/tcp.h"
 
 network::manager::manager()
+{
+	create_server();
+}
+
+void network::manager::create_server()
 {
 	servers.emplace_back(std::make_shared<tcp_server>(io_context));
 }
@@ -10,3 +15,8 @@ void network::manager::poll()
 {
 	io_context.poll();
 }
+
+void network::manager::connect()
+{
+
+}

network/manager.h

@@ -9,10 +9,13 @@ namespace network
 	{
 		asio::io_context io_context;
 		std::vector<std::shared_ptr<server>> servers;
+		//std::shared_ptr<client> client;
 
 	public:
 		manager();
 
+		void create_server();
+		void connect();
 		void poll();
 	};
 }

network/network.cpp

@@ -7,12 +7,38 @@ void network::connection::connected()
 	WriteLog("net: socket connected", logtype::net);
 }
 
-void network::connection::message_received(message msg)
+void network::connection::message_received(message &msg)
 {
+	if (msg.type == message::TYPE_MAX)
+	{
+		disconnect();
+		return;
+	}
 
+	if (msg.type == message::CONNECT_REQUEST)
+	{
+		message reply({message::CONNECT_ACCEPT});
+
+		std::string reply_buf;
+		std::ostringstream stream(reply_buf);
+		reply.serialize(stream);
+	}
 }
 
-void network::connection::data_received(uint8_t *buffer, size_t len)
+void network::connection::data_received(std::string &buffer)
 {
+	std::istringstream body(buffer);
+	message msg = message::deserialize(body);
 
+	message_received(msg);
+}
+
+void network::connection::send_message(message &msg)
+{
+	std::shared_ptr<std::string> buf = std::make_shared<std::string>();
+	std::ostringstream stream(*buf.get());
+	msg.serialize(stream);
+	stream.flush();
+
+	send_data(buf);
 }

network/network.h

@@ -10,12 +10,14 @@ namespace network
     class connection : public std::enable_shared_from_this<connection>
 	{
 	private:
-		void message_received(message msg);
+		void message_received(message &msg);
+		void send_message(message &msg);
 
 	protected:
 		virtual void disconnect() = 0;
-		virtual void send_data(uint8_t *buffer, size_t len) = 0;
+		virtual void send_data(std::shared_ptr<std::string> buffer) = 0;
-		void data_received(uint8_t *buffer, size_t len);
+
+		void data_received(std::string &buffer);
 
 	public:
 		virtual void connected();
@@ -26,4 +28,10 @@ namespace network
 	protected:
 		std::vector<std::shared_ptr<connection>> clients;
 	};
+
+	class client
+	{
+	protected:
+		std::shared_ptr<connection> srv;
+	};
 }

network/tcp.cpp

@@ -10,6 +10,7 @@ network::tcp_conn::tcp_conn(asio::io_context &io_ctx)
 
 void network::tcp_conn::disconnect()
 {
+	WriteLog("network: client dropped", logtype::net);
 	m_socket.close();
 }
 
@@ -21,56 +22,54 @@ void network::tcp_conn::connected()
 void network::tcp_conn::read_header()
 {
 	asio::async_read(m_socket, asio::buffer(m_header_buffer),
-	                    std::bind(&tcp_conn::handle_header, this, std::placeholders::_1));
+	                    std::bind(&tcp_conn::handle_header, this,
+	                              std::placeholders::_1, std::placeholders::_2));
 }
 
-void network::tcp_conn::send_data(uint8_t *buffer, size_t len)
+void network::tcp_conn::handle_send(std::shared_ptr<std::string> buf, const asio::error_code &err, size_t bytes_transferred)
 {
 
 }
 
-void network::tcp_conn::handle_header(const asio::error_code &err)
+void network::tcp_conn::send_data(std::shared_ptr<std::string> buffer)
+{
+	asio::async_write(m_socket, asio::buffer(*buffer.get()), std::bind(&tcp_conn::handle_send, this, buffer,
+	                                                            std::placeholders::_1,
+	                                                            std::placeholders::_2));
+}
+
+void network::tcp_conn::handle_header(const asio::error_code &err, size_t bytes_transferred)
 {
 	std::istringstream header(m_header_buffer);
+	if (m_header_buffer.size() != bytes_transferred) {
+		disconnect();
+		return;
+	}
+
 	uint32_t sig = sn_utils::ld_uint32(header);
-	if (sig != 0x37305545)
+	if (sig != 0x37305545) {
-	{
 		disconnect();
 		return;
 	}
 
 	uint32_t len = sn_utils::ld_uint32(header);
 	m_body_buffer.resize(len);
-	if (len > 10000)
+	if (len > 10000) {
-	{
 		disconnect();
 		return;
 	}
 
 	asio::async_read(m_socket, asio::buffer(m_body_buffer),
-	                 std::bind(&tcp_conn::handle_data, this, std::placeholders::_1));
+	                 std::bind(&tcp_conn::handle_data, this, std::placeholders::_1, std::placeholders::_2));
 }
 
-void network::tcp_conn::handle_data(const asio::error_code &err)
+void network::tcp_conn::handle_data(const asio::error_code &err, size_t bytes_transferred)
 {
-	std::istringstream body(m_body_buffer);
+	if (m_body_buffer.size() != bytes_transferred) {
-	message msg = message::deserialize(body);
-
-	if (msg.type == message::TYPE_MAX)
-	{
 		disconnect();
 		return;
 	}
-
+	data_received(m_body_buffer);
-	if (msg.type == message::CONNECT_REQUEST)
-	{
-		message reply({message::CONNECT_ACCEPT});
-
-		std::string reply_buf;
-		std::ostringstream stream(reply_buf);
-		reply.serialize(stream);
-	}
-
 	read_header();
 }
 
@@ -80,10 +79,14 @@ asio::ip::tcp::socket& network::tcp_conn::socket()
 }
 
 network::tcp_server::tcp_server(asio::io_context &io_ctx)
-    : m_acceptor(io_ctx, asio::ip::tcp::endpoint(asio::ip::tcp::v6(), 7424))
+    : m_acceptor(io_ctx)
 {
-	asio::ip::v6_only v6_only(false);
+	auto endpoint = asio::ip::tcp::endpoint(asio::ip::tcp::v6(), 7424);
-	m_acceptor.set_option(v6_only);
+	m_acceptor.open(endpoint.protocol());
+	m_acceptor.set_option(asio::socket_base::reuse_address(true));
+	m_acceptor.set_option(asio::ip::v6_only(false));
+	m_acceptor.bind(endpoint);
+	m_acceptor.listen(10);
 
 	accept_conn();
 }

network/tcp.h

@@ -17,12 +17,13 @@ namespace network
 		std::string m_body_buffer;
 
 		void read_header();
-		void handle_header(const asio::error_code &err);
+		void handle_send(std::shared_ptr<std::string> buf, const asio::error_code &err, size_t bytes_transferred);
-		void handle_data(const asio::error_code &err);
+		void handle_header(const asio::error_code &err, size_t bytes_transferred);
+		void handle_data(const asio::error_code &err, size_t bytes_transferred);
 
 	protected:
 		void disconnect() override;
-		void send_data(uint8_t *buffer, size_t len) override;
+		void send_data(std::shared_ptr<std::string> buffer) override;
 
 	public:
 		tcp_conn(asio::io_context &io_ctx);