cpp/openttd-patchpack/source Changeset - r716:ae3edbaa50e7

Changeset - r716:ae3edbaa50e7

Parent rev.

Child rev.

[Not reviewed]

master

0 15 0

truelight - 19 years ago 2004-12-19 10:17:26
truelight@openttd.org

(svn r1168) -Cleanup: [Network] Cleaned the network code a bit. Added 'const'
and 'void' where needed, prefixed all functions, typedefs and global
vars with 'Network' and organized all externals nicely.

15 files changed with 118 insertions and 116 deletions:

console_cmds.c

economy.c

network.c

network.h

network_client.c

network_client.h

network_data.c

network_data.h

network_gamelist.c

network_gamelist.h

network_gui.c

network_server.c

network_server.h

network_udp.c

network_udp.h

0 comments (0 inline, 0 general)

console_cmds.c

➞

Show inline comments

@@ @@ -138,25 +138,25 @@ DEF_CONSOLE_CMD(ConScrollToTile) @@
+}
 // ********************************* //
 // * Network Core Console Commands * //
 // ********************************* //
 #ifdef ENABLE_NETWORK
 DEF_CONSOLE_CMD(ConStatus)
+{
 	const char *status;
 	int lag;
-	const ClientState *cs;
+	const NetworkClientState *cs;
 	const NetworkClientInfo *ci;
 	FOR_ALL_CLIENTS(cs) {
 		lag = NetworkCalculateLag(cs);
 		ci = DEREF_CLIENT_INFO(cs);
 		switch (cs->status) {
 			case STATUS_INACTIVE:
 				status = "inactive";
 				break;
 			case STATUS_AUTH:
 				status = "authorized";
 				break;
@@ @@ -208,25 +208,25 @@ DEF_CONSOLE_CMD(ConKick) @@
 			return NULL;
+		}
+	}
 	IConsolePrint(_iconsole_color_default, "Unknown usage. Usage: kick <client-id>. For client-ids, see 'clients'.");
 	return NULL;
+}
 DEF_CONSOLE_CMD(ConResetCompany)
+{
 	Player *p;
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci;
 	if (argc == 2) {
 		uint32 index = atoi(argv[1]);
 		/* Check valid range */
 		if (index < 1 || index > MAX_PLAYERS) {
 			IConsolePrintF(_iconsole_color_error, "Company does not exist. Company-ID must be between 1 and %d.", MAX_PLAYERS);
 			return NULL;
+		}
 		/* Check if company does exist */

economy.c

➞

Show inline comments

@@ @@ -393,25 +393,25 @@ static void PlayersCheckBankrupt(Player @@
 			AddNewsItem( (StringID)(owner + 16*3), NEWS_FLAGS(NM_CALLBACK, 0, NT_COMPANY_INFO, DNC_BANKRUPCY),0,0);
 			// If the player is human, and it is no network play, leave the player playing
 			if (IS_HUMAN_PLAYER(owner) && !_networking) {
 				p->bankrupt_asked = 255;
 				p->bankrupt_timeout = 0x456;
 			} 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;
-					ClientState *cs;
+					NetworkClientState *cs;
 					/* 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
 							NetworkUpdateClientInfo(_network_own_client_index);
+						}
+					}
+				}
 				// Make sure the player no longer controls the company
 				if (IS_HUMAN_PLAYER(owner) && owner == _local_player) {

network.c

➞

Show inline comments

@@ @@ -26,51 +26,55 @@ @@
 // The listen socket for the server
 static SOCKET _listensocket;
 // Network copy of patches, so the patches of a client are not fucked up
 //  after he joined a server
 static Patches network_tmp_patches;
 // 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;
 /* Some externs / forwards */
 extern void ShowJoinStatusWindow();
 extern void StateGameLoop();
 // 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++)
 		if (ci->client_index == client_index)
 			return ci;
 	return NULL;
+}
 // Function that looks up the CS for a given client-index
-ClientState *NetworkFindClientStateFromIndex(uint16 client_index)
+NetworkClientState *NetworkFindClientStateFromIndex(uint16 client_index)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	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.
-void NetworkGetClientName(char *client_name, size_t size, ClientState *cs)
+void NetworkGetClientName(char *client_name, size_t size, const NetworkClientState *cs)
+{
 	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);
+}
 // This puts a text-message to the console, or in the future, the chat-box,
 //  (to keep it all a bit more general)
 void CDECL NetworkTextMessage(NetworkAction action, uint16 color, const char *name, const char *str, ...)
+{
@@ @@ -110,25 +114,25 @@ void CDECL NetworkTextMessage(NetworkAct @@
 		case NETWORK_ACTION_NAME_CHANGE:
 			IConsolePrintF(color, "*** %s changed his name to %s", name, buf);
 			AddTextMessage(color, duration, "*** %s changed his name to %s", name, buf);
 			break;
 		default:
 			IConsolePrintF(color, "[All] %s: %s", name, buf);
 			AddTextMessage(color, duration, "[All] %s: %s", name, buf);
 			break;
+	}
+}
 // Calculate the frame-lag of a client
-uint NetworkCalculateLag(const ClientState *cs)
+uint NetworkCalculateLag(const NetworkClientState *cs)
+{
 	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)
 		lag += _frame_counter - (cs->last_frame_server + DAY_TICKS + _network_frame_freq);
 	return lag;
+}
@@ @@ -141,59 +145,59 @@ void NetworkError(StringID error_string) @@
+}
 void ClientStartError(char *error) {
 	DEBUG(net, 0)("[NET] Client could not start network: %s",error);
 	NetworkError(STR_NETWORK_ERR_CLIENT_START);
+}
 void ServerStartError(char *error) {
 	DEBUG(net, 0)("[NET] Server could not start network: %s",error);
 	NetworkError(STR_NETWORK_ERR_SERVER_START);
+}
-void NetworkClientError(byte res, ClientState *cs) {
+static void NetworkClientError(byte res, NetworkClientState *cs) {
 	// 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;
-		CloseClient(cs);
+		NetworkCloseClient(cs);
 		_networking = false;
 		DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
 		return;
+	}
 	switch(res) {
 		case NETWORK_RECV_STATUS_DESYNC: errorno = NETWORK_ERROR_DESYNC; break;
 		case NETWORK_RECV_STATUS_SAVEGAME: errorno = NETWORK_ERROR_SAVEGAME_FAILED; break;
 		default: errorno = NETWORK_ERROR_GENERAL;
+	}
 	// This means we fucked up and the server closed the connection
 	if (res != NETWORK_RECV_STATUS_SERVER_ERROR && res != NETWORK_RECV_STATUS_SERVER_FULL) {
 		SEND_COMMAND(PACKET_CLIENT_ERROR)(errorno);
 		// Dequeue all commands before closing the socket
 		NetworkSend_Packets(DEREF_CLIENT(0));
+	}
 	_switch_mode = SM_MENU;
-	CloseClient(cs);
+	NetworkCloseClient(cs);
 	_networking = false;
+}
 // Find all IP-aliases for this host
 void NetworkFindIPs(void)
+static void NetworkFindIPs(void)
+{
 	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);
 	int seek_past_header(char **pos, const char *header) {
 		char *new_pos = strstr(*pos, header);
 		if (new_pos == 0) {
 			return B_ERROR;
+		}
@@ @@ -379,27 +383,27 @@ void ParseConnectionString(const byte ** @@
 		if (*p == '#') {
 			*player = p + 1;
 			*p = '\0';
 		} else if (*p == ':') {
 			*port = p + 1;
 			*p = '\0';
+		}
+	}
+}
 // Creates a new client from a socket
 //   Used both by the server and the client
