1

#include "stdafx.h"

     2

#include "network_data.h"

     3

     4

#ifdef ENABLE_NETWORK

     5

     6

#include "network_gamelist.h"

     7

     8

extern void UpdateNetworkGameWindow(bool unselect);

     9

extern void NetworkPopulateCompanyInfo(void);

    10

    11

//

    12

// This file handles all the LAN-stuff

    13

// Stuff like:

    14

//   - UDP search over the network

    15

//

    16

    17

typedef enum {

    18

	PACKET_UDP_CLIENT_FIND_SERVER,

    19

	PACKET_UDP_SERVER_RESPONSE,

    20

	PACKET_UDP_CLIENT_DETAIL_INFO,

    21

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

    22

	PACKET_UDP_END

    23

} PacketUDPType;

    24

    25

static SOCKET _udp_server_socket; // udp server socket

    26

    27

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

    28

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

    29

    30

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_FIND_SERVER)

    31

{

    32

	Packet *packet;

    33

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

    34

	if (!_network_udp_server)

    35

		return;

    36

    37

	packet = NetworkSend_Init(PACKET_UDP_SERVER_RESPONSE);

    38

    39

	// Update some game_info

    40

	_network_game_info.game_date = _date;

    41

	_network_game_info.map_set = _opt.landscape;

    42

    43

	NetworkSend_uint8 (packet, NETWORK_GAME_INFO_VERSION);

    44

	NetworkSend_string(packet, _network_game_info.server_name);

    45

	NetworkSend_string(packet, _network_game_info.server_revision);

    46

	NetworkSend_uint8 (packet, _network_game_info.server_lang);

    47

	NetworkSend_uint8 (packet, _network_game_info.use_password);

    48

	NetworkSend_uint8 (packet, _network_game_info.clients_max);

    49

	NetworkSend_uint8 (packet, _network_game_info.clients_on);

    50

	NetworkSend_uint8 (packet, _network_game_info.spectators_on);

    51

	NetworkSend_uint16(packet, _network_game_info.game_date);

    52

	NetworkSend_uint16(packet, _network_game_info.start_date);

    53

	NetworkSend_string(packet, _network_game_info.map_name);

    54

	NetworkSend_uint16(packet, _network_game_info.map_width);

    55

	NetworkSend_uint16(packet, _network_game_info.map_height);

    56

	NetworkSend_uint8 (packet, _network_game_info.map_set);

    57

	NetworkSend_uint8 (packet, _network_game_info.dedicated);

    58

    59

	// Let the client know that we are here

    60

	NetworkSendUDP_Packet(packet, client_addr);

    61

    62

	free(packet);

    63

    64

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

    65

}

    66

    67

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_SERVER_RESPONSE)

    68

{

    69

	NetworkGameList *item;

    70

	byte game_info_version;

    71

    72

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

    73

	if (_network_udp_server)

    74

		return;

    75

    76

	game_info_version = NetworkRecv_uint8(p);

    77

    78

	// Find next item

    79

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

    80

    81

	if (game_info_version == 1) {

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

		item->info.game_date = NetworkRecv_uint16(p);

    90

		item->info.start_date = NetworkRecv_uint16(p);

    91

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

    92

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

    93

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

    94

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

    95

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

    96

    97

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

    98

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

    99

	}

   100

   101

	item->online = true;

   102

   103

	UpdateNetworkGameWindow(false);

   104

}

   105

   106

DEF_UDP_RECEIVE_COMMAND(PACKET_UDP_CLIENT_DETAIL_INFO)

   107

