(svn r20924) -Codechange: make the game connection packet handling look more like UDP/content packet handling

3 files changed, 195 insertions, 2 deletions

diff --git a/src/network/core/tcp_content.cpp b/src/network/core/tcp_content.cpp
index b5bf52999..0cf03d7fa 100644
--- a/src/network/core/tcp_content.cpp
+++ b/src/network/core/tcp_content.cpp
@@ -115,7 +115,7 @@ bool NetworkContentSocketHandler::HandlePacket(Packet *p)
 }
 
 /**
- * Receive a packet at UDP level
+ * Receive a packet at TCP level
  */
 void NetworkContentSocketHandler::Recv_Packets()
 {
diff --git a/src/network/core/tcp_game.cpp b/src/network/core/tcp_game.cpp
index 6d8e174c8..b0db78eb7 100644
--- a/src/network/core/tcp_game.cpp
+++ b/src/network/core/tcp_game.cpp
@@ -18,6 +18,7 @@
 #include "../network.h"
 #include "../network_internal.h"
 #include "../../core/pool_func.hpp"
+#include "../../debug.h"
 
 #include "table/strings.h"
 
@@ -63,4 +64,147 @@ NetworkRecvStatus NetworkGameSocketHandler::CloseConnection(bool error)
 	return NetworkCloseClient(this, error ? NETWORK_RECV_STATUS_SERVER_ERROR : NETWORK_RECV_STATUS_CONN_LOST);
 }
 
+
+/**
+ * Defines a simple (switch) case for each network packet
+ * @param type the packet type to create the case for
+ */
+#define GAME_COMMAND(type) case type: return this->NetworkPacketReceive_ ## type ## _command(p); break;
+
+/**
+ * Handle the given packet, i.e. pass it to the right parser receive command.
+ * @param p the packet to handle
+ * @return #NetworkRecvStatus of handling.
+ */
+NetworkRecvStatus NetworkClientSocket::HandlePacket(Packet *p)
+{
+	PacketGameType type = (PacketGameType)p->Recv_uint8();
+
+	switch (this->HasClientQuit() ? PACKET_END : type) {
+		GAME_COMMAND(PACKET_SERVER_FULL)
+		GAME_COMMAND(PACKET_SERVER_BANNED)
+		GAME_COMMAND(PACKET_CLIENT_JOIN)
+		GAME_COMMAND(PACKET_SERVER_ERROR)
+		GAME_COMMAND(PACKET_CLIENT_COMPANY_INFO)
+		GAME_COMMAND(PACKET_SERVER_COMPANY_INFO)
+		GAME_COMMAND(PACKET_SERVER_CLIENT_INFO)
+		GAME_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD)
+		GAME_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD)
+		GAME_COMMAND(PACKET_CLIENT_GAME_PASSWORD)
+		GAME_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD)
+		GAME_COMMAND(PACKET_SERVER_WELCOME)
+		GAME_COMMAND(PACKET_CLIENT_GETMAP)
+		GAME_COMMAND(PACKET_SERVER_WAIT)
+		GAME_COMMAND(PACKET_SERVER_MAP)
+		GAME_COMMAND(PACKET_CLIENT_MAP_OK)
+		GAME_COMMAND(PACKET_SERVER_JOIN)
+		GAME_COMMAND(PACKET_SERVER_FRAME)
+		GAME_COMMAND(PACKET_SERVER_SYNC)
+		GAME_COMMAND(PACKET_CLIENT_ACK)
+		GAME_COMMAND(PACKET_CLIENT_COMMAND)
+		GAME_COMMAND(PACKET_SERVER_COMMAND)
+		GAME_COMMAND(PACKET_CLIENT_CHAT)
+		GAME_COMMAND(PACKET_SERVER_CHAT)
+		GAME_COMMAND(PACKET_CLIENT_SET_PASSWORD)
+		GAME_COMMAND(PACKET_CLIENT_SET_NAME)
+		GAME_COMMAND(PACKET_CLIENT_QUIT)
+		GAME_COMMAND(PACKET_CLIENT_ERROR)
+		GAME_COMMAND(PACKET_SERVER_QUIT)
+		GAME_COMMAND(PACKET_SERVER_ERROR_QUIT)
+		GAME_COMMAND(PACKET_SERVER_SHUTDOWN)
+		GAME_COMMAND(PACKET_SERVER_NEWGAME)
+		GAME_COMMAND(PACKET_SERVER_RCON)
+		GAME_COMMAND(PACKET_CLIENT_RCON)
+		GAME_COMMAND(PACKET_SERVER_CHECK_NEWGRFS)
+		GAME_COMMAND(PACKET_CLIENT_NEWGRFS_CHECKED)
+		GAME_COMMAND(PACKET_SERVER_MOVE)
+		GAME_COMMAND(PACKET_CLIENT_MOVE)
+		GAME_COMMAND(PACKET_SERVER_COMPANY_UPDATE)
+		GAME_COMMAND(PACKET_SERVER_CONFIG_UPDATE)
+
+		default:
+			this->CloseConnection();
+
+			if (this->HasClientQuit()) {
+				DEBUG(net, 0, "[tcp/game] received invalid packet type %d from client %d", type, this->client_id);
+			} else {
+				DEBUG(net, 0, "[tcp/game] received illegal packet from client %d", this->client_id);
+			}
+			return NETWORK_RECV_STATUS_MALFORMED_PACKET;
+	}
+}
+
+/**
+ * Do the actual receiving of packets.
+ * As long as HandlePacket returns OKAY packets are handled. Upon
+ * failure, or no more packets to process the last result of
+ * HandlePacket is returned.
+ * @return #NetworkRecvStatus of the last handled packet.
+ */
+NetworkRecvStatus NetworkClientSocket::Recv_Packets()
+{
+	Packet *p;
+	while ((p = this->Recv_Packet()) != NULL) {
+		NetworkRecvStatus res = HandlePacket(p);
+		if (res != NETWORK_RECV_STATUS_OKAY) return res;
+	}
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+/**
+ * Create stub implementations for all receive commands that only
+ * show a warning that the given command is not available for the
+ * socket where the packet came from.
+ * @param type the packet type to create the stub for
+ */
+#define DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(type) \
+NetworkRecvStatus NetworkClientSocket::NetworkPacketReceive_## type ##_command(Packet *p) \
+{ \
+	DEBUG(net, 0, "[tcp/game] received illegal packet type %d from client %d", \
+			type, this->client_id); \
+	return NETWORK_RECV_STATUS_MALFORMED_PACKET; \
+}
+
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_FULL)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_BANNED)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_ERROR)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMPANY_INFO)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CLIENT_INFO)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_GAME_PASSWORD)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_WELCOME)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_WAIT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_MAP)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_MAP_OK)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_JOIN)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_FRAME)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_SYNC)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_ACK)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMMAND)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_CHAT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CHAT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_SET_PASSWORD)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_SET_NAME)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_QUIT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_ERROR)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_QUIT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_ERROR_QUIT)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_SHUTDOWN)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEWGAME)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_RCON)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_RCON)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CHECK_NEWGRFS)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_NEWGRFS_CHECKED)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_MOVE)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_MOVE)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMPANY_UPDATE)
+DEFINE_UNAVAILABLE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CONFIG_UPDATE)
+
 #endif /* ENABLE_NETWORK */