-static ClientState *AllocClient(SOCKET s)
+static NetworkClientState *NetworkAllocClient(SOCKET s)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci;
 	byte client_no;
 	client_no = 0;
 	if (_network_server) {
 		// Can we handle a new client?
 		if (_network_clients_connected >= MAX_CLIENTS)
 			return NULL;
 		if (_network_game_info.clients_on >= _network_game_info.clients_max)
 			return NULL;
@@ @@ -420,38 +424,38 @@ static ClientState *AllocClient(SOCKET s @@
 		cs->index = _network_client_index++;
 		ci->client_index = cs->index;
 		ci->join_date = _date;
 		InvalidateWindow(WC_CLIENT_LIST, 0);
+	}
 	return cs;
+}
 // Close a connection
-void CloseClient(ClientState *cs)
+void NetworkCloseClient(NetworkClientState *cs)
+{
 	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];
-		ClientState *new_cs;
+		NetworkClientState *new_cs;
 		NetworkGetClientName(client_name, sizeof(client_name), cs);
 		GetString(str1, STR_NETWORK_ERR_LEFT);
 		GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + errorno);
 		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, client_name, "%s (%s)", str1, str2);
 		// Inform other clients of this... strange leaving ;)
 		FOR_ALL_CLIENTS(new_cs) {
 			if (new_cs->status > STATUS_AUTH && cs != new_cs) {
 				SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->index, errorno);
@@ @@ -494,28 +498,26 @@ void CloseClient(ClientState *cs) @@
+		}
 		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;
+}
 extern void ShowJoinStatusWindow();
 // A client wants to connect to a server
 bool NetworkConnect(const char *hostname, int port)
+static bool NetworkConnect(const char *hostname, int port)
+{
 	SOCKET s;
 	struct sockaddr_in sin;
 	DEBUG(net, 1) ("[NET] Connecting to %s %d", hostname, port);
 	s = socket(AF_INET, SOCK_STREAM, 0);
 	if (s == INVALID_SOCKET) {
 		ClientStartError("socket() failed");
 		return false;
+	}
@@ @@ -541,39 +543,39 @@ bool NetworkConnect(const char *hostname @@
 	{ // set nonblocking mode for socket..
 		unsigned long blocking = 1;
 		#if defined(__BEOS__) && defined(BEOS_NET_SERVER)
 		byte nonblocking = 1;
 		if (setsockopt(s, SOL_SOCKET, SO_NONBLOCK, &nonblocking, sizeof(blocking)) != 0)
 		#else
 		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.
-	AllocClient(s);
+	NetworkAllocClient(s);
 	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;
-	ClientState *cs;
+	NetworkClientState *cs;
 #ifndef __MORPHOS__
 	int sin_len;
 #else
 	LONG sin_len; // for some reason we need a 'LONG' under MorphOS
 #endif
 	// Should never ever happen.. is it possible??
 	assert(_listensocket != INVALID_SOCKET);
 	for (;;) {
 		sin_len = sizeof(sin);
 		s = accept(_listensocket, (struct sockaddr*)&sin, &sin_len);
@@ @@ -585,25 +587,25 @@ static void NetworkAcceptClients(void) @@
 		#else
 		{ unsigned long blocking = 1; ioctlsocket(s, FIONBIO, &blocking); }
 		#endif
 		DEBUG(net, 1) ("[NET] Client connected from %s on frame %d", inet_ntoa(sin.sin_addr), _frame_counter);
 		// 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
-		cs = AllocClient(s);
+		cs = NetworkAllocClient(s);
 		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;
 			p->buffer[1] = p->size >> 8;
 			send(s, p->buffer, p->size, 0);
 			closesocket(s);
 			free(p);
@@ @@ -617,25 +619,25 @@ static void NetworkAcceptClients(void) @@
 		cs->status = STATUS_INACTIVE;
+		{
 			// Save the IP of the client
 			NetworkClientInfo *ci;
 			ci = DEREF_CLIENT_INFO(cs);
 			ci->client_ip = sin.sin_addr.s_addr;
+		}
+	}
+}
 // Set up the listen socket for the server
 bool NetworkListen(void)
+static bool NetworkListen(void)
+{
 	SOCKET ls;
 	struct sockaddr_in sin;
 	int port;
 	port = _network_server_port;
 	DEBUG(net, 1) ("[NET] Listening on %s:%d", _network_server_bind_ip_host, port);
 	ls = socket(AF_INET, SOCK_STREAM, 0);
 	if (ls == INVALID_SOCKET) {
 		ServerStartError("socket() on listen socket failed");
@@ @@ -673,49 +675,49 @@ bool NetworkListen(void) @@
 	if (listen(ls, 1) != 0) {
 		ServerStartError("listen() failed");
 		return false;
+	}
 	_listensocket = ls;
 	return true;
+}
 // Close all current connections
 void NetworkClose(void)
+static void NetworkClose(void)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	FOR_ALL_CLIENTS(cs) {
 		if (!_network_server) {
 			SEND_COMMAND(PACKET_CLIENT_QUIT)("leaving");
 			NetworkSend_Packets(cs);
+		}
-		CloseClient(cs);
+		NetworkCloseClient(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)
 void NetworkInitialize(void)
+static void NetworkInitialize(void)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	uint i;
 	_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;
+	}
@@ @@ -726,25 +728,25 @@ void NetworkInitialize(void) @@
 	_sync_frame = 0;
 	_network_first_time = true;
 	_network_reconnect = 0;
 	InitPlayerRandoms();
 	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;
-		AddServer(_network_server_list[i]);
+		NetworkAddServer(_network_server_list[i]);
+	}
+}
 // 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
 void NetworkQueryServer(const byte* host, unsigned short port, bool game_info)
+{
 	if (!_network_available) return;
 	NetworkDisconnect();
@@ @@ -766,40 +768,43 @@ void NetworkQueryServer(const byte* host @@
 	// We are connected
 	if (_networking) {
 		SEND_COMMAND(PACKET_CLIENT_COMPANY_INFO)();
 		return;
+	}
 	// No networking, close everything down again
 	NetworkDisconnect();
+}
 // validates an address entered as a string and adds the server to
 // the list
-void AddServer(byte *b)
+void NetworkAddServer(const byte *b)
+{
 	if (*b != '\0') {
 		const byte *port = NULL;
 		const byte *player = NULL;
 		byte host[NETWORK_HOSTNAME_LENGTH];
 		uint16 rport;
 		ttd_strlcpy(host, b, lengthof(host));
 		ttd_strlcpy(_network_default_ip, b, lengthof(_network_default_ip));
 		rport = NETWORK_DEFAULT_PORT;
-		ParseConnectionString(&player, &port, b);
+		ParseConnectionString(&player, &port, host);
 		if (player != NULL) _network_playas = atoi(player);
 		if (port != NULL) rport = atoi(port);
-		NetworkQueryServer(b, rport, true);
+		NetworkQueryServer(host, rport, true);
+	}
+}
 // Used by clients, to connect to a server
 bool NetworkClientConnectGame(const byte* host, unsigned short port)
+{
 	if (!_network_available) return false;
 	if (port == 0) return false;
 	ttd_strlcpy(_network_last_host, host, sizeof(_network_last_host));
 	_network_last_port = port;
@@ @@ -814,25 +819,25 @@ bool NetworkClientConnectGame(const byte @@
 	// We are connected
 	if (_networking) {
 		IConsoleCmdExec("exec scripts/on_client.scr 0");
 		NetworkClient_Connected();
 	} else {
 		// Connecting failed
 		NetworkError(STR_NETWORK_ERR_NOCONNECTION);
+	}
 	return _networking;
+}
 void NetworkInitGameInfo(void)
+static void NetworkInitGameInfo(void)
+{
 	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 a client too ;)
 	if (_network_dedicated) {
 		_network_game_info.clients_on = 0;
 		_network_game_info.dedicated = true;
 	} else {
@@ @@ -904,49 +909,49 @@ bool NetworkServerStart(void) @@
 	/* Try to register us to the master server */
 	_network_last_advertise_date = 0;
 	NetworkUDPAdvertise();
 	return true;
+}
 // The server is rebooting...
 // The only difference with NetworkDisconnect, is the packets that is sent
 void NetworkReboot(void)
+{
 	if (_network_server) {
-		ClientState *cs;
+		NetworkClientState *cs;
 		FOR_ALL_CLIENTS(cs) {
 			SEND_COMMAND(PACKET_SERVER_NEWGAME)(cs);
 			NetworkSend_Packets(cs);
+		}
+	}
 	NetworkClose();
 	// Free all queued commands
 	while (_local_command_queue != NULL) {
 		CommandPacket *p = _local_command_queue;
 		_local_command_queue = _local_command_queue->next;
 		free(p);
+	}
 	_networking = false;
 	_network_server = false;
+}
 // We want to disconnect from the host/clients
 void NetworkDisconnect(void)
+{
 	if (_network_server) {
-		ClientState *cs;
+		NetworkClientState *cs;
 		FOR_ALL_CLIENTS(cs) {
 			SEND_COMMAND(PACKET_SERVER_SHUTDOWN)(cs);
 			NetworkSend_Packets(cs);
+		}
+	}
 	DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
 	NetworkClose();
 	// Free all queued commands
 	while (_local_command_queue != NULL) {
@@ @@ -955,27 +960,27 @@ void NetworkDisconnect(void) @@
 		free(p);
+	}
 	if (_networking && !_network_server) {
 		memcpy(&_patches, &network_tmp_patches, sizeof(_patches));
+	}
 	_networking = false;
 	_network_server = false;
+}
 // Receives something from the network
 bool NetworkReceive(void)
+static bool NetworkReceive(void)
+{
-	ClientState *cs;
+	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);
+	}
@@ @@ -1013,39 +1018,39 @@ bool NetworkReceive(void) @@
 					NetworkClientError(res, cs);
 					return false;
+				}
+			}
+		}
+	}
 	return true;