{

   108

	ClientState *cs;

   109

	NetworkClientInfo *ci;

   110

	Packet *packet;

   111

	Player *player;

   112

	byte active = 0;

   113

	byte current = 0;

   114

	int i;

   115

   116

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

   117

	if (!_network_udp_server)

   118

		return;

   119

   120

	packet = NetworkSend_Init(PACKET_UDP_SERVER_DETAIL_INFO);

   121

   122

	FOR_ALL_PLAYERS(player) {

   123

		if (player->is_active)

   124

			active++;

   125

	}

   126

   127

	/* Send the amount of active companies */

   128

	NetworkSend_uint8 (packet, NETWORK_COMPANY_INFO_VERSION);

   129

	NetworkSend_uint8 (packet, active);

   130

   131

	/* Fetch the latest version of everything */

   132

	NetworkPopulateCompanyInfo();

   133

   134

	/* Go through all the players */

   135

	FOR_ALL_PLAYERS(player) {

   136

		/* Skip non-active players */

   137

		if (!player->is_active)

   138

			continue;

   139

   140

		current++;

   141

   142

		/* Send the information */

   143

		NetworkSend_uint8 (packet, current);

   144

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

   152

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

   153

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

   154

   155

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

   156

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

   157

   158

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

   159

		FOR_ALL_CLIENTS(cs) {

   160

			ci = DEREF_CLIENT_INFO(cs);

   161

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

   162

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

   163

				NetworkSend_uint8(packet, 1);

   164

				NetworkSend_string(packet, ci->client_name);

   165

				NetworkSend_string(packet, ci->unique_id);

   166

				NetworkSend_uint16(packet, ci->join_date);

   167

			}

   168

		}

   169

		/* Also check for the server itself */

   170

		ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

   171

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

   172

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

   173

			NetworkSend_uint8(packet, 1);

   174

			NetworkSend_string(packet, ci->client_name);

   175

			NetworkSend_string(packet, ci->unique_id);

   176

			NetworkSend_uint16(packet, ci->join_date);

   177

		}

   178

   179

		/* Indicates end of client list */

   180

		NetworkSend_uint8(packet, 0);

   181

	}

   182

   183

	/* And check if we have any spectators */

   184

	FOR_ALL_CLIENTS(cs) {

   185

		ci = DEREF_CLIENT_INFO(cs);

   186

		if ((ci->client_playas - 1) > MAX_PLAYERS) {

   187

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

   188

			NetworkSend_uint8(packet, 1);

   189

			NetworkSend_string(packet, ci->client_name);

   190

			NetworkSend_string(packet, ci->unique_id);

   191

			NetworkSend_uint16(packet, ci->join_date);

   192

		}

   193

	}

   194

	/* Also check for the server itself */

   195

	ci = NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX);

   196

	if ((ci->client_playas - 1) > MAX_PLAYERS) {

   197

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

   198

		NetworkSend_uint8(packet, 1);

   199

		NetworkSend_string(packet, ci->client_name);

   200

		NetworkSend_string(packet, ci->unique_id);

   201

		NetworkSend_uint16(packet, ci->join_date);

   202

	}

   203

   204

	/* Indicates end of client list */

   205

	NetworkSend_uint8(packet, 0);

   206

   207

	NetworkSendUDP_Packet(packet, client_addr);

   208

   209

	free(packet);

   210

}

   211

   212

   213

// The layout for the receive-functions by UDP

   214

typedef void NetworkUDPPacket(Packet *p, struct sockaddr_in *client_addr);

   215

   216

static NetworkUDPPacket* const _network_udp_packet[] = {

   217

	RECEIVE_COMMAND(PACKET_UDP_CLIENT_FIND_SERVER),

   218

	RECEIVE_COMMAND(PACKET_UDP_SERVER_RESPONSE),

   219

	RECEIVE_COMMAND(PACKET_UDP_CLIENT_DETAIL_INFO),

   220

	NULL,

   221

};

   222

   223

// If this fails, check the array above with network_data.h

   224

assert_compile(lengthof(_network_udp_packet) == PACKET_UDP_END);

   225

   226

   227

void NetworkHandleUDPPacket(Packet *p, struct sockaddr_in *client_addr)

   228

{

   229

	byte type;

   230

   231

	type = NetworkRecv_uint8(p);

   232

   233

	if (type < PACKET_UDP_END && _network_udp_packet[type] != NULL) {

   234

		_network_udp_packet[type](p, client_addr);

   235

	}	else {

   236

		DEBUG(net, 0)("[NET][UDP] Received invalid packet type %d", type);

   237

	}

   238

}

   239

   240

   241

// Send a packet over UDP

   242

void NetworkSendUDP_Packet(Packet *p, struct sockaddr_in *recv)

   243

