(svn r942) -Merged branch/network back into the trunk

1 files changed, 808 insertions, 0 deletions

diff --git a/network_client.c b/network_client.c
new file mode 100644
index 000000000..1c70e0a2a
--- /dev/null
+++ b/network_client.c
@@ -0,0 +1,808 @@
+#include "stdafx.h"
+#include "network_data.h"
+
+#ifdef ENABLE_NETWORK
+
+#include "table/strings.h"
+#include "network_client.h"
+#include "network_gamelist.h"
+#include "command.h"
+#include "gfx.h"
+#include "window.h"
+#include "settings.h"
+
+
+// This file handles all the client-commands
+
+
+// So we don't make too much typos ;)
+#define MY_CLIENT DEREF_CLIENT(0)
+
+static uint32 last_ack_frame;
+
+void NetworkRecvPatchSettings(Packet *p);
+
+// **********
+// Sending functions
+//   DEF_CLIENT_SEND_COMMAND has no parameters
+// **********
+
+DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_COMPANY_INFO)
+{
+	//
+	// Packet: CLIENT_COMPANY_INFO
+	// Function: Request company-info (in detail)
+	// Data:
+	//    <none>
+	//
+	Packet *p;
+	_network_join_status = NETWORK_JOIN_STATUS_GETTING_COMPANY_INFO;
+	InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+
+	p = NetworkSend_Init(PACKET_CLIENT_COMPANY_INFO);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_JOIN)
+{
+	//
+	// Packet: CLIENT_JOIN
+	// Function: Try to join the server
+	// Data:
+	//    String: OpenTTD Revision (norev000 if no revision)
+	//    String: Player Name (max NETWORK_NAME_LENGTH)
+	//    uint8:  Play as Player id (1..MAX_PLAYERS)
+	//    uint8:  Language ID
+	//
+
+#if defined(WITH_REV)
+		extern char _openttd_revision[];
+#else
+		const char _openttd_revision[] = "norev000";
+#endif
+	Packet *p;
+	_network_join_status = NETWORK_JOIN_STATUS_AUTHORIZING;
+	InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+
+	p = NetworkSend_Init(PACKET_CLIENT_JOIN);
+	NetworkSend_string(p, _openttd_revision);
+	NetworkSend_string(p, _network_player_name); // Player name
+	NetworkSend_uint8(p, _network_playas); // Password
+	NetworkSend_uint8(p, NETLANG_ANY); // Language
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_PASSWORD)(NetworkPasswordType type, const char *password)
+{
+	//
+	// Packet: CLIENT_PASSWORD
+	// Function: Send a password to the server to authorize
+	// Data:
+	//    uint8:  NetworkPasswordType
+	//    String: Password
+	//
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_PASSWORD);
+	NetworkSend_uint8(p, type);
+	NetworkSend_string(p, password);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_GETMAP)
+{
+	//
+	// Packet: CLIENT_GETMAP
+	// Function: Request the map from the server
+	// Data:
+	//    <none>
+	//
+
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_GETMAP);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_MAP_OK)
+{
+	//
+	// Packet: CLIENT_MAP_OK
+	// Function: Tell the server that we are done receiving/loading the map
+	// Data:
+	//    <none>
+	//
+
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_MAP_OK);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_ACK)
+{
+	//
+	// Packet: CLIENT_ACK
+	// Function: Tell the server we are done with this frame
+	// Data:
+	//    uint32: current FrameCounter of the client
+	//
+
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_ACK);
+
+	NetworkSend_uint32(p, _frame_counter);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+// Send a command packet to the server
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_COMMAND)(CommandPacket *cp)
+{
+	//
+	// Packet: CLIENT_COMMAND
+	// Function: Send a DoCommand to the Server
+	// Data:
+	//    uint8:  PlayerID (0..MAX_PLAYERS-1)
+	//    uint32: CommandID (see command.h)
+	//    uint32: P1 (free variables used in DoCommand)
+	//    uint32: P2
+	//    uint32: Tile
+	//    uint32: decode_params
+	//      10 times the last one (lengthof(cp->dp))
+	//    uint8:  CallBackID (see callback_table.c)
+	//
+
+	int i;
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_COMMAND);
+
+	NetworkSend_uint8(p, cp->player);
+	NetworkSend_uint32(p, cp->cmd);
+	NetworkSend_uint32(p, cp->p1);
+	NetworkSend_uint32(p, cp->p2);
+	NetworkSend_uint32(p, (uint32)cp->tile);
+	for (i = 0; i < lengthof(cp->dp); i++) {
+		NetworkSend_uint32(p, cp->dp[i]);
+	}
+	NetworkSend_uint8(p, cp->callback);
+
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+// Send a chat-packet over the network
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_CHAT)(NetworkAction action, DestType desttype, int dest, const char *msg)
+{
+	//
+	// Packet: CLIENT_CHAT
+	// Function: Send a chat-packet to the serve
+	// Data:
+	//    uint8:  ActionID (see network_data.h, NetworkAction)
+	//    uint8:  Destination Type (see network_data.h, DestType);
+	//    uint8:  Destination Player (1..MAX_PLAYERS)
+	//    String: Message (max MAX_TEXT_MSG_LEN)
+	//
+
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_CHAT);
+
+	NetworkSend_uint8(p, action);
+	NetworkSend_uint8(p, desttype);
+	NetworkSend_uint8(p, dest);
+	NetworkSend_string(p, msg);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+// Send an error-packet over the network
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_ERROR)(NetworkErrorCode errorno)
+{
+	//
+	// Packet: CLIENT_ERROR
+	// Function: The client made an error and is quiting the game
+	// Data:
+	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)
+	//
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_ERROR);
+
+	NetworkSend_uint8(p, errorno);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_PASSWORD)(const char *password)
+{
+	//
+	// Packet: PACKET_CLIENT_SET_PASSWORD
+	// Function: Set the password for the clients current company
+	// Data:
+	//    String: Password
+	//
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_SET_PASSWORD);
+
+	NetworkSend_string(p, password);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_NAME)(const char *name)
+{
+	//
+	// Packet: PACKET_CLIENT_SET_NAME
+	// Function: Gives the player a new name
+	// Data:
+	//    String: Name
+	//
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_SET_NAME);
+
+	NetworkSend_string(p, name);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+// Send an quit-packet over the network
+DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_QUIT)(const char *leavemsg)
+{
+	//
+	// Packet: CLIENT_QUIT
+	// Function: The client is quiting the game
+	// Data:
+	//    String: leave-message
+	//
+	Packet *p = NetworkSend_Init(PACKET_CLIENT_QUIT);
+
+	NetworkSend_string(p, leavemsg);
+	NetworkSend_Packet(p, MY_CLIENT);
+}
+
+
+// **********
+// Receiving functions
+//   DEF_CLIENT_RECEIVE_COMMAND has parameter: Packet *p
+// **********
+
+extern bool SafeSaveOrLoad(const char *filename, int mode, int newgm);
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_FULL)
+{
+	// We try to join a server which is full
+	_switch_mode_errorstr = STR_NETWORK_ERR_SERVER_FULL;
+	DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
+
+	return NETWORK_RECV_STATUS_SERVER_FULL;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_COMPANY_INFO)
+{
+	byte company_info_version;
+	int i;
+
+	company_info_version = NetworkRecv_uint8(p);
+
+	if (company_info_version == 1) {
+		byte total;
+		byte current;
+
+		total = NetworkRecv_uint8(p);
+		_network_lobby_company_count = total;
+
+		// There is no data at all..
+		if (total == 0)
+			return NETWORK_RECV_STATUS_CLOSE_QUERY;
+
+		current = NetworkRecv_uint8(p) - 1;
+		if (current >= MAX_PLAYERS)
+			return NETWORK_RECV_STATUS_CLOSE_QUERY;
+
+		NetworkRecv_string(p, _network_player_info[current].company_name, sizeof(_network_player_info[current].company_name));
+		_network_player_info[current].inaugurated_year = NetworkRecv_uint8(p);
+		_network_player_info[current].company_value = NetworkRecv_uint64(p);
+		_network_player_info[current].money = NetworkRecv_uint64(p);
+		_network_player_info[current].income = NetworkRecv_uint64(p);
+		_network_player_info[current].performance = NetworkRecv_uint16(p);
+		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++)
+			_network_player_info[current].num_vehicle[i] = NetworkRecv_uint16(p);
+		for (i = 0; i < NETWORK_STATION_TYPES; i++)
+			_network_player_info[current].num_station[i] = NetworkRecv_uint16(p);
+
+		NetworkRecv_string(p, _network_player_info[current].players, sizeof(_network_player_info[current].players));
+
+		InvalidateWindow(WC_NETWORK_WINDOW, 0);
+
+		if (total == current + 1)
+			// This was the last one
+			return NETWORK_RECV_STATUS_CLOSE_QUERY;
+		else
+			return NETWORK_RECV_STATUS_OKAY;
+	}
+
+	return NETWORK_RECV_STATUS_CLOSE_QUERY;
+}
+
+// This packet contains info about the client (playas and name)
+//  as client we save this in NetworkClientInfo, linked via 'index'
+//  which is always an unique number on a server.
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_CLIENT_INFO)
+{
+	NetworkClientInfo *ci;
+	uint16 index = NetworkRecv_uint16(p);
+
+	ci = NetworkFindClientInfoFromIndex(index);
+	if (ci != NULL) {
+		byte playas;
+		char name[NETWORK_NAME_LENGTH];
+
+		playas = NetworkRecv_uint8(p);
+		NetworkRecv_string(p, name, sizeof(name));
+
+		if (playas == ci->client_playas && strcmp(name, ci->client_name) != 0) {
+			// Client name changed, display the change
+			NetworkTextMessage(NETWORK_ACTION_NAME_CHANGE, 1, ci->client_name, name);
+		} else if (playas != ci->client_playas) {
+			// The player changed from client-player..
+			// Do not display that for now
+		}
+
+		ci->client_playas = playas;
+		ttd_strlcpy(ci->client_name, name, sizeof(ci->client_name));
+		return NETWORK_RECV_STATUS_OKAY;
+	}
+
+	// We don't have this index yet, find an empty index, and put the data there
+	ci = NetworkFindClientInfoFromIndex(NETWORK_EMPTY_INDEX);
+	if (ci != NULL) {
+		ci->client_index = index;
+		ci->client_playas = NetworkRecv_uint8(p);
+		NetworkRecv_string(p, ci->client_name, sizeof(ci->client_name));
+		return NETWORK_RECV_STATUS_OKAY;
+	}
+
+	// Here the program should never ever come.....
+	return NETWORK_RECV_STATUS_MALFORMED_PACKET;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_ERROR)
+{
+	NetworkErrorCode error = NetworkRecv_uint8(p);
+
+	if (error == NETWORK_ERROR_NOT_AUTHORIZED || error == NETWORK_ERROR_NOT_EXPECTED ||
+			error == NETWORK_ERROR_PLAYER_MISMATCH) {
+		// We made an error in the protocol, and our connection is closed.... :(
+		_switch_mode_errorstr = STR_NETWORK_ERR_SERVER_ERROR;
+	} else if (error == NETWORK_ERROR_WRONG_REVISION) {
+		// Wrong revision :(
+		_switch_mode_errorstr = STR_NETWORK_ERR_WRONG_REVISION;
+	} else if (error == NETWORK_ERROR_WRONG_PASSWORD) {
+		// Wrong password
+		_switch_mode_errorstr = STR_NETWORK_ERR_WRONG_PASSWORD;
+	} else if (error == NETWORK_ERROR_KICKED) {
+		_switch_mode_errorstr = STR_NETWORK_ERR_KICKED;
+	}
+
+	DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
+
+	return NETWORK_RECV_STATUS_SERVER_ERROR;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_NEED_PASSWORD)
+{
+	NetworkPasswordType type;
+	type = NetworkRecv_uint8(p);
+
+	if (type == NETWORK_GAME_PASSWORD) {
+		ShowNetworkNeedGamePassword();
+		return NETWORK_RECV_STATUS_OKAY;
+	} else if (type == NETWORK_COMPANY_PASSWORD) {
+		ShowNetworkNeedCompanyPassword();
+		return NETWORK_RECV_STATUS_OKAY;
+	}
+
+	return NETWORK_RECV_STATUS_MALFORMED_PACKET;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_WELCOME)
+{
+	_network_own_client_index = NetworkRecv_uint16(p);
+
+	// Start receiving the map
+	SEND_COMMAND(PACKET_CLIENT_GETMAP)();
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_WAIT)
+{
+	_network_join_status = NETWORK_JOIN_STATUS_WAITING;
+	_network_join_waiting = NetworkRecv_uint8(p);
+	InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+
+	// We are put on hold for receiving the map.. we need GUI for this ;)
+	DEBUG(net, 1)("[NET] The server is currently busy sending the map to someone else.. please hold..." );
+	DEBUG(net, 1)("[NET]  There are %d clients in front of you", _network_join_waiting);
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_MAP)
+{
+	static char filename[256];
+	static FILE *file_pointer;
+
+	byte maptype;
+
+	maptype = NetworkRecv_uint8(p);
+
+	// First packet, init some stuff
+	if (maptype == MAP_PACKET_START) {
+		// The name for the temp-map
+		sprintf(filename, "%s%snetwork_client.tmp",  _path.autosave_dir, PATHSEP);
+
+		file_pointer = fopen(filename, "wb");
+		if (file_pointer == NULL) {
+			_switch_mode_errorstr = STR_NETWORK_ERR_SAVEGAMEERROR;
+			return NETWORK_RECV_STATUS_SAVEGAME;
+		}
+
+		_frame_counter = _frame_counter_server = _frame_counter_max = NetworkRecv_uint32(p);
+
+		_network_join_status = NETWORK_JOIN_STATUS_DOWNLOADING;
+		_network_join_kbytes = 0;
+		_network_join_kbytes_total = NetworkRecv_uint32(p) / 1024;
+		InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+
+		// The first packet does not contain any more data
+		return NETWORK_RECV_STATUS_OKAY;
+	}
+
+	if (maptype == MAP_PACKET_NORMAL) {
+		// We are still receiving data, put it to the file
+		fwrite(p->buffer + p->pos, 1, p->size - p->pos, file_pointer);
+
+		_network_join_kbytes = ftell(file_pointer) / 1024;
+		InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+	}
+
+	if (maptype == MAP_PACKET_PATCH) {
+		NetworkRecvPatchSettings(p);
+	}
+
+	// Check if this was the last packet
+	if (maptype == MAP_PACKET_END) {
+		// We also get, very nice, the player_seeds in this packet
+		int i;
+		for (i = 0; i < MAX_PLAYERS; i++) {
+			_player_seeds[i][0] = NetworkRecv_uint32(p);
+			_player_seeds[i][1] = NetworkRecv_uint32(p);
+		}
+
+		fclose(file_pointer);
+
+		_network_join_status = NETWORK_JOIN_STATUS_PROCESSING;
+		InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
+
+		// The map is done downloading, load it
+		// Load the map
+		if (!SafeSaveOrLoad(filename, SL_LOAD, GM_NORMAL)) {
+			DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
+			_switch_mode_errorstr = STR_NETWORK_ERR_SAVEGAMEERROR;
+			return NETWORK_RECV_STATUS_SAVEGAME;
+		}
+		_opt_mod_ptr = &_opt;
+
+		DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
+
+		// Say we received the map and loaded it correctly!
+		SEND_COMMAND(PACKET_CLIENT_MAP_OK)();
+
+		if (_network_playas == 0 || _network_playas > MAX_PLAYERS ||
+				!DEREF_PLAYER(_network_playas - 1)->is_active) {
+
+			if (_network_playas == OWNER_SPECTATOR) {
+				// The client wants to be a spectator..
+				_local_player = OWNER_SPECTATOR;
+			} else {
+				// send a command to make a new player
+				_local_player = 0;
+				NetworkSend_Command(0, 0, 0, CMD_PLAYER_CTRL, NULL);
+				_local_player = OWNER_SPECTATOR;
+			}
+		} else {
+			// take control over an existing company
+			_local_player = _network_playas - 1;
+		}
+
+		// Remeber the player
+		if (_local_player != OWNER_SPECTATOR)
+			_network_playas = _local_player + 1;
+		else
+			_network_playas = OWNER_SPECTATOR;
+	}
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_FRAME)
+{
+	_frame_counter_server = NetworkRecv_uint32(p);
+	_frame_counter_max = NetworkRecv_uint32(p);
+#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME
+	// Test if the server supports this option
+	//  and if we are at the frame the server is
+	if (p->pos < p->size) {
+		_sync_frame = _frame_counter_server;
+		_sync_seed_1 = NetworkRecv_uint32(p);
+#ifdef NETWORK_SEND_DOUBLE_SEED
+		_sync_seed_2 = NetworkRecv_uint32(p);
+#endif
+	}
+#endif
+	DEBUG(net, 7)("[NET] Received FRAME %d",_frame_counter_server);
+
+	// Let the server know that we received this frame correctly
+	//  We do this only once per day, to save some bandwidth ;)
+	if (!_network_first_time && last_ack_frame < _frame_counter) {
+		last_ack_frame = _frame_counter + DAY_TICKS;
+		DEBUG(net,6)("[NET] Sent ACK at %d", _frame_counter);
+		SEND_COMMAND(PACKET_CLIENT_ACK)();
+	}
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_SYNC)
+{
+	_sync_frame = NetworkRecv_uint32(p);
+	_sync_seed_1 = NetworkRecv_uint32(p);
+#ifdef NETWORK_SEND_DOUBLE_SEED
+	_sync_seed_2 = NetworkRecv_uint32(p);
+#endif
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_COMMAND)
+{
+	int i;
+	CommandPacket *cp = malloc(sizeof(CommandPacket));
+	cp->player = NetworkRecv_uint8(p);
+	cp->cmd = NetworkRecv_uint32(p);
+	cp->p1 = NetworkRecv_uint32(p);
+	cp->p2 = NetworkRecv_uint32(p);
+	cp->tile = NetworkRecv_uint32(p);
+	for (i = 0; i < lengthof(cp->dp); i++)
+		cp->dp[i] = NetworkRecv_uint32(p);
+	cp->callback = NetworkRecv_uint8(p);
+	cp->frame = NetworkRecv_uint32(p);
+	cp->next = NULL;
+
+	// The server did send us this command..
+	//  queue it in our own queue, so we can handle it in the upcoming frame!
+
+	if (_local_command_queue == NULL) {
+		_local_command_queue = cp;
+	} else {
+		// Find last packet
+		CommandPacket *c = _local_command_queue;
+		while (c->next != NULL) c = c->next;
+		c->next = cp;
+	}
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_CHAT)
+{
+	NetworkAction action = NetworkRecv_uint8(p);
+	char msg[MAX_TEXT_MSG_LEN];
+	NetworkClientInfo *ci, *ci_to;
+	uint16 index;
+	char name[NETWORK_NAME_LENGTH];
+
+	index = NetworkRecv_uint16(p);
+	NetworkRecv_string(p, msg, MAX_TEXT_MSG_LEN);
+
+	ci_to = NetworkFindClientInfoFromIndex(index);
+	if (ci_to == NULL) return NETWORK_RECV_STATUS_OKAY;
+
+	if (action == NETWORK_ACTION_CHAT_TO_CLIENT) {
+		snprintf(name, 80, "%s", ci_to->client_name);
+		ci = NetworkFindClientInfoFromIndex(_network_own_client_index);
+	} else if (action == NETWORK_ACTION_CHAT_TO_PLAYER) {
+		GetString(name, DEREF_PLAYER(ci_to->client_playas-1)->name_1);
+		ci = NetworkFindClientInfoFromIndex(_network_own_client_index);
+	} else {
+		snprintf(name, 80, "%s", ci_to->client_name);
+		ci = ci_to;
+	}
+
+	if (ci != NULL)
+		NetworkTextMessage(action, GetDrawStringPlayerColor(ci->client_playas-1), name, "%s", msg);
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_ERROR_QUIT)
+{
+	int errorno;
+	char str1[100], str2[100];
+	uint16 index;
+	NetworkClientInfo *ci;
+
+	index = NetworkRecv_uint16(p);
+	errorno = NetworkRecv_uint8(p);
+
+	GetString(str1, STR_NETWORK_ERR_LEFT);
+	GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + errorno);
+
+	ci = NetworkFindClientInfoFromIndex(index);
+	if (ci != NULL) {
+		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, ci->client_name, "%s (%s)", str1, str2);
+
+		// The client is gone, give the NetworkClientInfo free
+		ci->client_index = NETWORK_EMPTY_INDEX;
+	}
+
+	InvalidateWindow(WC_CLIENT_LIST, 0);
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_QUIT)
+{
+	char str1[100], str2[100];
+	uint16 index;
+	NetworkClientInfo *ci;
+
+	index = NetworkRecv_uint16(p);
+	NetworkRecv_string(p, str2, 100);
+
+	GetString(str1, STR_NETWORK_ERR_LEFT);
+
+	ci = NetworkFindClientInfoFromIndex(index);
+	if (ci != NULL) {
+		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, ci->client_name, "%s (%s)", str1, str2);
+
+		// The client is gone, give the NetworkClientInfo free
+		ci->client_index = NETWORK_EMPTY_INDEX;
+	} else {
+		DEBUG(net, 0)("[NET] Error - unknown client (%d) is leaving the game", index);
+	}
+
+	InvalidateWindow(WC_CLIENT_LIST, 0);
+
+	// If we come here it means we could not locate the client.. strange :s
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_JOIN)
+{
+	char str1[100];
+	uint16 index;
+	NetworkClientInfo *ci;
+
+	index = NetworkRecv_uint16(p);
+
+	GetString(str1, STR_NETWORK_CLIENT_JOINED);
+
+	ci = NetworkFindClientInfoFromIndex(index);
+	if (ci != NULL) {
+		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, ci->client_name, "%s", str1);
+	}
+
+	InvalidateWindow(WC_CLIENT_LIST, 0);
+
+	return NETWORK_RECV_STATUS_OKAY;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_SHUTDOWN)
+{
+	_switch_mode_errorstr = STR_NETWORK_SERVER_SHUTDOWN;
+
+	return NETWORK_RECV_STATUS_SERVER_ERROR;
+}
+
+DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_NEWGAME)
+{
+	// To trottle the reconnects a bit, every clients waits
+	//  his _local_player value before reconnecting
+	// OWNER_SPECTATOR is currently 255, so to avoid long wait periods
+	//  set the max to 10.
+	_network_reconnect = min(_local_player + 1, 10);
+	_switch_mode_errorstr = STR_NETWORK_SERVER_REBOOT;
+
+	return NETWORK_RECV_STATUS_SERVER_ERROR;
+}
+
+
+
+
+// The layout for the receive-functions by the client
+typedef NetworkRecvStatus NetworkClientPacket(Packet *p);
+
+// This array matches PacketType. At an incoming
+//  packet it is matches against this array
+//  and that way the right function to handle that
+//  packet is found.
+static NetworkClientPacket* const _network_client_packet[] = {
+	RECEIVE_COMMAND(PACKET_SERVER_FULL),
+	NULL, /*PACKET_CLIENT_JOIN,*/
+	RECEIVE_COMMAND(PACKET_SERVER_ERROR),
+	NULL, /*PACKET_CLIENT_COMPANY_INFO,*/
+	RECEIVE_COMMAND(PACKET_SERVER_COMPANY_INFO),
+	RECEIVE_COMMAND(PACKET_SERVER_CLIENT_INFO),
+	RECEIVE_COMMAND(PACKET_SERVER_NEED_PASSWORD),
+	NULL, /*PACKET_CLIENT_PASSWORD,*/
+	RECEIVE_COMMAND(PACKET_SERVER_WELCOME),
+	NULL, /*PACKET_CLIENT_GETMAP,*/
+	RECEIVE_COMMAND(PACKET_SERVER_WAIT),
+	RECEIVE_COMMAND(PACKET_SERVER_MAP),
+	NULL, /*PACKET_CLIENT_MAP_OK,*/
+	RECEIVE_COMMAND(PACKET_SERVER_JOIN),
+	RECEIVE_COMMAND(PACKET_SERVER_FRAME),
+	RECEIVE_COMMAND(PACKET_SERVER_SYNC),
+	NULL, /*PACKET_CLIENT_ACK,*/
+	NULL, /*PACKET_CLIENT_COMMAND,*/
+	RECEIVE_COMMAND(PACKET_SERVER_COMMAND),
+	NULL, /*PACKET_CLIENT_CHAT,*/
+	RECEIVE_COMMAND(PACKET_SERVER_CHAT),
+	NULL, /*PACKET_CLIENT_SET_PASSWORD,*/
+	NULL, /*PACKET_CLIENT_SET_NAME,*/
+	NULL, /*PACKET_CLIENT_QUIT,*/
+	NULL, /*PACKET_CLIENT_ERROR,*/
+	RECEIVE_COMMAND(PACKET_SERVER_QUIT),
+	RECEIVE_COMMAND(PACKET_SERVER_ERROR_QUIT),
+	RECEIVE_COMMAND(PACKET_SERVER_SHUTDOWN),
+	RECEIVE_COMMAND(PACKET_SERVER_NEWGAME),
+};
+
+// If this fails, check the array above with network_data.h
+assert_compile(lengthof(_network_client_packet) == PACKET_END);
+
+extern const SettingDesc patch_settings[];
+
+// This is a TEMPORARY solution to get the patch-settings
+//  to the client. When the patch-settings are saved in the savegame
+//  this should be removed!!
+void NetworkRecvPatchSettings(Packet *p)
+{
+	const SettingDesc *item;
+
+	item = patch_settings;
+
+	while (item->name != NULL) {
+		switch (item->flags) {
+			case SDT_BOOL:
+			case SDT_INT8:
+			case SDT_UINT8:
+				*(uint8 *)(item->ptr) = NetworkRecv_uint8(p);
+				break;
+			case SDT_INT16:
+			case SDT_UINT16:
+				*(uint16 *)(item->ptr) = NetworkRecv_uint16(p);
+				break;
+			case SDT_INT32:
+			case SDT_UINT32:
+				*(uint32 *)(item->ptr) = NetworkRecv_uint32(p);
+				break;
+		}
+		item++;
+	}
+}
+
+// Is called after a client is connected to the server
+void NetworkClient_Connected(void)
+{
+	// Set the frame-counter to 0 so nothing happens till we are ready
+	_frame_counter = 0;
+	_frame_counter_server = 0;
+	last_ack_frame = 0;
+	// Request the game-info
+	SEND_COMMAND(PACKET_CLIENT_JOIN)();
+}
+
+// Reads the packets from the socket-stream, if available
+NetworkRecvStatus NetworkClient_ReadPackets(ClientState *cs)
+{
+	Packet *p;
+	NetworkRecvStatus res = NETWORK_RECV_STATUS_OKAY;
+
+	while (res == NETWORK_RECV_STATUS_OKAY && (p = NetworkRecv_Packet(cs, &res)) != NULL) {
+		byte type = NetworkRecv_uint8(p);
+		if (type < PACKET_END && _network_client_packet[type] != NULL) {
+			res = _network_client_packet[type](p);
+		}	else {
+			res = NETWORK_RECV_STATUS_MALFORMED_PACKET;
+			DEBUG(net, 0)("[NET][client] Received invalid packet type %d", type);
+		}
+
+		free(p);
+	}
+
+	return res;
+}
+
+#endif /* ENABLE_NETWORK */