NetworkClose();

	// Free all queued commands

	while (_local_command_queue != NULL) {

		CommandPacket *p = _local_command_queue;

		_local_command_queue = _local_command_queue->next;

		free(p);

	}

	if (_networking && !_network_server) {

		memcpy(&_patches, &network_tmp_patches, sizeof(_patches));

	}

	_networking = false;

	_network_server = false;

}

// Receives something from the network

static bool NetworkReceive(void)

{

	NetworkClientState *cs;

	int n;

	fd_set read_fd, write_fd;

	struct timeval tv;

	FD_ZERO(&read_fd);

	FD_ZERO(&write_fd);

	FOR_ALL_CLIENTS(cs) {

		FD_SET(cs->socket, &read_fd);

		FD_SET(cs->socket, &write_fd);

	}

	// take care of listener port

	if (_network_server) {

		FD_SET(_listensocket, &read_fd);

	}

	tv.tv_sec = tv.tv_usec = 0; // don't block at all.

#if !defined(__MORPHOS__) && !defined(__AMIGA__)

	n = select(FD_SETSIZE, &read_fd, &write_fd, NULL, &tv);

#else

	n = WaitSelect(FD_SETSIZE, &read_fd, &write_fd, NULL, &tv, NULL);

#endif

	if (n == -1 && !_network_server) NetworkError(STR_NETWORK_ERR_LOSTCONNECTION);

	// accept clients..

	if (_network_server && FD_ISSET(_listensocket, &read_fd))

		NetworkAcceptClients();

	// read stuff from clients

	FOR_ALL_CLIENTS(cs) {

		cs->writable = !!FD_ISSET(cs->socket, &write_fd);

		if (FD_ISSET(cs->socket, &read_fd)) {

			if (_network_server)

				NetworkServer_ReadPackets(cs);

			else {

				byte res;

				// The client already was quiting!

				if (cs->quited) return false;

				if ((res = NetworkClient_ReadPackets(cs)) != NETWORK_RECV_STATUS_OKAY) {

					// The client made an error of which we can not recover

					//   close the client and drop back to main menu

					NetworkClientError(res, cs);

					return false;

				}

			}

		}

	}

	return true;

}

// This sends all buffered commands (if possible)

static void NetworkSend(void)

{

	NetworkClientState *cs;

	FOR_ALL_CLIENTS(cs) {

		if (cs->writable) {

			NetworkSend_Packets(cs);

			if (cs->status == STATUS_MAP) {

				// This client is in the middle of a map-send, call the function for that

				SEND_COMMAND(PACKET_SERVER_MAP)(cs);

			}

		}

	}

}

// Handle the local-command-queue

static void NetworkHandleLocalQueue(void)

{

	CommandPacket *cp, **cp_prev;

	cp_prev = &_local_command_queue;

	while ( (cp = *cp_prev) != NULL) {

		// The queue is always in order, which means

		// that the first element will be executed first.

		if (_frame_counter < cp->frame)

			break;

		if (_frame_counter > cp->frame) {

			// If we reach here, it means for whatever reason, we've already executed

			// past the command we need to execute.

			DEBUG(net, 0)("[NET] Trying to execute a packet in the past!");

			assert(0);

		}

		// We can execute this command

		NetworkExecuteCommand(cp);

		*cp_prev = cp->next;

		free(cp);

	}

	// Just a safety check, to be removed in the future.

	// Make sure that no older command appears towards the end of the queue

	// In that case we missed executing it. This will never happen.

	for(cp = _local_command_queue; cp; cp = cp->next) {

		assert(_frame_counter < cp->frame);

	}

}

static bool NetworkDoClientLoop(void)