+}
 // This sends all buffered commands (if possible)
 static void NetworkSend(void)
+{
-	ClientState *cs;
+	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
 void NetworkHandleLocalQueue(void)
+static void NetworkHandleLocalQueue(void)
+{
 	if (_local_command_queue != NULL) {
 		CommandPacket *cp;
 		CommandPacket *cp_prev;
 		cp = _local_command_queue;
 		cp_prev = NULL;
 		while (cp != NULL) {
 			if (_frame_counter > cp->frame) {
 				// We can execute this command
 				NetworkExecuteCommand(cp);
@@ @@ -1062,28 +1067,25 @@ void NetworkHandleLocalQueue(void) @@
+				}
 			} else {
 				// Command is in the future, skip to next
 				//  (commands don't have to be in order in the queue!!)
 				cp_prev = cp;
 				cp = cp->next;
+			}
+		}
+	}
+}
 extern void StateGameLoop();
 bool NetworkDoClientLoop(void)
 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]) {
@@ @@ -1159,25 +1161,25 @@ void NetworkGameLoop(void) @@
+			}
 		} else {
 			// Else, keep on going till _frame_counter_max
 			if (_frame_counter_max > _frame_counter) {
 				NetworkDoClientLoop();
+			}
+		}
+	}
 	NetworkSend();
+}
 void NetworkGenerateUniqueId()
+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));

network.h

➞

Show inline comments

@@ @@ -184,15 +184,15 @@ VARDEF uint8 _network_autoclean_protecte @@
 #endif /* ENABLE_NETWORK */
 // Those variables must always be registered!
 VARDEF bool _networking;
 VARDEF bool _network_available;  // is network mode available?
 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);
-void AddServer(byte *b);
+void NetworkAddServer(const byte *b);
 #endif /* NETWORK_H */

network_client.c

➞

Show inline comments

@@ @@ -6,24 +6,26 @@ @@
 #include "table/strings.h"
 #include "network_client.h"
 #include "network_gamelist.h"
 #include "command.h"
 #include "gfx.h"
 #include "window.h"
 #include "settings.h"
 // This file handles all the client-commands
 extern const char _openttd_revision[];
 // So we don't make too much typos ;)
 #define MY_CLIENT DEREF_CLIENT(0)
 static uint32 last_ack_frame;
 void NetworkRecvPatchSettings(Packet *p);
 // **********
 // Sending functions
 //   DEF_CLIENT_SEND_COMMAND has no parameters
 // **********
@@ @@ -34,26 +36,24 @@ DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_CO @@
 	// Function: Request company-info (in detail)
 	// Data:
 	//    <none>
 	//
 	Packet *p;
 	_network_join_status = NETWORK_JOIN_STATUS_GETTING_COMPANY_INFO;
 	InvalidateWindow(WC_NETWORK_STATUS_WINDOW, 0);
 	p = NetworkSend_Init(PACKET_CLIENT_COMPANY_INFO);
 	NetworkSend_Packet(p, MY_CLIENT);
+}
 extern const char _openttd_revision[];
 DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_JOIN)
+{
 	//
 	// Packet: CLIENT_JOIN
 	// Function: Try to join the server
 	// Data:
 	//    String: OpenTTD Revision (norev000 if no revision)
 	//    String: Player Name (max NETWORK_NAME_LENGTH)
 	//    uint8:  Play as Player id (1..MAX_PLAYERS)
 	//    uint8:  Language ID
 	//    String: Unique id to find the player back in server-listing
 	//
@@ @@ -796,25 +796,25 @@ void NetworkRecvPatchSettings(Packet *p) @@
 // Is called after a client is connected to the server
 void NetworkClient_Connected(void)
+{
 	// Set the frame-counter to 0 so nothing happens till we are ready
 	_frame_counter = 0;
 	_frame_counter_server = 0;
 	last_ack_frame = 0;
 	// Request the game-info
 	SEND_COMMAND(PACKET_CLIENT_JOIN)();
+}
 // Reads the packets from the socket-stream, if available
-NetworkRecvStatus NetworkClient_ReadPackets(ClientState *cs)
+NetworkRecvStatus NetworkClient_ReadPackets(NetworkClientState *cs)
+{
 	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);
 		if (type < PACKET_END && _network_client_packet[type] != NULL) {
 			res = _network_client_packet[type](p);
 		}	else {
 			res = NETWORK_RECV_STATUS_MALFORMED_PACKET;
 			DEBUG(net, 0)("[NET][client] Received invalid packet type %d", type);
+		}

network_client.h

➞

Show inline comments

@@ @@ -5,18 +5,18 @@ @@
 DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_GAME_INFO);
 DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_COMPANY_INFO);
 DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_COMMAND)(CommandPacket *cp);
 DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_ERROR)(NetworkErrorCode errorno);
 DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_QUIT)(const char *leavemsg);
 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);
