/* $Id$ */

#ifdef ENABLE_NETWORK

#include "../stdafx.h"

#include "../openttd.h" // XXX StringID

#include "../debug.h"

#include "../string.h"

#include "../strings.h"

#include "network_data.h"

#include "core/tcp.h"

#include "../train.h"

#include "../date.h"

#include "table/strings.h"

#include "../functions.h"

#include "network_server.h"

#include "network_udp.h"

#include "../console.h"

#include "../command.h"

#include "../saveload.h"

#include "../vehicle.h"

#include "../station.h"

#include "../variables.h"

#include "../genworld.h"

// This file handles all the server-commands

static void NetworkHandleCommandQueue(NetworkClientState* cs);

// **********

// Sending functions

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

// **********

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CLIENT_INFO)(NetworkClientState *cs, NetworkClientInfo *ci)

{

	//

	// Packet: SERVER_CLIENT_INFO

	// Function: Sends info about a client

	// Data:

	//    uint16:  The index of the client (always unique on a server. 1 = server)

	//    uint8:  As which player the client is playing

	//    String: The name of the client

	//    String: The unique id of the client

	//

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

		Packet *p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

		NetworkSend_uint16(p, ci->client_index);

		NetworkSend_uint8 (p, ci->client_playas);

		NetworkSend_string(p, ci->client_name);

		NetworkSend_string(p, ci->unique_id);

		NetworkSend_Packet(p, cs);

	}

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

{

//

	// Packet: SERVER_COMPANY_INFO

	// Function: Sends info about the companies

	// Data:

	//

	int i;

	Player *player;

	Packet *p;

	byte active = ActivePlayerCount();

	if (active == 0) {

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

		NetworkSend_uint8 (p, active);

		NetworkSend_Packet(p, cs);

		return;

	}

	NetworkPopulateCompanyInfo();

	FOR_ALL_PLAYERS(player) {

		if (!player->is_active) continue;

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

		NetworkSend_uint8 (p, active);

		NetworkSend_uint8 (p, player->index);

		NetworkSend_string(p, _network_player_info[player->index].company_name);

		NetworkSend_uint32(p, _network_player_info[player->index].inaugurated_year);

		NetworkSend_uint64(p, _network_player_info[player->index].company_value);

		NetworkSend_uint64(p, _network_player_info[player->index].money);

		NetworkSend_uint64(p, _network_player_info[player->index].income);

		NetworkSend_uint16(p, _network_player_info[player->index].performance);

		/* Send 1 if there is a passord for the company else send 0 */

		if (_network_player_info[player->index].password[0] != '\0') {

			NetworkSend_uint8(p, 1);

		} else {

			NetworkSend_uint8(p, 0);

		}

		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++) {

			NetworkSend_uint16(p, _network_player_info[player->index].num_vehicle[i]);

		}

		for (i = 0; i < NETWORK_STATION_TYPES; i++) {

			NetworkSend_uint16(p, _network_player_info[player->index].num_station[i]);

		}

		if (_network_player_info[player->index].players[0] == '\0') {

			NetworkSend_string(p, "<none>");

		} else {

			NetworkSend_string(p, _network_player_info[player->index].players);

		}

		NetworkSend_Packet(p, cs);

	}

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

	NetworkSend_uint8 (p, 0);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(NetworkClientState *cs, NetworkErrorCode error)

{

	//

	// Packet: SERVER_ERROR

	// Function: The client made an error

	// Data:

	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)

	//

	char str[100];

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

	NetworkSend_uint8(p, error);

	NetworkSend_Packet(p, cs);

	GetNetworkErrorMsg(str, error, lastof(str));

	// Only send when the current client was in game

	if (cs->status > STATUS_AUTH) {

		NetworkClientState *new_cs;

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

		NetworkGetClientName(client_name, sizeof(client_name), cs);

		DEBUG(net, 1, "'%s' made an error and has been disconnected. Reason: '%s'", client_name, str);

		NetworkTextMessage(NETWORK_ACTION_LEAVE, 1, false, client_name, "%s", str);

		FOR_ALL_CLIENTS(new_cs) {

			if (new_cs->status > STATUS_AUTH && new_cs != cs) {

				// Some errors we filter to a more general error. Clients don't have to know the real

				//  reason a joining failed.

				if (error == NETWORK_ERROR_NOT_AUTHORIZED || error == NETWORK_ERROR_NOT_EXPECTED || error == NETWORK_ERROR_WRONG_REVISION)

					error = NETWORK_ERROR_ILLEGAL_PACKET;

				SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->index, error);

			}

		}

	} else {

		DEBUG(net, 1, "Client %d made an error and has been disconnected. Reason: '%s'", cs->index, str);

	}

	cs->has_quit = true;

	// Make sure the data get's there before we close the connection

	NetworkSend_Packets(cs);

	// The client made a mistake, so drop his connection now!

	NetworkCloseClient(cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_PASSWORD)(NetworkClientState *cs, NetworkPasswordType type)

