Small TOCLIENT_HELLO logging fix

[oweals/minetest.git] / src / network / networkpacket.cpp

diff --git a/src/network/networkpacket.cpp b/src/network/networkpacket.cpp
index cfbca32d33a70372feb5c5acd55b97d3eeae10a3..1e4b6e23eec92e7d36e25727b4880eac12c05df1 100644 (file)
--- a/src/network/networkpacket.cpp
+++ b/src/network/networkpacket.cpp
@@ -22,17 +22,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "exceptions.h"
 #include "util/serialize.h"
 
-NetworkPacket::NetworkPacket(u8 *data, u32 datasize, u16 peer_id):
-m_read_offset(0), m_peer_id(peer_id)
-{
-       m_read_offset = 0;
-       m_datasize = datasize - 2;
-
-       // split command and datas
-       m_command = readU16(&data[0]);
-       m_data = std::vector<u8>(&data[2], &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)
 {
@@ -50,18 +39,41 @@ NetworkPacket::~NetworkPacket()
        m_data.clear();
 }
 
+void NetworkPacket::checkReadOffset(u32 from_offset)
+{
+       if (from_offset >= m_datasize) {
+               std::stringstream ss;
+               ss << "Reading outside packet (offset: " <<
+                               from_offset << ", packet size: " << getSize() << ")";
+               throw PacketError(ss.str());
+       }
+}
+
+void NetworkPacket::putRawPacket(u8 *data, u32 datasize, u16 peer_id)
+{
+       // If a m_command is already set, we are rewriting on same packet
+       // This is not permitted
+       assert(m_command == 0);
+
+       m_datasize = datasize - 2;
+       m_peer_id = peer_id;
+
+       // split command and datas
+       m_command = readU16(&data[0]);
+       m_data = std::vector<u8>(&data[2], &data[2 + m_datasize]);
+}
+
 char* NetworkPacket::getString(u32 from_offset)
 {
-       if (from_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(from_offset);
 
        return (char*)&m_data[from_offset];
 }
 
 void NetworkPacket::putRawString(const char* src, u32 len)
 {
-       if (m_read_offset + len * sizeof(char) >= m_datasize) {
-               m_datasize += len * sizeof(char);
+       if (m_read_offset + len > m_datasize) {
+               m_datasize = m_read_offset + len;
                m_data.resize(m_datasize);
        }
 
@@ -83,7 +95,7 @@ NetworkPacket& NetworkPacket::operator>>(std::string& dst)
        dst.reserve(strLen);
        dst.append((char*)&m_data[m_read_offset], strLen);
 
-       m_read_offset += strLen * sizeof(char);
+       m_read_offset += strLen;
        return *this;
 }
 
@@ -96,13 +108,7 @@ NetworkPacket& NetworkPacket::operator<<(std::string src)
 
        *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;
+       putRawString(src.c_str(), (u32)msgsize);
 
        return *this;
 }
@@ -116,13 +122,7 @@ void NetworkPacket::putLongString(std::string src)
 
        *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;
+       putRawString(src.c_str(), msgsize);
 }
 
 NetworkPacket& NetworkPacket::operator>>(std::wstring& dst)
@@ -177,15 +177,14 @@ std::string NetworkPacket::readLongString()
        dst.reserve(strLen);
        dst.append((char*)&m_data[m_read_offset], strLen);
 
-       m_read_offset += strLen*sizeof(char);
+       m_read_offset += strLen;
 
        return dst;
 }
 
 NetworkPacket& NetworkPacket::operator>>(char& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU8(&m_data[m_read_offset]);
 
@@ -195,8 +194,7 @@ NetworkPacket& NetworkPacket::operator>>(char& dst)
 
 char NetworkPacket::getChar(u32 offset)
 {
-       if (offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(offset);
 
        return readU8(&m_data[offset]);
 }
@@ -273,8 +271,7 @@ NetworkPacket& NetworkPacket::operator<<(float src)
 
 NetworkPacket& NetworkPacket::operator>>(bool& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU8(&m_data[m_read_offset]);
 
@@ -284,8 +281,7 @@ NetworkPacket& NetworkPacket::operator>>(bool& dst)
 
 NetworkPacket& NetworkPacket::operator>>(u8& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU8(&m_data[m_read_offset]);
 
@@ -295,8 +291,7 @@ NetworkPacket& NetworkPacket::operator>>(u8& dst)
 
 u8 NetworkPacket::getU8(u32 offset)
 {
-       if (offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(offset);
 
        return readU8(&m_data[offset]);
 }
@@ -307,16 +302,14 @@ u8* NetworkPacket::getU8Ptr(u32 from_offset)
                return NULL;
        }
 
-       if (from_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(from_offset);
 
        return (u8*)&m_data[from_offset];
 }
 
 NetworkPacket& NetworkPacket::operator>>(u16& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU16(&m_data[m_read_offset]);
 
@@ -326,16 +319,14 @@ NetworkPacket& NetworkPacket::operator>>(u16& dst)
 
 u16 NetworkPacket::getU16(u32 from_offset)
 {
-       if (from_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(from_offset);
 
        return readU16(&m_data[from_offset]);
 }
 
 NetworkPacket& NetworkPacket::operator>>(u32& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU32(&m_data[m_read_offset]);
 
@@ -345,8 +336,7 @@ NetworkPacket& NetworkPacket::operator>>(u32& dst)
 
 NetworkPacket& NetworkPacket::operator>>(u64& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readU64(&m_data[m_read_offset]);
 
@@ -356,8 +346,7 @@ NetworkPacket& NetworkPacket::operator>>(u64& dst)
 
 NetworkPacket& NetworkPacket::operator>>(float& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readF1000(&m_data[m_read_offset]);
 
@@ -367,8 +356,7 @@ NetworkPacket& NetworkPacket::operator>>(float& dst)
 
 NetworkPacket& NetworkPacket::operator>>(v2f& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readV2F1000(&m_data[m_read_offset]);
 
@@ -378,8 +366,7 @@ NetworkPacket& NetworkPacket::operator>>(v2f& dst)
 
 NetworkPacket& NetworkPacket::operator>>(v3f& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readV3F1000(&m_data[m_read_offset]);
 
@@ -389,8 +376,7 @@ NetworkPacket& NetworkPacket::operator>>(v3f& dst)
 
 NetworkPacket& NetworkPacket::operator>>(s16& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readS16(&m_data[m_read_offset]);
 
@@ -406,8 +392,7 @@ NetworkPacket& NetworkPacket::operator<<(s16 src)
 
 NetworkPacket& NetworkPacket::operator>>(s32& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readS32(&m_data[m_read_offset]);
 
@@ -423,8 +408,7 @@ NetworkPacket& NetworkPacket::operator<<(s32 src)
 
 NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readV3S16(&m_data[m_read_offset]);
 
@@ -442,8 +426,7 @@ NetworkPacket& NetworkPacket::operator>>(v2s32& dst)
 
 NetworkPacket& NetworkPacket::operator>>(v3s32& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readV3S32(&m_data[m_read_offset]);
 
@@ -491,8 +474,7 @@ NetworkPacket& NetworkPacket::operator<<(v3s32 src)
 
 NetworkPacket& NetworkPacket::operator>>(video::SColor& dst)
 {
-       if (m_read_offset >= m_datasize)
-               throw SerializationError("Malformed packet read");
+       checkReadOffset(m_read_offset);
 
        dst = readARGB8(&m_data[m_read_offset]);
 
@@ -512,7 +494,7 @@ NetworkPacket& NetworkPacket::operator<<(video::SColor src)
 
 Buffer<u8> NetworkPacket::oldForgePacket()
 {
-       SharedBuffer<u8> sb(m_datasize + 2);
+       Buffer<u8> sb(m_datasize + 2);
        writeU16(&sb[0], m_command);
 
        u8* datas = getU8Ptr(0);