closesocket(cs->socket);

	cs->writable = false;

	cs->quited = true;

	// Free all pending and partially received packets

	while (cs->packet_queue != NULL) {

		Packet *p = cs->packet_queue->next;

		free(cs->packet_queue);

		cs->packet_queue = p;

	}

	free(cs->packet_recv);

	cs->packet_recv = NULL;

	while (cs->command_queue != NULL) {

		CommandPacket *p = cs->command_queue->next;

		free(cs->command_queue);

		cs->command_queue = p;

	}

	// Close the gap in the client-list

	ci = DEREF_CLIENT_INFO(cs);

	if (_network_server) {

		// We just lost one client :(

			_network_game_info.clients_on--;

		_network_clients_connected--;

		while ((cs + 1) != DEREF_CLIENT(MAX_CLIENTS) && (cs + 1)->socket != INVALID_SOCKET) {

			*cs = *(cs + 1);

			*ci = *(ci + 1);

			cs++;

			ci++;

		}

		InvalidateWindow(WC_CLIENT_LIST, 0);

	}

	// Reset the status of the last socket

	cs->socket = INVALID_SOCKET;

	cs->status = STATUS_INACTIVE;

	cs->index = NETWORK_EMPTY_INDEX;

	ci->client_index = NETWORK_EMPTY_INDEX;

}

// A client wants to connect to a server

static bool NetworkConnect(const char *hostname, int port)

{

	SOCKET s;

	struct sockaddr_in sin;

		// We are a server, also close the listensocket

		closesocket(_listensocket);

		_listensocket = INVALID_SOCKET;

		DEBUG(net, 1) ("[NET] Closed listener");

		NetworkUDPClose();

	}

}

// Inits the network (cleans sockets and stuff)

static void NetworkInitialize(void)

{

	NetworkClientState *cs;

	_local_command_queue = NULL;

	// Clean all client-sockets

	memset(_clients, 0, sizeof(_clients));

	for (cs = _clients; cs != &_clients[MAX_CLIENTS]; cs++) {

		cs->socket = INVALID_SOCKET;

		cs->status = STATUS_INACTIVE;

		cs->command_queue = NULL;

	}

	// Clean the client_info memory

	_sync_frame = 0;

	_network_first_time = true;

	_network_reconnect = 0;

	NetworkUDPInitialize();

}

// Query a server to fetch his game-info

//  If game_info is true, only the gameinfo is fetched,

//   else only the client_info is fetched

NetworkGameList *NetworkQueryServer(const char* host, unsigned short port, bool game_info)

{

	if (!_network_available) return NULL;

	NetworkDisconnect();

	if (game_info) {

		return NetworkUDPQueryServer(host, port);

	}

	NetworkInitialize();

	_networking = NetworkConnect(host, port);

	// We are connected

	if (_networking) {

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

		NetworkClient_Connected();

	} else {

		// Connecting failed

		NetworkError(STR_NETWORK_ERR_NOCONNECTION);

	}

	return _networking;

}

static void NetworkInitGameInfo(void)

{

	NetworkClientInfo *ci;

	ttd_strlcpy(_network_game_info.server_name, _network_server_name, sizeof(_network_game_info.server_name));

	ttd_strlcpy(_network_game_info.server_password, _network_server_password, sizeof(_network_server_password));

	ttd_strlcpy(_network_game_info.rcon_password, _network_rcon_password, sizeof(_network_rcon_password));

	if (_network_game_info.server_name[0] == '\0')

		snprintf(_network_game_info.server_name, sizeof(_network_game_info.server_name), "Unnamed Server");

	// The server is a client too ;)

	if (_network_dedicated) {

		_network_game_info.clients_on = 0;

		_network_game_info.dedicated = true;

	} else {

		_network_game_info.clients_on = 1;

		_network_game_info.dedicated = false;

	}

	_network_game_info.spectators_on = 0;

	_network_game_info.game_date = _date;

	_network_game_info.start_date = ConvertIntDate(_patches.starting_date);

	_network_game_info.map_width = MapSizeX();

	_network_game_info.map_height = MapSizeY();

	_network_game_info.map_set = _opt.landscape;

	_network_game_info.use_password = (_network_server_password[0] != '\0');

	// We use _network_client_info[MAX_CLIENT_INFO - 1] to store the server-data in it

	//  The index is NETWORK_SERVER_INDEX ( = 1)

	ci = &_network_client_info[MAX_CLIENT_INFO - 1];

	memset(ci, 0, sizeof(*ci));

	ci->client_index = NETWORK_SERVER_INDEX;

	if (_network_dedicated)

		ci->client_playas = OWNER_SPECTATOR;

	else

		ci->client_playas = _local_player + 1;

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

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

}

bool NetworkServerStart(void)

{

						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_frame = 0;

	_network_need_advertise = true;

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

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

	// 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.");