#ifdef ENABLE_NETWORK

DEF_CONSOLE_CMD(ConStatus)

{

	const char *status;

	int lag;

	const NetworkClientInfo *ci;

	FOR_ALL_CLIENTS(cs) {

		lag = NetworkCalculateLag(cs);

		ci = DEREF_CLIENT_INFO(cs);

		switch (cs->status) {

	return NULL;

}

DEF_CONSOLE_CMD(ConResetCompany)

{

	Player *p;

	NetworkClientInfo *ci;

	if (argc == 2) {

		uint32 index = atoi(argv[1]);

		/* Check valid range */

			} else {

#ifdef ENABLE_NETWORK

				if (IS_HUMAN_PLAYER(owner) && _network_server) {

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

						if ((ci->client_playas-1) == owner) {

							ci->client_playas = OWNER_SPECTATOR;

							// Send the new info to all the clients

// The amount of clients connected

static byte _network_clients_connected = 0;

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

{

	NetworkClientInfo *ci;

	for (ci = _network_client_info; ci != &_network_client_info[MAX_CLIENT_INFO]; ci++)

			return ci;

	return NULL;

}

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

			return cs;

	return NULL;

}

// 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')

		snprintf(client_name, size, "Client #%d", cs->index);

	else

		snprintf(client_name, size, "%s", ci->client_name);

			AddTextMessage(color, duration, "[All] %s: %s", name, buf);

			break;

	}

}

// 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..

	//  so we increase his lag for every frame that passes!

	// The packet can be out by a max of _net_frame_freq

	if (cs->last_frame_server + DAY_TICKS + _network_frame_freq < _frame_counter)

void ServerStartError(char *error) {

	DEBUG(net, 0)("[NET] Server could not start network: %s",error);

	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);

		return;

	}

		// Dequeue all commands before closing the socket

		NetworkSend_Packets(DEREF_CLIENT(0));

	}

	_switch_mode = SM_MENU;

	_networking = false;

}

// Find all IP-aliases for this host

{

	int i, last;

#if defined(BEOS_NET_SERVER) /* doesn't have neither getifaddrs or net/if.h */

	/* Based on Andrew Bachmann's netstat+.c. Big thanks to him! */

	int _netstat(int fd, char **output, int verbose);

		}

	}

}

// Creates a new client from a socket

//   Used both by the server and the client

{

	NetworkClientInfo *ci;

	byte client_no;

	client_no = 0;

	if (_network_server) {

	}

	return cs;

}

// Close a connection

{

	NetworkClientInfo *ci;

	// Socket is already dead

	if (cs->socket == INVALID_SOCKET) return;

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

	if (!cs->quited && _network_server && cs->status > STATUS_INACTIVE) {

		// We did not receive a leave message from this client...

		NetworkErrorCode errorno = NETWORK_ERROR_CONNECTION_LOST;

		char str1[100], str2[100];

		char client_name[NETWORK_NAME_LENGTH];

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

		GetString(str1, STR_NETWORK_ERR_LEFT);

		GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + errorno);

	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

{

	SOCKET s;

	struct sockaddr_in sin;

	DEBUG(net, 1) ("[NET] Connecting to %s %d", hostname, port);

		if (ioctlsocket(s, FIONBIO, &blocking) != 0)

		#endif

			DEBUG(net, 0)("[NET] Setting non-blocking failed"); /* XXX should this be an error? */

	}

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

	ShowJoinStatusWindow();

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

	return true;

// For the server, to accept new clients

static void NetworkAcceptClients(void)

{

	struct sockaddr_in sin;

	SOCKET s;

#ifndef __MORPHOS__

	int sin_len;

#else

	LONG sin_len; // for some reason we need a 'LONG' under MorphOS

#endif

		// set nodelay

		#if !defined(BEOS_NET_SERVER) // not implemented on BeOS net_server...

		// The (const char*) cast is needed for windows!!

		{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!

			Packet *p = NetworkSend_Init(PACKET_SERVER_FULL);

			p->buffer[0] = p->size & 0xFF;

			ci->client_ip = sin.sin_addr.s_addr;

		}

	}

}

// Set up the listen socket for the server

{

	SOCKET ls;

	struct sockaddr_in sin;

	int port;

	port = _network_server_port;

	_listensocket = ls;

	return true;

}

// Close all current connections

{

	FOR_ALL_CLIENTS(cs) {

		if (!_network_server) {

			SEND_COMMAND(PACKET_CLIENT_QUIT)("leaving");

			NetworkSend_Packets(cs);

		}

	}

	if (_network_server) {

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

{

	uint i;

	_local_command_queue = NULL;

	// Clean all client-sockets

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

	NetworkUDPInitialize();

	// 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;

	}

}

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

	// No networking, close everything down again

	NetworkDisconnect();

}

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

	}

}

// Used by clients, to connect to a server

bool NetworkClientConnectGame(const byte* host, unsigned short port)

{

		NetworkError(STR_NETWORK_ERR_NOCONNECTION);

	}

	return _networking;

}

