1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gui.h"

     4

#include "command.h"

     5

#include "player.h"

     7

     8

#if defined(WIN32)

     9

#	include <windows.h>

    10

#	include <winsock.h>

    11

    12

# pragma comment (lib, "ws2_32.lib")

    13

# define ENABLE_NETWORK

    14

# define GET_LAST_ERROR() WSAGetLastError()

    15

# define EWOULDBLOCK WSAEWOULDBLOCK

    16

#endif

    17

    18

#if defined(UNIX)

    19

// Make compatible with WIN32 names

    20

#	define SOCKET int

    21

#	define INVALID_SOCKET -1

    22

// we need different defines for MorphOS and AmigaOS

    23

#if !defined(__MORPHOS__) && !defined(__AMIGA__)

    24

#	define ioctlsocket ioctl

    25

# define closesocket close

    26

# define GET_LAST_ERROR() errno

    27

#endif

    28

// Need this for FIONREAD on solaris

    29

#	define BSD_COMP

    30

#	include <unistd.h>

    31

#	include <sys/ioctl.h>

    32

    33

// Socket stuff

    34

#	include <sys/socket.h>

    35

#	include <netinet/in.h>

    36

#	include <arpa/inet.h>

    37

# 	include <errno.h>

    38

# 	include <sys/time.h>

    39

// NetDB

    40

#   include <netdb.h>

    41

    42

# ifndef TCP_NODELAY

    43

#  define TCP_NODELAY 0x0001

    44

# endif

    45

    46

#endif

    47

    48

    49

#if defined(__MORPHOS__) || defined(__AMIGA__)

    50

#	include <exec/types.h>

    51

#	include <proto/exec.h> 		// required for Open/CloseLibrary()

    52

#	if defined(__MORPHOS__)

    53

#		include <sys/filio.h> 	// FION#? defines

    54

#	else // __AMIGA__

    55

#		include	<proto/socket.h>

    56

#	endif

    57

    58

// make source compatible with bsdsocket.library functions

    59

# define closesocket(s)     						CloseSocket(s)

    60

# define GET_LAST_ERROR() 							Errno()

    61

#	define ioctlsocket(s,request,status)  IoctlSocket((LONG)s,(ULONG)request,(char*)status)

    62

    63

struct Library *SocketBase = NULL;

    73

#endif /* __MORPHOS__ || __AMIGA__ */

    74

    75

    76

#define SEND_MTU 1460

    77

    78

#if defined(ENABLE_NETWORK)

    79

    80

// sent from client -> server whenever the client wants to exec a command.

    81

// send from server -> client when another player execs a command.

    82

typedef struct CommandPacket {

    83

	byte packet_length;

    84

	byte packet_type;

    85

	uint16 cmd;

    86

	uint32 p1,p2;

    87

	TileIndex tile;

    88

	byte player;// player id, this is checked by the server.

    89

	byte when;  // offset from the current max_frame value minus 1. this is set by the server.

    90

	uint32 dp[8];

    91

} CommandPacket;

    92

    93

assert_compile(sizeof(CommandPacket) == 16 + 32);

    94

    95

#define COMMAND_PACKET_BASE_SIZE (sizeof(CommandPacket) - 8 * sizeof(uint32))

    96

    97

// sent from server -> client periodically to tell the client about the current tick in the server

    98

// and how far the client may progress.

    99

typedef struct SyncPacket {

   100

	byte packet_length;

   101

	byte packet_type;

   102

	byte frames; // how many more frames may the client execute? this is relative to the old value of max.

   103

	byte server; // where is the server currently executing? this is negatively relative to the old value of max.

   104

	uint32 random_seed_1; // current random state at server. used to detect out of sync.

   105

	uint32 random_seed_2;

   106

} SyncPacket;

   107

   108

assert_compile(sizeof(SyncPacket) == 12);

   109

   110