diff --git a/src/network/core/tcp_game.h b/src/network/core/tcp_game.h
index 77da6218c..f083396e8 100644
--- a/src/network/core/tcp_game.h
+++ b/src/network/core/tcp_game.h
@@ -27,7 +27,7 @@
  * it protects old clients from joining newer servers
  * (because SERVER_ERROR is the respond to a wrong revision)
  */
-enum TCPPacketType {
+enum PacketGameType {
 	PACKET_SERVER_FULL,
 	PACKET_SERVER_BANNED,
 	PACKET_CLIENT_JOIN,
@@ -113,12 +113,59 @@ typedef NetworkGameSocketHandler NetworkClientSocket;
 typedef Pool<NetworkClientSocket, ClientIndex, 8, MAX_CLIENT_SLOTS> NetworkClientSocketPool;
 extern NetworkClientSocketPool _networkclientsocket_pool;
 
+#define DECLARE_GAME_RECEIVE_COMMAND(type) virtual NetworkRecvStatus NetworkPacketReceive_## type ##_command(Packet *p)
+#define DEF_GAME_RECEIVE_COMMAND(cls, type) NetworkRecvStatus cls ##NetworkGameSocketHandler::NetworkPacketReceive_ ## type ## _command(Packet *p)
+
 /** Base socket handler for all TCP sockets */
 class NetworkGameSocketHandler : public NetworkClientSocketPool::PoolItem<&_networkclientsocket_pool>, public NetworkTCPSocketHandler {
 /* TODO: rewrite into a proper class */
 private:
 	NetworkClientInfo *info;  ///< Client info related to this socket
+
 protected:
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_FULL);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_BANNED);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_JOIN);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_ERROR);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMPANY_INFO);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CLIENT_INFO);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_GAME_PASSWORD);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_WELCOME);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_WAIT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_MAP);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_MAP_OK);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_JOIN);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_FRAME);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_SYNC);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_ACK);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMMAND);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_CHAT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CHAT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_SET_PASSWORD);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_SET_NAME);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_QUIT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_ERROR);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_QUIT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_ERROR_QUIT);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_SHUTDOWN);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_NEWGAME);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_RCON);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_RCON);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CHECK_NEWGRFS);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_NEWGRFS_CHECKED);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_MOVE);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_CLIENT_MOVE);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_COMPANY_UPDATE);
+	DECLARE_GAME_RECEIVE_COMMAND(PACKET_SERVER_CONFIG_UPDATE);
+
+	NetworkRecvStatus HandlePacket(Packet *p);
+
 	NetworkGameSocketHandler(SOCKET s);
 public:
 	ClientID client_id;       ///< Client identifier
@@ -137,6 +184,8 @@ public:
 	inline void SetInfo(NetworkClientInfo *info) { assert(info != NULL && this->info == NULL); this->info = info; }
 	inline NetworkClientInfo *GetInfo() const { return this->info; }
 
+	NetworkRecvStatus Recv_Packets();
+
 	const char *Recv_Command(Packet *p, CommandPacket *cp);
 	void Send_Command(Packet *p, const CommandPacket *cp);
 };