{

   244

	SOCKET udp;

   245

	int res;

   246

   247

	// Find the correct socket

   248

	if (_network_udp_server)

   249

		udp = _udp_server_socket;

   250

	else

   251

		udp = _udp_client_socket;

   252

   253

	// Put the length in the buffer

   254

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

   255

	p->buffer[1] = p->size >> 8;

   256

   257

	// Send the buffer

   258

	res = sendto(udp, p->buffer, p->size, 0, (struct sockaddr *)recv, sizeof(*recv));

   259

   260

	// Check for any errors, but ignore it for the rest

   261

	if (res == -1) {

   262

		DEBUG(net, 1)("[NET][UDP] Send error: %i", GET_LAST_ERROR());

   263

	}

   264

}

   265

   266

// Start UDP listener

   267

bool NetworkUDPListen(uint32 host, uint16 port)

   268

{

   269

	struct sockaddr_in sin;

   270

	SOCKET udp;

   271

   272

	// Make sure sockets are closed

   273

	if (_network_udp_server)

   274

		closesocket(_udp_server_socket);

   275

	else

   276

		closesocket(_udp_client_socket);

   277

   278

	udp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

   279

	if (udp == INVALID_SOCKET) {

   280

		DEBUG(net, 1)("[NET][UDP] Failed to start UDP support");

   281

		return false;

   282

	}

   283

   284

	// set nonblocking mode for socket

   285

	{

   286

		unsigned long blocking = 1;

   287

		ioctlsocket(udp, FIONBIO, &blocking);

   288

	}

   289

   290

	sin.sin_family = AF_INET;

   291

	// Listen on all IPs

   292

	sin.sin_addr.s_addr = host;

   293

	sin.sin_port = htons(port);

   294

   295

	if (bind(udp, (struct sockaddr*)&sin, sizeof(sin)) != 0) {

   296

		DEBUG(net, 1) ("[NET][UDP] error: bind failed on %s:%i", inet_ntoa(*(struct in_addr *)&host), port);

   297

		return false;

   298

	}

   299

   300

	// enable broadcasting

   301

	// allow reusing

   302

	{

   303

		unsigned long val = 1;

   304

		setsockopt(udp, SOL_SOCKET, SO_BROADCAST, (char *) &val , sizeof(val));

   305

		val = 1;

   306

		setsockopt(udp, SOL_SOCKET, SO_REUSEADDR, (char *) &val , sizeof(val));

   307

	}

   308

   309

	if (_network_udp_server)

   310

		_udp_server_socket = udp;

   311

	else

   312

		_udp_client_socket = udp;

   313

   314

	DEBUG(net, 1)("[NET][UDP] Listening on port %s:%d", inet_ntoa(*(struct in_addr *)&host), port);

   315

   316

	return true;

   317

}

   318

   319

// Close UDP connection

   320

void NetworkUDPClose(void)

   321

{

   322

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

   323

   324

	if (_network_udp_server) {

   325

		closesocket(_udp_server_socket);

   326

		_udp_server_socket = INVALID_SOCKET;

   327

		_network_udp_server = false;

   328

		_network_udp_broadcast = 0;

   329

	} else {

   330

		closesocket(_udp_client_socket);

   331

		_udp_client_socket = INVALID_SOCKET;

   332

		_network_udp_broadcast = 0;

   333

	}

   334

}

   335

   336

// Receive something on UDP level

   337

void NetworkUDPReceive(void)

   338

{

   339

	struct sockaddr_in client_addr;

   340

#ifndef __MORPHOS__

   341

	int client_len;

   342

#else

   343

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

   344

#endif

   345

	int nbytes;

   346

	static Packet *p = NULL;

   347

	int packet_len;

   348

	SOCKET udp;

   349

   350

	if (_network_udp_server)

   351

		udp = _udp_server_socket;

   352

	else

   353

		udp = _udp_client_socket;

   354

   355

	// If p is NULL, malloc him.. this prevents unneeded mallocs

   356

	if (p == NULL)

   357

		p = malloc(sizeof(Packet));

   358

   359

	packet_len = sizeof(p->buffer);

   360

	client_len = sizeof(client_addr);

   361

   362

	// Try to receive anything

   363

	nbytes = recvfrom(udp, p->buffer, packet_len, 0, (struct sockaddr *)&client_addr, &client_len);

   364

   365

	// We got some bytes.. just asume we receive the whole packet

   366

	if (nbytes > 0) {

   367

		// Get the size of the buffer

   368

		p->size = (uint16)p->buffer[0];

   369

		p->size += (uint16)p->buffer[1] << 8;

   370

		// Put the position on the right place

   371

		p->pos = 2;

   372

		p->next = NULL;

   373

   374

		// Handle the packet

   375

		NetworkHandleUDPPacket(p, &client_addr);

   376

   377

		// Free the packet

   378

		free(p);

   379

		p = NULL;

   380

	}

   381

}

   382

   383

