[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<u8>
* 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<u8>)

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/clientopcodes.cpp

@@ -108,3 +108,77 @@ const ToClientCommandHandler toClientCommandTable[TOCLIENT_NUM_MSG_TYPES] =
 	{ "TOCLIENT_LOCAL_PLAYER_ANIMATIONS",  TOCLIENT_STATE_CONNECTED, &Client::handleCommand_LocalPlayerAnimations }, // 0x51
 	{ "TOCLIENT_EYE_OFFSET",               TOCLIENT_STATE_CONNECTED, &Client::handleCommand_EyeOffset }, // 0x52
 };
+
+const static ServerCommandFactory null_command_factory = { "TOSERVER_NULL", 0, false };
+
+const ServerCommandFactory serverCommandFactoryTable[TOSERVER_NUM_MSG_TYPES] =
+{
+	null_command_factory, // 0x00
+	null_command_factory, // 0x01
+	null_command_factory, // 0x02
+	null_command_factory, // 0x03
+	null_command_factory, // 0x04
+	null_command_factory, // 0x05
+	null_command_factory, // 0x06
+	null_command_factory, // 0x07
+	null_command_factory, // 0x08
+	null_command_factory, // 0x09
+	null_command_factory, // 0x0a
+	null_command_factory, // 0x0b
+	null_command_factory, // 0x0c
+	null_command_factory, // 0x0d
+	null_command_factory, // 0x0e
+	null_command_factory, // 0x0f
+	{ "TOSERVER_INIT",               1, false }, // 0x10
+	{ "TOSERVER_INIT2",              1, true }, // 0x11
+	null_command_factory, // 0x12
+	null_command_factory, // 0x13
+	null_command_factory, // 0x14
+	null_command_factory, // 0x15
+	null_command_factory, // 0x16
+	null_command_factory, // 0x17
+	null_command_factory, // 0x18
+	null_command_factory, // 0x19
+	null_command_factory, // 0x1a
+	null_command_factory, // 0x1b
+	null_command_factory, // 0x1c
+	null_command_factory, // 0x1d
+	null_command_factory, // 0x1e
+	null_command_factory, // 0x1f
+	null_command_factory, // 0x20
+	null_command_factory, // 0x21
+	null_command_factory, // 0x22
+	{ "TOSERVER_PLAYERPOS",          0, false }, // 0x23
+	{ "TOSERVER_GOTBLOCKS",          2, true }, // 0x24
+	{ "TOSERVER_DELETEDBLOCKS",      2, true }, // 0x25
+	null_command_factory, // 0x26
+	{ "TOSERVER_CLICK_OBJECT",       0, false }, // 0x27
+	{ "TOSERVER_GROUND_ACTION",      0, false }, // 0x28
+	{ "TOSERVER_RELEASE",            0, false }, // 0x29
+	null_command_factory, // 0x2a
+	null_command_factory, // 0x2b
+	null_command_factory, // 0x2c
+	null_command_factory, // 0x2d
+	null_command_factory, // 0x2e
+	null_command_factory, // 0x2f
+	{ "TOSERVER_SIGNTEXT",           0, false }, // 0x30
+	{ "TOSERVER_INVENTORY_ACTION",   0, true }, // 0x31
+	{ "TOSERVER_CHAT_MESSAGE",       0, true }, // 0x32
+	{ "TOSERVER_SIGNNODETEXT",       0, false }, // 0x33
+	{ "TOSERVER_CLICK_ACTIVEOBJECT", 0, false }, // 0x34
+	{ "TOSERVER_DAMAGE",             0, true }, // 0x35
+	{ "TOSERVER_PASSWORD",           0, true }, // 0x36
+	{ "TOSERVER_PLAYERITEM",         0, true }, // 0x37
+	{ "TOSERVER_RESPAWN",            0, true }, // 0x38
+	{ "TOSERVER_INTERACT",           0, true }, // 0x39
+	{ "TOSERVER_REMOVED_SOUNDS",     1, true }, // 0x3a
+	{ "TOSERVER_NODEMETA_FIELDS",    0, true }, // 0x3b
+	{ "TOSERVER_INVENTORY_FIELDS",   0, true }, // 0x3c
+	null_command_factory, // 0x3d
+	null_command_factory, // 0x3e
+	null_command_factory, // 0x3f
+	{ "TOSERVER_REQUEST_MEDIA",      1, true }, // 0x40
+	{ "TOSERVER_RECEIVED_MEDIA",     1, true }, // 0x41
+	{ "TOSERVER_BREATH",             0, true }, // 0x42
+	{ "TOSERVER_CLIENT_READY",       0, true }, // 0x43
+};