{

	//

	// Packet: SERVER_NEED_PASSWORD

	// Function: Indication to the client that the server needs a password

	// Data:

	//    uint8:  Type of password

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

	NetworkSend_uint8(p, type);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

{

	//

	// Packet: SERVER_WELCOME

	// Function: The client is joined and ready to receive his map

	// Data:

	//    uint16:  Own ClientID

	//

	Packet *p;

	const NetworkClientState *new_cs;

	// Invalid packet when status is AUTH or higher

	if (cs->status >= STATUS_AUTH) return;

	cs->status = STATUS_AUTH;

	_network_game_info.clients_on++;

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

	NetworkSend_uint16(p, cs->index);

	NetworkSend_Packet(p, cs);

		// Transmit info about all the active clients

	FOR_ALL_CLIENTS(new_cs) {

		if (new_cs != cs && new_cs->status > STATUS_AUTH)

			SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, DEREF_CLIENT_INFO(new_cs));

	}

	// Also send the info of the server

	SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX));

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

{

	//

	// Packet: PACKET_SERVER_WAIT

	// Function: The client can not receive the map at the moment because

	//             someone else is already receiving the map

	// Data:

	//    uint8:  Clients awaiting map

	//

	int waiting = 0;

	NetworkClientState *new_cs;

	Packet *p;

	// Count how many players are waiting in the queue

	FOR_ALL_CLIENTS(new_cs) {

		if (new_cs->status == STATUS_MAP_WAIT) waiting++;

	}

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

	NetworkSend_uint8(p, waiting);

	NetworkSend_Packet(p, cs);

}

// This sends the map to the client

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

{

	//

	// Packet: SERVER_MAP

	// Function: Sends the map to the client, or a part of it (it is splitted in

	//   a lot of multiple packets)

	// Data:

	//    uint8:  packet-type (MAP_PACKET_START, MAP_PACKET_NORMAL and MAP_PACKET_END)

	//  if MAP_PACKET_START:

	//    uint32: The current FrameCounter

	//  if MAP_PACKET_NORMAL:

	//    piece of the map (till max-size of packet)

	//  if MAP_PACKET_END:

	//    uint32: seed0 of player

	//    uint32: seed1 of player

	//      last 2 are repeated MAX_PLAYERS time

	//

	static FILE *file_pointer;

	static uint sent_packets; // How many packets we did send succecfully last time

	if (cs->status < STATUS_AUTH) {

		// Illegal call, return error and ignore the packet

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

		return;

	}

	if (cs->status == STATUS_AUTH) {

		char filename[256];

		Packet *p;

		// Make a dump of the current game

		snprintf(filename, lengthof(filename), "%s%snetwork_server.tmp",  _paths.autosave_dir, PATHSEP);

		if (SaveOrLoad(filename, SL_SAVE) != SL_OK) error("network savedump failed");

		file_pointer = fopen(filename, "rb");

		fseek(file_pointer, 0, SEEK_END);

		// Now send the _frame_counter and how many packets are coming

		p = NetworkSend_Init(PACKET_SERVER_MAP);

		NetworkSend_uint8(p, MAP_PACKET_START);

		NetworkSend_uint32(p, _frame_counter);

		NetworkSend_uint32(p, ftell(file_pointer));

		NetworkSend_Packet(p, cs);

		fseek(file_pointer, 0, SEEK_SET);

		sent_packets = 4; // We start with trying 4 packets

		cs->status = STATUS_MAP;

		/* Mark the start of download */

		cs->last_frame = _frame_counter;

		cs->last_frame_server = _frame_counter;

	}

	if (cs->status == STATUS_MAP) {

		uint i;

		int res;

		for (i = 0; i < sent_packets; i++) {

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

			res = (int)fread(p->buffer + p->size, 1, SEND_MTU - p->size, file_pointer);

			if (ferror(file_pointer)) error("Error reading temporary network savegame!");

			p->size += res;

			NetworkSend_Packet(p, cs);

			if (feof(file_pointer)) {

				// Done reading!

				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

				NetworkSend_uint8(p, MAP_PACKET_END);

				NetworkSend_Packet(p, cs);

				// Set the status to DONE_MAP, no we will wait for the client

				//  to send it is ready (maybe that happens like never ;))

				cs->status = STATUS_DONE_MAP;

				fclose(file_pointer);

				{

					NetworkClientState *new_cs;

					bool new_map_client = false;

					// Check if there is a client waiting for receiving the map

					//  and start sending him the map

					FOR_ALL_CLIENTS(new_cs) {

						if (new_cs->status == STATUS_MAP_WAIT) {

							// Check if we already have a new client to send the map to

							if (!new_map_client) {

								// If not, this client will get the map

								new_cs->status = STATUS_AUTH;

								new_map_client = true;

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

							} else {

								// Else, send the other clients how many clients are in front of them

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

							}

						}

					}

				}

				// There is no more data, so break the for

				break;

			}

		}

		// Send all packets (forced) and check if we have send it all

		NetworkSend_Packets(cs);

		if (cs->packet_queue == NULL) {

			// All are sent, increase the sent_packets

			sent_packets *= 2;

		} else {

			// Not everything is sent, decrease the sent_packets

			if (sent_packets > 1) sent_packets /= 2;

		}

	}

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_JOIN)(NetworkClientState *cs, uint16 client_index)

