Big Refactor.

General support for encryption and decryption.
Game Session creation.
Discovery Server.

Still broken as hell, but less so?

Network/GenericNetMessage.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../misc/ByteStream.h"
+
+class GenericMessage
+{
+public:
+	uint16_t m_packetId;
+	ByteStream m_stream;
+
+	GenericMessage( uint16_t packetId ) : m_packetId( packetId )
+	{
+	}
+
+	virtual ~GenericMessage() = default;
+	virtual ByteStream& Serialize() = 0;
+};
+
+typedef std::shared_ptr< GenericMessage > sptr_generic_message;

Network/GenericNetRequest.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../Network/RealmSocket.h"
+#include "../misc/ByteStream.h"
+
+class GenericResponse;
+typedef std::shared_ptr< GenericResponse > sptr_generic_response;
+
+class GenericRequest
+{
+public:
+	int16_t m_packetId;
+	uint32_t m_requestId;
+
+	virtual ~GenericRequest() = default;
+
+	virtual sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) = 0;
+	void DeserializeHeader( sptr_byte_stream stream )
+	{
+		m_packetId = stream->read_u16();
+		m_requestId = stream->read_u32();
+		auto _ = stream->read_u32();	// Always 2 from client.
+	};
+	virtual void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) = 0;
+};
+
+typedef std::shared_ptr< GenericRequest > sptr_generic_request;
+

Network/GenericNetResponse.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "GenericNetRequest.hpp"
+#include "../misc/ByteStream.h"
+
+class GenericResponse
+{
+public:
+	uint16_t m_packetId;
+	uint32_t m_requestId;
+	ByteStream m_stream;
+
+	GenericResponse( GenericRequest &request ) : m_packetId( request.m_packetId ), m_requestId( request.m_requestId )
+	{
+	}
+
+	virtual ~GenericResponse() = default;
+	virtual ByteStream& Serialize() = 0;
+};
+
+typedef std::shared_ptr< GenericResponse > sptr_generic_response;

Network/RealmSocket.cpp

@@ -0,0 +1,102 @@
+
+#include "../global_define.h"
+
+RealmSocket::RealmSocket()
+{
+	fd = INVALID_SOCKET;
+
+	memset( &local_address, 0, sizeof( local_address ) );
+	memset( &remote_address, 0, sizeof( remote_address ) );
+	port = 0;
+
+	flag.disconnected = 0;
+	flag.is_listener = 0;
+	flag.want_more_read_data = 0;
+	flag.want_more_write_data = 0;
+
+	last_write_position = 0;
+
+	latency = 0;
+	last_recv_time = 0;
+	last_send_time = 0;
+}
+
+RealmSocket::~RealmSocket()
+{
+	if( INVALID_SOCKET != fd )
+	{
+		closesocket( fd );
+	}
+
+	fd = INVALID_SOCKET;
+
+	memset( &local_address, 0, sizeof( local_address ) );
+	memset( &remote_address, 0, sizeof( remote_address ) );
+	port = 0;
+
+	flag.disconnected = 0;
+	flag.is_listener = 0;
+	flag.want_more_read_data = 0;
+	flag.want_more_write_data = 0;
+
+	last_write_position = 0;
+
+	latency = 0;
+	last_recv_time = 0;
+	last_send_time = 0;
+}
+
+RealmTCPSocket::RealmTCPSocket()
+{
+	m_pendingWriteBuffer.reserve( WRITE_BUFFER_SIZE );
+}
+
+RealmTCPSocket::~RealmTCPSocket()
+{
+	
+}
+
+void RealmTCPSocket::send( const sptr_byte_stream stream )
+{
+	auto packetSize = htonl( stream->get_position() );
+
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), ( uint8_t * )&packetSize, ( uint8_t * )&packetSize + 4 );
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), stream->data.begin(), stream->data.end() );
+}
+
+void RealmTCPSocket::send( const ByteStream &stream )
+{
+	auto packetSize = htonl( stream.get_position() );
+
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), ( uint8_t * )&packetSize, ( uint8_t * )&packetSize + 4 );
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), stream.data.begin(), stream.data.end() );
+}
+
+void RealmTCPSocket::send( const sptr_generic_response response )
+{
+	auto &stream = response->Serialize();
+	auto netSize = htonl( stream.get_position() + 4 );
+
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), ( uint8_t * )&netSize, ( uint8_t * )&netSize + 4 );
+	m_pendingWriteBuffer.insert( m_pendingWriteBuffer.end(), stream.data.begin(), stream.data.end() );
+
+	//Log::Packet( stream->data, packetSize, true );
+}
+
+RealmUDPSocket::RealmUDPSocket()
+{
+}
+
+RealmUDPSocket::~RealmUDPSocket()
+{
+}
+
+void RealmUDPSocket::send( const sptr_byte_stream stream )
+{
+	m_pendingWriteQueue.push( stream );
+}
+
+void RealmUDPSocket::send( const ByteStream &stream )
+{
+	m_pendingWriteQueue.push( std::make_shared< ByteStream >( stream ) );
+}