// sent from server -> client as an acknowledgement that the server received the command.

   111

// the command will be executed at the current value of "max".

   112

typedef struct AckPacket {

   113

	byte packet_length;

   114

	byte packet_type;

   115

} AckPacket;

   116

   117

typedef struct FilePacketHdr {

   118

	byte packet_length;

   119

	byte packet_type;

   120

	byte unused[2];

   121

} FilePacketHdr;

   122

   123

assert_compile(sizeof(FilePacketHdr) == 4);

   124

   125

// sent from server to client when the client has joined.

   126

typedef struct WelcomePacket {

   127

	byte packet_length;

   128

	byte packet_type;

   129

	byte unused[2];

   130

} WelcomePacket;

   131

   132

typedef struct Packet Packet;

   133

struct Packet {

   134

	Packet *next; // this one has to be the first element.

   135

	uint siz;

   136

	byte buf[SEND_MTU]; // packet payload

   137

};

   138

   139

typedef struct ClientState {

   140

	int socket;

   141

	bool inactive; // disable sending of commands/syncs to client

   142

	bool writable;

   143

	uint xmitpos;

   144

   145

	uint eaten;

   146

	Packet *head, **last;

   147

   148

	uint buflen;											// receive buffer len

   149

	byte buf[256];										// receive buffer

   150

} ClientState;

   151

   152

   153

static uint _not_packet;

   154

   155

typedef struct QueuedCommand QueuedCommand;

   156

struct QueuedCommand {

   157

	QueuedCommand *next;

   158

	CommandPacket cp;

   159

	CommandCallback *callback;

   160

	uint32 cmd;

   161

	int32 frame;

   162

};

   163

   164

typedef struct CommandQueue CommandQueue;

   165

struct CommandQueue {

   166

	QueuedCommand *head, **last;

   167

};

   168

   169

#define MAX_CLIENTS (MAX_PLAYERS + 1)

   170

   171

// packets waiting to be executed, for each of the players.

   172

// this list is sorted in frame order, so the item on the front will be executed first.

   173

static CommandQueue _command_queue;

   174

   175

// in the client, this is the list of commands that have not yet been acked.

   176

// when it is acked, it will be moved to the appropriate position at the end of the player queue.

   177

static CommandQueue _ack_queue;

   178

   179

static ClientState _clients[MAX_CLIENTS];

   180

static int _num_clients;

   181

   182

// keep a history of the 16 most recent seeds to be able to capture out of sync errors.

   183

static uint32 _my_seed_list[16][2];

   184

   185

typedef struct FutureSeeds {

   186

	int32 frame;

   187

	uint32 seed[2];

   188

} FutureSeeds;

   189

   190

// remember some future seeds that the server sent to us.

   191

static FutureSeeds _future_seed[8];

   192

static int _num_future_seed;

   193

   194

static SOCKET _listensocket; // tcp socket

   195

   196

static SOCKET _udp_client_socket; // udp server socket

   197

static SOCKET _udp_server_socket; // udp client socket

   198

   199

typedef struct UDPPacket {

   200

	byte command_code;

   201

	byte data_len;

   202

	byte command_check;

   203

	byte data[255];

   204

} UDPPacket;

   205

   206

enum {

   207

	NET_UDPCMD_SERVERSEARCH = 1,

   208

	NET_UDPCMD_SERVERACTIVE,

   209

	NET_UDPCMD_GETSERVERINFO,

   210

	NET_UDPCMD_SERVERINFO,

   211

};

   212

   213

void NetworkUDPSend(bool client, struct sockaddr_in recv,struct UDPPacket packet);

   214

   215

uint32 _network_ip_list[10]; // network ip list

   216

   217

// this is set to point to the savegame

   218

static byte *_transmit_file;

   219

static size_t _transmit_file_size;

   220

   221

static FILE *_recv_file;

   222

   223