// Broadcast to all ips

   384

void NetworkUDPBroadCast(void)

   385

{

   386

	int i;

   387

	struct sockaddr_in out_addr;

   388

	byte *bcptr;

   389

	uint32 bcaddr;

   390

	Packet *p;

   391

   392

	// Init the packet

   393

	p = NetworkSend_Init(PACKET_UDP_CLIENT_FIND_SERVER);

   394

   395

	// Go through all the ips on this pc

   396

	i = 0;

   397

	while (_network_ip_list[i] != 0) {

   398

		bcaddr = _network_ip_list[i];

   399

		bcptr = (byte *)&bcaddr;

   400

		// Make the address a broadcast address

   401

		bcptr[3] = 255;

   402

   403

		DEBUG(net, 6)("[NET][UDP] Broadcasting to %s", inet_ntoa(*(struct in_addr *)&bcaddr));

   404

   405

		out_addr.sin_family = AF_INET;

   406

		out_addr.sin_port = htons(_network_server_port);

   407

		out_addr.sin_addr.s_addr = bcaddr;

   408

   409

		NetworkSendUDP_Packet(p, &out_addr);

   410

   411

		i++;

   412

	}

   413

   414

	free(p);

   415

}

   416

   417

// Find all servers

   418

void NetworkUDPSearchGame(void)

   419

{

   420

	// We are still searching..

   421

	if (_network_udp_broadcast > 0)

   422

		return;

   423

   424

	// No UDP-socket yet..

   425

	if (_udp_client_socket == INVALID_SOCKET)

   426

		if (!NetworkUDPListen(0, 0))

   427

			return;

   428

   429

	DEBUG(net, 0)("[NET][UDP] Searching server");

   430

   431

	NetworkUDPBroadCast();

   432

	_network_udp_broadcast = 300; // Stay searching for 300 ticks

   433

}

   434

   435

void NetworkUDPQueryServer(const byte* host, unsigned short port)

   436

{

   437

	struct sockaddr_in out_addr;

   438

	Packet *p;

   439

	NetworkGameList *item;

   440

	char hostname[NETWORK_HOSTNAME_LENGTH];

   441

   442

	// No UDP-socket yet..

   443

	if (_udp_client_socket == INVALID_SOCKET)

   444

		if (!NetworkUDPListen(0, 0))

   445

			return;

   446

   447

	ttd_strlcpy(hostname, host, sizeof(hostname));

   448

   449

	out_addr.sin_family = AF_INET;

   450

	out_addr.sin_port = htons(port);

   451

	out_addr.sin_addr.s_addr = NetworkResolveHost(host);

   452

   453

	// Clear item in gamelist

   454

	item = NetworkGameListAddItem(inet_addr(inet_ntoa(out_addr.sin_addr)), ntohs(out_addr.sin_port));

   455

	memset(&item->info, 0, sizeof(item->info));

   456

	snprintf(item->info.server_name, sizeof(item->info.server_name), "%s", hostname);

   457

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

   458

	item->online = false;

   459

   460

	// Init the packet

   461

	p = NetworkSend_Init(PACKET_UDP_CLIENT_FIND_SERVER);

   462

   463

	NetworkSendUDP_Packet(p, &out_addr);

   464

   465

	free(p);

   466

   467

	UpdateNetworkGameWindow(false);

   468

}

   469

   470

void NetworkUDPInitialize(void)

   471

{

   472

	_udp_client_socket = INVALID_SOCKET;

   473

	_udp_server_socket = INVALID_SOCKET;

   474

   475

	_network_udp_server = false;

   476

	_network_udp_broadcast = 0;

   477

}

   478

   479

#endif /* ENABLE_NETWORK */