-NetworkRecvStatus NetworkClient_ReadPackets(ClientState *cs);
+NetworkRecvStatus NetworkClient_ReadPackets(NetworkClientState *cs);
 void NetworkClient_Connected(void);
 #endif /* ENABLE_NETWORK */
 #endif // NETWORK_CLIENT_H

network_data.c

➞

Show inline comments

@@ @@ -77,25 +77,25 @@ void NetworkSend_string(Packet *packet, @@
 	while ((packet->buffer[packet->size++] = *data++) != '\0') {}
+}
 // If PacketSize changes of size, you have to change the 2 packet->size
 //   lines below matching the size of packet->size/PacketSize!
 // (line 'packet->buffer[0] = packet->size & 0xFF;'  and below)
 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)
-void NetworkSend_Packet(Packet *packet, ClientState *cs)
+void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)
+{
 	Packet *p;
 	assert(packet != NULL);
 	packet->pos = 0;
 	packet->next = NULL;
 	packet->buffer[0] = packet->size & 0xFF;
 	packet->buffer[1] = packet->size >> 8;
 	// Locate last packet buffered for the client
 	p = cs->packet_queue;
@@ @@ -105,47 +105,47 @@ void NetworkSend_Packet(Packet *packet, @@
 	} else {
 		// Skip to the last packet
 		while (p->next != NULL) p = p->next;
 		p->next = packet;
+	}
+}
 // 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
-NetworkRecvStatus CloseConnection(ClientState *cs)
+NetworkRecvStatus CloseConnection(NetworkClientState *cs)
+{
-	CloseClient(cs);
+	NetworkCloseClient(cs);
 	// Clients drop back to the main menu
 	if (!_network_server) {
 		_switch_mode = SM_MENU;
 		_networking = false;
 		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;
 		return NETWORK_RECV_STATUS_CONN_LOST;
+	}
 	return NETWORK_RECV_STATUS_OKAY;
+}
 // 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