typedef struct NetworkGameInfo {	

   224

	char server_name[40]; // name of the game

   225

	char server_revision[8]; // server game version

   226

	byte server_lang; // langid

   227

	byte players_max; // max players allowed on server

   228

	byte players_on; // current count of players on server

   229

	uint16 game_date; // current date

   230

	char game_password[10]; // should fit ... 14 chars

   231

	char map_name[40]; // map which is played ["random" for a randomized map]

   232

	uint map_width; // map width / 8

   233

	uint map_height; // map height / 8

   234

	byte map_set; // graphical set

   235

} NetworkGameInfo;

   236

   237

typedef struct NetworkGameList {

   238

	NetworkGameInfo item;

   239

	uint32 ip;

   240

	uint16 port;

   241

	char * _next;

   242

} NetworkGameList;

   243

   244

static NetworkGameInfo _network_game;

   245

static NetworkGameList * _network_game_list = NULL;

   246

   247

/* multi os compatible sleep function */

   248

void CSleep(int milliseconds) {

   249

#if defined(WIN32)

   250

Sleep(milliseconds);

   251

#endif

   252

#if defined(UNIX)

   254

usleep(milliseconds*1000);

   255

#endif

   256

#ifdef __BEOS__

   257

snooze(milliseconds*1000);

   258

#endif

   276

#endif

   277

}

   278

   279

//////////////////////////////////////////////////////////////////////

   280

   281

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

   282

// * TCP Packets and Handlers   * //

   283

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

   284

   285

static QueuedCommand *AllocQueuedCommand(CommandQueue *nq)

   286

{

   287

	QueuedCommand *qp = (QueuedCommand*)calloc(sizeof(QueuedCommand), 1);

   288

	assert(qp);

   289

	*nq->last = qp;

   290

	nq->last = &qp->next;

   291

	return qp;

   292

}

   293

   294

// go through the player queues for each player and see if there are any pending commands

   295

// that should be executed this frame. if there are, execute them.

   296

void NetworkProcessCommands()

   297

{

   298

	CommandQueue *nq;

   299

	QueuedCommand *qp;

   300

   301

	// queue mode ?

   302

	if (_networking_queuing)

   303

		return;

   304

   305

	nq = &_command_queue;

   306

	while ( (qp=nq->head) && (!_networking_sync || qp->frame <= _frame_counter)) {

   307

		// unlink it.

   308

		if (!(nq->head = qp->next)) nq->last = &nq->head;

   309

   310

		if (qp->frame < _frame_counter && _networking_sync) {

   311

			error("!qp->cp.frame < _frame_counter, %d < %d\n", qp->frame, _frame_counter);

   312

		}

   313

   314

		// run the command

   315

		_current_player = qp->cp.player;

   316

		memcpy(_decode_parameters, qp->cp.dp, (qp->cp.packet_length - COMMAND_PACKET_BASE_SIZE));

   317

		DoCommandP(qp->cp.tile, qp->cp.p1, qp->cp.p2, qp->callback, qp->cmd | CMD_DONT_NETWORK);

   318

		free(qp);

   319

	}

   320

   321

	if (!_networking_server) {

   322

		// remember the random seed so we can check if we're out of sync.

   323

		_my_seed_list[_frame_counter & 15][0] = _sync_seed_1;

   324

		_my_seed_list[_frame_counter & 15][1] = _sync_seed_2;

   325

   326

		while (_num_future_seed) {

   327

			assert(_future_seed[0].frame >= _frame_counter);

   328

			if (_future_seed[0].frame != _frame_counter) break;

   329

			if (_future_seed[0].seed[0] != _sync_seed_1 ||_future_seed[0].seed[1] != _sync_seed_2)

   330

				error("!network sync error");

   331

			memcpy_overlapping(_future_seed, _future_seed + 1, --_num_future_seed * sizeof(FutureSeeds));

   332

		}

   333

	}

   334

}

   335

   336

// send a packet to a client

   337