{

	//

	// Packet: SERVER_JOIN

	// Function: A client is joined (all active clients receive this after a

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

	//     PACKET_SERVER_CLIENT_INFO

	// Data:

	//    uint16:  Client-Index

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

	NetworkSend_uint16(p, client_index);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

{

	//

	// Packet: SERVER_FRAME

	// Function: Sends the current frame-counter to the client

	// Data:

	//    uint32: Frame Counter

	//    uint32: Frame Counter Max (how far may the client walk before the server?)

	//    [uint32: general-seed-1]

	//    [uint32: general-seed-2]

	//      (last two depends on compile-settings, and are not default settings)

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

	NetworkSend_uint32(p, _frame_counter);

	NetworkSend_uint32(p, _frame_counter_max);

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

	NetworkSend_uint32(p, _sync_seed_1);

#ifdef NETWORK_SEND_DOUBLE_SEED

	NetworkSend_uint32(p, _sync_seed_2);

#endif

#endif

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

{

	//

	// Packet: SERVER_SYNC

	// Function: Sends a sync-check to the client

	// Data:

	//    uint32: Frame Counter

	//    uint32: General-seed-1

	//    [uint32: general-seed-2]

	//      (last one depends on compile-settings, and are not default settings)

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

	NetworkSend_uint32(p, _frame_counter);

	NetworkSend_uint32(p, _sync_seed_1);

#ifdef NETWORK_SEND_DOUBLE_SEED

	NetworkSend_uint32(p, _sync_seed_2);

#endif

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_COMMAND)(NetworkClientState *cs, CommandPacket *cp)

{

	//

	// Packet: SERVER_COMMAND

	// Function: Sends a DoCommand to the client

	// Data:

	//    uint8:  PlayerID (0..MAX_PLAYERS-1)

	//    uint32: CommandID (see command.h)

	//    uint32: P1 (free variables used in DoCommand)

	//    uint32: P2

	//    uint32: Tile

	//    string: text

	//    uint8:  CallBackID (see callback_table.c)

	//    uint32: Frame of execution

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

	NetworkSend_uint8(p, cp->player);

	NetworkSend_uint32(p, cp->cmd);

	NetworkSend_uint32(p, cp->p1);

	NetworkSend_uint32(p, cp->p2);

	NetworkSend_uint32(p, cp->tile);

	NetworkSend_string(p, cp->text);

	NetworkSend_uint8(p, cp->callback);

	NetworkSend_uint32(p, cp->frame);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(NetworkClientState *cs, NetworkAction action, uint16 client_index, bool self_send, const char *msg)

{

	//

	// Packet: SERVER_CHAT

	// Function: Sends a chat-packet to the client

	// Data:

	//    uint8:  ActionID (see network_data.h, NetworkAction)

	//    uint16:  Client-index

	//    String: Message (max MAX_TEXT_MSG_LEN)

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

	NetworkSend_uint8(p, action);

	NetworkSend_uint16(p, client_index);

	NetworkSend_uint8(p, self_send);

	NetworkSend_string(p, msg);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(NetworkClientState *cs, uint16 client_index, NetworkErrorCode errorno)

{

	//

	// Packet: SERVER_ERROR_QUIT

	// Function: One of the clients made an error and is quiting the game

	//      This packet informs the other clients of that.

	// Data:

	//    uint16:  Client-index

	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

	NetworkSend_uint16(p, client_index);

	NetworkSend_uint8(p, errorno);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_QUIT)(NetworkClientState *cs, uint16 client_index, const char *leavemsg)

{

	//

	// Packet: SERVER_ERROR_QUIT

	// Function: A client left the game, and this packets informs the other clients

	//      of that.

	// Data:

	//    uint16:  Client-index

	//    String: leave-message

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);

	NetworkSend_uint16(p, client_index);

	NetworkSend_string(p, leavemsg);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SHUTDOWN)

{

	//

	// Packet: SERVER_SHUTDOWN

	// Function: Let the clients know that the server is closing

	// Data:

	//     <none>

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_SHUTDOWN);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_NEWGAME)

{

	//

	// Packet: PACKET_SERVER_NEWGAME

	// Function: Let the clients know that the server is loading a new map

	// Data:

	//     <none>

	//

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEWGAME);

	NetworkSend_Packet(p, cs);

}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_RCON)(NetworkClientState *cs, uint16 color, const char *command)