{

	_frame_counter++;

	NetworkHandleLocalQueue();

	StateGameLoop();

	// Check if we are in sync!

	if (_sync_frame != 0) {

		if (_sync_frame == _frame_counter) {

#ifdef NETWORK_SEND_DOUBLE_SEED

			if (_sync_seed_1 != _random_seeds[0][0] || _sync_seed_2 != _random_seeds[0][1]) {

#else

			if (_sync_seed_1 != _random_seeds[0][0]) {

#endif

				NetworkError(STR_NETWORK_ERR_DESYNC);

				DEBUG(net, 0)("[NET] Sync error detected!");

				NetworkClientError(NETWORK_RECV_STATUS_DESYNC, DEREF_CLIENT(0));

				return false;

			}

			// If this is the first time we have a sync-frame, we

			//   need to let the server know that we are ready and at the same

			//   frame as he is.. so we can start playing!

			if (_network_first_time) {

				_network_first_time = false;

				SEND_COMMAND(PACKET_CLIENT_ACK)();

			}

			_sync_frame = 0;

		} else if (_sync_frame < _frame_counter) {

			DEBUG(net, 1)("[NET] Missed frame for sync-test (%d / %d)", _sync_frame, _frame_counter);

			_sync_frame = 0;

		}

	}

	return true;

}

// We have to do some UDP checking

void NetworkUDPGameLoop(void)

{

	if (_network_udp_server) {

		NetworkUDPReceive(_udp_server_socket);

		if (_udp_master_socket != INVALID_SOCKET) {

			NetworkUDPReceive(_udp_master_socket);

		}

	}

	else if (_udp_client_socket != INVALID_SOCKET) {

		NetworkUDPReceive(_udp_client_socket);

		if (_network_udp_broadcast > 0)

			_network_udp_broadcast--;

	}

}

// The main loop called from ttd.c

//  Here we also have to do StateGameLoop if needed!

void NetworkGameLoop(void)

{

	if (!_networking) return;

	if (!NetworkReceive()) return;

	if (_network_server) {

		// We first increase the _frame_counter

		_frame_counter++;

		NetworkHandleLocalQueue();

		// Then we make the frame

		StateGameLoop();

		_sync_seed_1 = _random_seeds[0][0];

#ifdef NETWORK_SEND_DOUBLE_SEED

		_sync_seed_2 = _random_seeds[0][1];

#endif

	} else {

		// Client

		// Make sure we are at the frame were the server is (quick-frames)

		if (_frame_counter_server > _frame_counter) {

			while (_frame_counter_server > _frame_counter) {

				if (!NetworkDoClientLoop()) break;

			}

		} else {

			// Else, keep on going till _frame_counter_max

			if (_frame_counter_max > _frame_counter) {

				NetworkDoClientLoop();

			}

		}

	}

	NetworkSend();

}

static void NetworkGenerateUniqueId(void)

{

	md5_state_t state;

	md5_byte_t digest[16];

	char hex_output[16*2 + 1];

	char coding_string[NETWORK_NAME_LENGTH];

	int di;

	snprintf(coding_string, sizeof(coding_string), "%d%s", (uint)Random(), "OpenTTD Unique ID");

	/* Generate the MD5 hash */

	md5_init(&state);

	md5_append(&state, coding_string, strlen(coding_string));

	md5_finish(&state, digest);

	for (di = 0; di < 16; ++di)

		sprintf(hex_output + di * 2, "%02x", digest[di]);

	/* _network_unique_id is our id */

	snprintf(_network_unique_id, sizeof(_network_unique_id), "%s", hex_output);

}

// This tries to launch the network for a given OS

void NetworkStartUp(void)

{

	DEBUG(net, 3) ("[NET][Core] Starting network...");

	#if defined(__MORPHOS__) || defined(__AMIGA__)

	/*

	 *  IMPORTANT NOTE: SocketBase needs to be initialized before we use _any_

	 *  network related function, else: crash.

	 */

	{

		DEBUG(misc,3) ("[NET][Core] Loading bsd socket library");

		if (!(SocketBase = OpenLibrary("bsdsocket.library", 4))) {

			DEBUG(net, 0) ("[NET][Core] Error: couldn't open bsdsocket.library version 4. Network not available.");

			_network_available = false;

			return;

		}

		#if defined(__AMIGA__)

		// for usleep() implementation (only required for legacy AmigaOS builds)

		if ( (TimerPort = CreateMsgPort()) ) {

			if ( (TimerRequest = (struct timerequest *) CreateIORequest(TimerPort, sizeof(struct timerequest))) ) {

				if ( OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *) TimerRequest, 0) == 0 ) {

					if ( !(TimerBase = TimerRequest->tr_node.io_Device) ) {

						// free ressources...

						DEBUG(net, 0) ("[NET][Core] Error: couldn't initialize timer. Network not available.");

						_network_available = false;

						return;

					}

				}

			}

		}

		#endif // __AMIGA__

	}

	#endif // __MORPHOS__ / __AMIGA__

    // Network is available

	_network_available = true;

	_network_dedicated = false;

	_network_last_advertise_date = 0;

	_network_advertise_retries = 0;

	/* Load the ip from the openttd.cfg */

	_network_server_bind_ip = inet_addr(_network_server_bind_ip_host);

	/* And put the data back in it in case it was an invalid ip */

	snprintf(_network_server_bind_ip_host, sizeof(_network_server_bind_ip_host), "%s", inet_ntoa(*(struct in_addr *)&_network_server_bind_ip));

	/* Generate an unique id when there is none yet */

	if (_network_unique_id[0] == '\0')

		NetworkGenerateUniqueId();

	memset(&_network_game_info, 0, sizeof(_network_game_info));

	/* XXX - Hard number here, because the strings can currently handle no more

	    than 10 clients -- TrueLight */

	_network_game_info.clients_max = 10;

	// Let's load the network in windows

	#if defined(WIN32)

	{

		WSADATA wsa;

		DEBUG(net, 3) ("[NET][Core] Loading windows socket library");

		if (WSAStartup(MAKEWORD(2,0), &wsa) != 0) {

			DEBUG(net, 0) ("[NET][Core] Error: WSAStartup failed. Network not available.");

			_network_available = false;

			return;

		}

	}

	#endif // WIN32

	NetworkInitialize();

	DEBUG(net, 3) ("[NET][Core] Network online. Multiplayer available.");

	NetworkFindIPs();

}

