1

/* $Id$ */

     2

     3

#ifdef ENABLE_NETWORK

     4

     5

#include "stdafx.h"

     6

#include "debug.h"

     7

#include "string.h"

     8

#include "network_data.h"

     9

#include "date.h"

    10

#include "map.h"

    11

#include "network_gamelist.h"

    12

#include "network_udp.h"

    13

#include "variables.h"

    14

#include "newgrf_config.h"

    15

    16

//

    17

// This file handles all the LAN-stuff

    18

// Stuff like:

    19

//   - UDP search over the network

    20

//

    21

    22

typedef enum {

    23

	PACKET_UDP_CLIENT_FIND_SERVER,

    24

	PACKET_UDP_SERVER_RESPONSE,

    25

	PACKET_UDP_CLIENT_DETAIL_INFO,

    26

	PACKET_UDP_SERVER_DETAIL_INFO,   // Is not used in OpenTTD itself, only for external querying

    27

	PACKET_UDP_SERVER_REGISTER,      // Packet to register itself to the master server

    28

	PACKET_UDP_MASTER_ACK_REGISTER,  // Packet indicating registration has succedeed

    29

	PACKET_UDP_CLIENT_GET_LIST,      // Request for serverlist from master server

    30

	PACKET_UDP_MASTER_RESPONSE_LIST, // Response from master server with server ip's + port's

    31

	PACKET_UDP_SERVER_UNREGISTER,    // Request to be removed from the server-list

    32

	PACKET_UDP_CLIENT_GET_NEWGRFS,   // Requests the name for a list of GRFs (GRF_ID and MD5)

    33

	PACKET_UDP_SERVER_NEWGRFS,       // Sends the list of NewGRF's requested.

    34

	PACKET_UDP_END

    35

} PacketUDPType;

    36

    37

enum {

    38

	ADVERTISE_NORMAL_INTERVAL = 30000, // interval between advertising in ticks (15 minutes)

    39

	ADVERTISE_RETRY_INTERVAL  =   300, // readvertise when no response after this many ticks (9 seconds)

    40

	ADVERTISE_RETRY_TIMES     =     3  // give up readvertising after this much failed retries

    41

};

    42

    43

#define DEF_UDP_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(Packet *p, struct sockaddr_in *client_addr)

    44

static void NetworkSendUDP_Packet(SOCKET udp, Packet* p, struct sockaddr_in* recv);

    45

    46

static NetworkClientState _udp_cs;

    47

    48

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_FIND_SERVER)

    49

