PACKET_SERVER_MOVE,

	PACKET_CLIENT_MOVE,

	PACKET_SERVER_COMPANY_UPDATE,

	PACKET_SERVER_CONFIG_UPDATE,

	PACKET_END                   ///< Must ALWAYS be on the end of this list!! (period)

};

/** Packet that wraps a command */

struct CommandPacket;

/** Status of a client */

enum ClientStatus {

	STATUS_AUTH_COMPANY, ///< The client is authorizing with company password

};

class NetworkClientSocket;

typedef Pool<NetworkClientSocket, ClientIndex, 8, MAX_CLIENT_SLOTS> NetworkClientSocketPool;

extern NetworkClientSocketPool _networkclientsocket_pool;

/** Base socket handler for all TCP sockets */

class NetworkClientSocket : public NetworkClientSocketPool::PoolItem<&_networkclientsocket_pool>, public NetworkTCPSocketHandler {

/* TODO: rewrite into a proper class */

private:

	NetworkClientInfo *info;  ///< Client info related to this socket

public:

	}

	CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);

}

/**

 * Checks whether there is a joining client

 * @return true iff one client is joining (but not authorizing)

 */

static bool NetworkHasJoiningClient()

{

	const NetworkClientSocket *cs;

	FOR_ALL_CLIENT_SOCKETS(cs) {

	}

	return false;

}

/**

 * Check whether we should pause on join

 */

static void CheckPauseOnJoin()

{

	if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||

			(!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {

NetworkRecvStatus NetworkCloseClient(NetworkClientSocket *cs, NetworkRecvStatus status)

{

	assert(status != NETWORK_RECV_STATUS_OKAY);

	/*

	 * Sending a message just before leaving the game calls cs->Send_Packets.

	 * This might invoke this function, which means that when we close the

	 * connection after cs->Send_Packets we will close an already closed

	 * connection. This handles that case gracefully without having to make

	 * that code any more complex or more aware of the validity of the socket.

	 */

	if (cs->sock == INVALID_SOCKET) return status;

		/* We did not receive a leave message from this client... */

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

		NetworkClientSocket *new_cs;

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

		NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, client_name, NULL, STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST);

		/* Inform other clients of this... strange leaving ;) */

		FOR_ALL_CLIENT_SOCKETS(new_cs) {

				SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->client_id, NETWORK_ERROR_CONNECTION_LOST);

			}

		}

	}

	DEBUG(net, 1, "Closed client connection %d", cs->client_id);

	if (_network_server) {

		/* We just lost one client :( */

		_network_clients_connected--;

		SetWindowDirty(WC_CLIENT_LIST, 0);

	}

	cs->Send_Packets(true);

	delete cs->GetInfo();

	delete cs;

	return status;

}

	 */

	char str[100];

	Packet *p = new Packet(PACKET_SERVER_ERROR);

	p->Send_uint8(error);

	cs->Send_Packet(p);

	StringID strid = GetNetworkErrorMsg(error);

	GetString(str, strid, lastof(str));

	/* Only send when the current client was in game */

		NetworkClientSocket *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, CC_DEFAULT, false, client_name, NULL, strid);

		FOR_ALL_CLIENT_SOCKETS(new_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->client_id, error);

			}

		}

	} else {

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

	}