static void SendBytes(ClientState *cs, void *bytes, uint len)

   338

{

   339

	byte *b = (byte*)bytes;

   340

	uint n;

   341

	Packet *p;

   342

   343

	assert(len != 0);

   344

   345

	// see if there's space in the last packet?

   346

	if (!cs->head || (p = (Packet*)cs->last, p->siz == sizeof(p->buf)))

   347

		p = NULL;

   348

   349

	do {

   350

		if (!p) {

   351

			// need to allocate a new packet buffer.

   352

			p = (Packet*)malloc(sizeof(Packet));

   353

   354

			// insert at the end of the linked list.

   355

			*cs->last = p;

   356

			cs->last = &p->next;

   357

			p->next = NULL;

   358

			p->siz = 0;

   359

		}

   360

   361

		// copy bytes to packet.

   362

		n = minu(sizeof(p->buf) - p->siz, len);

   363

		memcpy(p->buf + p->siz, b, n);

   364

		p->siz += n;

   365

		b += n;

   366

		p = NULL;

   367

	} while (len -= n);

   368

}

   369

   370

// client:

   371

//   add it to the client's ack queue, and send the command to the server

   372

// server:

   373

//   add it to the server's player queue, and send it to all clients.

   374

void NetworkSendCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback)

   375

{

   376

	int nump;

   377

	QueuedCommand *qp;

   378

	ClientState *cs;

   379

   380

	qp = AllocQueuedCommand(_networking_server ? &_command_queue : &_ack_queue);

   381

	qp->cp.packet_type = 0;

   382

	qp->cp.tile = tile;

   383

	qp->cp.p1 = p1;

   384

	qp->cp.p2 = p2;

   385

	qp->cp.cmd = (uint16)cmd;

   386

	qp->cp.player = _local_player;

   387

	qp->cp.when = 0;

   388

	qp->cmd = cmd;

   389

	qp->callback = callback;

   390

   391

	// so the server knows when to execute it.

   392

	qp->frame = _frame_counter_max;

   393

   394

	// calculate the amount of extra bytes.

   395

	nump = 8;

   396

	while ( nump != 0 && ((uint32*)_decode_parameters)[nump-1] == 0) nump--;

   397

	qp->cp.packet_length = COMMAND_PACKET_BASE_SIZE + nump * sizeof(uint32);

   398

	if (nump != 0) memcpy(qp->cp.dp, _decode_parameters, nump * sizeof(uint32));

   399

   400

#if defined(TTD_BIG_ENDIAN)

   401

	// need to convert the command to little endian before sending it.

   402

	{

   403

		CommandPacket cp;

   404

		cp = qp->cp;

   405

		cp.cmd = TO_LE16(cp.cmd);

   406

		cp.tile = TO_LE16(cp.tile);

   407

		cp.p1 = TO_LE32(cp.p1);

   408

		cp.p2 = TO_LE32(cp.p2);

   409

		for(cs=_clients; cs->socket != INVALID_SOCKET; cs++) if (!cs->inactive) SendBytes(cs, &cp, cp.packet_length);

   410

	}

   411

#else

   412

	// send it to the peers

   413

	for(cs=_clients; cs->socket != INVALID_SOCKET; cs++) if (!cs->inactive) SendBytes(cs, &qp->cp, qp->cp.packet_length);

   414

   415

#endif

   416

}

   417

   418

// client:

   419

//   server sends a command from another player that we should execute.

   420

//   put it in the command queue.

   421

//

   422

// server:

   423

//   client sends a command that it wants to execute.

   424

//   fill the when field so the client knows when to execute it.

   425

//   put it in the appropriate player queue.

   426

//   send it to all other clients.

   427

//   send an ack packet to the actual client.

   428

   429

static void HandleCommandPacket(ClientState *cs, CommandPacket *np)

   430