{

    50

	Packet *packet;

    51

	// Just a fail-safe.. should never happen

    52

	if (!_network_udp_server)

    53

		return;

    54

    55

	packet = NetworkSend_Init(PACKET_UDP_SERVER_RESPONSE);

    56

    57

	// Update some game_info

    58

	_network_game_info.game_date = _date;

    59

	_network_game_info.map_width = MapSizeX();

    60

	_network_game_info.map_height = MapSizeY();

    61

	_network_game_info.map_set = _opt.landscape;

    62

    63

	NetworkSend_uint8 (packet, NETWORK_GAME_INFO_VERSION);

    64

    65

	/* NETWORK_GAME_INFO_VERSION = 4 */

    66

	{

    67

		/* Only send the GRF Identification (GRF_ID and MD5 checksum) of

    68

		 * the GRFs that are needed, i.e. the ones that the server has

    69

		 * selected in the NewGRF GUI and not the ones that are used due

    70

		 * to the fact that they are in [newgrf-static] in openttd.cfg */

    71

		const GRFConfig *c;

    72

		uint i = 0;

    73

    74

		/* Count number of GRFs to send information about */

    75

		for (c = _grfconfig; c != NULL; c = c->next) {

    76

			if (!HASBIT(c->flags, GCF_STATIC)) i++;

    77

		}

    78

		NetworkSend_uint8 (packet, i); // Send number of GRFs

    79

    80

		/* Send actual GRF Identifications */

    81

		for (c = _grfconfig; c != NULL; c = c->next) {

    82

			if (!HASBIT(c->flags, GCF_STATIC)) NetworkSend_GRFIdentifier(packet, c);

    83

		}

    84

	}

    85

    86

	/* NETWORK_GAME_INFO_VERSION = 3 */

    87

	NetworkSend_uint32(packet, _network_game_info.game_date);

    88

	NetworkSend_uint32(packet, _network_game_info.start_date);

    89

    90

	/* NETWORK_GAME_INFO_VERSION = 2 */

    91

	NetworkSend_uint8 (packet, _network_game_info.companies_max);

    92

	NetworkSend_uint8 (packet, ActivePlayerCount());

    93

	NetworkSend_uint8 (packet, _network_game_info.spectators_max);

    94

    95

	/* NETWORK_GAME_INFO_VERSION = 1 */

    96

	NetworkSend_string(packet, _network_game_info.server_name);

    97

	NetworkSend_string(packet, _network_game_info.server_revision);

    98

	NetworkSend_uint8 (packet, _network_game_info.server_lang);

    99

	NetworkSend_uint8 (packet, _network_game_info.use_password);

   100

	NetworkSend_uint8 (packet, _network_game_info.clients_max);

   101

	NetworkSend_uint8 (packet, _network_game_info.clients_on);

   102

	NetworkSend_uint8 (packet, NetworkSpectatorCount());

   103

	NetworkSend_string(packet, _network_game_info.map_name);

   104

	NetworkSend_uint16(packet, _network_game_info.map_width);

   105

	NetworkSend_uint16(packet, _network_game_info.map_height);

   106

	NetworkSend_uint8 (packet, _network_game_info.map_set);

   107

	NetworkSend_uint8 (packet, _network_game_info.dedicated);

   108

   109

	// Let the client know that we are here

   110

	NetworkSendUDP_Packet(_udp_server_socket, packet, client_addr);

   111

   112

	free(packet);

   113

   114

	DEBUG(net, 2)("[NET][UDP] Queried from %s", inet_ntoa(client_addr->sin_addr));

   115

}

   116

   117

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_SERVER_RESPONSE)

   118