{

	/*

	 * Packet: SERVER_WELCOME

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

	 * Data:

	 *    uint32:  Own Client identifier

	 */

	Packet *p;

	NetworkClientSocket *new_cs;

	/* Invalid packet when status is AUTH or higher */

	_network_game_info.clients_on++;

	p = new Packet(PACKET_SERVER_WELCOME);

	p->Send_uint32(cs->client_id);

	p->Send_uint32(_settings_game.game_creation.generation_seed);

	p->Send_string(_settings_client.network.network_id);

	cs->Send_Packet(p);

		/* Transmit info about all the active clients */

	FOR_ALL_CLIENT_SOCKETS(new_cs) {

			SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, new_cs->GetInfo());

	}

	/* Also send the info of the server */

	return SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, NetworkFindClientInfoFromClientID(CLIENT_ID_SERVER));

}

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

	 *    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:

	 *    nothing

	 */

	static FILE *file_pointer;

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

		/* Illegal call, return error and ignore the packet */

		return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

	}

		const char *filename = "network_server.tmp";

		Packet *p;

		/* Make a dump of the current game */

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

		file_pointer = FioFOpenFile(filename, "rb", AUTOSAVE_DIR);

		fseek(file_pointer, 0, SEEK_END);

		if (ftell(file_pointer) == 0) usererror("network savedump failed - zero sized savegame?");

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

				cs->status = STATUS_DONE_MAP;

				fclose(file_pointer);

				NetworkClientSocket *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_CLIENT_SOCKETS(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_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;

			}

			/* The version we get from the client differs, it must have the

			 * wrong version. The client must be wrong. */

			return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);

		}

	} else if (p->size != 3) {

		/* We received a packet from a version that claims to be stable.

		 * That shouldn't happen. The client must be wrong. */

		return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);

	}

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

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

		return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

	}

	/* Check if someone else is receiving the map */

	FOR_ALL_CLIENT_SOCKETS(new_cs) {

		if (new_cs->status == STATUS_MAP) {

			/* Tell the new client to wait */

			cs->status = STATUS_MAP_WAIT;

			return SEND_COMMAND(PACKET_SERVER_WAIT)(cs);

		}

	}

		 *  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_CLIENT_SOCKETS(new_cs) {

				SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(new_cs, cs->GetInfo());

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

			}

		}

		/* also update the new client with our max values */

		SEND_COMMAND(PACKET_SERVER_CONFIG_UPDATE)(cs);

		/* quickly update the syncing client with company details */

		return SEND_COMMAND(PACKET_SERVER_COMPANY_UPDATE)(cs);

	}

	}

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

	StringID strid = GetNetworkErrorMsg(errorno);

	GetString(str, strid, lastof(str));

	DEBUG(net, 2, "'%s' reported an error and is closing its connection (%s)", client_name, str);

	NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, client_name, NULL, strid);

	FOR_ALL_CLIENT_SOCKETS(new_cs) {

			SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->client_id, errorno);

		}

	}

	cs->CloseConnection(false);

	return NETWORK_RECV_STATUS_CONN_LOST;

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_QUIT)

{

	/* The client wants to leave. Display this and report it to the other

	 *  clients. */

	/* The client was never joined.. thank the client for the packet, but ignore it */

	if (cs->status < STATUS_DONE_MAP || cs->HasClientQuit()) {

		cs->CloseConnection();

		return NETWORK_RECV_STATUS_CONN_LOST;

	}

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

	NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, client_name, NULL, STR_NETWORK_MESSAGE_CLIENT_LEAVING);

	FOR_ALL_CLIENT_SOCKETS(new_cs) {

			SEND_COMMAND(PACKET_SERVER_QUIT)(new_cs, cs->client_id);

		}

	}

	cs->CloseConnection(false);

	return NETWORK_RECV_STATUS_CONN_LOST;

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_ACK)

{

		/* Illegal call, return error and ignore the packet */

		return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

	}

	uint32 frame = p->Recv_uint32();

	/* The client is trying to catch up with the server */

	if (cs->status == STATUS_PRE_ACTIVE) {

		/* The client is not yet catched up? */

		if (frame + DAY_TICKS < _frame_counter) return NETWORK_RECV_STATUS_OKAY;

		/* Now he is! Unpause the game */

		FOR_ALL_CLIENT_SOCKETS(cs) {

			SEND_COMMAND(PACKET_SERVER_CHAT)(cs, action, from_id, false, msg, data);

		}

		ci = NetworkFindClientInfoFromClientID(from_id);

		if (ci != NULL)

			NetworkTextMessage(action, (ConsoleColour)GetDrawStringCompanyColour(ci->client_playas), false, ci->client_name, msg, data);

		break;

	}

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_CHAT)

{

		/* Illegal call, return error and ignore the packet */

		return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

	}

	NetworkAction action = (NetworkAction)p->Recv_uint8();

	DestType desttype = (DestType)p->Recv_uint8();

	int dest = p->Recv_uint32();

	char msg[NETWORK_CHAT_LENGTH];

	p->Recv_string(msg, NETWORK_CHAT_LENGTH);

	int64 data = p->Recv_uint64();