{

	const char *status;

	int lag;

	const NetworkClientInfo *ci;

	FOR_ALL_CLIENTS(cs) {

		lag = NetworkCalculateLag(cs);

DEF_CONSOLE_CMD(ConResetCompany)

{

	Player *p;

	NetworkClientInfo *ci;

	if (argc == 2) {

					// If we are the server, make sure it is clear that his player is no

					//  longer with us!

					NetworkClientInfo *ci;

					/* Find all clients that were in control of this company */

					FOR_ALL_CLIENTS(cs) {

						ci = DEREF_CLIENT_INFO(cs);

// The index counter for new clients (is never decreased)

static uint16 _network_client_index = NETWORK_SERVER_INDEX + 1;

// Function that looks up the CI for a given client-index

NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index)

{

}

// Function that looks up the CS for a given client-index

{

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

		if (cs->index == client_index)

// NetworkGetClientName is a server-safe function to get the name of the client

//  if the user did not send it yet, Client #<no> is used.

{

	NetworkClientInfo *ci = DEREF_CLIENT_INFO(cs);

	if (ci->client_name[0] == '\0')

}

// Calculate the frame-lag of a client

{

	int lag = cs->last_frame_server - cs->last_frame;

	// This client has missed his ACK packet after 1 DAY_TICKS..

	NetworkError(STR_NETWORK_ERR_SERVER_START);

}

	// First, send a CLIENT_ERROR to the server, so he knows we are

	//  disconnection (and why!)

	NetworkErrorCode errorno;

	// We just want to close the connection..

	if (res == NETWORK_RECV_STATUS_CLOSE_QUERY) {

		cs->quited = true;

		_networking = false;

		DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);

	}

	_switch_mode = SM_MENU;

	_networking = false;

}

// Find all IP-aliases for this host

{

	int i, last;

// Creates a new client from a socket

//   Used both by the server and the client

{

	NetworkClientInfo *ci;

	byte client_no;

}

// Close a connection

{

	NetworkClientInfo *ci;

	// Socket is already dead

		NetworkErrorCode errorno = NETWORK_ERROR_CONNECTION_LOST;

		char str1[100], str2[100];

		char client_name[NETWORK_NAME_LENGTH];

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

	ci->client_index = NETWORK_EMPTY_INDEX;

}

// A client wants to connect to a server

{

	SOCKET s;

	struct sockaddr_in sin;

	}

	// in client mode, only the first client field is used. it's pointing to the server.

	ShowJoinStatusWindow();

{

	struct sockaddr_in sin;

	SOCKET s;

#ifndef __MORPHOS__

	int sin_len;

#else

		{int b = 1; setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const char*)&b, sizeof(b));}

		#endif

		if (cs == NULL) {

			// no more clients allowed?

			// Send to the client that we are full!

}

// Set up the listen socket for the server

{

	SOCKET ls;

	struct sockaddr_in sin;

}

// Close all current connections

{

	FOR_ALL_CLIENTS(cs) {

		if (!_network_server) {

			SEND_COMMAND(PACKET_CLIENT_QUIT)("leaving");

			NetworkSend_Packets(cs);

		}

	}

	if (_network_server) {

}

// Inits the network (cleans sockets and stuff)

{

	uint i;

	_local_command_queue = NULL;

	// add all servers from the config file to our list

	for (i=0; i != lengthof(_network_server_list); i++) {

		if (_network_server_list[i] == NULL) break;

	}

}

// validates an address entered as a string and adds the server to

// the list

{

	if (*b != '\0') {

		const byte *port = NULL;

		const byte *player = NULL;

		uint16 rport;

		ttd_strlcpy(_network_default_ip, b, lengthof(_network_default_ip));

		rport = NETWORK_DEFAULT_PORT;

		if (player != NULL) _network_playas = atoi(player);

		if (port != NULL) rport = atoi(port);

	}

}

	return _networking;

}

{

	NetworkClientInfo *ci;

void NetworkReboot(void)

{

	if (_network_server) {

		FOR_ALL_CLIENTS(cs) {

			SEND_COMMAND(PACKET_SERVER_NEWGAME)(cs);

			NetworkSend_Packets(cs);

void NetworkDisconnect(void)

{

	if (_network_server) {

		FOR_ALL_CLIENTS(cs) {

			SEND_COMMAND(PACKET_SERVER_SHUTDOWN)(cs);

			NetworkSend_Packets(cs);

}

// Receives something from the network

{

	int n;

	fd_set read_fd, write_fd;

	struct timeval tv;

// This sends all buffered commands (if possible)

static void NetworkSend(void)

{

	FOR_ALL_CLIENTS(cs) {

		if (cs->writable) {

			NetworkSend_Packets(cs);

}

// Handle the local-command-queue

{

	if (_local_command_queue != NULL) {

		CommandPacket *cp;

	}

}

{

	_frame_counter++;

	NetworkSend();

}

{

	md5_state_t state;

	md5_byte_t digest[16];

void ParseConnectionString(const byte **player, const byte **port, byte *connection_string);

void NetworkUpdateClientInfo(uint16 client_index);

#endif /* NETWORK_H */

// This file handles all the client-commands

// So we don't make too much typos ;)

#define MY_CLIENT DEREF_CLIENT(0)

	NetworkSend_Packet(p, MY_CLIENT);

}

DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_JOIN)

{

	//

}

// Reads the packets from the socket-stream, if available

{

	Packet *p;

	NetworkRecvStatus res = NETWORK_RECV_STATUS_OKAY;

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_NAME)(const char *name);

DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_ACK);

void NetworkClient_Connected(void);

#endif /* ENABLE_NETWORK */

//  as soon as possible

// (that is: the next tick, or maybe one tick later if the

//   OS-network-buffer is full)

{

	Packet *p;

	assert(packet != NULL);

//  this handles what to do.

// For clients: close connection and drop back to main-menu

// For servers: close connection and that is it

{

	// Clients drop back to the main menu

	if (!_network_server) {

//   2) the OS reports back that it can not send any more

//        data right now (full network-buffer, it happens ;))

//   3) sending took too long

{

	ssize_t res;

	Packet *p;

// (the line: 'p->size = (uint16)p->buffer[0];' and below)

assert_compile(sizeof(PacketSize) == 2);

{

	ssize_t res;

	Packet *p;

}

// Add a command to the local command queue

{

	CommandPacket *new_cp = malloc(sizeof(CommandPacket));

		//   client on the server can do everything 1 tick faster then others.

		//   So to keep the game fair, we delay the command with 1 tick

		//   which gives about the same speed as most clients.

		// And we queue it for delivery to the clients

		FOR_ALL_CLIENTS(cs) {

} NetworkPasswordType;

// To keep the clients all together

	int socket;

	uint16 index;

	uint32 last_frame;

	Packet *packet_recv; // Partially received packet

	CommandPacket *command_queue; // The command-queue awaiting delivery

// What packet types are there

// WARNING: The first 3 packets can NEVER change order again

// Here we keep track of the clients

//  (and the client uses [0] for his own communication)

#define DEREF_CLIENT(i) (&_clients[i])

#define DEREF_CLIENT_INFO(cs) (&_network_client_info[cs - _clients])

// Macros to make life a bit more easier

#define DEF_CLIENT_RECEIVE_COMMAND(type) NetworkRecvStatus NetworkPacketReceive_ ## type ## _command(Packet *p)

#define DEF_CLIENT_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(void)

#define DEF_CLIENT_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

#define DEF_SERVER_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

#define SEND_COMMAND(type) NetworkPacketSend_ ## type ## _command

void NetworkSend_uint32(Packet *packet, uint32 data);

void NetworkSend_uint64(Packet *packet, uint64 data);

void NetworkSend_string(Packet *packet, const char* data);

uint8 NetworkRecv_uint8(Packet *packet);

uint16 NetworkRecv_uint16(Packet *packet);

uint32 NetworkRecv_uint32(Packet *packet);

uint64 NetworkRecv_uint64(Packet *packet);

void NetworkRecv_string(Packet *packet, char* buffer, size_t size);

void NetworkExecuteCommand(CommandPacket *cp);

// from network.c

void CDECL NetworkTextMessage(NetworkAction action, uint16 color, const char *name, const char *str, ...);

byte NetworkGetCurrentLanguageIndex();

NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index);

unsigned long NetworkResolveHost(const char *hostname);

#endif /* ENABLE_NETWORK */

	return item;

}

{

	// We queried a server and now we are going to add it to the list

	NetworkGameList *item;

void NetworkGameListClear(void);

NetworkGameList *NetworkGameListAddItem(uint32 ip, uint16 port);

#endif /* NETWORK_GAMELIST_H */

		break;

	case WE_ON_EDIT_TEXT: {

	} break;

	case WE_CREATE: {

// This file handles all the server-commands

void NetworkPopulateCompanyInfo(void);

// Is the network enabled?

// **********

// Sending functions

// **********

{

	//

	// Packet: SERVER_CLIENT_INFO

	}

}

{

	//

	// Packet: SERVER_ERROR

	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)

	//

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

	NetworkSend_Packets(cs);

	// The client made a mistake, so drop his connection now!

}

{

	//

	// Packet: SERVER_NEED_PASSWORD

	//

	Packet *p;

	// Invalid packet when status is AUTH or higher

	if (cs->status >= STATUS_AUTH)

	//    uint8:  Clients awaiting map

	//

	int waiting = 0;

	Packet *p;

	// Count how many players are waiting in the queue

				fclose(file_pointer);

				{

					bool new_map_client = false;

					// Check if there is a client waiting for receiving the map

					//  and start sending him the map

	}

}

{

	//

	// Packet: SERVER_JOIN

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_COMMAND

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_CHAT

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_ERROR_QUIT

	NetworkSend_Packet(p, cs);

}

{

	//

	// Packet: SERVER_ERROR_QUIT

// **********

// Receiving functions

// **********

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO)

	SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)(cs);

}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)

{

	char name[NETWORK_NAME_LENGTH];

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)

{

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

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

	if (cs->status == STATUS_DONE_MAP && !cs->quited) {

		char client_name[NETWORK_NAME_LENGTH];

		char str[100];

		GetString(str, STR_NETWORK_CLIENT_JOINED);

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

	// The client has done a command and wants us to handle it

	int i;

	byte callback;

	NetworkClientInfo *ci;

	char *dparam_char;

{

	// This packets means a client noticed an error and is reporting this

	//  to us. Display the error and report it to the other clients

	byte errorno = NetworkRecv_uint8(p);

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

{

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

	//  clients.

	char str1[100], str2[100];

	char client_name[NETWORK_NAME_LENGTH];

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

{

	NetworkClientInfo *ci, *ci_own, *ci_to;

	switch (desttype) {

}

// The layout for the receive-functions by the server

// This array matches PacketType. At an incoming

// This is a TEMPORARY solution to get the patch-settings

//  to the client. When the patch-settings are saved in the savegame

//  this should be removed!!

{

	const SettingDesc *item;

	Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

	Player *p;

	Vehicle *v;

	Station *s;

	NetworkClientInfo *ci;

	int i;

	uint16 months_empty;

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

void NetworkUpdateClientInfo(uint16 client_index)

{

	NetworkClientInfo *ci;

	ci = NetworkFindClientInfoFromIndex(client_index);

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

static void NetworkAutoCleanCompanies()

{

	NetworkClientInfo *ci;

	Player *p;

	bool clients_in_company[MAX_PLAYERS];

//  and it returns true if that succeeded.

bool NetworkFindName(char new_name[NETWORK_NAME_LENGTH])

{

	NetworkClientInfo *ci;

	bool found_name = false;

	byte number = 0;

}

// Reads a packet from the stream