// This shuts the network down

void NetworkShutDown(void)

{

	DEBUG(net, 3) ("[NET][Core] Shutting down the network.");

	_network_available = false;

	#if defined(__MORPHOS__) || defined(__AMIGA__)

	{

		// free allocated ressources

		#if defined(__AMIGA__)

			if (TimerBase)    { CloseDevice((struct IORequest *) TimerRequest); }

			if (TimerRequest) { DeleteIORequest(TimerRequest); }

			if (TimerPort)    { DeleteMsgPort(TimerPort); }

		#endif

		if (SocketBase) {

			CloseLibrary(SocketBase);

		}

	}

	#endif

	#if defined(WIN32)

	{

		WSACleanup();

	}

	#endif

}

#else

void ParseConnectionString(const char **player, const char **port, char *connection_string) {}

void NetworkUpdateClientInfo(uint16 client_index) {}

#endif /* ENABLE_NETWORK */

				_network_player_info[s->owner].num_station[4]++;

		}

	}

	ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

	// Register local player (if not dedicated)

	if (ci != NULL && ci->client_playas > 0  && ci->client_playas <= MAX_PLAYERS)

		ttd_strlcpy(_network_player_info[ci->client_playas-1].players, ci->client_name, sizeof(_network_player_info[ci->client_playas-1].players));

	FOR_ALL_CLIENTS(cs) {

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

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

		ci = DEREF_CLIENT_INFO(cs);

		if (ci != NULL && ci->client_playas > 0 && ci->client_playas <= MAX_PLAYERS) {

			if (strlen(_network_player_info[ci->client_playas-1].players) != 0)

				ttd_strlcat(_network_player_info[ci->client_playas - 1].players, ", ", lengthof(_network_player_info[ci->client_playas - 1].players));

			ttd_strlcat(_network_player_info[ci->client_playas - 1].players, client_name, lengthof(_network_player_info[ci->client_playas - 1].players));

		}

	}

}

// Send a packet to all clients with updated info about this client_index

void NetworkUpdateClientInfo(uint16 client_index)

{

	NetworkClientState *cs;

	NetworkClientInfo *ci;

	ci = NetworkFindClientInfoFromIndex(client_index);

	if (ci == NULL)

		return;

	FOR_ALL_CLIENTS(cs) {

		SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, ci);

	}

}

extern void SwitchMode(int new_mode);

/* Check if we want to restart the map */

static void NetworkCheckRestartMap(void)