Network/RealmSocket.h

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <vector>
+#include <queue>
+#include <memory>
+#include <mutex>
+
+class GenericResponse;
+typedef std::shared_ptr< GenericResponse > sptr_generic_response;
+
+class RealmSocket
+{
+public:
+	RealmSocket();
+	~RealmSocket();
+
+	virtual void send( const sptr_byte_stream stream ) = 0;
+	virtual void send( const ByteStream &stream ) = 0;
+
+	struct s_flag
+	{
+		bool disconnected;
+		bool is_listener;
+		bool want_more_read_data;
+		bool want_more_write_data;
+	} flag;
+
+	// Comparison operator for sorting
+	bool operator<( const RealmSocket &rhs ) const
+	{
+		return fd < rhs.fd;
+	}
+
+	// Comparison operator for comparing
+	bool operator==( const RealmSocket &rhs ) const
+	{
+		return fd == rhs.fd;
+	}
+
+	SOCKET fd;
+	uint16_t port;
+	sockaddr_in local_address;
+	sockaddr_in remote_address;
+
+	std::string peer_ip_address;
+	int32_t peer_port;
+
+	uint32_t last_write_position;
+
+	uint64_t latency;
+	uint64_t last_recv_time;
+	uint64_t last_send_time;
+
+	std::mutex write_mutex;
+	std::mutex read_mutex;
+
+	std::vector< uint8_t >		read_buffer;
+	//std::list< sptr_packet >	read_queue;
+	//std::list< sptr_packet >	write_queue;
+};
+
+class RealmTCPSocket : public RealmSocket
+{
+private:
+	const size_t WRITE_BUFFER_SIZE = 65535;
+
+public:
+	RealmTCPSocket();
+	~RealmTCPSocket();
+
+	// Comparison operator for sorting
+	bool operator<( const RealmTCPSocket &rhs ) const
+	{
+		return fd < rhs.fd;
+	}
+
+	// Comparison operator for comparing
+	bool operator==( const RealmTCPSocket &rhs ) const
+	{
+		return fd == rhs.fd;
+	}
+
+	void send( const sptr_byte_stream stream ) override;
+	void send( const ByteStream &stream ) override;
+	void send( const sptr_generic_response response );
+
+public:
+	std::vector< uint8_t > m_pendingWriteBuffer;
+	std::vector< uint8_t > m_pendingReadBuffer;
+};
+
+typedef std::shared_ptr< RealmTCPSocket > sptr_tcp_socket;
+
+class RealmUDPSocket : public RealmSocket
+{
+private:
+	const int DATAGRAM_SIZE = 1024;
+
+public:
+	RealmUDPSocket();
+	~RealmUDPSocket();
+
+	// Comparison operator for sorting
+	bool operator<( const RealmUDPSocket &rhs ) const
+	{
+		return fd < rhs.fd;
+	}
+
+	// Comparison operator for comparing
+	bool operator==( const RealmUDPSocket &rhs ) const
+	{
+		return fd == rhs.fd;
+	}
+
+	void send( const sptr_byte_stream stream ) override;
+	void send( const ByteStream &stream ) override;
+
+public:
+	std::queue< sptr_byte_stream > m_pendingWriteQueue;
+};
+
+typedef std::shared_ptr< RealmUDPSocket > sptr_udp_socket;