{

   119

	extern const char _openttd_revision[];

   120

	NetworkGameList *item;

   121

	byte game_info_version;

   122

   123

	// Just a fail-safe.. should never happen

   124

	if (_network_udp_server)

   125

		return;

   126

   127

	game_info_version = NetworkRecv_uint8(&_udp_cs, p);

   128

   129

	if (_udp_cs.has_quit) return;

   130

   131

	DEBUG(net, 6)("[NET][UDP] Server response from %s:%d", inet_ntoa(client_addr->sin_addr),ntohs(client_addr->sin_port));

   132

   133

	// Find next item

   134

	item = NetworkGameListAddItem(inet_addr(inet_ntoa(client_addr->sin_addr)), ntohs(client_addr->sin_port));

   135

   136

	item->info.compatible = true;

   137

	/* Please observer the order. In the order in which packets are sent

   138

	 * they are to be received */

   139

	switch (game_info_version) {

   140

		case 4: {

   141

			GRFConfig *c, **dst = &item->info.grfconfig;

   142

			const GRFConfig *f;

   143

			uint i;

   144

			uint num_grfs = NetworkRecv_uint8(&_udp_cs, p);

   145

   146

			for (i = 0; i < num_grfs; i++) {

   147

				c = calloc(1, sizeof(*c));

   148

				NetworkRecv_GRFIdentifier(&_udp_cs, p, c);

   149

   150

				/* Find the matching GRF file */

   151

				f = FindGRFConfig(c->grfid, c->md5sum);

   152

				if (f == NULL) {

   153

					/* Don't know the GRF, so mark game incompatible and the (possibly)

   154

					 * already resolved name for this GRF (another server has sent the

   155

					 * name of the GRF already */

   156

					item->info.compatible = false;

   157

					c->name     = FindUnknownGRFName(c->grfid, c->md5sum, true);

   158

					SETBIT(c->flags, GCF_NOT_FOUND);

   159

				} else {

   160

					c->filename = f->filename;

   161

					c->name     = f->name;

   162

					c->info     = f->info;

   163

				}

   164

				SETBIT(c->flags, GCF_COPY);

   165

   166

				/* Append GRFConfig to the list */

   167

				*dst = c;

   168

				dst = &c->next;

   169

			}

   170

		} /* Fallthrough */

   171

		case 3:

   172

			item->info.game_date     = NetworkRecv_uint32(&_udp_cs, p);

   173

			item->info.start_date    = NetworkRecv_uint32(&_udp_cs, p);

   174

			/* Fallthrough */

   175

		case 2:

   176

			item->info.companies_max = NetworkRecv_uint8(&_udp_cs, p);

   177

			item->info.companies_on = NetworkRecv_uint8(&_udp_cs, p);

   178

			item->info.spectators_max = NetworkRecv_uint8(&_udp_cs, p);

   179

			/* Fallthrough */

   180

		case 1:

   181

			NetworkRecv_string(&_udp_cs, p, item->info.server_name, sizeof(item->info.server_name));

   182

			NetworkRecv_string(&_udp_cs, p, item->info.server_revision, sizeof(item->info.server_revision));

   183

			item->info.server_lang   = NetworkRecv_uint8(&_udp_cs, p);

   184

			item->info.use_password  = NetworkRecv_uint8(&_udp_cs, p);

   185

			item->info.clients_max   = NetworkRecv_uint8(&_udp_cs, p);

   186

			item->info.clients_on    = NetworkRecv_uint8(&_udp_cs, p);

   187

			item->info.spectators_on = NetworkRecv_uint8(&_udp_cs, p);

   188

			if (game_info_version < 3) { // 16 bits dates got scrapped and are read earlier

   189

				item->info.game_date     = NetworkRecv_uint16(&_udp_cs, p) + DAYS_TILL_ORIGINAL_BASE_YEAR;

   190

				item->info.start_date    = NetworkRecv_uint16(&_udp_cs, p) + DAYS_TILL_ORIGINAL_BASE_YEAR;

   191

			}

   192

			NetworkRecv_string(&_udp_cs, p, item->info.map_name, sizeof(item->info.map_name));

   193

			item->info.map_width     = NetworkRecv_uint16(&_udp_cs, p);

   194

			item->info.map_height    = NetworkRecv_uint16(&_udp_cs, p);

   195

			item->info.map_set       = NetworkRecv_uint8(&_udp_cs, p);

   196

			item->info.dedicated     = NetworkRecv_uint8(&_udp_cs, p);

   197

   198

			if (item->info.server_lang >= NETWORK_NUM_LANGUAGES) item->info.server_lang = 0;

   199

			if (item->info.map_set >= NUM_LANDSCAPE ) item->info.map_set = 0;

   200

   201

			if (item->info.hostname[0] == '\0')

   202

				snprintf(item->info.hostname, sizeof(item->info.hostname), "%s", inet_ntoa(client_addr->sin_addr));

   203

   204

			/* Check if we are allowed on this server based on the revision-match */

   205

			item->info.version_compatible =

   206

				strcmp(item->info.server_revision, _openttd_revision) == 0 ||

   207

				strcmp(item->info.server_revision, NOREV_STRING) == 0;

   208

			item->info.compatible &= item->info.version_compatible; // Already contains match for GRFs

   209

			break;

   210

	}

   211

   212

	{

   213

		/* Checks whether there needs to be a request for names of GRFs and makes

   214

		 * the request if necessary. GRFs that need to be requested are the GRFs

   215

		 * that do not exist on the clients system and we do not have the name

   216

		 * resolved of, i.e. the name is still UNKNOWN_GRF_NAME_PLACEHOLDER.

   217

		 * The in_request array and in_request_count are used so there is no need

   218

		 * to do a second loop over the GRF list, which can be relatively expensive

   219

		 * due to the string comparisons. */

   220

		const GRFConfig *in_request[NETWORK_MAX_GRF_COUNT];

   221

		const GRFConfig *c;

   222

		uint in_request_count = 0;

   223

		struct sockaddr_in out_addr;

   224

   225

		for (c = item->info.grfconfig; c != NULL; c = c->next) {

   226

			if (!HASBIT(c->flags, GCF_NOT_FOUND) || strcmp(c->name, UNKNOWN_GRF_NAME_PLACEHOLDER) != 0) continue;

   227

			in_request[in_request_count] = c;

   228

			in_request_count++;

   229

		}

   230

   231

		if (in_request_count > 0) {

   232

			/* There are 'unknown' GRFs, now send a request for them */

   233

			uint i;

   234

			Packet *packet = NetworkSend_Init(PACKET_UDP_CLIENT_GET_NEWGRFS);

   235

   236

			NetworkSend_uint8 (packet, in_request_count);

   237

			for (i = 0; i < in_request_count; i++) {

   238

				NetworkSend_GRFIdentifier(packet, in_request[i]);

   239

			}

   240

   241

			out_addr.sin_family      = AF_INET;

   242

			out_addr.sin_port        = htons(item->port);

   243

			out_addr.sin_addr.s_addr = item->ip;

   244

			NetworkSendUDP_Packet(_udp_client_socket, packet, &out_addr);

   245

			free(packet);

   246

		}

   247

	}

   248

   249

	item->online = true;

   250

   251

	UpdateNetworkGameWindow(false);

   252

}

   253

   254

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_DETAIL_INFO)

   255