-bool NetworkSend_Packets(ClientState *cs)
+bool NetworkSend_Packets(NetworkClientState *cs)
+{
 	ssize_t res;
 	Packet *p;
 	// We can not write to this socket!!
 	if (!cs->writable) return false;
 	if (cs->socket == INVALID_SOCKET) return false;
 	p = cs->packet_queue;
 	while (p != NULL) {
 		res = send(cs->socket, p->buffer + p->pos, p->size - p->pos, 0);
 		if (res == -1) {
@@ @@ -233,25 +233,25 @@ void NetworkRecv_string(Packet *p, char* @@
 		//  skip till the \0, so the packet can be read out correctly for the rest
 		while (pos < p->size && p->buffer[pos] != '\0') ++pos;
 		++pos;
+	}
 	p->pos = pos;
+}
 // 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);
-Packet *NetworkRecv_Packet(ClientState *cs, NetworkRecvStatus *status)
+Packet *NetworkRecv_Packet(NetworkClientState *cs, NetworkRecvStatus *status)
+{
 	ssize_t res;
 	Packet *p;
 	*status = NETWORK_RECV_STATUS_OKAY;
 	if (cs->socket == INVALID_SOCKET) return NULL;
 	if (cs->packet_recv == NULL) {
 		cs->packet_recv = malloc(sizeof(Packet));
 		if (cs->packet_recv == NULL) error("Failed to allocate packet");
 		// Set pos to zero!
@@ @@ -321,25 +321,25 @@ Packet *NetworkRecv_Packet(ClientState * @@
 	// We have a complete packet, return it!
 	p->pos = 2;
 	p->next = NULL; // Should not be needed, but who knows...
 	// Prepare for receiving a new packet
 	cs->packet_recv = NULL;
 	return p;
+}
 // Add a command to the local command queue
-void NetworkAddCommandQueue(ClientState *cs, CommandPacket *cp)
+void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp)
+{
 	CommandPacket *new_cp = malloc(sizeof(CommandPacket));
 	*new_cp = *cp;
 	if (cs->command_queue == NULL)
 		cs->command_queue = new_cp;
 	else {
 		CommandPacket *c = cs->command_queue;
 		while (c->next != NULL) c = c->next;
 		c->next = new_cp;
+	}
@@ @@ -381,25 +381,25 @@ void NetworkSend_Command(uint32 tile, ui @@
 		c->frame = 0; // The client can't tell which frame, so just make it 0
+	}
 	// Copy the _decode_parameters to dp
 	memcpy(c->dp, _decode_parameters, 20 * sizeof(uint32));
 	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.
-		ClientState *cs;
+		NetworkClientState *cs;
 		// And we queue it for delivery to the clients
 		FOR_ALL_CLIENTS(cs) {
 			if (cs->status > STATUS_AUTH) {
 				NetworkAddCommandQueue(cs, c);
+			}
+		}
 		// Only the server gets the callback, because clients should not get them
 		c->callback = temp_callback;
 		if (_local_command_queue == NULL) {
 			_local_command_queue = c;

network_data.h

➞

Show inline comments

@@ @@ -98,40 +98,40 @@ typedef enum { @@
 	NETWORK_ACTION_CHAT_TO_CLIENT,
 	NETWORK_ACTION_CHAT_TO_PLAYER,
 	NETWORK_ACTION_GIVE_MONEY,
 	NETWORK_ACTION_NAME_CHANGE,
 } NetworkAction;
 typedef enum {
 	NETWORK_GAME_PASSWORD,
 	NETWORK_COMPANY_PASSWORD,
 } NetworkPasswordType;
 // To keep the clients all together
-typedef struct ClientState {
+typedef struct NetworkClientState {
 	int socket;
 	uint16 index;
 	uint32 last_frame;
 	uint32 last_frame_server;
 	byte lag_test; // This byte is used for lag-testing the client
 	ClientStatus status;
 	bool writable; // is client ready to write to?
 	bool quited;
 	Packet *packet_queue; // Packets that are awaiting delivery
 	Packet *packet_recv; // Partially received packet
 	CommandPacket *command_queue; // The command-queue awaiting delivery
-} ClientState;
+} NetworkClientState;
 // 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 {
 	PACKET_SERVER_FULL,
 	PACKET_CLIENT_JOIN,
 	PACKET_SERVER_ERROR,
 	PACKET_CLIENT_COMPANY_INFO,
 	PACKET_SERVER_COMPANY_INFO,
 	PACKET_SERVER_CLIENT_INFO,
@@ @@ -164,62 +164,62 @@ typedef enum { @@
 typedef enum {
 	DESTTYPE_BROADCAST,
 	DESTTYPE_PLAYER,
 	DESTTYPE_CLIENT
 } DestType;
 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)
-ClientState _clients[MAX_CLIENTS];
+NetworkClientState _clients[MAX_CLIENTS];
 #define DEREF_CLIENT(i) (&_clients[i])
-// This returns the NetworkClientInfo from a ClientState
+// This returns the NetworkClientInfo from a NetworkClientState
 #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_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(ClientState *cs, Packet *p)
 #define DEF_SERVER_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(ClientState *cs)
 #define DEF_SERVER_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(NetworkClientState *cs, Packet *p)
 #define DEF_SERVER_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(NetworkClientState *cs)
 #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);
-void NetworkSend_Packet(Packet *packet, ClientState *cs);
+void NetworkSend_Packet(Packet *packet, NetworkClientState *cs);
 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);
-Packet *NetworkRecv_Packet(ClientState *cs, NetworkRecvStatus *status);
+Packet *NetworkRecv_Packet(NetworkClientState *cs, NetworkRecvStatus *status);
-bool NetworkSend_Packets(ClientState *cs);
+bool NetworkSend_Packets(NetworkClientState *cs);
 void NetworkExecuteCommand(CommandPacket *cp);
-void NetworkAddCommandQueue(ClientState *cs, CommandPacket *cp);
+void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp);
 // from network.c
-void CloseClient(ClientState *cs);
+void NetworkCloseClient(NetworkClientState *cs);
 void CDECL NetworkTextMessage(NetworkAction action, uint16 color, const char *name, const char *str, ...);
 void NetworkGetClientName(char *clientname, size_t size, ClientState *cs);
 uint NetworkCalculateLag(const ClientState *cs);
 void NetworkGetClientName(char *clientname, size_t size, const NetworkClientState *cs);
 uint NetworkCalculateLag(const NetworkClientState *cs);
 byte NetworkGetCurrentLanguageIndex();
 NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index);
-ClientState *NetworkFindClientStateFromIndex(uint16 client_index);
+NetworkClientState *NetworkFindClientStateFromIndex(uint16 client_index);
 unsigned long NetworkResolveHost(const char *hostname);
 #endif /* ENABLE_NETWORK */
 #endif // NETWORK_DATA_H

network_gamelist.c

➞

Show inline comments

@@ @@ -56,25 +56,25 @@ NetworkGameList *NetworkGameListAddItem( @@
 	memset(item, 0, sizeof(*item));
 	item->next = NULL;
 	item->ip = ip;
 	item->port = port;
 	_network_game_count++;
 	UpdateNetworkGameWindow(false);
 	return item;
+}
 void NetworkGameListAddQueriedItem(NetworkGameInfo *info, bool server_online)
+void NetworkGameListAddQueriedItem(const NetworkGameInfo *info, bool server_online)
+{
 	// 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;
 	memcpy(&item->info, info, sizeof(NetworkGameInfo));
 	ttd_strlcpy(item->info.hostname, _network_last_host, sizeof(item->info.hostname));
 	UpdateNetworkGameWindow(false);
+}

network_gamelist.h

➞

Show inline comments

 #ifndef NETWORK_GAMELIST_H
 #define NETWORK_GAMELIST_H
 void NetworkGameListClear(void);
 NetworkGameList *NetworkGameListAddItem(uint32 ip, uint16 port);
 void NetworkGameListAddQueriedItem(NetworkGameInfo *info, bool server_online);
+void NetworkGameListAddQueriedItem(const NetworkGameInfo *info, bool server_online);
 #endif /* NETWORK_GAMELIST_H */

network_gui.c

➞

Show inline comments

@@ @@ -308,25 +308,25 @@ static void NetworkGameWindowWndProc(Win @@
 			break;
+		}
 		// The name is only allowed when it starts with a letter!
 		if (_edit_str_buf[0] != '\0' && _edit_str_buf[0] != ' ')
 			ttd_strlcpy(_network_player_name, _edit_str_buf, lengthof(_network_player_name));
 		else
 			ttd_strlcpy(_network_player_name, "Player", lengthof(_network_player_name));
 		break;
 	case WE_ON_EDIT_TEXT: {
-		AddServer(e->edittext.str);
+		NetworkAddServer(e->edittext.str);
 	} break;
 	case WE_CREATE: {
 		_selected_item = NULL;
 	} break;
+	}
+}
 static const Widget _network_game_window_widgets[] = {
 {   WWT_CLOSEBOX,   BGC,     0,    10,     0,    13, STR_00C5,										STR_018B_CLOSE_WINDOW},
 {    WWT_CAPTION,   BGC,    11,   479,     0,    13, STR_NETWORK_MULTIPLAYER,			STR_NULL},
 {     WWT_IMGBTN,   BGC,     0,   479,    14,   214, 0x0,													STR_NULL},

network_server.c

➞

Show inline comments

@@ @@ -6,36 +6,38 @@ @@
 #include "table/strings.h"
 #include "network_server.h"
 #include "network_udp.h"
 #include "console.h"
 #include "command.h"
 #include "gfx.h"
 #include "vehicle.h"
 #include "station.h"
 #include "settings.h"
 // This file handles all the server-commands
-void NetworkHandleCommandQueue(ClientState *cs);
+void NetworkHandleCommandQueue(NetworkClientState *cs);
 void NetworkPopulateCompanyInfo(void);
 void NetworkSendPatchSettings(ClientState *cs);
 void NetworkSendPatchSettings(NetworkClientState *cs);
 extern const char _openttd_revision[];
 // Is the network enabled?
 // **********
 // Sending functions
-//   DEF_SERVER_SEND_COMMAND has parameter: ClientState *cs
+//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs
 // **********
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CLIENT_INFO)(ClientState *cs, NetworkClientInfo *ci)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CLIENT_INFO)(NetworkClientState *cs, NetworkClientInfo *ci)
+{
 	//
 	// Packet: SERVER_CLIENT_INFO
 	// Function: Sends info about a client
 	// Data:
 	//    uint16:  The index of the client (always unique on a server. 1 = server)
 	//    uint8:  As which player the client is playing
 	//    String: The name of the client
 	//    String: The unique id of the client
 	//
 	Packet *p;
@@ @@ -110,34 +112,34 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_CO @@
 		for (i = 0; i < NETWORK_STATION_TYPES; i++)
 			NetworkSend_uint16(p, _network_player_info[player->index].num_station[i]);
 		if (_network_player_info[player->index].players[0] == '\0')
 			NetworkSend_string(p, "<none>");
 		else
 			NetworkSend_string(p, _network_player_info[player->index].players);
 		NetworkSend_Packet(p, cs);
+	}
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(ClientState *cs, NetworkErrorCode error)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(NetworkClientState *cs, NetworkErrorCode error)
+{
 	//
 	// Packet: SERVER_ERROR
 	// Function: The client made an error
 	// Data:
 	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)
 	//
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	char str1[100], str2[100];
 	char client_name[NETWORK_NAME_LENGTH];
 	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);
 	NetworkSend_uint8(p, error);
 	NetworkSend_Packet(p, cs);
 	// Only send when the current client was in game
 	if (cs->status > STATUS_AUTH) {
 		NetworkGetClientName(client_name, sizeof(client_name), cs);
 		GetString(str1, STR_NETWORK_ERR_LEFT);
@@ @@ -158,52 +160,52 @@ DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SER @@
+			}
+		}
 	} else {
 		DEBUG(net, 2)("[NET] Clientno %d has made an error and his connection is closed", cs->index);
+	}
 	cs->quited = true;
 	// Make sure the data get's there before we close the connection
 	NetworkSend_Packets(cs);
 	// The client made a mistake, so drop his connection now!
-	CloseClient(cs);
+	NetworkCloseClient(cs);
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_PASSWORD)(ClientState *cs, NetworkPasswordType type)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_PASSWORD)(NetworkClientState *cs, NetworkPasswordType type)
+{
 	//
 	// Packet: SERVER_NEED_PASSWORD
 	// Function: Indication to the client that the server needs a password
 	// Data:
 	//    uint8:  Type of password
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);
 	NetworkSend_uint8(p, type);
 	NetworkSend_Packet(p, cs);
+}
 DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)