{

	if (_network_restart_game_date != 0 && _cur_year + MAX_YEAR_BEGIN_REAL >= _network_restart_game_date) {

		_docommand_recursive = 0;

		DEBUG(net, 0)("Auto-restarting map. Year %d reached.", _cur_year + MAX_YEAR_BEGIN_REAL);

		_random_seeds[0][0] = Random();

		_random_seeds[0][1] = InteractiveRandom();

		SwitchMode(SM_NEWGAME);

	}

}

/* Check if the server has autoclean_companies activated

    Two things happen:

      1) If a company is not protected, it is closed after 1 year (for example)

      2) If a company is protected, protection is disabled after 3 years (for example)

           (and item 1. happens a year later) */

static void NetworkAutoCleanCompanies(void)

{

	NetworkClientState *cs;

	NetworkClientInfo *ci;

	Player *p;

	bool clients_in_company[MAX_PLAYERS];

	if (!_network_autoclean_companies)

		return;

	memset(clients_in_company, 0, sizeof(clients_in_company));

	/* Detect the active companies */

	FOR_ALL_CLIENTS(cs) {

		ci = DEREF_CLIENT_INFO(cs);

		if (ci->client_playas >= 1 && ci->client_playas <= MAX_PLAYERS) {

			clients_in_company[ci->client_playas-1] = true;

		}

	}

	if (!_network_dedicated) {

		ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

		if (ci->client_playas >= 1 && ci->client_playas <= MAX_PLAYERS) {

			clients_in_company[ci->client_playas-1] = true;

		}

	}

	/* Go through all the comapnies */

	FOR_ALL_PLAYERS(p) {

		/* Skip the non-active once */

		if (!p->is_active || p->is_ai)

			continue;

		if (!clients_in_company[p->index]) {

			/* The company is empty for one month more */

			_network_player_info[p->index].months_empty++;

			/* Is the company empty for autoclean_unprotected-months, and is there no protection? */

			if (_network_player_info[p->index].months_empty > _network_autoclean_unprotected && _network_player_info[p->index].password[0] == '\0') {

				/* Shut the company down */

				DoCommandP(0, 2, p->index, NULL, CMD_PLAYER_CTRL);

				IConsolePrintF(_icolour_def, "Auto-cleaned company #%d", p->index+1);

			}

			/* Is the compnay empty for autoclean_protected-months, and there is a protection? */

			if (_network_player_info[p->index].months_empty > _network_autoclean_protected && _network_player_info[p->index].password[0] != '\0') {

				/* Unprotect the company */

				_network_player_info[p->index].password[0] = '\0';

				IConsolePrintF(_icolour_def, "Auto-removed protection from company #%d", p->index+1);

				_network_player_info[p->index].months_empty = 0;

			}

		} else {

			/* It is not empty, reset the date */

			_network_player_info[p->index].months_empty = 0;

		}

	}

}

// This function changes new_name to a name that is unique (by adding #1 ...)

//  and it returns true if that succeeded.

bool NetworkFindName(char new_name[NETWORK_CLIENT_NAME_LENGTH])

{

	NetworkClientState *new_cs;

	NetworkClientInfo *ci;

	bool found_name = false;

	byte number = 0;

	char original_name[NETWORK_CLIENT_NAME_LENGTH];

	// We use NETWORK_NAME_LENGTH in here, because new_name is really a pointer

	ttd_strlcpy(original_name, new_name, NETWORK_CLIENT_NAME_LENGTH);

	while (!found_name) {

		found_name = true;

		FOR_ALL_CLIENTS(new_cs) {

			ci = DEREF_CLIENT_INFO(new_cs);

			if (strncmp(ci->client_name, new_name, NETWORK_CLIENT_NAME_LENGTH) == 0) {

				// Name already in use

				found_name = false;

				break;

			}

		}

		// Check if it is the same as the server-name

		ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

		if (ci != NULL) {

			if (strncmp(ci->client_name, new_name, NETWORK_CLIENT_NAME_LENGTH) == 0) {

				// Name already in use

				found_name = false;

			}

		}

		if (!found_name) {

			// Try a new name (<name> #1, <name> #2, and so on)

			// Stop if we tried for more than 50 times..

			if (number++ > 50) break;

			snprintf(new_name, NETWORK_CLIENT_NAME_LENGTH, "%s #%d", original_name, number);

		}

	}

	return found_name;

}