src/network/clientopcodes.h

@@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "client.h"
 #include "networkprotocol.h"
-#include "toclientpacket.h"
+#include "networkpacket.h"
 
 enum ToClientConnectionState {
 	TOCLIENT_STATE_NOT_CONNECTED,
@@ -33,11 +33,20 @@ enum ToClientConnectionState {
 
 struct ToClientCommandHandler
 {
-    char const* name;
+    const char* name;
     ToClientConnectionState state;
-    void (Client::*handler)(ToClientPacket* pkt);
+    void (Client::*handler)(NetworkPacket* pkt);
+};
+
+struct ServerCommandFactory
+{
+	const char* name;
+	u16 channel;
+	bool reliable;
 };
 
 extern const ToClientCommandHandler toClientCommandTable[TOCLIENT_NUM_MSG_TYPES];
 
+extern const ServerCommandFactory serverCommandFactoryTable[TOSERVER_NUM_MSG_TYPES];
+
 #endif

src/network/networkpacket.cpp

@@ -1,6 +1,5 @@
 /*
 Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
 
 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<u8>(&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<msgsize; i++) {
+		*this << (u16) src[i];
+	}
+
+	return *this;
+}
+
 std::string NetworkPacket::readLongString()
 {
 	u32 strLen = readU32(&m_data[m_read_offset]);
@@ -114,151 +184,251 @@ std::string NetworkPacket::readLongString()
 
 NetworkPacket& NetworkPacket::operator>>(char& dst)
 {
-	dst = getChar(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(char);
+	dst = readU8(&m_data[m_read_offset]);
+
+	incrOffset<char>();
 	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<u8>();
 
-	return m_data[offset];
+	writeU8(&m_data[m_read_offset], src);
+
+	incrOffset<char>();
+	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<u8>();
 
-	m_read_offset += sizeof(u8);
+	writeU8(&m_data[m_read_offset], src);
+
+	incrOffset<u8>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(bool src)
+{
+	checkDataSize<u8>();
+
+	writeU8(&m_data[m_read_offset], src);
+
+	incrOffset<u8>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(u16 src)
+{
+	checkDataSize<u16>();
+
+	writeU16(&m_data[m_read_offset], src);
+
+	incrOffset<u16>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(u32 src)
+{
+	checkDataSize<u32>();
+
+	writeU32(&m_data[m_read_offset], src);
+
+	incrOffset<u32>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(u64 src)
+{
+	checkDataSize<u64>();
+
+	writeU64(&m_data[m_read_offset], src);
+
+	incrOffset<u64>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(float src)
+{
+	checkDataSize<float>();
+
+	writeF1000(&m_data[m_read_offset], src);
+
+	incrOffset<float>();
 	return *this;
 }
 
 NetworkPacket& NetworkPacket::operator>>(bool& dst)
 {
-	assert(m_read_offset < m_datasize);
-	dst = m_data[m_read_offset];
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(u8);
+	dst = readU8(&m_data[m_read_offset]);
+
+	incrOffset<u8>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator>>(u8& dst)
+{
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
+
+	dst = readU8(&m_data[m_read_offset]);
+
+	incrOffset<u8>();
+	return *this;
+}
+
+u8 NetworkPacket::getU8(u32 offset)
+{
+	if (offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
+
+	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<u16>();
 	return *this;
 }
 
 u16 NetworkPacket::getU16(u32 from_offset)
 {
-	assert(from_offset < m_datasize);
+	if (from_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
 	return readU16(&m_data[from_offset]);
 }
 
-NetworkPacket& NetworkPacket::operator>>(u16& dst)
-{
-	dst = getU16(m_read_offset);
-
-	m_read_offset += sizeof(u16);
-	return *this;
-}
-
-u32 NetworkPacket::getU32(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readU32(&m_data[from_offset]);
-}
-
 NetworkPacket& NetworkPacket::operator>>(u32& dst)
 {
-	dst = getU32(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(u32);
+	dst = readU32(&m_data[m_read_offset]);
+
+	incrOffset<u32>();
 	return *this;
 }
 
-u64 NetworkPacket::getU64(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readU64(&m_data[from_offset]);
-}
-
 NetworkPacket& NetworkPacket::operator>>(u64& dst)
 {
-	dst = getU64(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(u64);
+	dst = readU64(&m_data[m_read_offset]);
+
+	incrOffset<u64>();
 	return *this;
 }
 
-float NetworkPacket::getF1000(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readF1000(&m_data[from_offset]);
-}
-
 NetworkPacket& NetworkPacket::operator>>(float& dst)
 {
-	dst = getF1000(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(float);
+	dst = readF1000(&m_data[m_read_offset]);
+
+	incrOffset<float>();
 	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<v2f>();
 	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<v3f>();
 	return *this;
 }
 
-s16 NetworkPacket::getS16(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readS16(&m_data[from_offset]);
-}
-
 NetworkPacket& NetworkPacket::operator>>(s16& dst)
 {
-	dst = getS16(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(s16);
+	dst = readS16(&m_data[m_read_offset]);
+
+	incrOffset<s16>();
 	return *this;
 }
 
-s32 NetworkPacket::getS32(u32 from_offset)
+NetworkPacket& NetworkPacket::operator<<(s16 src)
 {
-	assert(from_offset < m_datasize);
-
-	return readS32(&m_data[from_offset]);
+	*this << (u16) src;
+	return *this;
 }
 
 NetworkPacket& NetworkPacket::operator>>(s32& dst)
 {
-	dst = getS32(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(s32);
+	dst = readS32(&m_data[m_read_offset]);
+
+	incrOffset<s32>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(s32 src)
+{
+	*this << (u32) src;
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
+{
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
+
+	dst = readV3S16(&m_data[m_read_offset]);
+
+	incrOffset<v3s16>();
 	return *this;
 }
 
@@ -266,36 +436,88 @@ NetworkPacket& NetworkPacket::operator>>(v2s32& dst)
 {
 	dst = readV2S32(&m_data[m_read_offset]);
 
-	m_read_offset += sizeof(v2s32);
+	incrOffset<v2s32>();
 	return *this;
 }
 
-v3s16 NetworkPacket::getV3S16(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readV3S16(&m_data[from_offset]);
-}
-
-NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
-{
-	dst = getV3S16(m_read_offset);
-
-	m_read_offset += sizeof(v3s16);
-	return *this;
-}
-
-v3s32 NetworkPacket::getV3S32(u32 from_offset)
-{
-	assert(from_offset < m_datasize);
-
-	return readV3S32(&m_data[from_offset]);
-}
-
 NetworkPacket& NetworkPacket::operator>>(v3s32& dst)
 {
-	dst = getV3S32(m_read_offset);
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
 
-	m_read_offset += sizeof(v3s32);
+	dst = readV3S32(&m_data[m_read_offset]);
+
+	incrOffset<v3s32>();
 	return *this;
 }
+
+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)
+{
+	*this << (s16) src.X;
+	*this << (s16) src.Y;
+	*this << (s16) src.Z;
+	return *this;
+}
+
+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;
+}
+
+NetworkPacket& NetworkPacket::operator>>(video::SColor& dst)
+{
+	if (m_read_offset >= m_datasize)
+		throw SerializationError("Malformed packet read");
+
+	dst = readARGB8(&m_data[m_read_offset]);
+
+	incrOffset<u32>();
+	return *this;
+}
+
+NetworkPacket& NetworkPacket::operator<<(video::SColor src)
+{
+	checkDataSize<u32>();
+
+	writeU32(&m_data[m_read_offset], src.color);
+
+	incrOffset<u32>();
+	return *this;
+}
+
+SharedBuffer<u8> NetworkPacket::oldForgePacket()
+{
+	SharedBuffer<u8> sb(m_datasize + 2);
+	writeU16(&sb[0], m_command);
+
+	u8* datas = getU8Ptr(0);
+
+	if (datas != NULL)
+		memcpy(&sb[2], datas, m_datasize);
+	return sb;
+}

src/network/networkpacket.h

@@ -1,6 +1,5 @@
 /*
 Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
 
 This program is free software; you can redistribute it and/or modify
@@ -21,6 +20,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #ifndef NETWORKPACKET_HEADER
 #define NETWORKPACKET_HEADER
 
+#include "util/pointer.h"
 #include "util/numeric.h"
 #include "networkprotocol.h"
 
@@ -29,57 +29,100 @@ class NetworkPacket
 
 public:
 		NetworkPacket(u8 *data, u32 datasize, u16 peer_id);
+		NetworkPacket(u16 command, u32 datasize, u16 peer_id);
+		NetworkPacket(u16 command, u32 datasize);
 		~NetworkPacket();
 
 		// Getters
 		u32 getSize() { return m_datasize; }
 		u16 getPeerId() { return m_peer_id; }
+		u16 getCommand() { return m_command; }
 
 		// Data extractors
 		char* getString(u32 from_offset);
+		void putRawString(const char* src, u32 len);
+
 		NetworkPacket& operator>>(std::string& dst);
+		NetworkPacket& operator<<(std::string src);
+
+		void putLongString(std::string src);
+
 		NetworkPacket& operator>>(std::wstring& dst);
+		NetworkPacket& operator<<(std::wstring src);
+
 		std::string readLongString();
 
 		char getChar(u32 offset);
 		NetworkPacket& operator>>(char& dst);
+		NetworkPacket& operator<<(char src);
 
 		NetworkPacket& operator>>(bool& dst);
+		NetworkPacket& operator<<(bool src);
 
 		u8 getU8(u32 offset);
+
 		NetworkPacket& operator>>(u8& dst);
+		NetworkPacket& operator<<(u8 src);
 
 		u8* getU8Ptr(u32 offset);
+
 		u16 getU16(u32 from_offset);
 		NetworkPacket& operator>>(u16& dst);
-		u32 getU32(u32 from_offset);
+		NetworkPacket& operator<<(u16 src);
+
 		NetworkPacket& operator>>(u32& dst);
-		u64 getU64(u32 from_offset);
+		NetworkPacket& operator<<(u32 src);
+
 		NetworkPacket& operator>>(u64& dst);
+		NetworkPacket& operator<<(u64 src);
 
-		float getF1000(u32 offset);
 		NetworkPacket& operator>>(float& dst);
-		NetworkPacket& operator>>(v2f& dst);
-		NetworkPacket& operator>>(v3f& dst);
+		NetworkPacket& operator<<(float src);
+
+		NetworkPacket& operator>>(v2f& dst);
+		NetworkPacket& operator<<(v2f src);
+
+		NetworkPacket& operator>>(v3f& dst);
+		NetworkPacket& operator<<(v3f src);
 
-		s16 getS16(u32 from_offset);
 		NetworkPacket& operator>>(s16& dst);
-		s32 getS32(u32 from_offset);
+		NetworkPacket& operator<<(s16 src);
+
 		NetworkPacket& operator>>(s32& dst);
+		NetworkPacket& operator<<(s32 src);
 
 		NetworkPacket& operator>>(v2s32& dst);
+		NetworkPacket& operator<<(v2s32 src);
 
-		v3s16 getV3S16(u32 from_offset);
 		NetworkPacket& operator>>(v3s16& dst);
+		NetworkPacket& operator<<(v3s16 src);
 
-		v3s32 getV3S32(u32 from_offset);
 		NetworkPacket& operator>>(v3s32& dst);
+		NetworkPacket& operator<<(v3s32 src);
 
-protected:
-		u8 *m_data;
+		NetworkPacket& operator>>(video::SColor& dst);
+		NetworkPacket& operator<<(video::SColor src);
+
+		// Temp, we remove SharedBuffer when migration finished
+		SharedBuffer<u8> oldForgePacket();
+private:
+		template<typename T> void checkDataSize()
+		{
+			if (m_read_offset + sizeof(T) > m_datasize) {
+				m_datasize += sizeof(T);
+				m_data.resize(m_datasize);
+			}
+		}
+
+		template<typename T> void incrOffset()
+		{
+			m_read_offset += sizeof(T);
+		}
+
+		std::vector<u8> m_data;
 		u32 m_datasize;
 		u32 m_read_offset;
-private:
+		u16 m_command;
 		u16 m_peer_id;
 };
 

src/network/serveropcodes.cpp

@@ -93,3 +93,92 @@ const ToServerCommandHandler toServerCommandTable[TOSERVER_NUM_MSG_TYPES] =
 	{ "TOSERVER_BREATH",                   TOSERVER_STATE_INGAME, &Server::handleCommand_Breath }, // 0x42
 	{ "TOSERVER_CLIENT_READY",             TOSERVER_STATE_STARTUP, &Server::handleCommand_ClientReady }, // 0x43
 };
+
+const static ClientCommandFactory null_command_factory = { "TOCLIENT_NULL", 0, false };
+
+const ClientCommandFactory clientCommandFactoryTable[TOCLIENT_NUM_MSG_TYPES] =
+{
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	{ "TOCLIENT_INIT",                     0, true }, // 0x10
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	{ "TOCLIENT_BLOCKDATA",                2, true }, // 0x20
+	{ "TOCLIENT_ADDNODE",                  0, true }, // 0x21
+	{ "TOCLIENT_REMOVENODE",               0, true }, // 0x22
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	{ "TOCLIENT_INVENTORY",                0, true }, // 0x27
+	null_command_factory,
+	{ "TOCLIENT_TIME_OF_DAY",              0, true }, // 0x29
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	null_command_factory,
+	{ "TOCLIENT_CHAT_MESSAGE",             0, true }, // 0x30
+	{ "TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD", 0, true }, // 0x31
+	{ "TOCLIENT_ACTIVE_OBJECT_MESSAGES",   0, true }, // 0x32 Special packet, sent by 0 (rel) and 1 (unrel) channel
+	{ "TOCLIENT_HP",                       0, true }, // 0x33
+	{ "TOCLIENT_MOVE_PLAYER",              0, true }, // 0x34
+	{ "TOCLIENT_ACCESS_DENIED",            0, true }, // 0x35
+	{ "TOCLIENT_PLAYERITEM",               0, false }, // 0x36 obsolete
+	{ "TOCLIENT_DEATHSCREEN",              0, true }, // 0x37
+	{ "TOCLIENT_MEDIA",                    2, true }, // 0x38
+	{ "TOCLIENT_TOOLDEF",                  0, false }, // 0x39 obsolete
+	{ "TOCLIENT_NODEDEF",                  0, true }, // 0x3a
+	{ "TOCLIENT_CRAFTITEMDEF",             0, false }, // 0x3b obsolete
+	{ "TOCLIENT_ANNOUNCE_MEDIA",           0, true }, // 0x3c
+	{ "TOCLIENT_ITEMDEF",                  0, true }, // 0x3d
+	null_command_factory,
+	{ "TOCLIENT_PLAY_SOUND",               0, true }, // 0x3f
+	{ "TOCLIENT_STOP_SOUND",               0, true }, // 0x40
+	{ "TOCLIENT_PRIVILEGES",               0, true }, // 0x41
+	{ "TOCLIENT_INVENTORY_FORMSPEC",       0, true }, // 0x42
+	{ "TOCLIENT_DETACHED_INVENTORY",       0, true }, // 0x43
+	{ "TOCLIENT_SHOW_FORMSPEC",            0, true }, // 0x44
+	{ "TOCLIENT_MOVEMENT",                 0, true }, // 0x45
+	{ "TOCLIENT_SPAWN_PARTICLE",           0, true }, // 0x46
+	{ "TOCLIENT_ADD_PARTICLESPAWNER",      0, true }, // 0x47
+	{ "TOCLIENT_DELETE_PARTICLESPAWNER",   0, true }, // 0x48
+	{ "TOCLIENT_HUDADD",                   1, true }, // 0x49
+	{ "TOCLIENT_HUDRM",                    1, true }, // 0x4a
+	{ "TOCLIENT_HUDCHANGE",                0, true }, // 0x4b
+	{ "TOCLIENT_HUD_SET_FLAGS",            0, true }, // 0x4c
+	{ "TOCLIENT_HUD_SET_PARAM",            0, true }, // 0x4d
+	{ "TOCLIENT_BREATH",                   0, true }, // 0x4e
+	{ "TOCLIENT_SET_SKY",                  0, true }, // 0x4f
+	{ "TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO", 0, true }, // 0x50
+	{ "TOCLIENT_LOCAL_PLAYER_ANIMATIONS",  0, true }, // 0x51
+	{ "TOCLIENT_EYE_OFFSET",               0, true }, // 0x52
+};

src/network/serveropcodes.h

@@ -23,7 +23,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "server.h"
 #include "networkprotocol.h"
-#include "toserverpacket.h"
+#include "networkpacket.h"
 
 enum ToServerConnectionState {
 	TOSERVER_STATE_NOT_CONNECTED,
@@ -35,9 +35,18 @@ struct ToServerCommandHandler
 {
     const std::string name;
     ToServerConnectionState state;
-    void (Server::*handler)(ToServerPacket* pkt);
+    void (Server::*handler)(NetworkPacket* pkt);
+};
+
+struct ClientCommandFactory
+{
+	const char* name;
+	u16 channel;
+	bool reliable;
 };
 
 extern const ToServerCommandHandler toServerCommandTable[TOSERVER_NUM_MSG_TYPES];
 
+extern const ClientCommandFactory clientCommandFactoryTable[TOCLIENT_NUM_MSG_TYPES];
+
 #endif

src/network/toclientpacket.cpp

@@ -1,28 +0,0 @@
-/*
-Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-*/
-
-#include "toclientpacket.h"
-#include "util/serialize.h"
-
-ToClientPacket::ToClientPacket(u8 *data, u32 datasize, u16 peer_id):
-NetworkPacket(data, datasize, peer_id)
-{
-	m_command = (ToClientCommand)readU16(&data[0]);
-}

src/network/toclientpacket.h

@@ -1,38 +0,0 @@
-/*
-Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-*/
-
-#ifndef TOCLIENTPACKET_HEADER
-#define TOCLIENTPACKET_HEADER
-
-#include "util/numeric.h"
-#include "networkprotocol.h"
-#include "networkpacket.h"
-
-class ToClientPacket: public NetworkPacket
-{
-public:
-	ToClientPacket(u8 *data, u32 datasize, u16 peer_id);
-	ToClientCommand getCommand() { return m_command; }
-
-private:
-	ToClientCommand m_command;
-};
-
-#endif

src/network/toserverpacket.cpp

@@ -1,28 +0,0 @@
-/*
-Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-*/
-
-#include "toserverpacket.h"
-#include "util/serialize.h"
-
-ToServerPacket::ToServerPacket(u8 *data, u32 datasize, u16 peer_id):
-NetworkPacket(data, datasize, peer_id)
-{
-	m_command = (ToServerCommand)readU16(&data[0]);
-}

src/network/toserverpacket.h

@@ -1,38 +0,0 @@
-/*
-Minetest
-Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-*/
-
-#ifndef TOSERVERPACKET_HEADER
-#define TOSERVERPACKET_HEADER
-
-#include "util/numeric.h"
-#include "networkprotocol.h"
-#include "networkpacket.h"
-
-class ToServerPacket: public NetworkPacket
-{
-public:
-	ToServerPacket(u8 *data, u32 datasize, u16 peer_id);
-	ToServerCommand getCommand() { return m_command; }
-
-private:
-	ToServerCommand m_command;
-};
-
-#endif