+{
 	//
 	// Packet: SERVER_WELCOME
 	// Function: The client is joined and ready to receive his map
 	// Data:
 	//    uint16:  Own ClientID
 	//
 	Packet *p;
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	// Invalid packet when status is AUTH or higher
 	if (cs->status >= STATUS_AUTH)
 		return;
 	cs->status = STATUS_AUTH;
 	_network_game_info.clients_on++;
 	p = NetworkSend_Init(PACKET_SERVER_WELCOME);
 	NetworkSend_uint16(p, cs->index);
 	NetworkSend_Packet(p, cs);
@@ @@ -217,25 +219,25 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WE @@
+}
 DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)
+{
 	//
 	// Packet: PACKET_SERVER_WAIT
 	// Function: The client can not receive the map at the moment because
 	//             someone else is already receiving the map
 	// Data:
 	//    uint8:  Clients awaiting map
 	//
 	int waiting = 0;
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	Packet *p;
 	// Count how many players are waiting in the queue
 	FOR_ALL_CLIENTS(new_cs) {
 		if (new_cs->status == STATUS_MAP_WAIT)
 			waiting++;
+	}
 	p = NetworkSend_Init(PACKET_SERVER_WAIT);
 	NetworkSend_uint8(p, waiting);
 	NetworkSend_Packet(p, cs);
+}
@@ @@ -318,25 +320,25 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MA @@
 				for (i = 0; i < MAX_PLAYERS; i++) {
 					NetworkSend_uint32(p, _player_seeds[i][0]);
 					NetworkSend_uint32(p, _player_seeds[i][1]);
+				}
 				NetworkSend_Packet(p, cs);
 				// Set the status to DONE_MAP, no we will wait for the client
 				//  to send it is ready (maybe that happens like never ;))
 				cs->status = STATUS_DONE_MAP;
 				fclose(file_pointer);
+				{
-					ClientState *new_cs;
+					NetworkClientState *new_cs;
 					bool new_map_client = false;
 					// Check if there is a client waiting for receiving the map
 					//  and start sending him the map
 					FOR_ALL_CLIENTS(new_cs) {
 						if (new_cs->status == STATUS_MAP_WAIT) {
 							// Check if we already have a new client to send the map to
 							if (!new_map_client) {
 								// If not, this client will get the map
 								new_cs->status = STATUS_AUTH;
 								new_map_client = true;
 								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);
 							} else {
@@ @@ -355,25 +357,25 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MA @@
 		// Send all packets (forced) and check if we have send it all
 		NetworkSend_Packets(cs);
 		if (cs->packet_queue == NULL) {
 			// All are sent, increase the sent_packets
 			sent_packets *= 2;
 		} else {
 			// Not everything is sent, decrease the sent_packets
 			if (sent_packets > 1) sent_packets /= 2;
+		}
+	}
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_JOIN)(ClientState *cs, uint16 client_index)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_JOIN)(NetworkClientState *cs, uint16 client_index)
+{
 	//
 	// Packet: SERVER_JOIN
 	// Function: A client is joined (all active clients receive this after a
 	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a
 	//     PACKET_SERVER_CLIENT_INFO
 	// Data:
 	//    uint16:  Client-Index
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);
@@ @@ -421,25 +423,25 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SY @@
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);
 	NetworkSend_uint32(p, _frame_counter);
 	NetworkSend_uint32(p, _sync_seed_1);
 #ifdef NETWORK_SEND_DOUBLE_SEED
 	NetworkSend_uint32(p, _sync_seed_2);
 #endif
 	NetworkSend_Packet(p, cs);
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_COMMAND)(ClientState *cs, CommandPacket *cp)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_COMMAND)(NetworkClientState *cs, CommandPacket *cp)
+{
 	//
 	// Packet: SERVER_COMMAND
 	// Function: Sends a DoCommand to the client
 	// Data:
 	//    uint8:  PlayerID (0..MAX_PLAYERS-1)
 	//    uint32: CommandID (see command.h)
 	//    uint32: P1 (free variables used in DoCommand)
 	//    uint32: P2
 	//    uint32: Tile
 	//    uint32: decode_params
 	//      10 times the last one (lengthof(cp->dp))
@@ @@ -461,64 +463,64 @@ DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SER @@
 	    problem.. we should fix the misuse of dparam... -- TrueLight */
 	dparam_char = (char *)&cp->dp[0];
 	for (i = 0; i < lengthof(cp->dp) * 4; i++) {
 		NetworkSend_uint8(p, *dparam_char);
 		dparam_char++;
+	}
 	NetworkSend_uint8(p, cp->callback);
 	NetworkSend_uint32(p, cp->frame);
 	NetworkSend_Packet(p, cs);
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(ClientState *cs, NetworkAction action, uint16 client_index, const char *msg)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(NetworkClientState *cs, NetworkAction action, uint16 client_index, const char *msg)
+{
 	//
 	// Packet: SERVER_CHAT
 	// Function: Sends a chat-packet to the client
 	// Data:
 	//    uint8:  ActionID (see network_data.h, NetworkAction)
 	//    uint16:  Client-index
 	//    String: Message (max MAX_TEXT_MSG_LEN)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);
 	NetworkSend_uint8(p, action);
 	NetworkSend_uint16(p, client_index);
 	NetworkSend_string(p, msg);
 	NetworkSend_Packet(p, cs);
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(ClientState *cs, uint16 client_index, NetworkErrorCode errorno)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(NetworkClientState *cs, uint16 client_index, NetworkErrorCode errorno)
+{
 	//
 	// Packet: SERVER_ERROR_QUIT
 	// Function: One of the clients made an error and is quiting the game
 	//      This packet informs the other clients of that.
 	// Data:
 	//    uint16:  Client-index
 	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);
 	NetworkSend_uint16(p, client_index);
 	NetworkSend_uint8(p, errorno);
 	NetworkSend_Packet(p, cs);
+}
-DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_QUIT)(ClientState *cs, uint16 client_index, const char *leavemsg)
+DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_QUIT)(NetworkClientState *cs, uint16 client_index, const char *leavemsg)
+{
 	//
 	// Packet: SERVER_ERROR_QUIT
 	// Function: A client left the game, and this packets informs the other clients
 	//      of that.
 	// Data:
 	//    uint16:  Client-index
 	//    String: leave-message
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);
@@ @@ -547,34 +549,32 @@ DEF_SERVER_SEND_COMMAND(PACKET_SERVER_NE @@
 	// Packet: PACKET_SERVER_NEWGAME
 	// Function: Let the clients know that the server is loading a new map
 	// Data:
 	//     <none>
 	//
 	Packet *p = NetworkSend_Init(PACKET_SERVER_NEWGAME);
 	NetworkSend_Packet(p, cs);
+}
 // **********
 // Receiving functions
-//   DEF_SERVER_RECEIVE_COMMAND has parameter: ClientState *cs, Packet *p
+//   DEF_SERVER_RECEIVE_COMMAND has parameter: NetworkClientState *cs, Packet *p
 // **********
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO)
+{
 	SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)(cs);
+}
 extern const char _openttd_revision[];
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)
+{
 	char name[NETWORK_NAME_LENGTH];
 	char unique_id[NETWORK_NAME_LENGTH];
 	NetworkClientInfo *ci;
 	char test_name[NETWORK_NAME_LENGTH];
 	byte playas;
 	NetworkLanguage client_lang;
 	char client_revision[NETWORK_REVISION_LENGTH];
 	NetworkRecv_string(p, client_revision, sizeof(client_revision));
@@ @@ -673,25 +673,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
 		SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
 		return;
+	}
 	SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
 	return;