{

	Packet *p = NetworkSend_Init(PACKET_SERVER_RCON);

	NetworkSend_uint16(p, color);

	NetworkSend_string(p, command);

	NetworkSend_Packet(p, cs);

}

// **********

// Receiving functions

//   DEF_SERVER_RECEIVE_COMMAND has parameter: NetworkClientState *cs, Packet *p

// **********

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO)

{

	SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)(cs);

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)

{

	char name[NETWORK_CLIENT_NAME_LENGTH];

	char unique_id[NETWORK_NAME_LENGTH];

	NetworkClientInfo *ci;

	byte playas;

	NetworkLanguage client_lang;

	char client_revision[NETWORK_REVISION_LENGTH];

	NetworkRecv_string(cs, p, client_revision, sizeof(client_revision));

#if defined(WITH_REV) || defined(WITH_REV_HACK)

	// Check if the client has revision control enabled

	if (strcmp(NOREV_STRING, client_revision) != 0 &&

			strcmp(_network_game_info.server_revision, client_revision) != 0) {

		// Different revisions!!

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_REVISION);

		return;

	}

#endif

	NetworkRecv_string(cs, p, name, sizeof(name));

	playas = NetworkRecv_uint8(cs, p);

	client_lang = NetworkRecv_uint8(cs, p);

	NetworkRecv_string(cs, p, unique_id, sizeof(unique_id));

	if (cs->has_quit) return;

	// join another company does not affect these values

	switch (playas) {

		case PLAYER_NEW_COMPANY: /* New company */

			if (ActivePlayerCount() >= _network_game_info.companies_max) {

				SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_FULL);

				return;

			}

			break;

		case PLAYER_SPECTATOR: /* Spectator */

			if (NetworkSpectatorCount() >= _network_game_info.spectators_max) {

				SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_FULL);

				return;

			}

			break;

		default: /* Join another company (companies 1-8 (index 0-7)) */

			if (!IsValidPlayer(playas)) {

				SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_PLAYER_MISMATCH);

				return;

			}

			break;

	}

	// We need a valid name.. make it Player

	if (*name == '\0') ttd_strlcpy(name, "Player", sizeof(name));

	if (!NetworkFindName(name)) { // Change name if duplicate

		// We could not create a name for this player

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NAME_IN_USE);

		return;

	}

	ci = DEREF_CLIENT_INFO(cs);

	ttd_strlcpy(ci->client_name, name, sizeof(ci->client_name));

	ttd_strlcpy(ci->unique_id, unique_id, sizeof(ci->unique_id));

	ci->client_playas = playas;

	ci->client_lang = client_lang;

	// We now want a password from the client

	//  else we do not allow him in!

	if (_network_game_info.use_password) {

		SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_GAME_PASSWORD);

	} else {

		if (IsValidPlayer(ci->client_playas) && _network_player_info[ci->client_playas].password[0] != '\0') {

			SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_COMPANY_PASSWORD);

		} else {

			SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);

		}

	}

	/* Make sure companies to which people try to join are not autocleaned */

	if (IsValidPlayer(playas)) _network_player_info[playas].months_empty = 0;

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_PASSWORD)