{

   256

	NetworkClientState *cs;

   257

	NetworkClientInfo *ci;

   258

	Packet *packet;

   259

	Player *player;

   260

	byte current = 0;

   261

	int i;

   262

   263

	// Just a fail-safe.. should never happen

   264

	if (!_network_udp_server) return;

   265

   266

	packet = NetworkSend_Init(PACKET_UDP_SERVER_DETAIL_INFO);

   267

   268

	/* Send the amount of active companies */

   269

	NetworkSend_uint8 (packet, NETWORK_COMPANY_INFO_VERSION);

   270

	NetworkSend_uint8 (packet, ActivePlayerCount());

   271

   272

	/* Fetch the latest version of everything */

   273

	NetworkPopulateCompanyInfo();

   274

   275

	/* Go through all the players */

   276

	FOR_ALL_PLAYERS(player) {

   277

		/* Skip non-active players */

   278

		if (!player->is_active) continue;

   279

   280

		current++;

   281

   282

		/* Send the information */

   283

		NetworkSend_uint8(packet, current);

   284

   285

		NetworkSend_string(packet, _network_player_info[player->index].company_name);

   286

		NetworkSend_uint32(packet, _network_player_info[player->index].inaugurated_year);

   287

		NetworkSend_uint64(packet, _network_player_info[player->index].company_value);

   288

		NetworkSend_uint64(packet, _network_player_info[player->index].money);

   289

		NetworkSend_uint64(packet, _network_player_info[player->index].income);

   290

		NetworkSend_uint16(packet, _network_player_info[player->index].performance);

   291

   292

		/* Send 1 if there is a passord for the company else send 0 */

   293

		if (_network_player_info[player->index].password[0] != '\0') {

   294

			NetworkSend_uint8(packet, 1);

   295

		} else {

   296

			NetworkSend_uint8(packet, 0);

   297

		}

   298

   299

		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++)

   300

			NetworkSend_uint16(packet, _network_player_info[player->index].num_vehicle[i]);

   301

   302

		for (i = 0; i < NETWORK_STATION_TYPES; i++)

   303

			NetworkSend_uint16(packet, _network_player_info[player->index].num_station[i]);

   304

   305

		/* Find the clients that are connected to this player */

   306

		FOR_ALL_CLIENTS(cs) {

   307

			ci = DEREF_CLIENT_INFO(cs);

   308

			if (ci->client_playas == player->index) {

   309

				/* The uint8 == 1 indicates that a client is following */

   310

				NetworkSend_uint8(packet, 1);

   311

				NetworkSend_string(packet, ci->client_name);

   312

				NetworkSend_string(packet, ci->unique_id);

   313

				NetworkSend_uint32(packet, ci->join_date);

   314

			}

   315

		}

   316

		/* Also check for the server itself */

   317

		ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

   318

		if (ci->client_playas == player->index) {

   319

			/* The uint8 == 1 indicates that a client is following */

   320

			NetworkSend_uint8(packet, 1);

   321

			NetworkSend_string(packet, ci->client_name);

   322

			NetworkSend_string(packet, ci->unique_id);

   323

			NetworkSend_uint32(packet, ci->join_date);

   324

		}

   325

   326

		/* Indicates end of client list */

   327

		NetworkSend_uint8(packet, 0);

   328

	}

   329

   330

	/* And check if we have any spectators */

   331

	FOR_ALL_CLIENTS(cs) {

   332

		ci = DEREF_CLIENT_INFO(cs);

   333

		if (!IsValidPlayer(ci->client_playas)) {

   334

			/* The uint8 == 1 indicates that a client is following */

   335

			NetworkSend_uint8(packet, 1);

   336

			NetworkSend_string(packet, ci->client_name);

   337

			NetworkSend_string(packet, ci->unique_id);

   338

			NetworkSend_uint32(packet, ci->join_date);

   339

		}

   340

	}

   341

   342

	/* Also check for the server itself */

   343

	ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

   344

	if (!IsValidPlayer(ci->client_playas)) {

   345

		/* The uint8 == 1 indicates that a client is following */

   346

		NetworkSend_uint8(packet, 1);

   347

		NetworkSend_string(packet, ci->client_name);

   348

		NetworkSend_string(packet, ci->unique_id);

   349

		NetworkSend_uint32(packet, ci->join_date);

   350

	}

   351

   352

	/* Indicates end of client list */

   353

	NetworkSend_uint8(packet, 0);

   354

   355

	NetworkSendUDP_Packet(_udp_server_socket, packet, client_addr);

   356

   357

	free(packet);

   358

}

   359

   360

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_MASTER_RESPONSE_LIST)

   361

