void OnFailure() override

	{

		NetworkGameList *item = NetworkGameListAddItem(connection_string);

		item->status = NGLS_OFFLINE;

		item->refreshing = false;

	void OnConnect(SOCKET s) override

	{

		QueryNetworkGameSocketHandler::QueryServer(s, this->connection_string);

	}

};

{

	if (!_network_available) return;

	/* Mark the entry as refreshing, so the GUI can show the refresh is pending. */

	NetworkGameList *item = NetworkGameListAddItem(connection_string);

	item->refreshing = true;

	void OnFailure() override

	{

		ShowNetworkError(STR_NETWORK_ERROR_NOCONNECTION);

	}

	void OnConnect(SOCKET s) override

	{

		_networking = true;

		new ClientNetworkGameSocketHandler(s, this->connection_string);

		IConsoleCmdExec("exec scripts/on_client.scr 0");

 */

bool NetworkClientConnectGame(const std::string &connection_string, CompanyID default_company, const std::string &join_server_password, const std::string &join_company_password)

{

	CompanyID join_as = default_company;

	std::string resolved_connection_string = ServerAddress::Parse(connection_string, NETWORK_DEFAULT_PORT, &join_as).connection_string;

	NetworkInitialize();

	_settings_client.network.last_joined = _network_join.connection_string;

	_network_join_status = NETWORK_JOIN_STATUS_CONNECTING;

	ShowJoinStatusWindow();

/** Tell the server we would like to join. */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendJoin()

{

	my_client->status = STATUS_JOIN;

	_network_join_status = NETWORK_JOIN_STATUS_AUTHORIZING;

	SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);

/** Tell the server we got all the NewGRFs. */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendNewGRFsOk()

{

	Packet *p = new Packet(PACKET_CLIENT_NEWGRFS_CHECKED);

	my_client->SendPacket(p);

	return NETWORK_RECV_STATUS_OKAY;

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendGamePassword(const std::string &password)

{

	Packet *p = new Packet(PACKET_CLIENT_GAME_PASSWORD);

	p->Send_string(password);

	my_client->SendPacket(p);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendCompanyPassword(const std::string &password)

{

	Packet *p = new Packet(PACKET_CLIENT_COMPANY_PASSWORD);

	p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));

	my_client->SendPacket(p);

/** Request the map from the server. */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendGetMap()

{

	my_client->status = STATUS_MAP_WAIT;

	Packet *p = new Packet(PACKET_CLIENT_GETMAP);

/** Tell the server we received the complete map. */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendMapOk()

{

	my_client->status = STATUS_ACTIVE;

	Packet *p = new Packet(PACKET_CLIENT_MAP_OK);

/** Send an acknowledgement from the server's ticks. */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendAck()

{

	Packet *p = new Packet(PACKET_CLIENT_ACK);

	p->Send_uint32(_frame_counter);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendCommand(const CommandPacket *cp)

{

	Packet *p = new Packet(PACKET_CLIENT_COMMAND);

	my_client->NetworkGameSocketHandler::SendCommand(p, cp);

/** Send a chat-packet over the network */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64_t data)

{

	Packet *p = new Packet(PACKET_CLIENT_CHAT);

	p->Send_uint8 (action);

/** Send an error-packet over the network */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendError(NetworkErrorCode errorno)

{

	Packet *p = new Packet(PACKET_CLIENT_ERROR);

	p->Send_uint8(errorno);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendSetPassword(const std::string &password)

{

	Packet *p = new Packet(PACKET_CLIENT_SET_PASSWORD);

	p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendSetName(const std::string &name)

{

	Packet *p = new Packet(PACKET_CLIENT_SET_NAME);

	p->Send_string(name);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendQuit()

{

	Packet *p = new Packet(PACKET_CLIENT_QUIT);

	my_client->SendPacket(p);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendRCon(const std::string &pass, const std::string &command)

{

	Packet *p = new Packet(PACKET_CLIENT_RCON);

	p->Send_string(pass);

	p->Send_string(command);

 */

NetworkRecvStatus ClientNetworkGameSocketHandler::SendMove(CompanyID company, const std::string &password)

{

	Packet *p = new Packet(PACKET_CLIENT_MOVE);

	p->Send_uint8(company);

	p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FULL(Packet *)

{

	/* We try to join a server which is full */

	ShowErrorMessage(STR_NETWORK_ERROR_SERVER_FULL, INVALID_STRING_ID, WL_CRITICAL);

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet *)

{

	/* We try to join a server where we are banned */

	ShowErrorMessage(STR_NETWORK_ERROR_SERVER_BANNED, INVALID_STRING_ID, WL_CRITICAL);

	ClientID client_id = (ClientID)p->Recv_uint32();

	CompanyID playas = (CompanyID)p->Recv_uint8();

	std::string name = p->Recv_string(NETWORK_NAME_LENGTH);

	if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	NetworkErrorCode error = (NetworkErrorCode)p->Recv_uint8();

	StringID err = STR_NETWORK_ERROR_LOSTCONNECTION;

	if (error < (ptrdiff_t)lengthof(network_error_strings)) err = network_error_strings[error];

	/* In case of kicking a client, we assume there is a kick message in the packet if we can read one byte */

	uint grf_count = p->Recv_uint8();

	NetworkRecvStatus ret = NETWORK_RECV_STATUS_OKAY;

	/* Check all GRFs */

	for (; grf_count > 0; grf_count--) {

		GRFIdentifier c;

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEED_GAME_PASSWORD(Packet *)

{

	if (this->status < STATUS_JOIN || this->status >= STATUS_AUTH_GAME) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	this->status = STATUS_AUTH_GAME;

	if (!_network_join.server_password.empty()) {

		return SendGamePassword(_network_join.server_password);

	}

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEED_COMPANY_PASSWORD(Packet *p)

{

	if (this->status < STATUS_JOIN || this->status >= STATUS_AUTH_COMPANY) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	this->status = STATUS_AUTH_COMPANY;

	_password_game_seed = p->Recv_uint32();

	_password_server_id = p->Recv_string(NETWORK_SERVER_ID_LENGTH);

	if (this->HasClientQuit()) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WELCOME(Packet *p)

{

	if (this->status < STATUS_JOIN || this->status >= STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	this->status = STATUS_AUTHORIZED;

	_network_own_client_id = (ClientID)p->Recv_uint32();

	/* Initialize the password hash salting variables, even if they were previously. */

	_password_game_seed = p->Recv_uint32();

	_password_server_id = p->Recv_string(NETWORK_SERVER_ID_LENGTH);

	/* We set the internal wait state when requesting the map. */

	if (this->status != STATUS_MAP_WAIT) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	/* But... only now we set the join status to waiting, instead of requesting. */

	_network_join_status = NETWORK_JOIN_STATUS_WAITING;

	_network_join_waiting = p->Recv_uint8();

	SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packet *p)

{

	if (this->status < STATUS_AUTHORIZED || this->status >= STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	this->status = STATUS_MAP;

	if (this->savegame != nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	_frame_counter = _frame_counter_server = _frame_counter_max = p->Recv_uint32();

	_network_join_bytes = 0;

	_network_join_bytes_total = 0;

	_network_join_status = NETWORK_JOIN_STATUS_DOWNLOADING;

	SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);

	_network_join_bytes_total = p->Recv_uint32();

	SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);

	return NETWORK_RECV_STATUS_OKAY;

}

	if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	_network_join_status = NETWORK_JOIN_STATUS_PROCESSING;

	SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);

		if (_network_join.company != COMPANY_SPECTATOR) {

			/* We have arrived and ready to start playing; send a command to make a new company;

			 * the server will give us a client-id and let us in */

			_network_join_status = NETWORK_JOIN_STATUS_REGISTERING;

			ShowJoinStatusWindow();

			Command<CMD_COMPANY_CTRL>::SendNet(STR_NULL, _local_company, CCA_NEW, INVALID_COMPANY, CRR_NONE, INVALID_CLIENT_ID);

	/* Receive the token. */

	if (p->CanReadFromPacket(sizeof(uint8_t))) this->token = p->Recv_uint8();

	/* 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) {

	_sync_seed_2 = p->Recv_uint32();

#endif

	return NETWORK_RECV_STATUS_OKAY;

}

	cp.frame    = p->Recv_uint32();

	cp.my_cmd   = p->Recv_bool();

	if (err != nullptr) {

		IConsolePrint(CC_WARNING, "Dropping server connection due to {}.", err);

		return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);

	int64_t data = p->Recv_uint64();

	ci_to = NetworkClientInfo::GetByClientID(client_id);

	if (ci_to == nullptr) return NETWORK_RECV_STATUS_OKAY;

	std::string user = p->Recv_string(NETWORK_CHAT_LENGTH);

	std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);

	if (!IsValidConsoleColour(colour)) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	NetworkTextMessage(NETWORK_ACTION_EXTERNAL_CHAT, colour, false, user, msg, 0, source);

	ClientID client_id = (ClientID)p->Recv_uint32();

	NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);

	if (ci != nullptr) {

		NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, ci->client_name, "", GetNetworkErrorMsg((NetworkErrorCode)p->Recv_uint8()));

	ClientID client_id = (ClientID)p->Recv_uint32();

	NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);

	if (ci != nullptr) {

		NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, ci->client_name, "", STR_NETWORK_MESSAGE_CLIENT_LEAVING);

	ClientID client_id = (ClientID)p->Recv_uint32();

	NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);

	if (ci != nullptr) {

		NetworkTextMessage(NETWORK_ACTION_JOIN, CC_DEFAULT, false, ci->client_name);

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SHUTDOWN(Packet *)

{

	/* Only when we're trying to join we really

	 * care about the server shutting down. */

	if (this->status >= STATUS_JOIN) {

NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEWGAME(Packet *)

{

	/* Only when we're trying to join we really

	 * care about the server shutting down. */

	if (this->status >= STATUS_JOIN) {

{

	if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	TextColour colour_code = (TextColour)p->Recv_uint16();

	if (!IsValidConsoleColour(colour_code)) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	ClientID client_id   = (ClientID)p->Recv_uint32();

	CompanyID company_id = (CompanyID)p->Recv_uint8();

	if (client_id == 0) {

		/* definitely an invalid client id, debug message and do nothing. */

		Debug(net, 1, "Received invalid client index = 0");

	_network_server_name = p->Recv_string(NETWORK_NAME_LENGTH);

	SetWindowClassesDirty(WC_CLIENT_LIST);

	return NETWORK_RECV_STATUS_OKAY;

}

	_network_company_passworded = p->Recv_uint16();

	SetWindowClassesDirty(WC_COMPANY);

	return NETWORK_RECV_STATUS_OKAY;

}

	_frame_counter = 0;

	_frame_counter_server = 0;

	last_ack_frame = 0;

	/* Request the game-info */

	MyClient::SendJoin();

}

 */

NetworkRecvStatus QueryNetworkGameSocketHandler::SendGameInfo()

{

	this->SendPacket(new Packet(PACKET_CLIENT_GAME_INFO));

	return NETWORK_RECV_STATUS_OKAY;

}

NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_FULL(Packet *)

{

	NetworkGameList *item = NetworkGameListAddItem(this->connection_string);

	item->status = NGLS_FULL;

	item->refreshing = false;

NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet *)

{

	NetworkGameList *item = NetworkGameListAddItem(this->connection_string);

	item->status = NGLS_BANNED;

	item->refreshing = false;

NetworkRecvStatus QueryNetworkGameSocketHandler::Receive_SERVER_GAME_INFO(Packet *p)

{

	NetworkGameList *item = NetworkGameListAddItem(this->connection_string);

	/* Clear any existing GRFConfig chain. */

{

	NetworkErrorCode error = (NetworkErrorCode)p->Recv_uint8();

	NetworkGameList *item = NetworkGameListAddItem(this->connection_string);

	if (error == NETWORK_ERROR_NOT_EXPECTED) {

	this->client_id = _network_client_id++;

	this->receive_limit = _settings_client.network.bytes_per_frame_burst;

	/* The Socket and Info pools need to be the same in size. After all,

	 * each Socket will be associated with at most one Info object. As

	 * such if the Socket was allocated the Info object can as well. */

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendClientInfo(NetworkClientInfo *ci)

{

	if (ci->client_id != INVALID_CLIENT_ID) {

		Packet *p = new Packet(PACKET_SERVER_CLIENT_INFO);

		p->Send_uint32(ci->client_id);

/** Send the client information about the server. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendGameInfo()

{

	Packet *p = new Packet(PACKET_SERVER_GAME_INFO, TCP_MTU);

	SerializeNetworkGameInfo(p, GetCurrentNetworkServerGameInfo());

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendError(NetworkErrorCode error, const std::string &reason)

{

	Packet *p = new Packet(PACKET_SERVER_ERROR);

	p->Send_uint8(error);

/** Send the check for the NewGRFs. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendNewGRFCheck()

{

	Packet *p = new Packet(PACKET_SERVER_CHECK_NEWGRFS, TCP_MTU);

	const GRFConfig *c;

	uint grf_count = 0;

/** Request the game password. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendNeedGamePassword()

{

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

	if (this->status >= STATUS_AUTH_GAME) return this->CloseConnection(NETWORK_RECV_STATUS_MALFORMED_PACKET);

	this->status = STATUS_AUTH_GAME;

	/* Reset 'lag' counters */

	this->last_frame = this->last_frame_server = _frame_counter;

/** Request the company password. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendNeedCompanyPassword()

{

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

	if (this->status >= STATUS_AUTH_COMPANY) return this->CloseConnection(NETWORK_RECV_STATUS_MALFORMED_PACKET);

	this->status = STATUS_AUTH_COMPANY;

	/* Reset 'lag' counters */

	this->last_frame = this->last_frame_server = _frame_counter;

/** Send the client a welcome message with some basic information. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendWelcome()

{

	Packet *p;

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

	if (this->status >= STATUS_AUTHORIZED) return this->CloseConnection(NETWORK_RECV_STATUS_MALFORMED_PACKET);

	this->status = STATUS_AUTHORIZED;

	/* Reset 'lag' counters */

	this->last_frame = this->last_frame_server = _frame_counter;

/** Tell the client that its put in a waiting queue. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendWait()

{

	int waiting = 1; // current player getting the map counts as 1

	Packet *p;

void ServerNetworkGameSocketHandler::CheckNextClientToSendMap(NetworkClientSocket *ignore_cs)

{

	/* Find the best candidate for joining, i.e. the first joiner. */

	NetworkClientSocket *best = nullptr;

	for (NetworkClientSocket *new_cs : NetworkClientSocket::Iterate()) {

	}

	if (this->status == STATUS_AUTHORIZED) {

		WaitTillSaved();

		this->savegame = new PacketWriter(this);

		this->SendPacket(p);

		NetworkSyncCommandQueue(this);

		this->status = STATUS_MAP;

		/* Mark the start of download */

		this->last_frame = _frame_counter;

	if (this->status == STATUS_MAP) {

		bool last_packet = this->savegame->TransferToNetworkQueue(this);

		if (last_packet) {

			/* Done reading, make sure saving is done as well */

			this->savegame->Destroy();

			this->savegame = nullptr;

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

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

			this->status = STATUS_DONE_MAP;

			this->CheckNextClientToSendMap();

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendJoin(ClientID client_id)

{

	Packet *p = new Packet(PACKET_SERVER_JOIN);

	p->Send_uint32(client_id);

/** Request the client to sync. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendSync()

{

	Packet *p = new Packet(PACKET_SERVER_SYNC);

	p->Send_uint32(_frame_counter);

	p->Send_uint32(_sync_seed_1);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendCommand(const CommandPacket *cp)

{

	Packet *p = new Packet(PACKET_SERVER_COMMAND);

	this->NetworkGameSocketHandler::SendCommand(p, cp);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendChat(NetworkAction action, ClientID client_id, bool self_send, const std::string &msg, int64_t data)

{

	if (this->status < STATUS_PRE_ACTIVE) return NETWORK_RECV_STATUS_OKAY;

	Packet *p = new Packet(PACKET_SERVER_CHAT);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendExternalChat(const std::string &source, TextColour colour, const std::string &user, const std::string &msg)

{

	if (this->status < STATUS_PRE_ACTIVE) return NETWORK_RECV_STATUS_OKAY;

	Packet *p = new Packet(PACKET_SERVER_EXTERNAL_CHAT);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendErrorQuit(ClientID client_id, NetworkErrorCode errorno)

{

	Packet *p = new Packet(PACKET_SERVER_ERROR_QUIT);

	p->Send_uint32(client_id);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendQuit(ClientID client_id)

{

	Packet *p = new Packet(PACKET_SERVER_QUIT);

	p->Send_uint32(client_id);

/** Tell the client we're shutting down. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendShutdown()

{

	Packet *p = new Packet(PACKET_SERVER_SHUTDOWN);

	this->SendPacket(p);

	return NETWORK_RECV_STATUS_OKAY;

/** Tell the client we're starting a new game. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendNewGame()

{

	Packet *p = new Packet(PACKET_SERVER_NEWGAME);

	this->SendPacket(p);

	return NETWORK_RECV_STATUS_OKAY;

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendRConResult(uint16_t colour, const std::string &command)

{

	Packet *p = new Packet(PACKET_SERVER_RCON);

	p->Send_uint16(colour);

 */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendMove(ClientID client_id, CompanyID company_id)

{

	Packet *p = new Packet(PACKET_SERVER_MOVE);

	p->Send_uint32(client_id);

/** Send an update about the company password states. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendCompanyUpdate()

{

	Packet *p = new Packet(PACKET_SERVER_COMPANY_UPDATE);

	static_assert(sizeof(_network_company_passworded) <= sizeof(uint16_t));

/** Send an update about the max company/spectator counts. */

NetworkRecvStatus ServerNetworkGameSocketHandler::SendConfigUpdate()

{

	Packet *p = new Packet(PACKET_SERVER_CONFIG_UPDATE);

	p->Send_uint8(_settings_client.network.max_companies);

NetworkRecvStatus ServerNetworkGameSocketHandler::Receive_CLIENT_GAME_INFO(Packet *)

{

	return this->SendGameInfo();

}

		return this->SendError(NETWORK_ERROR_NOT_EXPECTED);

	}

	NetworkClientInfo *ci = this->GetInfo();

	/* We now want a password from the client else we do not allow them in! */

	std::string client_revision = p->Recv_string(NETWORK_REVISION_LENGTH);

	uint32_t newgrf_version = p->Recv_uint32();

	/* Check if the client has revision control enabled */

	if (!IsNetworkCompatibleVersion(client_revision) || _openttd_newgrf_version != newgrf_version) {

		/* Different revisions!! */

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

	if (Company::IsValidID(playas)) _network_company_states[playas].months_empty = 0;

	this->status = STATUS_NEWGRFS_CHECK;

	if (_grfconfig == nullptr) {

		return this->SendError(NETWORK_ERROR_NOT_EXPECTED);

	}

	std::string password = p->Recv_string(NETWORK_PASSWORD_LENGTH);

	/* Check game password. Allow joining if we cleared the password meanwhile */

		return this->SendError(NETWORK_ERROR_NOT_EXPECTED);

	}

	std::string password = p->Recv_string(NETWORK_PASSWORD_LENGTH);

	/* Check company password. Allow joining if we cleared the password meanwhile.

		return this->SendError(NETWORK_ERROR_NOT_AUTHORIZED);

	}

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

	for (NetworkClientSocket *new_cs : NetworkClientSocket::Iterate()) {

		if (new_cs->status == STATUS_MAP) {

			/* Tell the new client to wait */