// Reads a packet from the stream

bool NetworkServer_ReadPackets(NetworkClientState *cs)

{

	Packet *p;

	NetworkRecvStatus res;

	while((p = NetworkRecv_Packet(cs, &res)) != NULL) {

		byte type = NetworkRecv_uint8(cs, p);

		if (type < PACKET_END && _network_server_packet[type] != NULL && !cs->quited)

			_network_server_packet[type](cs, p);

		else

			DEBUG(net, 0)("[NET][Server] Received invalid packet type %d", type);

		free(p);

	}

	return true;

}

// Handle the local command-queue

void NetworkHandleCommandQueue(NetworkClientState *cs) {

	CommandPacket *cp;

	while ( (cp = cs->command_queue) != NULL) {

		SEND_COMMAND(PACKET_SERVER_COMMAND)(cs, cp);

		cs->command_queue = cp->next;

		free(cp);

	}

}

// This is called every tick if this is a _network_server

{

	NetworkClientState *cs;

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

	bool send_sync = false;

#endif

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

	if (_frame_counter >= _last_sync_frame + _network_sync_freq) {

		_last_sync_frame = _frame_counter;

		send_sync = true;

	}

#endif

	// Now we are done with the frame, inform the clients that they can

	//  do their frame!

	FOR_ALL_CLIENTS(cs) {

		// Check if the speed of the client is what we can expect from a client

		if (cs->status == STATUS_ACTIVE) {

			// 1 lag-point per day

			int lag = NetworkCalculateLag(cs) / DAY_TICKS;

			if (lag > 0) {

				if (lag > 3) {

					// Client did still not report in after 4 game-day, drop him

					//  (that is, the 3 of above, + 1 before any lag is counted)

					IConsolePrintF(_icolour_err,"Client #%d is dropped because the client did not respond for more than 4 game-days", cs->index);

					NetworkCloseClient(cs);

					continue;

				}

				// Report once per time we detect the lag

				if (cs->lag_test == 0) {

					IConsolePrintF(_icolour_warn,"[%d] Client #%d is slow, try increasing *net_frame_freq to a higher value!", _frame_counter, cs->index);

					cs->lag_test = 1;

				}

			} else {

				cs->lag_test = 0;

			}

		} else if (cs->status == STATUS_PRE_ACTIVE) {

			int lag = NetworkCalculateLag(cs);

			if (lag > _network_max_join_time) {

				IConsolePrintF(_icolour_err,"Client #%d is dropped because it took longer than %d ticks for him to join", cs->index, _network_max_join_time);

				NetworkCloseClient(cs);

			}

		}

		if (cs->status >= STATUS_PRE_ACTIVE) {

			// Check if we can send command, and if we have anything in the queue

			NetworkHandleCommandQueue(cs);

			// Send an updated _frame_counter_max to the client

			if (send_frame)

				SEND_COMMAND(PACKET_SERVER_FRAME)(cs);

#ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME

			// Send a sync-check packet

			if (send_sync)

				SEND_COMMAND(PACKET_SERVER_SYNC)(cs);

#endif

		}

	}

	/* See if we need to advertise */

	NetworkUDPAdvertise();

}

void NetworkServerYearlyLoop(void)

{

	NetworkCheckRestartMap();

}

void NetworkServerMonthlyLoop(void)

{

	NetworkAutoCleanCompanies();

}

#endif /* ENABLE_NETWORK */

/* $Id$ */

#ifndef NETWORK_SERVER_H

#define NETWORK_SERVER_H

#ifdef ENABLE_NETWORK

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP);

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

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

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SHUTDOWN);

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_NEWGAME);

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

bool NetworkFindName(char new_name[NETWORK_NAME_LENGTH]);

void NetworkServer_HandleChat(NetworkAction action, DestType desttype, int dest, const char *msg, uint16 from_index);

bool NetworkServer_ReadPackets(NetworkClientState *cs);

void NetworkServerMonthlyLoop(void);

void NetworkServerYearlyLoop(void);

#endif /* ENABLE_NETWORK */

#endif // NETWORK_SERVER_H