From ed04e8e9e407f0dd57fa83a9732b3a3968cb80e0 Mon Sep 17 00:00:00 2001 From: Loic Blot Date: Fri, 16 Jan 2015 11:37:49 +0100 Subject: [Patch 2/4] Network rework: packet writing, sending and cleanups NetworkPacket.cpp: * Remove some deprecated functions, we must use streaming interface * m_data converted from u8* to std::vector * Add an exporter to forge packet to Connection object * implement operator << std::wstring. n * implement operator << std::string * dynamic resize when write packet content. * fix string writing and performances. * create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Reliability * Transmit channel * Implement putRawString for some ugly char (_INIT packet), and use it. * Many packet read and write migrated * Implement oldForgePacket to interface writing with current connection * fix U8/char/bool writing * fix string writing and performances. * add some missing functions * Use v3s16 read instead of reading x,y,z separately * Add irr::video::SColor support into packets * Add some missing handlers * Add a template function to increase offset * Throw a serialization error on packet reading (must be improved) PacketFactories: * Create ServerCommandFactory, used by client to get useful informations about packet processing (sending). * Create ClientCommandFactory, used by server to get useful informations about packet processing (sending). Client.cpp: * implement NetworkPacket ::Send interface. * Move packet handlers to a dedicated file * Remove Client::Send(SharedBuffer) Server.cpp: * implement NetworkPacket ::Send interface. * Rewrite all packets using NetworkPacket * Move packet handlers to a dedicated file * Remove Server::Send(SharedBuffer) ClientIface.cpp: * Remove sendToAll(SharedBuffer) Connection.hpp rework: * Remove duplicate include * Remove duplicate negation * Remove a useless variable * Improve code performance by using a m_peers_list instead of scanning m_peers map * Remove Connection::Send(SharedBuffer) * Fix useafterfree into NetworkPacket Sending * Remove unused Connection::sendToAll Test.cpp: * Remove dead code * Update tests to use NetworkPackets Misc: * add new wrappers to Send packets in client, using NetworkPacket * Add NetworkPacket methods for Connection * coding style fix * dead code since changes cleanup * Use v3s16 read instead of reading x,y,z separately in some packets * Use different files to handle packets received by client and server * Cleanup: Remove useless includes ok @Zeno- Tested by @Zeno- @VanessaE and @nerzhul on running servers --- src/network/networkpacket.cpp | 384 +++++++++++++++++++++++++++++++++--------- 1 file changed, 303 insertions(+), 81 deletions(-) (limited to 'src/network/networkpacket.cpp') diff --git a/src/network/networkpacket.cpp b/src/network/networkpacket.cpp index 80ea830f9..b2b1974d7 100644 --- a/src/network/networkpacket.cpp +++ b/src/network/networkpacket.cpp @@ -1,6 +1,5 @@ /* Minetest -Copyright (C) 2013 celeron55, Perttu Ahola Copyright (C) 2015 nerzhul, Loic Blot This program is free software; you can redistribute it and/or modify @@ -20,37 +19,54 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "networkpacket.h" #include "debug.h" +#include "exceptions.h" #include "util/serialize.h" NetworkPacket::NetworkPacket(u8 *data, u32 datasize, u16 peer_id): -m_peer_id(peer_id) +m_read_offset(0), m_peer_id(peer_id) { m_read_offset = 0; m_datasize = datasize - 2; - // Copy data packet to remove opcode - m_data = new u8[m_datasize]; + // split command and datas + m_command = readU16(&data[0]); + m_data = std::vector(&data[2], &data[2 + m_datasize]); +} - memcpy(m_data, &data[2], m_datasize); +NetworkPacket::NetworkPacket(u16 command, u32 datasize, u16 peer_id): +m_datasize(datasize), m_read_offset(0), m_command(command), m_peer_id(peer_id) +{ + m_data.resize(m_datasize); +} + +NetworkPacket::NetworkPacket(u16 command, u32 datasize): +m_datasize(datasize), m_read_offset(0), m_command(command), m_peer_id(0) +{ + m_data.resize(m_datasize); } NetworkPacket::~NetworkPacket() { - delete [] m_data; + m_data.clear(); } char* NetworkPacket::getString(u32 from_offset) { - assert(from_offset < m_datasize); + if (from_offset >= m_datasize) + throw SerializationError("Malformed packet read"); return (char*)&m_data[from_offset]; } -char NetworkPacket::getChar(u32 offset) +void NetworkPacket::putRawString(const char* src, u32 len) { - assert(offset < m_datasize); + if (m_read_offset + len * sizeof(char) >= m_datasize) { + m_datasize += len * sizeof(char); + m_data.resize(m_datasize); + } - return m_data[offset]; + memcpy(&m_data[m_read_offset], src, len); + m_read_offset += len; } NetworkPacket& NetworkPacket::operator>>(std::string& dst) @@ -64,14 +80,51 @@ NetworkPacket& NetworkPacket::operator>>(std::string& dst) return *this; } - dst.reserve(strLen); dst.append((char*)&m_data[m_read_offset], strLen); - m_read_offset += strLen*sizeof(char); + m_read_offset += strLen * sizeof(char); + return *this; +} + +NetworkPacket& NetworkPacket::operator<<(std::string src) +{ + u16 msgsize = src.size(); + if (msgsize > 0xFFFF) { + msgsize = 0xFFFF; + } + + *this << msgsize; + + if (m_read_offset + msgsize * sizeof(char) >= m_datasize) { + m_datasize += msgsize * sizeof(char); + m_data.resize(m_datasize); + } + + memcpy(&m_data[m_read_offset], src.c_str(), msgsize); + m_read_offset += msgsize; + return *this; } +void NetworkPacket::putLongString(std::string src) +{ + u32 msgsize = src.size(); + if (msgsize > 0xFFFFFFFF) { + msgsize = 0xFFFFFFFF; + } + + *this << msgsize; + + if (m_read_offset + msgsize * sizeof(char) >= m_datasize) { + m_datasize += msgsize * sizeof(char); + m_data.resize(m_datasize); + } + + memcpy(&m_data[m_read_offset], src.c_str(), msgsize); + m_read_offset += msgsize; +} + NetworkPacket& NetworkPacket::operator>>(std::wstring& dst) { u16 strLen = readU16(&m_data[m_read_offset]); @@ -93,6 +146,23 @@ NetworkPacket& NetworkPacket::operator>>(std::wstring& dst) return *this; } +NetworkPacket& NetworkPacket::operator<<(std::wstring src) +{ + u16 msgsize = src.size(); + if (msgsize > 0xFFFF) { + msgsize = 0xFFFF; + } + + *this << msgsize; + + // Write string + for (u16 i=0; i>(char& dst) { - dst = getChar(m_read_offset); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readU8(&m_data[m_read_offset]); - m_read_offset += sizeof(char); + incrOffset(); return *this; } -u8* NetworkPacket::getU8Ptr(u32 from_offset) +char NetworkPacket::getChar(u32 offset) { - assert(from_offset < m_datasize); + if (offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return (u8*)&m_data[from_offset]; + return readU8(&m_data[offset]); } -u8 NetworkPacket::getU8(u32 offset) +NetworkPacket& NetworkPacket::operator<<(char src) { - assert(offset < m_datasize); + checkDataSize(); + + writeU8(&m_data[m_read_offset], src); - return m_data[offset]; + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(u8& dst) +NetworkPacket& NetworkPacket::operator<<(u8 src) { - assert(m_read_offset < m_datasize); - dst = m_data[m_read_offset]; + checkDataSize(); - m_read_offset += sizeof(u8); + writeU8(&m_data[m_read_offset], src); + + incrOffset(); return *this; } -NetworkPacket& NetworkPacket::operator>>(bool& dst) +NetworkPacket& NetworkPacket::operator<<(bool src) { - assert(m_read_offset < m_datasize); - dst = m_data[m_read_offset]; + checkDataSize(); - m_read_offset += sizeof(u8); + writeU8(&m_data[m_read_offset], src); + + incrOffset(); return *this; } -u16 NetworkPacket::getU16(u32 from_offset) +NetworkPacket& NetworkPacket::operator<<(u16 src) { - assert(from_offset < m_datasize); + checkDataSize(); - return readU16(&m_data[from_offset]); + writeU16(&m_data[m_read_offset], src); + + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(u16& dst) +NetworkPacket& NetworkPacket::operator<<(u32 src) { - dst = getU16(m_read_offset); + checkDataSize(); - m_read_offset += sizeof(u16); + writeU32(&m_data[m_read_offset], src); + + incrOffset(); return *this; } -u32 NetworkPacket::getU32(u32 from_offset) +NetworkPacket& NetworkPacket::operator<<(u64 src) { - assert(from_offset < m_datasize); + checkDataSize(); + + writeU64(&m_data[m_read_offset], src); - return readU32(&m_data[from_offset]); + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(u32& dst) +NetworkPacket& NetworkPacket::operator<<(float src) { - dst = getU32(m_read_offset); + checkDataSize(); - m_read_offset += sizeof(u32); + writeF1000(&m_data[m_read_offset], src); + + incrOffset(); return *this; } -u64 NetworkPacket::getU64(u32 from_offset) +NetworkPacket& NetworkPacket::operator>>(bool& dst) { - assert(from_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return readU64(&m_data[from_offset]); + dst = readU8(&m_data[m_read_offset]); + + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(u64& dst) +NetworkPacket& NetworkPacket::operator>>(u8& dst) { - dst = getU64(m_read_offset); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); - m_read_offset += sizeof(u64); + dst = readU8(&m_data[m_read_offset]); + + incrOffset(); return *this; } -float NetworkPacket::getF1000(u32 from_offset) +u8 NetworkPacket::getU8(u32 offset) { - assert(from_offset < m_datasize); + if (offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return readF1000(&m_data[from_offset]); + return readU8(&m_data[offset]); +} + +u8* NetworkPacket::getU8Ptr(u32 from_offset) +{ + if (m_datasize == 0) { + return NULL; + } + + if (from_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + return (u8*)&m_data[from_offset]; +} + +NetworkPacket& NetworkPacket::operator>>(u16& dst) +{ + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readU16(&m_data[m_read_offset]); + + incrOffset(); + return *this; +} + +u16 NetworkPacket::getU16(u32 from_offset) +{ + if (from_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + return readU16(&m_data[from_offset]); +} + +NetworkPacket& NetworkPacket::operator>>(u32& dst) +{ + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readU32(&m_data[m_read_offset]); + + incrOffset(); + return *this; +} + +NetworkPacket& NetworkPacket::operator>>(u64& dst) +{ + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readU64(&m_data[m_read_offset]); + + incrOffset(); + return *this; } NetworkPacket& NetworkPacket::operator>>(float& dst) { - dst = getF1000(m_read_offset); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readF1000(&m_data[m_read_offset]); - m_read_offset += sizeof(float); + incrOffset(); return *this; } NetworkPacket& NetworkPacket::operator>>(v2f& dst) { - assert(m_read_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); dst = readV2F1000(&m_data[m_read_offset]); - m_read_offset += sizeof(v2f); + incrOffset(); return *this; } NetworkPacket& NetworkPacket::operator>>(v3f& dst) { - assert(m_read_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); dst = readV3F1000(&m_data[m_read_offset]); - m_read_offset += sizeof(v3f); + incrOffset(); return *this; } -s16 NetworkPacket::getS16(u32 from_offset) +NetworkPacket& NetworkPacket::operator>>(s16& dst) { - assert(from_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return readS16(&m_data[from_offset]); + dst = readS16(&m_data[m_read_offset]); + + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(s16& dst) +NetworkPacket& NetworkPacket::operator<<(s16 src) { - dst = getS16(m_read_offset); - - m_read_offset += sizeof(s16); + *this << (u16) src; return *this; } -s32 NetworkPacket::getS32(u32 from_offset) +NetworkPacket& NetworkPacket::operator>>(s32& dst) { - assert(from_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readS32(&m_data[m_read_offset]); - return readS32(&m_data[from_offset]); + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(s32& dst) +NetworkPacket& NetworkPacket::operator<<(s32 src) { - dst = getS32(m_read_offset); + *this << (u32) src; + return *this; +} - m_read_offset += sizeof(s32); +NetworkPacket& NetworkPacket::operator>>(v3s16& dst) +{ + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); + + dst = readV3S16(&m_data[m_read_offset]); + + incrOffset(); return *this; } @@ -266,36 +436,88 @@ NetworkPacket& NetworkPacket::operator>>(v2s32& dst) { dst = readV2S32(&m_data[m_read_offset]); - m_read_offset += sizeof(v2s32); + incrOffset(); return *this; } -v3s16 NetworkPacket::getV3S16(u32 from_offset) +NetworkPacket& NetworkPacket::operator>>(v3s32& dst) { - assert(from_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return readV3S16(&m_data[from_offset]); + dst = readV3S32(&m_data[m_read_offset]); + + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(v3s16& dst) +NetworkPacket& NetworkPacket::operator<<(v2f src) +{ + *this << (float) src.X; + *this << (float) src.Y; + return *this; +} + +NetworkPacket& NetworkPacket::operator<<(v3f src) +{ + *this << (float) src.X; + *this << (float) src.Y; + *this << (float) src.Z; + return *this; +} + +NetworkPacket& NetworkPacket::operator<<(v3s16 src) { - dst = getV3S16(m_read_offset); + *this << (s16) src.X; + *this << (s16) src.Y; + *this << (s16) src.Z; + return *this; +} - m_read_offset += sizeof(v3s16); +NetworkPacket& NetworkPacket::operator<<(v2s32 src) +{ + *this << (s32) src.X; + *this << (s32) src.Y; + return *this; +} + +NetworkPacket& NetworkPacket::operator<<(v3s32 src) +{ + *this << (s32) src.X; + *this << (s32) src.Y; + *this << (s32) src.Z; return *this; } -v3s32 NetworkPacket::getV3S32(u32 from_offset) +NetworkPacket& NetworkPacket::operator>>(video::SColor& dst) { - assert(from_offset < m_datasize); + if (m_read_offset >= m_datasize) + throw SerializationError("Malformed packet read"); - return readV3S32(&m_data[from_offset]); + dst = readARGB8(&m_data[m_read_offset]); + + incrOffset(); + return *this; } -NetworkPacket& NetworkPacket::operator>>(v3s32& dst) +NetworkPacket& NetworkPacket::operator<<(video::SColor src) { - dst = getV3S32(m_read_offset); + checkDataSize(); - m_read_offset += sizeof(v3s32); + writeU32(&m_data[m_read_offset], src.color); + + incrOffset(); return *this; } + +SharedBuffer NetworkPacket::oldForgePacket() +{ + SharedBuffer sb(m_datasize + 2); + writeU16(&sb[0], m_command); + + u8* datas = getU8Ptr(0); + + if (datas != NULL) + memcpy(&sb[2], datas, m_datasize); + return sb; +} -- cgit v1.2.3