{

	NetworkPasswordType type;

	char password[NETWORK_PASSWORD_LENGTH];

	const NetworkClientInfo *ci;

	type = NetworkRecv_uint8(cs, p);

	NetworkRecv_string(cs, p, password, sizeof(password));

	if (cs->status == STATUS_INACTIVE && type == NETWORK_GAME_PASSWORD) {

		// Check game-password

		if (strcmp(password, _network_game_info.server_password) != 0) {

			// Password is invalid

			SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);

			return;

		}

		ci = DEREF_CLIENT_INFO(cs);

		if (IsValidPlayer(ci->client_playas) && _network_player_info[ci->client_playas].password[0] != '\0') {

			SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_COMPANY_PASSWORD);

			return;

		}

		// Valid password, allow user

		SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);

		return;

	} else if (cs->status == STATUS_INACTIVE && type == NETWORK_COMPANY_PASSWORD) {

		ci = DEREF_CLIENT_INFO(cs);

		if (strcmp(password, _network_player_info[ci->client_playas].password) != 0) {

			// Password is invalid

			SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);

			return;

		}

		SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);

		return;

	}

	SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);

	return;

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)

{

	const NetworkClientState *new_cs;

	// The client was never joined.. so this is impossible, right?

	//  Ignore the packet, give the client a warning, and close his connection

	if (cs->status < STATUS_AUTH || cs->has_quit) {

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

		return;

	}

	// Check if someone else is receiving the map

	FOR_ALL_CLIENTS(new_cs) {

		if (new_cs->status == STATUS_MAP) {

			// Tell the new client to wait

			cs->status = STATUS_MAP_WAIT;

			SEND_COMMAND(PACKET_SERVER_WAIT)(cs);

			return;

		}

	}

	// We receive a request to upload the map.. give it to the client!

	SEND_COMMAND(PACKET_SERVER_MAP)(cs);

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_MAP_OK)

{

	// Client has the map, now start syncing

	if (cs->status == STATUS_DONE_MAP && !cs->has_quit) {

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

		NetworkClientState *new_cs;

		NetworkGetClientName(client_name, sizeof(client_name), cs);

		NetworkTextMessage(NETWORK_ACTION_JOIN, 1, false, client_name, "");

		// Mark the client as pre-active, and wait for an ACK

		//  so we know he is done loading and in sync with us

		cs->status = STATUS_PRE_ACTIVE;

		NetworkHandleCommandQueue(cs);

		SEND_COMMAND(PACKET_SERVER_FRAME)(cs);

		SEND_COMMAND(PACKET_SERVER_SYNC)(cs);

		// This is the frame the client receives

		//  we need it later on to make sure the client is not too slow

		cs->last_frame = _frame_counter;

		cs->last_frame_server = _frame_counter;

		FOR_ALL_CLIENTS(new_cs) {

			if (new_cs->status > STATUS_AUTH) {

				SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(new_cs, DEREF_CLIENT_INFO(cs));

				SEND_COMMAND(PACKET_SERVER_JOIN)(new_cs, cs->index);

			}

		}

		if (_network_pause_on_join) {

			/* Now pause the game till the client is in sync */

			DoCommandP(0, 1, 0, NULL, CMD_PAUSE);

			NetworkServer_HandleChat(NETWORK_ACTION_SERVER_MESSAGE, DESTTYPE_BROADCAST, 0, "Game paused (incoming client)", NETWORK_SERVER_INDEX);

		}

	} else {

		// Wrong status for this packet, give a warning to client, and close connection

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);

	}

}

/** Enforce the command flags.

 * Eg a server-only command can only be executed by a server, etc.

 * @param *cp the commandpacket that is going to be checked

 * @param *ci client information for debugging output to console

 */

static bool CheckCommandFlags(const CommandPacket *cp, const NetworkClientInfo *ci)

{

	byte flags = GetCommandFlags(cp->cmd);

	if (flags & CMD_SERVER && ci->client_index != NETWORK_SERVER_INDEX) {

		IConsolePrintF(_icolour_err, "WARNING: server only command from client %d (IP: %s), kicking...", ci->client_index, GetPlayerIP(ci));

		return false;

	}

	if (flags & CMD_OFFLINE) {

		IConsolePrintF(_icolour_err, "WARNING: offline only command from client %d (IP: %s), kicking...", ci->client_index, GetPlayerIP(ci));

		return false;

	}