1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "command.h"

     4

#include "player.h"

     5

     6

#if defined(WIN32)

     7

#	include <windows.h>

     8

#	include <winsock.h>

     9

    10

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

    11

# define ENABLE_NETWORK

    12

# define GET_LAST_ERROR() WSAGetLastError()

    13

# define EWOULDBLOCK WSAEWOULDBLOCK

    14

#endif

    15

    16

#if defined(UNIX)

    17

// Make compatible with WIN32 names

    18

#	define SOCKET int

    19

#	define INVALID_SOCKET -1

    20

// we need different defines for MorphOS and AmigaOS

    21

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

    22

#	define ioctlsocket ioctl

    23

# define closesocket close

    24

# define GET_LAST_ERROR() errno

    25

#endif

    26

// Need this for FIONREAD on solaris

    27

#	define BSD_COMP

    28

#	include <unistd.h>

    29

#	include <sys/ioctl.h>

    30

    31

// Socket stuff

    32

#	include <sys/socket.h>

    33

#	include <netinet/in.h>

    34

#	include <arpa/inet.h>

    35

# 	include <errno.h>

    36

# 	include <sys/time.h>

    37

// NetDB

    38

#   include <netdb.h>

    39

    40

# ifndef TCP_NODELAY

    41

#  define TCP_NODELAY 0x0001

    42

# endif

    43

    44

#endif

    45

    46

    47

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

    48

#	include <exec/types.h>

    49

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

    50

#	if defined(__MORPHOS__)

    51

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

    52

#	else // __AMIGA__

    53

#		include	<proto/socket.h>

    54

#	endif

    55

    56

// make source compatible with bsdsocket.library functions

    57

# define closesocket(s)     						CloseSocket(s)

    58

# define GET_LAST_ERROR() 							Errno()

    59

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

    60

    61

struct Library *SocketBase = NULL;

    62

#endif /* __MORPHOS__ || __AMIGA__ */

    63

    64

    65

#define SEND_MTU 1460

    66

    67

#if defined(ENABLE_NETWORK)

    68

    69

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

    70

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

    71

typedef struct CommandPacket {

    72

	byte packet_length;

    73

	byte packet_type;

    74

	uint16 cmd;

    75

	uint32 p1,p2;

    76

	TileIndex tile;

    77

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

    78

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

    79

	uint32 dp[8];

    80

} CommandPacket;

    81

    82

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

    83

    84

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

    85

    86

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

    87

// and how far the client may progress.

    88

typedef struct SyncPacket {

    89

	byte packet_length;

    90

	byte packet_type;

    91

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

    92

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

    93

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

    94

	uint32 random_seed_2;

    95

} SyncPacket;

    96

    97

assert_compile(sizeof(SyncPacket) == 12);

    98

    99

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

   100

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

   101

typedef struct AckPacket {

   102

	byte packet_length;

   103

	byte packet_type;

   104

} AckPacket;

   105

   106

typedef struct FilePacketHdr {

   107

	byte packet_length;

   108

	byte packet_type;

   109

	byte unused[2];

   110

} FilePacketHdr;

   111

   112

assert_compile(sizeof(FilePacketHdr) == 4);

   113

   114

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

   115

typedef struct WelcomePacket {

   116

	byte packet_length;

   117

	byte packet_type;

   118

	byte unused[2];

   119

} WelcomePacket;

   120

   121

typedef struct Packet Packet;

   122

struct Packet {

   123

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

   124

	uint siz;

   125

	byte buf[SEND_MTU]; // packet payload

   126

};

   127

   128

typedef struct ClientState {

   129

	int socket;

   130

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

   131

	bool writable;

   132

	uint xmitpos;

   133

   134

	uint eaten;

   135

	Packet *head, **last;

   136

   137

	uint buflen;											// receive buffer len

   138

	byte buf[256];										// receive buffer

   139

} ClientState;

   140

   141

   142

static uint _not_packet;

   143

   144

typedef struct QueuedCommand QueuedCommand;

   145

struct QueuedCommand {

   146

	QueuedCommand *next;

   147

	CommandPacket cp;

   148

	CommandCallback *callback;

   149

	uint32 cmd;

   150

	int32 frame;

   151

};

   152

   153

typedef struct CommandQueue CommandQueue;

   154

struct CommandQueue {

   155

	QueuedCommand *head, **last;

   156

};

   157

   158

#define MAX_CLIENTS (MAX_PLAYERS + 1)

   159

   160

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

   161

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

   162

static CommandQueue _command_queue;

   163

   164

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

   165

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

   166

static CommandQueue _ack_queue;

   167

   168

static ClientState _clients[MAX_CLIENTS];

   169

static int _num_clients;

   170

   171

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

   172

static uint32 _my_seed_list[16][2];

   173

   174

typedef struct FutureSeeds {

   175

	int32 frame;

   176

	uint32 seed[2];

   177

} FutureSeeds;

   178

   179

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

   180