{

   431

	QueuedCommand *qp;

   432

	ClientState *c;

   433

	AckPacket ap;

   434

   435

	printf("net: cmd size %d\n", np->packet_length);

   436

   437

	assert(np->packet_length >= COMMAND_PACKET_BASE_SIZE);

   438

   439

	// put it into the command queue

   440

	qp = AllocQueuedCommand(&_command_queue);

   441

	qp->cp = *np;

   442

   443

	qp->frame = _frame_counter_max;

   444

   445

	qp->callback = NULL;

   446

   447

	// extra params

   448

	memcpy(&qp->cp.dp, np->dp, np->packet_length - COMMAND_PACKET_BASE_SIZE);

   449

   450

	ap.packet_type = 2;

   451

	ap.packet_length = 2;

   452

   453

	// send it to the peers

   454

	if (_networking_server) {

   455

		for(c=_clients; c->socket != INVALID_SOCKET; c++) {

   456

			if (c == cs) {

   457

				SendBytes(c, &ap, 2);

   458

			} else {

   459

				if (!cs->inactive) SendBytes(c, &qp->cp, qp->cp.packet_length);

   460

			}

   461

		}

   462

	}

   463

   464

// convert from little endian to big endian?

   465

#if defined(TTD_BIG_ENDIAN)

   466

	qp->cp.cmd = TO_LE16(qp->cp.cmd);

   467

	qp->cp.tile = TO_LE16(qp->cp.tile);

   468

	qp->cp.p1 = TO_LE32(qp->cp.p1);

   469

	qp->cp.p2 = TO_LE32(qp->cp.p2);

   470

#endif

   471

   472

	qp->cmd = qp->cp.cmd;

   473

}

   474

   475

// sent from server -> client periodically to tell the client about the current tick in the server

   476

// and how far the client may progress.

   477

static void HandleSyncPacket(SyncPacket *sp)

   478

{

   479

	uint32 s1,s2;

   480

   481

	_frame_counter_srv = _frame_counter_max - sp->server;

   482

	_frame_counter_max += sp->frames;

   483

   484

	printf("net: sync max=%d  cur=%d  server=%d\n", _frame_counter_max, _frame_counter, _frame_counter_srv);

   485

   486

	// queueing only?

   487

	if (_networking_queuing || _frame_counter == 0)

   488

		return;

   489

   490

	s1 = TO_LE32(sp->random_seed_1);

   491

	s2 = TO_LE32(sp->random_seed_2);

   492

   493

	if (_frame_counter_srv <= _frame_counter) {

   494

		// we are ahead of the server check if the seed is in our list.

   495

		if (_frame_counter_srv + 16 > _frame_counter) {

   496

			// the random seed exists in our array check it.

   497

			if (s1 != _my_seed_list[_frame_counter_srv & 0xF][0] || s2 != _my_seed_list[_frame_counter_srv & 0xF][1])

   498

				error("!network is desynched\n");

   499

		}

   500

	} else {

   501

		// the server's frame has not been executed yet. store the server's seed in a list.

   502

		if (_num_future_seed < lengthof(_future_seed)) {

   503

			_future_seed[_num_future_seed].frame = _frame_counter_srv;

   504

			_future_seed[_num_future_seed].seed[0] = s1;

   505

			_future_seed[_num_future_seed].seed[1] = s2;

   506

			_num_future_seed++;

   507

		}

   508

	}

   509

}

   510

   511

// sent from server -> client as an acknowledgement that the server received the command.

   512

// the command will be executed at the current value of "max".

   513

static void HandleAckPacket()

   514

{

   515

	QueuedCommand *q;

   516

	// move a packet from the ack queue to the end of this player's queue.

   517

	q = _ack_queue.head;

   518

	assert(q);

   519

	if (!(_ack_queue.head = q->next)) _ack_queue.last = &_ack_queue.head;

   520

	q->next = NULL;

   521

	q->frame = _frame_counter_max;

   522

   523