NetworkBuffer now has valid parameter

Removed NetworkBuffer variable in NetworkMessage
TcpClient DataAvailable parameter type is now int32
Fixed NetworkMessage::EncododeMessage to put the size in the Buffer's header and to validate and fixed DecodeMessage to check the buffer's valid variable
Fixed some methods in TcpClientWindows

include/NetworkBuffer.hpp

@@ -17,6 +17,8 @@ struct NetworkBuffer
 
 	std::vector<byte> header; // size must always be 8
 	std::vector<byte> body;
+
+	bool valid = false;
 };
 
 #endif

include/NetworkMessage.hpp

@@ -12,7 +12,7 @@ struct NetworkMessage
 {
 	NetworkMessage();
 	NetworkMessage(const NetworkBuffer &buffer);
-	NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, byte subject, NetworkBuffer buffer);
+	NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, byte subject);
 	~NetworkMessage();
 
 	static const NetworkBuffer &EncodeMessage(const NetworkMessage &message);
@@ -27,9 +27,6 @@ struct NetworkMessage
 	void *data;
 	
 	bool valid = false;
-
-private:
-	NetworkBuffer buffer;
 };
 
 #endif

include/TcpClient.hpp

@@ -35,7 +35,7 @@ public:
 
 	bool Connect();
 
-	bool DataAvailable(uint16 &size);
+	bool DataAvailable(int32 &size);
 
 	//this method will receive the messages automaticaly and use the callback methods
 	void ReceiveMessages();

src/NetworkMessage.cpp

@@ -8,8 +8,8 @@ NetworkMessage::NetworkMessage()
 {
 }
 
-NetworkMessage::NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, byte subject, NetworkBuffer buffer) :
+NetworkMessage::NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, byte subject) :
-	sender(sender), distribution_mode(distribution_mode), destination_id(destination_id), tag(tag), subject(subject), buffer(buffer)
+	sender(sender), distribution_mode(distribution_mode), destination_id(destination_id), tag(tag), subject(subject)
 {
 }
 
@@ -24,53 +24,63 @@ NetworkMessage::~NetworkMessage()
 
 const NetworkBuffer &NetworkMessage::EncodeMessage(const NetworkMessage &message)
 {
-	NetworkBuffer net_buffer;
+	if (message.valid)
+	{
+		NetworkBuffer net_buffer;
 
-	std::vector<byte> sender = Utility::BitConverter::FromUint16(message.sender);
+		std::vector<byte> sender = Utility::BitConverter::FromUint16(message.sender);
-	std::vector<byte> distribution_mode = Utility::BitConverter::FromUint8(message.distribution_mode);
+		std::vector<byte> distribution_mode = Utility::BitConverter::FromUint8(message.distribution_mode);
-	std::vector<byte> destination_id = Utility::BitConverter::FromUint16(message.destination_id);
+		std::vector<byte> destination_id = Utility::BitConverter::FromUint16(message.destination_id);
-	std::vector<byte> tag = Utility::BitConverter::FromUint8(message.tag);
+		std::vector<byte> tag = Utility::BitConverter::FromUint8(message.tag);
-	std::vector<byte> subject = Utility::BitConverter::FromUint16(message.subject);
+		std::vector<byte> subject = Utility::BitConverter::FromUint16(message.subject);
-	std::vector<byte> data;
+		std::vector<byte> data;
-	if (message.data != nullptr)
+		if (message.data != nullptr)
-		data = Serializer::to_bytes(message.data);
+			data = Serializer::to_bytes(message.data);
 
-	net_buffer.body.insert(net_buffer.body.end(), sender.begin(), sender.end());
+		net_buffer.body.insert(net_buffer.body.end(), sender.begin(), sender.end());
-	net_buffer.body.insert(net_buffer.body.end(), distribution_mode.begin(), distribution_mode.end());
+		net_buffer.body.insert(net_buffer.body.end(), distribution_mode.begin(), distribution_mode.end());
-	net_buffer.body.insert(net_buffer.body.end(), destination_id.begin(), destination_id.end());
+		net_buffer.body.insert(net_buffer.body.end(), destination_id.begin(), destination_id.end());
-	net_buffer.body.insert(net_buffer.body.end(), tag.begin(), tag.end());
+		net_buffer.body.insert(net_buffer.body.end(), tag.begin(), tag.end());
-	net_buffer.body.insert(net_buffer.body.end(), subject.begin(), subject.end());
+		net_buffer.body.insert(net_buffer.body.end(), subject.begin(), subject.end());
-	if (message.data != nullptr && data.size() > 0)
+		if (message.data != nullptr && data.size() > 0)
-		net_buffer.body.insert(net_buffer.body.end(), data.begin(), data.end());
+			net_buffer.body.insert(net_buffer.body.end(), data.begin(), data.end());
+		net_buffer.header = Utility::BitConverter::FromInt32(sender.size() + distribution_mode.size() + destination_id.size() +
+			tag.size() + subject.size() + data.size());
+		net_buffer.valid = true;
+	}
+	return NetworkBuffer();
 }
 
 const NetworkMessage &NetworkMessage::DecodeMessage(const NetworkBuffer &buffer)
 {
-	NetworkMessage message;
+	if (buffer.valid)
-	message.sender = Utility::BitConverter::ToUint16(buffer.body, 1);
+	{
-	message.distribution_mode = buffer.body[3];
+		NetworkMessage message;
-	message.destination_id = Utility::BitConverter::ToUint16(buffer.body, 4);
+		message.sender = Utility::BitConverter::ToUint16(buffer.body, 1);
-	message.tag = buffer.body[6];
+		message.distribution_mode = buffer.body[3];
-	message.subject = Utility::BitConverter::ToUint8(buffer.body, 7);
+		message.destination_id = Utility::BitConverter::ToUint16(buffer.body, 4);
-	message.buffer = buffer;
+		message.tag = buffer.body[6];
-	message.valid = message.sender != -2 && message.tag != CONNECT && message.tag != DISCONNECT;
+		message.subject = Utility::BitConverter::ToUint8(buffer.body, 7);
+		message.valid = message.sender != -2 && message.tag != CONNECT && message.tag != DISCONNECT;
+
+		if (Utility::BitConverter::ToInt32(buffer.header) < 9)
+			return message;
+		byte version = buffer.body[0];
+		switch (version)
+		{
+		case 0:
+		{
+			void *object;
+			object = Serializer::from_bytes(buffer.body, object);
+		}
+		default:
+		{
+			//version not supported
+			throw std::runtime_error("NetworkMessage - Decoding version not supported");
+		}
+		}
 
-	if (Utility::BitConverter::ToUint32(buffer.header) < 9)
 		return message;
-	byte version = buffer.body[0];
-	switch (version)
-	{
-	case 0:
-	{
-		void *object;
-		object = Serializer::from_bytes(buffer.body, object);
 	}
-	default:
+	return NetworkMessage();
-	{
-		//version not supported
-		throw std::runtime_error("NetworkMessage - Decoding version not supported");
-	}
-	}
-
-	return message;
 }

src/TcpClientWindows.cpp

@@ -134,43 +134,53 @@ bool TcpClient::Connect()
 	if (connect_code == SOCKET_ERROR)
 		return false;
 
-	NetworkBuffer message(receive_data_array());
+	NetworkBuffer buffer(receive_data_array());
-	Handshake handshake = Handshake::DecodeHandshake(message.body);
+	if (buffer.valid)
-	if (handshake.con_code == ConnectionCode::Accept)
 	{
-		receive = true;
+		Handshake handshake = Handshake::DecodeHandshake(buffer.body);
-		return true;
+		if (handshake.con_code == ConnectionCode::Accept)
+		{
+			receive = true;
+			OnConnect(handshake.id);
+			return true;
+		}
 	}
 	return false;
 }
 