static FutureSeeds _future_seed[8];

   181

static int _num_future_seed;

   182

   183

static SOCKET _listensocket;

   184

static SOCKET _udpsocket;

   185

   186

   187

typedef struct UDPPacket {

   188

	byte command_code;

   189

	byte data_len;

   190

	byte command_check;

   191

	byte data[255];

   192

} UDPPacket;

   193

   194

enum {

   195

	NET_UDPCMD_SERVERSEARCH = 1,

   196

	NET_UDPCMD_SERVERACTIVE,

   197

};

   198

   199

uint32 _network_ip_list[10]; // Network ips

   200

char * _network_detected_serverip = "255.255.255.255"; // UDP Broadcast detected server-ip

   201

uint32 _network_detected_serverport = 0; // UDP Broadcast detected server-port

   202

   203

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

   204

   205

static bool _network_synced;

   206

   207

// this is set to point to the savegame

   208

static byte *_transmit_file;

   209

static size_t _transmit_file_size;

   210

   211

static FILE *_recv_file;

   212

   213

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

   214

   215

static QueuedCommand *AllocQueuedCommand(CommandQueue *nq)

   216

{

   217

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

   218

	assert(qp);

   219

	*nq->last = qp;

   220

	nq->last = &qp->next;

   221

	return qp;

   222

}

   223

   224

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

   225

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

   226

void NetworkProcessCommands()

   227

{

   228

	CommandQueue *nq;

   229

	QueuedCommand *qp;

   230

   231

	// queue mode ?

   232

	if (_networking_queuing)

   233

		return;

   234

   235

	nq = &_command_queue;

   236

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

   237

		// unlink it.

   238

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

   239

   240

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

   241

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

   242

		}

   243

   244

		// run the command

   245

		_current_player = qp->cp.player;

   246

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

   247

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

   248

		free(qp);

   249

	}

   250

   251

	if (!_networking_server) {

   252

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

   253

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

   254

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

   255

   256

		while (_num_future_seed) {

   257

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

   258

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

   259

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

   260

				error("!network sync error");

   261

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

   262

		}

   263

	}

   264

}

   265

   266

// send a packet to a client

   267

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

   268

{

   269

	byte *b = (byte*)bytes;

   270

	uint n;

   271

	Packet *p;

   272

   273

	assert(len != 0);

   274

   275

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

   276

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

   277

		p = NULL;

   278

   279

	do {

   280

		if (!p) {

   281

			// need to allocate a new packet buffer.

   282

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

   283

   284

			// insert at the end of the linked list.

   285

			*cs->last = p;

   286

			cs->last = &p->next;

   287

			p->next = NULL;

   288

			p->siz = 0;

   289

		}

   290

   291

		// copy bytes to packet.

   292

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

   293

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

   294

		p->siz += n;

   295

		b += n;

   296

		p = NULL;

   297

	} while (len -= n);

   298

}

   299

   300

// client:

   301

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

   302

// server:

   303

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

   304

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

   305

{

   306

	int nump;

   307

	QueuedCommand *qp;

   308

	ClientState *cs;

   309

   310

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

   311

	qp->cp.packet_type = 0;

   312

	qp->cp.tile = tile;

   313

	qp->cp.p1 = p1;

   314

	qp->cp.p2 = p2;

   315

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

   316

	qp->cp.player = _local_player;

   317

	qp->cp.when = 0;

   318

	qp->cmd = cmd;

   319

	qp->callback = callback;

   320

   321

	// so the server knows when to execute it.

   322

	qp->frame = _frame_counter_max;

   323

   324

	// calculate the amount of extra bytes.

   325

	nump = 8;

   326

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

   327

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

   328

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

   329

   330

#if defined(TTD_BIG_ENDIAN)

   331

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

   332

	{

   333

		CommandPacket cp;

   334

		cp = qp->cp;

   335

		cp.cmd = TO_LE16(cp.cmd);

   336

		cp.tile = TO_LE16(cp.tile);

   337

		cp.p1 = TO_LE32(cp.p1);

   338

		cp.p2 = TO_LE32(cp.p2);

   339

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

   340

	}

   341

#else

   342

	// send it to the peers

   343

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

   344

   345

#endif

   346

}

   347

   348

// client:

   349

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

   350

//   put it in the command queue.

   351

//

   352

// server:

   353

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

   354

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

   355

//   put it in the appropriate player queue.

   356

//   send it to all other clients.

   357

//   send an ack packet to the actual client.

   358

   359

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

   360