+}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)
+{
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	// 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_AUTH || cs->quited) {
 		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);
 		return;
+	}
 	// Check if someone else is receiving the map
 	FOR_ALL_CLIENTS(new_cs) {
 		if (new_cs->status == STATUS_MAP) {
 			// Tell the new client to wait
@@ @@ -702,25 +702,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
+	}
 	// We receive a request to upload the map.. give it to the client!
 	SEND_COMMAND(PACKET_SERVER_MAP)(cs);
+}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_MAP_OK)
+{
 	// Client has the map, now start syncing
 	if (cs->status == STATUS_DONE_MAP && !cs->quited) {
 		char client_name[NETWORK_NAME_LENGTH];
 		char str[100];
-		ClientState *new_cs;
+		NetworkClientState *new_cs;
 		GetString(str, STR_NETWORK_CLIENT_JOINED);
 		NetworkGetClientName(client_name, sizeof(client_name), cs);
 		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, client_name, str);
 		// Mark the client as pre-active, and wait for an ACK
 		//  so we know he is done loading and in sync with us
 		cs->status = STATUS_PRE_ACTIVE;
 		NetworkHandleCommandQueue(cs);
 		SEND_COMMAND(PACKET_SERVER_FRAME)(cs);
 		SEND_COMMAND(PACKET_SERVER_SYNC)(cs);
@@ @@ -738,25 +738,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
+		}
 	} else {
 		// Wrong status for this packet, give a warning to client, and close connection
 		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
+	}
+}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)
+{
 	// The client has done a command and wants us to handle it
 	int i;
 	byte callback;
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	NetworkClientInfo *ci;
 	char *dparam_char;
 	CommandPacket *cp = malloc(sizeof(CommandPacket));
 	// 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) {
 		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
 		return;
+	}
@@ @@ -823,25 +823,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
 	} else {
 		// Find last packet
 		CommandPacket *c = _local_command_queue;
 		while (c->next != NULL) c = c->next;
 		c->next = cp;
+	}
+}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_ERROR)
+{
 	// This packets means a client noticed an error and is reporting this
 	//  to us. Display the error and report it to the other clients
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	byte errorno = NetworkRecv_uint8(p);
 	char str1[100], str2[100];
 	char client_name[NETWORK_NAME_LENGTH];
 	// The client was never joined.. thank the client for the packet, but ignore it
 	if (cs->status < STATUS_DONE_MAP || cs->quited) {
 		cs->quited = true;
 		return;
+	}
 	NetworkGetClientName(client_name, sizeof(client_name), cs);
@@ @@ -856,25 +856,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
 		if (new_cs->status > STATUS_AUTH) {
 			SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->index, errorno);
+		}
+	}
 	cs->quited = true;
+}
 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_QUIT)