-bool TcpClient::DataAvailable(uint16 &size)
+bool TcpClient::DataAvailable(int32 &size)
 {
-	return ioctlsocket(tcp_socket, FIONREAD, (u_long*)size) != NO_ERROR && size > 0;
+	return ioctlsocket(tcp_socket, FIONREAD, reinterpret_cast<u_long*>(size)) != NO_ERROR && size > 0;
 }
 
 const NetworkBuffer &TcpClient::receive_data_array()
 {
 	NetworkBuffer buffer;
 
-	uint16 temp;
+	int32 temp;
-	if (DataAvailable(temp) && temp > 0)
+	if (DataAvailable(temp) && temp > sizeof(int32))
 	{
-		if (recv(tcp_socket, reinterpret_cast<char*>(buffer.header.data()), 4, 0) == 4)
+		byte *header = new byte[sizeof(int32)]();
+		if (recv(tcp_socket, reinterpret_cast<char*>(header), sizeof(int32), 0) != 4)
 			//invalid header
 			return NetworkBuffer();
+		buffer.header = std::vector<byte>(header, header + 4);
 	}
 	else 
 		return NetworkBuffer();
 
-	uint32 body_size = Utility::BitConverter::ToUint32(buffer.header);
+	int32 body_size = Utility::BitConverter::ToInt32(buffer.header);
-	int16 body_received = recv(tcp_socket, reinterpret_cast<char*>(buffer.body.data()), body_size, 0);
+	byte *body = new byte[body_size]();
-	if (body_received == SOCKET_ERROR || body_received != body_size || WSAGetLastError() != 0)
+	int16 received_bytes = recv(tcp_socket, reinterpret_cast<char*>(body), body_size, 0);
+	if (received_bytes == SOCKET_ERROR || received_bytes != body_size || WSAGetLastError() != 0)
 	{
 		//there was a problem receiving the body of the message or theres no body to receive
 		return NetworkBuffer();
 	}
 
+	buffer.body = std::vector<byte>(body, body + body_size);
+	buffer.valid = true;
+
 	return buffer;
 }
 
@@ -204,7 +214,7 @@ const NetworkMessage & TcpClient::ReceiveMessage()
 void TcpClient::send_network_message(const NetworkMessage &message, TcpClient *client)
 {
 	NetworkBuffer buffer = NetworkMessage::EncodeMessage(message);
-	int32 lenght = Utility::BitConverter::ToUint32(buffer.header);
+	int32 lenght = Utility::BitConverter::ToInt32(buffer.header);
 	int32 bytes_sent = send(client->tcp_socket, reinterpret_cast<char*>(buffer.body.data()), lenght, 0);
 	if (bytes_sent == SOCKET_ERROR || bytes_sent != lenght || WSAGetLastError() != 0)
 	{