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_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