+{
 	// The client wants to leave. Display this and report it to the other
 	//  clients.
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	char str1[100], str2[100];
 	char client_name[NETWORK_NAME_LENGTH];
 	// The client was never joined.. thank the client for the packet, but ignore it
 	if (cs->status < STATUS_DONE_MAP || cs->quited) {
 		cs->quited = true;
 		return;
+	}
 	NetworkRecv_string(p, str2, 100);
 	NetworkGetClientName(client_name, sizeof(client_name), cs);
@@ @@ -899,25 +899,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
 	// With those 2 values we can calculate the lag realtime
 	cs->last_frame_server = _frame_counter;
 	// The client is now really active
 	if (cs->status == STATUS_PRE_ACTIVE)
 		cs->status = STATUS_ACTIVE;
+}
 void NetworkServer_HandleChat(NetworkAction action, DestType desttype, int dest, const char *msg, byte from_index)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci, *ci_own, *ci_to;
 	switch (desttype) {
 	case DESTTYPE_CLIENT:
 		if (dest == 1) {
 			ci = NetworkFindClientInfoFromIndex(from_index);
 			if (ci != NULL)
 				NetworkTextMessage(action, GetDrawStringPlayerColor(ci->client_playas-1), ci->client_name, "%s", msg);
 		} else {
 			FOR_ALL_CLIENTS(cs) {
 				if (cs->index == dest) {
 					SEND_COMMAND(PACKET_SERVER_CHAT)(cs, action, from_index, msg);
@@ @@ -1027,25 +1027,25 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT @@
 	if (ci != NULL) {
 		// Display change
 		if (NetworkFindName(name)) {
 			NetworkTextMessage(NETWORK_ACTION_NAME_CHANGE, 1, ci->client_name, name);
 			ttd_strlcpy(ci->client_name, name, sizeof(ci->client_name));
 			NetworkUpdateClientInfo(ci->client_index);
+		}
+	}
+}
 // The layout for the receive-functions by the server
-typedef void NetworkServerPacket(ClientState *cs, Packet *p);
+typedef void NetworkServerPacket(NetworkClientState *cs, Packet *p);
 // This array matches PacketType. At an incoming
 //  packet it is matches against this array
 //  and that way the right function to handle that
 //  packet is found.
 static NetworkServerPacket* const _network_server_packet[] = {
 	NULL, /*PACKET_SERVER_FULL,*/
 	RECEIVE_COMMAND(PACKET_CLIENT_JOIN),
 	NULL, /*PACKET_SERVER_ERROR,*/
 	RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO),
 	NULL, /*PACKET_SERVER_COMPANY_INFO,*/
@@ @@ -1075,25 +1075,25 @@ static NetworkServerPacket* const _netwo @@
 	NULL, /*PACKET_SERVER_NEWGAME,*/
 };
 // If this fails, check the array above with network_data.h
 assert_compile(lengthof(_network_server_packet) == PACKET_END);
 extern const SettingDesc patch_settings[];
 // 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!!
-void NetworkSendPatchSettings(ClientState *cs)
+void NetworkSendPatchSettings(NetworkClientState *cs)
+{
 	const SettingDesc *item;
 	Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);
 	NetworkSend_uint8(p, MAP_PACKET_PATCH);
 	// Now send all the patch-settings in a pretty order..
 	item = patch_settings;
 	while (item->name != NULL) {
 		switch (item->flags) {
 			case SDT_BOOL:
 			case SDT_INT8:
@@ @@ -1113,25 +1113,25 @@ void NetworkSendPatchSettings(ClientStat @@
+	}
 	NetworkSend_Packet(p, cs);
+}
 // This update the company_info-stuff
 void NetworkPopulateCompanyInfo(void)
+{
 	char password[NETWORK_PASSWORD_LENGTH];
 	Player *p;
 	Vehicle *v;
 	Station *s;
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci;
 	int i;
 	uint16 months_empty;
 	FOR_ALL_PLAYERS(p) {
 		if (!p->is_active) {
 			memset(&_network_player_info[p->index], 0, sizeof(NetworkPlayerInfo));
 			continue;
+		}
 		// Clean the info but not the password
 		ttd_strlcpy(password, _network_player_info[p->index].password, sizeof(password));
@@ @@ -1213,45 +1213,45 @@ void NetworkPopulateCompanyInfo(void) @@
 		if (ci != NULL && ci->client_playas > 0 && ci->client_playas <= MAX_PLAYERS) {
 			if (strlen(_network_player_info[ci->client_playas-1].players) != 0)
 				strncat(_network_player_info[ci->client_playas-1].players, ", ", sizeof(_network_player_info[ci->client_playas-1].players));
 			strncat(_network_player_info[ci->client_playas-1].players, client_name, sizeof(_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)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci;
 	ci = NetworkFindClientInfoFromIndex(client_index);
 	if (ci == NULL)
 		return;
 	FOR_ALL_CLIENTS(cs) {
 		SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, ci);
+	}
+}
 /* Check if the server has autoclean_companies activated
     Two things happen:
 ) If a company is not protected, it is closed after 1 year (for example)
 ) If a company is protected, protection is disabled after 3 years (for example)
            (and item 1. happens a year later) */
 static void NetworkAutoCleanCompanies()
+{
-	ClientState *cs;
+	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);
@@ @@ -1291,25 +1291,25 @@ static void NetworkAutoCleanCompanies() @@
+			}
 		} 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_NAME_LENGTH])
+{
-	ClientState *new_cs;
+	NetworkClientState *new_cs;
 	NetworkClientInfo *ci;
 	bool found_name = false;
 	byte number = 0;
 	char original_name[NETWORK_NAME_LENGTH];
 	// We use NETWORK_NAME_LENGTH in here, because new_name is really a pointer
 	ttd_strlcpy(original_name, new_name, NETWORK_NAME_LENGTH);
 	while (!found_name) {
 		found_name = true;
 		FOR_ALL_CLIENTS(new_cs) {
 			ci = DEREF_CLIENT_INFO(new_cs);
@@ @@ -1332,42 +1332,42 @@ bool NetworkFindName(char new_name[NETWO @@
 			// Try a new name (<name> #1, <name> #2, and so on)
 			// Stop if we tried for more then 50 times..
 			if (number++ > 50) break;
 			snprintf(new_name, NETWORK_NAME_LENGTH, "%s #%d", original_name, number);
+		}
+	}
 	return found_name;
+}
 // Reads a packet from the stream
-bool NetworkServer_ReadPackets(ClientState *cs)
+bool NetworkServer_ReadPackets(NetworkClientState *cs)
+{
 	Packet *p;
 	NetworkRecvStatus res;
 	while((p = NetworkRecv_Packet(cs, &res)) != NULL) {
 		byte type = NetworkRecv_uint8(p);
 		if (type < PACKET_END && _network_server_packet[type] != NULL)
 			_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(ClientState *cs) {
+void NetworkHandleCommandQueue(NetworkClientState *cs) {
 	if (cs->command_queue != NULL) {
 		CommandPacket *cp;
 		CommandPacket *cp_prev;
 		cp = cs->command_queue;
 		cp_prev = NULL;
 		while (cp != NULL) {
 			SEND_COMMAND(PACKET_SERVER_COMMAND)(cs, cp);
 			if (cp_prev != NULL) {
 				cp_prev->next = cp->next;
@@ @@ -1380,46 +1380,46 @@ void NetworkHandleCommandQueue(ClientSta @@
 				cp = cs->command_queue;
+			}
+		}
+	}
+}
 // This is called every tick if this is a _network_server
 void NetworkServer_Tick(void)
+{
 #ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME
 	static uint32 last_sync_frame = 0;
 #endif
-	ClientState *cs;
+	NetworkClientState *cs;
 	bool send_frame = false;
 	// Update max-frame-counter
 	if (_frame_counter > _frame_counter_max) {
 		_frame_counter_max = _frame_counter + _network_frame_freq;
 		send_frame = true;
+	}
 	// 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(_iconsole_color_error,"Client #%d is dropped because the client did not respond for more then 4 game-days", cs->index);
-					CloseClient(cs);
+					NetworkCloseClient(cs);
 					continue;
+				}
 				// Report once per time we detect the lag
 				if (cs->lag_test == 0) {
 					IConsolePrintF(_iconsole_color_warning,"[%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;
+			}
+		}
@@ @@ -1444,18 +1444,18 @@ void NetworkServer_Tick(void) @@
 #ifndef ENABLE_NETWORK_SYNC_EVERY_FRAME
 	// Update the last_sync_frame if needed!
 	if (last_sync_frame + _network_sync_freq < _frame_counter) {
 		last_sync_frame = _frame_counter;
+	}
 #endif
 	/* See if we need to advertise */
 	NetworkUDPAdvertise();
+}
 void NetworkServerMonthlyLoop()
+void NetworkServerMonthlyLoop(void)
+{
 	NetworkAutoCleanCompanies();
+}
 #endif /* ENABLE_NETWORK */

network_server.h

➞

Show inline comments

 #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)(ClientState *cs, uint16 client_index, NetworkErrorCode errorno);
 DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(ClientState *cs, NetworkErrorCode error);
 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);
 bool NetworkFindName(char new_name[NETWORK_NAME_LENGTH]);
 void NetworkServer_HandleChat(NetworkAction action, DestType desttype, int dest, const char *msg, byte from_index);
 bool NetworkServer_ReadPackets(ClientState *cs);
 void NetworkServer_Tick();
 void NetworkServerMonthlyLoop();
 bool NetworkServer_ReadPackets(NetworkClientState *cs);
 void NetworkServer_Tick(void);
 void NetworkServerMonthlyLoop(void);
 #endif /* ENABLE_NETWORK */
 #endif // NETWORK_SERVER_H

network_udp.c

➞

Show inline comments

@@ @@ -97,25 +97,25 @@ DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_SERVE @@
 		if (item->info.hostname[0] == '\0')
 			snprintf(item->info.hostname, sizeof(item->info.hostname), "%s", inet_ntoa(client_addr->sin_addr));
+	}
 	item->online = true;
 	UpdateNetworkGameWindow(false);
+}
 DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_DETAIL_INFO)
+{
-	ClientState *cs;
+	NetworkClientState *cs;
 	NetworkClientInfo *ci;
 	Packet *packet;
 	Player *player;
 	byte active = 0;
 	byte current = 0;
 	int i;
 	// Just a fail-safe.. should never happen
 	if (!_network_udp_server)
 		return;
 	packet = NetworkSend_Init(PACKET_UDP_SERVER_DETAIL_INFO);
@@ @@ -462,25 +462,25 @@ void NetworkUDPQueryServer(const byte* h @@
 	// Init the packet
 	p = NetworkSend_Init(PACKET_UDP_CLIENT_FIND_SERVER);
 	NetworkSendUDP_Packet(p, &out_addr);
 	free(p);
 	UpdateNetworkGameWindow(false);
+}
 /* Register us to the master server
      This function checks if it needs to send an advertise */
 void NetworkUDPAdvertise()
+void NetworkUDPAdvertise(void)
+{
 	struct sockaddr_in out_addr;
 	Packet *p;
 	/* Check if we should send an advertise */
 	if (!_networking || !_network_server || !_network_udp_server || !_network_advertise)
 		return;
 	/* Only send once in the 450 game-days (about 15 minutes) */
 	if (_network_last_advertise_date + 450 > _date)
 		return;
 	_network_last_advertise_date = _date;

network_udp.h

➞

Show inline comments

 #ifndef NETWORK_LAN_H
 #define NETWORK_LAN_H
 void NetworkUDPInitialize(void);
 bool NetworkUDPListen(uint32 host, uint16 port);
 void NetworkUDPReceive(void);
 void NetworkUDPSearchGame(void);
 void NetworkUDPQueryServer(const byte* host, unsigned short port);
 void NetworkUDPAdvertise();
+void NetworkUDPAdvertise(void);
 #endif /* NETWORK_LAN_H */

0 comments (0 inline, 0 general)