{

   362

	int i;

   363

	struct in_addr ip;

   364

	uint16 port;

   365

	uint8 ver;

   366

   367

	/* packet begins with the protocol version (uint8)

   368

	 * then an uint16 which indicates how many

   369

	 * ip:port pairs are in this packet, after that

   370

	 * an uint32 (ip) and an uint16 (port) for each pair

   371

	 */

   372

   373

	ver = NetworkRecv_uint8(&_udp_cs, p);

   374

   375

	if (_udp_cs.has_quit) return;

   376

   377

	if (ver == 1) {

   378

		for (i = NetworkRecv_uint16(&_udp_cs, p); i != 0 ; i--) {

   379

			ip.s_addr = TO_LE32(NetworkRecv_uint32(&_udp_cs, p));

   380

			port = NetworkRecv_uint16(&_udp_cs, p);

   381

			NetworkUDPQueryServer(inet_ntoa(ip), port);

   382

		}

   383

	}

   384

}

   385

   386

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_MASTER_ACK_REGISTER)

   387

{

   388

	_network_advertise_retries = 0;

   389

	DEBUG(net, 2)("[NET][UDP] We are advertised on the master-server!");

   390

   391

	if (!_network_advertise) {

   392

		/* We are advertised, but we don't want to! */

   393

		NetworkUDPRemoveAdvertise();

   394

	}

   395

}

   396

   397

/**

   398

 * A client has requested the names of some NewGRFs.

   399

 *

   400

 * Replying this can be tricky as we have a limit of SEND_MTU bytes

   401

 * in the reply packet and we can send up to 100 bytes per NewGRF

   402

 * (GRF ID, MD5sum and NETWORK_GRF_NAME_LENGTH bytes for the name).

   403

 * As SEND_MTU is _much_ less than 100 * NETWORK_MAX_GRF_COUNT, it

   404

 * could be that a packet overflows. To stop this we only reply

   405

 * with the first N NewGRFs so that if the first N + 1 NewGRFs

   406

 * would be sent, the packet overflows.

   407

 * in_reply and in_reply_count are used to keep a list of GRFs to

   408

 * send in the reply.

   409

 */

   410

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_GET_NEWGRFS)

   411