{

	NetworkClientInfo *ci;

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

	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 rebooting...

// The only difference with NetworkDisconnect, is the packets that is sent

void NetworkReboot(void)

{

	if (_network_server) {

		FOR_ALL_CLIENTS(cs) {

			SEND_COMMAND(PACKET_SERVER_NEWGAME)(cs);

			NetworkSend_Packets(cs);

		}

	}

}

// We want to disconnect from the host/clients

void NetworkDisconnect(void)

{

	if (_network_server) {

		FOR_ALL_CLIENTS(cs) {

			SEND_COMMAND(PACKET_SERVER_SHUTDOWN)(cs);

			NetworkSend_Packets(cs);

		}

	}

	_networking = false;

	_network_server = false;

}

// Receives something from the network

{

	int n;

	fd_set read_fd, write_fd;

	struct timeval tv;

	FD_ZERO(&read_fd);

	FD_ZERO(&write_fd);

	return true;

}

// This sends all buffered commands (if possible)

static void NetworkSend(void)

{

	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

			}

		}

	}

}

// Handle the local-command-queue

{

	if (_local_command_queue != NULL) {

		CommandPacket *cp;

		CommandPacket *cp_prev;

		cp = _local_command_queue;

				cp = cp->next;

			}

		}

	}

}

{

	_frame_counter++;

	NetworkHandleLocalQueue();

	StateGameLoop();

		}

	}

	NetworkSend();

}

{

	md5_state_t state;

	md5_byte_t digest[16];

	char hex_output[16*2 + 1];

	char coding_string[NETWORK_NAME_LENGTH];

	int di;

VARDEF bool _network_server; // network-server is active

VARDEF bool _network_dedicated; // are we a dedicated server?

VARDEF byte _network_playas; // an id to play as..

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

void NetworkUpdateClientInfo(uint16 client_index);

#endif /* NETWORK_H */

#include "settings.h"

// This file handles all the client-commands

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

#define MY_CLIENT DEREF_CLIENT(0)

static uint32 last_ack_frame;

void NetworkRecvPatchSettings(Packet *p);

	InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);

	p = NetworkSend_Init(PACKET_CLIENT_COMPANY_INFO);

	NetworkSend_Packet(p, MY_CLIENT);

}

DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_JOIN)

{

	//

	// Packet: CLIENT_JOIN

	// Function: Try to join the server

	// Data:

	last_ack_frame = 0;

	// Request the game-info

	SEND_COMMAND(PACKET_CLIENT_JOIN)();

}

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

{

	Packet *p;

	NetworkRecvStatus res = NETWORK_RECV_STATUS_OKAY;

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

		byte type = NetworkRecv_uint8(p);

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_CHAT)(NetworkAction action, DestType desttype, int dest, const char *msg);

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_PASSWORD)(NetworkPasswordType type, const char *password);

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_PASSWORD)(const char *password);

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

#endif // NETWORK_CLIENT_H

assert_compile(sizeof(PacketSize) == 2);

// This function puts the packet in the send-queue and it is send

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

	packet->pos = 0;

	packet->next = NULL;

// Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

//  A socket can make errors. When that happens

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

		_switch_mode = SM_MENU;

		_networking = false;

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

// Sends all the buffered packets out for this client

//  it stops when:

//   1) all packets are send (queue is empty)

//   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;

	// We can not write to this socket!!

	if (!cs->writable) return false;

// If PacketSize changes of size, you have to change the 2 packet->size

//   lines below matching the size of packet->size/PacketSize!

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

assert_compile(sizeof(PacketSize) == 2);

{

	ssize_t res;

	Packet *p;

	*status = NETWORK_RECV_STATUS_OKAY;

	cs->packet_recv = NULL;

	return p;

}

// Add a command to the local command queue

{

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

	*new_cp = *cp;

	if (cs->command_queue == NULL)

	if (_network_server) {

		// If we are the server, we queue the command in our 'special' queue.

		//   In theory, we could execute the command right away, but then the

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

			if (cs->status > STATUS_AUTH) {

				NetworkAddCommandQueue(cs, c);

			}

typedef enum {

	NETWORK_GAME_PASSWORD,

	NETWORK_COMPANY_PASSWORD,

} NetworkPasswordType;

// To keep the clients all together

	int socket;

	uint16 index;

	uint32 last_frame;

	uint32 last_frame_server;

	byte lag_test; // This byte is used for lag-testing the client

	bool quited;

	Packet *packet_queue; // Packets that are awaiting delivery

	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

//   it protects old clients from joining newer servers (because SERVER_ERROR

//   is the respond to a wrong revision)

typedef enum {

CommandPacket *_local_command_queue;

SOCKET _udp_client_socket; // udp client socket

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

#define RECEIVE_COMMAND(type) NetworkPacketReceive_ ## type ## _command

#define FOR_ALL_CLIENTS(cs) for (cs = _clients; cs != &_clients[MAX_CLIENTS] && cs->socket != INVALID_SOCKET; cs++)

Packet *NetworkSend_Init(PacketType type);

void NetworkSend_uint8(Packet *packet, uint8 data);

void NetworkSend_uint16(Packet *packet, uint16 data);

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

#endif // NETWORK_DATA_H

	UpdateNetworkGameWindow(false);

	return item;

}

{

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

	NetworkGameList *item;

	item = NetworkGameListAddItem(_network_last_host_ip, _network_last_port);

	item->online = server_online;

#ifndef NETWORK_GAMELIST_H

#define NETWORK_GAMELIST_H

void NetworkGameListClear(void);

NetworkGameList *NetworkGameListAddItem(uint32 ip, uint16 port);