GuilhermeStrice/VoidNet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NetworkBuffer now has valid parameter

Browse Source 
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
This commit is contained in:
xX-TheDoctor-Xx
2016-08-15 01:08:41 +01:00
parent e3de0a1489
commit fcc5c570e1
5 changed files with 80 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/NetworkBuffer.hpp
View File

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

5
include/NetworkMessage.hpp
View File

@ -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

2
include/TcpClient.hpp
View File

@ -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();

94
src/NetworkMessage.cpp
View File

@ -8,8 +8,8 @@ NetworkMessage::NetworkMessage()
{
}
NetworkMessage::NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, byte subject, NetworkBuffer buffer) :
sender(sender), distribution_mode(distribution_mode), destination_id(destination_id), tag(tag), subject(subject), buffer(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)
{
}
@ -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> distribution_mode = Utility::BitConverter::FromUint8(message.distribution_mode);
std::vector<byte> destination_id = Utility::BitConverter::FromUint16(message.destination_id);
std::vector<byte> tag = Utility::BitConverter::FromUint8(message.tag);
std::vector<byte> subject = Utility::BitConverter::FromUint16(message.subject);
std::vector<byte> data;
if (message.data != nullptr)
data = Serializer::to_bytes(message.data);
std::vector<byte> sender = Utility::BitConverter::FromUint16(message.sender);
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> tag = Utility::BitConverter::FromUint8(message.tag);
std::vector<byte> subject = Utility::BitConverter::FromUint16(message.subject);
std::vector<byte> data;
if (message.data != nullptr)
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(), 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(), tag.begin(), tag.end());
net_buffer.body.insert(net_buffer.body.end(), subject.begin(), subject.end());
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(), 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(), 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(), subject.begin(), subject.end());
if (message.data != nullptr && data.size() > 0)
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;
message.sender = Utility::BitConverter::ToUint16(buffer.body, 1);
message.distribution_mode = buffer.body[3];
message.destination_id = Utility::BitConverter::ToUint16(buffer.body, 4);
message.tag = buffer.body[6];
message.subject = Utility::BitConverter::ToUint8(buffer.body, 7);
message.buffer = buffer;
message.valid = message.sender != -2 && message.tag != CONNECT && message.tag != DISCONNECT;
if (buffer.valid)
{
NetworkMessage message;
message.sender = Utility::BitConverter::ToUint16(buffer.body, 1);
message.distribution_mode = buffer.body[3];
message.destination_id = Utility::BitConverter::ToUint16(buffer.body, 4);
message.tag = buffer.body[6];
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:
{
//version not supported
throw std::runtime_error("NetworkMessage - Decoding version not supported");
}
}
return message;
return NetworkMessage();
}

38
src/TcpClientWindows.cpp
View File

@ -134,43 +134,53 @@ bool TcpClient::Connect()
if (connect_code == SOCKET_ERROR)
return false;
NetworkBuffer message(receive_data_array());
Handshake handshake = Handshake::DecodeHandshake(message.body);
if (handshake.con_code == ConnectionCode::Accept)
NetworkBuffer buffer(receive_data_array());
if (buffer.valid)
{
receive = true;
return true;
Handshake handshake = Handshake::DecodeHandshake(buffer.body);
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;
if (DataAvailable(temp) && temp > 0)
int32 temp;
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);
int16 body_received = recv(tcp_socket, reinterpret_cast<char*>(buffer.body.data()), body_size, 0);
if (body_received == SOCKET_ERROR || body_received != body_size || WSAGetLastError() != 0)
int32 body_size = Utility::BitConverter::ToInt32(buffer.header);
byte *body = new byte[body_size]();
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)
{