{

   361

	QueuedCommand *qp;

   362

	ClientState *c;

   363

	AckPacket ap;

   364

   365

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

   366

   367

	assert(np->packet_length >= COMMAND_PACKET_BASE_SIZE);

   368

   369

	// put it into the command queue

   370

	qp = AllocQueuedCommand(&_command_queue);

   371

	qp->cp = *np;

   372

   373

	qp->frame = _frame_counter_max;

   374

   375

	qp->callback = NULL;

   376

   377

	// extra params

   378

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

   379

   380

	ap.packet_type = 2;

   381

	ap.packet_length = 2;

   382

   383

	// send it to the peers

   384

	if (_networking_server) {

   385

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

   386

			if (c == cs) {

   387

				SendBytes(c, &ap, 2);

   388

			} else {

   389

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

   390

			}

   391

		}

   392

	}

   393

   394

// convert from little endian to big endian?

   395

#if defined(TTD_BIG_ENDIAN)

   396

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

   397

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

   398

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

   399

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

   400

#endif

   401

   402

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

   403

}

   404

   405

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

   406

// and how far the client may progress.

   407

static void HandleSyncPacket(SyncPacket *sp)

   408

{

   409

	uint32 s1,s2;

   410

   411

	_frame_counter_srv = _frame_counter_max - sp->server;

   412

	_frame_counter_max += sp->frames;

   413

   414

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

   415

   416

	// queueing only?

   417

	if (_networking_queuing || _frame_counter == 0)

   418

		return;

   419

   420

	s1 = TO_LE32(sp->random_seed_1);

   421

	s2 = TO_LE32(sp->random_seed_2);

   422

   423

	if (_frame_counter_srv <= _frame_counter) {

   424

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

   425

		if (_frame_counter_srv + 16 > _frame_counter) {

   426

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

   427

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

   428

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

   429

		}

   430

	} else {

   431

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

   432

		if (_num_future_seed < lengthof(_future_seed)) {

   433

			_future_seed[_num_future_seed].frame = _frame_counter_srv;

   434

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

   435

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

   436

			_num_future_seed++;

   437

		}

   438

	}

   439

}

   440

   441

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

   442

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

   443

static void HandleAckPacket()

   444

{

   445

	QueuedCommand *q;

   446

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

   447

	q = _ack_queue.head;

   448

	assert(q);

   449

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

   450

	q->next = NULL;

   451

	q->frame = _frame_counter_max;

   452

   453

	*_command_queue.last = q;

   454

	_command_queue.last = &q->next;

   455

   456

	printf("net: ack\n");

   457

}

   458

   459

static void HandleFilePacket(FilePacketHdr *fp)

   460

{

   461

	int n = fp->packet_length - sizeof(FilePacketHdr);

   462

	if (n == 0) {

   463

		assert(_networking_queuing);

   464

		assert(!_networking_sync);

   465

		// eof

   466

		if (_recv_file) { fclose(_recv_file); _recv_file = NULL; }

   467

   468

		// attempt loading the game.

   469

		_game_mode = GM_NORMAL;

   470

		if (SaveOrLoad("networkc.tmp", SL_LOAD) != SL_OK) error("network load failed");

   471

   472

		// sync to server.

   473

		_networking_queuing = false;

   474

   475

		_networking_sync = true;

   476

		_frame_counter = 0; // start executing at frame 0.

   477

		_sync_seed_1 = _sync_seed_2 = 0;

   478

		_num_future_seed = 0;

   479

		memset(_my_seed_list, 0, sizeof(_my_seed_list));

   480

   481

		if (_network_playas == 0) {

   482

			// send a command to make a new player

   483

			_local_player = 0;

   484

			NetworkSendCommand(0, 0, 0, CMD_PLAYER_CTRL, NULL);

   485

			_local_player = OWNER_SPECTATOR;

   486

		} else {

   487

			// take control over an existing company

   488

			if (DEREF_PLAYER(_network_playas-1)->is_active)

   489

				_local_player = _network_playas-1;

   490

			else

   491

				_local_player = OWNER_SPECTATOR;

   492

		}

   493

   494

	} else {

   495

		if(!_recv_file) {

   496

			_recv_file = fopen("networkc.tmp", "wb");

   497

			if (!_recv_file) error("can't open savefile");

   498

		}

   499

		fwrite( (char*)fp + sizeof(*fp), n, 1, _recv_file);

   500

	}

   501

}

   502

   503

static void CloseClient(ClientState *cs)

   504

{

   505

	Packet *p, *next;

   506

   507

	printf("CloseClient\n");

   508

   509

	assert(cs->socket != INVALID_SOCKET);

   510

   511

	closesocket(cs->socket);

   512

   513

	// free buffers

   514

	for(p = cs->head; p; p=next) {

   515

		next = p->next;

   516

		free(p);

   517

	}

   518

   519

	// copy up structs...

   520

	while ((cs+1)->socket != INVALID_SOCKET) {

   521

		*cs = *(cs+1);

   522

		cs++;

   523

	}

   524

	cs->socket = INVALID_SOCKET;

   525

   526

	_num_clients--;

   527

}

   528

   529

#define NETWORK_BUFFER_SIZE 4096