{

   412

	uint8 num_grfs;

   413

	uint i;

   414

   415

	const GRFConfig *in_reply[NETWORK_MAX_GRF_COUNT];

   416

	Packet *packet;

   417

	uint8 in_reply_count = 0;

   418

	uint packet_len = 0;

   419

   420

	/* Just a fail-safe.. should never happen */

   421

	if (_udp_cs.has_quit) return;

   422

   423

	DEBUG(net, 6)("[NET][UDP] NewGRF data request from %s:%d", inet_ntoa(client_addr->sin_addr), ntohs(client_addr->sin_port));

   424

   425

	num_grfs = NetworkRecv_uint8 (&_udp_cs, p);

   426

	if (num_grfs > NETWORK_MAX_GRF_COUNT) return;

   427

   428

	for (i = 0; i < num_grfs; i++) {

   429

		GRFConfig c;

   430

		const GRFConfig *f;

   431

   432

		NetworkRecv_GRFIdentifier(&_udp_cs, p, &c);

   433

   434

		/* Find the matching GRF file */

   435

		f = FindGRFConfig(c.grfid, c.md5sum);

   436

		if (f == NULL) continue; // The GRF is unknown to this server

   437

   438

		/* If the reply might exceed the size of the packet, only reply

   439

		 * the current list and do not send the other data.

   440

		 * The name could be an empty string, if so take the filename. */

   441

		packet_len += sizeof(c.grfid) + sizeof(c.md5sum) +

   442

				min(strlen((f->name != NULL && strlen(f->name) > 0) ? f->name : f->filename) + 1, NETWORK_GRF_NAME_LENGTH);

   443

		if (packet_len > SEND_MTU - 4) { // 4 is 3 byte header + grf count in reply

   444

			break;

   445

		}

   446

		in_reply[in_reply_count] = f;

   447

		in_reply_count++;

   448

	}

   449

   450

	if (in_reply_count == 0) return;

   451

   452

	packet = NetworkSend_Init(PACKET_UDP_SERVER_NEWGRFS);

   453

	NetworkSend_uint8 (packet, in_reply_count);

   454

	for (i = 0; i < in_reply_count; i++) {

   455

		char name[NETWORK_GRF_NAME_LENGTH];

   456

   457

		/* The name could be an empty string, if so take the filename */

   458

		ttd_strlcpy(name, (in_reply[i]->name != NULL && strlen(in_reply[i]->name) > 0) ?

   459

				in_reply[i]->name : in_reply[i]->filename, sizeof(name));

   460

	 	NetworkSend_GRFIdentifier(packet, in_reply[i]);

   461

		NetworkSend_string(packet, name);

   462

	}

   463

   464

	NetworkSendUDP_Packet(_udp_server_socket, packet, client_addr);

   465

	free(packet);

   466

}

   467

   468

/** The return of the client's request of the names of some NewGRFs */

   469

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_SERVER_NEWGRFS)

   470

{

   471

	uint8 num_grfs;

   472

	uint i;

   473

   474

	/* Just a fail-safe.. should never happen */

   475

	if (_udp_cs.has_quit) return;

   476

   477

	DEBUG(net, 6)("[NET][UDP] NewGRF data reply from %s:%d", inet_ntoa(client_addr->sin_addr),ntohs(client_addr->sin_port));

   478

   479

	num_grfs = NetworkRecv_uint8 (&_udp_cs, p);

   480

	if (num_grfs > NETWORK_MAX_GRF_COUNT) return;

   481

   482

	for (i = 0; i < num_grfs; i++) {

   483

		char *unknown_name;

   484

		char name[NETWORK_GRF_NAME_LENGTH];

   485

		GRFConfig c;

   486

   487

		NetworkRecv_GRFIdentifier(&_udp_cs, p, &c);

   488

		NetworkRecv_string(&_udp_cs, p, name, sizeof(name));

   489

   490

		/* An empty name is not possible under normal circumstances

   491

		 * and causes problems when showing the NewGRF list. */

   492

		if (strlen(name) == 0) continue;