1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gui.h"

     4

#include "command.h"

     5

#include "player.h"

     6

#include "console.h"

     7

#include "economy.h"

     8

     9

#if defined(WIN32)

    10

#	include <windows.h>

    11

#	include <winsock.h>

    12

    13

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

    14

# define ENABLE_NETWORK

    15

# define GET_LAST_ERROR() WSAGetLastError()

    16

# define EWOULDBLOCK WSAEWOULDBLOCK

    17

#endif

    18

    19

#if defined(UNIX)

    20

// Make compatible with WIN32 names

    21

#	define SOCKET int

    22

#	define INVALID_SOCKET -1

    23

// we need different defines for MorphOS and AmigaOS

    24

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

    25

#	define ioctlsocket ioctl

    26

# define closesocket close

    27

# define GET_LAST_ERROR() errno

    28

#endif

    29

// Need this for FIONREAD on solaris

    30

#	define BSD_COMP

    31

#	include <unistd.h>

    32

#	include <sys/ioctl.h>

    33

    34

// Socket stuff

    35

#	include <sys/socket.h>

    36

#	include <netinet/in.h>

    37

#	include <arpa/inet.h>

    38

# 	include <errno.h>

    39

# 	include <sys/time.h>

    40

// NetDB

    41

#   include <netdb.h>

    42

    43

# ifndef TCP_NODELAY

    44

#  define TCP_NODELAY 0x0001

    45

# endif

    46

    47

#endif

    48

    49

    50

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

    51

#	include <exec/types.h>

    52

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

    53

#	if defined(__MORPHOS__)

    54

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

    55

#	else // __AMIGA__

    56

#		include	<proto/socket.h>

    57

#	endif

    58

    59

// make source compatible with bsdsocket.library functions

    60

# define closesocket(s)     						CloseSocket(s)

    61

# define GET_LAST_ERROR() 							Errno()

    62

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

    63

    64

struct Library *SocketBase = NULL;

    65

    66

#if !defined(__MORPHOS__)

    67

// usleep() implementation

    68

#include <devices/timer.h>

    69

#include <dos/dos.h>

    70

    71

struct Device       *TimerBase    = NULL;

    72

struct MsgPort      *TimerPort    = NULL;

    73

struct timerequest  *TimerRequest = NULL;

    74

#endif

    75

    76

#endif /* __MORPHOS__ || __AMIGA__ */

    77

    78

    79

#define SEND_MTU 1460

    80

    81

#if defined(ENABLE_NETWORK)

    82

    83

enum {

    84

	PACKET_TYPE_WELCOME = 0,

    85

	PACKET_TYPE_READY,

    86

	PACKET_TYPE_ACK,

    87

	PACKET_TYPE_SYNC,

    88

	PACKET_TYPE_FSYNC,

    89

	PACKET_TYPE_XMIT,

    90

	PACKET_TYPE_COMMAND,

    91

	PACKET_TYPE_EVENT,

    92

};

    93

    94

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

    95

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

    96

typedef struct CommandPacket {

    97

	byte packet_length;

    98

	byte packet_type;

    99

	uint16 cmd;

   100

	uint32 p1,p2;

   101

	TileIndex tile;

   102

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

   103

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

   104

	uint32 dp[8];

   105

} CommandPacket;

   106

   107

typedef struct EventPacket {

   108

	byte packet_length;

   109

	byte packet_type;

   110

	byte event_type;

   111

	byte data_start;

   112

} EventPacket;

   113

   114

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

   115

   116

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

   117

// and how far the client may progress.

   118

typedef struct SyncPacket {

   119

	byte packet_length;

   120

	byte packet_type;

   121

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

   122

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

   123

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

   124

	uint32 random_seed_2;

   125

} SyncPacket;

   126

   127

typedef struct FrameSyncPacket {

   128

	byte packet_length;

   129

	byte packet_type;

   130

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

   131

} FrameSyncPacket;

   132

   133

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

   134

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

   135

typedef struct AckPacket {

   136

	byte packet_length;

   137

	byte packet_type;

   138

	int16 when;

   139

} AckPacket;

   140

   141

typedef struct ReadyPacket {

   142

	byte packet_length;

   143

	byte packet_type;

   144

} ReadyPacket;

   145

   146

typedef struct FilePacketHdr {

   147

	byte packet_length;

   148

	byte packet_type;

   149

} FilePacketHdr;

   150

   151

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

   152

typedef struct WelcomePacket {

   153

	byte packet_length;

   154

	byte packet_type;

   155

	uint32 player_seeds[MAX_PLAYERS][2];

   156

	uint32 frames_max;

   157

	uint32 frames_srv;

   158

	uint32 frames_cnt;

   159

} WelcomePacket;

   160

   161

typedef struct Packet Packet;

   162

struct Packet {

   163

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

   164

	uint siz;

   165

	byte buf[SEND_MTU]; // packet payload

   166

};

   167

   168

typedef struct ClientState {

   169

	int socket;

   170

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

   171

	bool writable;

   172

	bool ready;

   173

	uint timeout;

   174

	uint xmitpos;

   175

   176

	uint eaten;

   177

	Packet *head, **last;

   178

   179

	uint buflen;											// receive buffer len

   180

	byte buf[1024];										// receive buffer

   181

} ClientState;

   182

   183

   184

typedef struct QueuedCommand QueuedCommand;

   185

struct QueuedCommand {

   186

	QueuedCommand *next;

   187

	CommandPacket cp;

   188

	CommandCallback *callback;

   189

	uint32 cmd;

   190

	uint32 frame;

   191

};

   192

   193

typedef struct CommandQueue CommandQueue;

   194

struct CommandQueue {

   195

	QueuedCommand *head, **last;

   196

};

   197

   198

#define MAX_CLIENTS (MAX_PLAYERS + 1)

   199

   200

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

   201

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

   202

static CommandQueue _command_queue;

   203

   204

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

   205

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

   206

static CommandQueue _ack_queue;

   207

   208

static ClientState _clients[MAX_CLIENTS];

   209

static int _num_clients;

   210

   211

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

   212

static uint32 _my_seed_list[16][2];

   213

static bool _network_ready_sent;

   214

static uint32 _frame_fsync_last;

   215

   216

typedef struct FutureSeeds {

   217

	uint32 frame;

   218

	uint32 seed[2];

   219

} FutureSeeds;

   220

   221

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

   222

static FutureSeeds _future_seed[8];

   223

static uint _num_future_seed;

   224

   225

static SOCKET _listensocket; // tcp socket

   226

   227

static SOCKET _udp_client_socket; // udp server socket

   228

static SOCKET _udp_server_socket; // udp client socket

   229

   230

typedef struct UDPPacket {

   231

	byte command_code;

   232

	byte data_len;

   233

	byte command_check;

   234

	byte data[255];

   235

} UDPPacket;

   236

   237

enum {

   238

	NET_UDPCMD_SERVERSEARCH = 1,

   239

	NET_UDPCMD_SERVERACTIVE,

   240

	NET_UDPCMD_GETSERVERINFO,

   241

	NET_UDPCMD_SERVERINFO,

   242

};

   243

   244

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

   245

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

   246

static void CloseClient(ClientState *cs);

   247

void NetworkSendWelcome(ClientState *cs, bool direct);

   248

   249

uint32 _network_ip_list[10]; // network ip list

   250

   251

// this is set to point to the savegame

   252

static byte *_transmit_file;

   253

static size_t _transmit_file_size;

   254

   255

static FILE *_recv_file;

   256

   257

/* multi os compatible sleep function */

   258

void CSleep(int milliseconds) {

   259

#if defined(WIN32)

   260

Sleep(milliseconds);

   261

#endif

   262

#if defined(UNIX)

   263

#if !defined(__BEOS__) && !defined(__MORPHOS__) && !defined(__AMIGAOS__)

   264

usleep(milliseconds*1000);

   265

#endif

   266

#ifdef __BEOS__

   267

snooze(milliseconds*1000);

   268

#endif

   269

#if defined(__MORPHOS__)

   270

usleep(milliseconds*1000);

   271

#endif

   272

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

   273

{

   274

	ULONG signals;

   275

	ULONG TimerSigBit = 1 << TimerPort->mp_SigBit;

   276

   277

	// send IORequest

   278

	TimerRequest->tr_node.io_Command = TR_ADDREQUEST;

   279

	TimerRequest->tr_time.tv_secs    = (milliseconds * 1000) / 1000000;

   280

	TimerRequest->tr_time.tv_micro   = (milliseconds * 1000) % 1000000;

   281

	SendIO((struct IORequest *)TimerRequest);

   282

   283

	if ( !((signals = Wait(TimerSigBit|SIGBREAKF_CTRL_C)) & TimerSigBit) ) {

   284

		AbortIO((struct IORequest *)TimerRequest);

   285

	}

   286

	WaitIO((struct IORequest *)TimerRequest);

   287

}

   288

#endif // __AMIGAOS__ && !__MORPHOS__

   289

#endif

   290

}

   291

   292

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

   293

   294

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

   295

// * Network Error Handlers     * //

   296

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

   297

   298

static void NetworkHandleSaveGameError()

   299

{

   300

		_networking_sync = false;

   301

		_networking_queuing = true;

   302

		_switch_mode = SM_MENU;

   303

		_switch_mode_errorstr = STR_NETWORK_ERR_SAVEGAMEERROR;

   304

}

   305

   306

static void NetworkHandleConnectionLost()

   307

{

   308

		_networking_sync = false;

   309

		_networking_queuing = true;

   310

		_switch_mode = SM_MENU;

   311

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   312

}

   313

   314

static void NetworkHandleDeSync()

   315

{

   316

	DEBUG(net, 0) ("[NET] Fatal ERROR: network sync error at frame %i", _frame_counter);

   317

	{

   318

		int i;

   319

		for (i=15; i>=0; i--) DEBUG(net,0) ("[NET] frame %i: [0]=%i, [1]=%i",_frame_counter-(i+1),_my_seed_list[i][0],_my_seed_list[i][1]);

   320

		for (i=0; i<8; i++) DEBUG(net,0) ("[NET] frame %i: [0]=%i, [1]=%i",_frame_counter+i,_future_seed[i].seed[0],_future_seed[i].seed[1]);

   321

	}

   322

	_networking_sync = false;

   323

	_networking_queuing = true;

   324

	_switch_mode = SM_MENU;

   325

	_switch_mode_errorstr = STR_NETWORK_ERR_DESYNC;

   326

}

   327

   328

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

   329

// * TCP Packets and Handlers   * //

   330

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

   331

   332

static QueuedCommand *AllocQueuedCommand(CommandQueue *nq)

   333

{

   334

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

   335

	assert(qp);

   336

	*nq->last = qp;

   337

	nq->last = &qp->next;

   338

	return qp;

   339

}

   340

   341

static void QueueClear(CommandQueue *nq)

   342

{

   343

	QueuedCommand *qp;

   344

	while ((qp=nq->head)) {

   345

		// unlink it.

   346

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

   347

		free(qp);

   348

		}

   349

	nq->last = &nq->head;

   350

}

   351

   352

static int GetNextSyncFrame()

   353

{

   354

	uint32 newframe;

   355

	if (_frame_fsync_last == 0) return -5;

   357

	if ( (newframe + 4) > _frame_counter_max) return -5;

   358

	return (_frame_counter_max - newframe);

   359

   360

}

   361

   362

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

   363

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

   364

void NetworkProcessCommands()

   365

{

   366

	CommandQueue *nq;

   367

	QueuedCommand *qp;

   368

   369

	// queue mode ?

   370

	if (_networking_queuing)

   371

		return;

   372

   373

	nq = &_command_queue;

   374

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

   375

		// unlink it.

   376

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

   377

   378

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

   379

			DEBUG(net,0) ("warning: !qp->cp.frame < _frame_counter, %d < %d [%d]\n", qp->frame, _frame_counter, _frame_counter_srv+4);

   380

		}

   381

   382

		// run the command

   383

		_current_player = qp->cp.player;

   384

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

   385

   386

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

   387

		free(qp);

   388

	}

   389

   390

	if (!_networking_server) {

   391

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

   392

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

   393

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

   394

   395

		while (_num_future_seed) {

   396

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

   397

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

   398

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

   399

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

   400

		}

   401

	}

   402

}

   403

   404

// send a packet to a client

   405

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

   406

{

   407

	byte *b = (byte*)bytes;

   408

	uint n;

   409

	Packet *p;

   410

   411

	assert(len != 0);

   412

   413

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

   414

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

   415

		p = NULL;

   416

   417

	do {

   418

		if (!p) {

   419

			// need to allocate a new packet buffer.

   420

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

   421

   422

			// insert at the end of the linked list.

   423

			*cs->last = p;

   424

			cs->last = &p->next;

   425

			p->next = NULL;

   426

			p->siz = 0;

   427

		}

   428

   429

		// copy bytes to packet.

   430

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

   431

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

   432

		p->siz += n;

   433

		b += n;

   434

		p = NULL;

   435

	} while (len -= n);

   436

}

   437

   438

// send data direct to a client

   439

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

   440

{

   441

	char *buf = (char*)bytes;

   442

	uint n;

   443

   444

	n = send(cs->socket, buf, len, 0);

   445

	if (n == -1) {

   446

				int err = GET_LAST_ERROR();

   447

				DEBUG(net, 0) ("[NET] send() failed with error %d", err);

   448

				CloseClient(cs);

   449

			}

   450

}

   451

   452

// client:

   453

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

   454

// server:

   455

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

   456

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

   457

{

   458

	int nump;

   459

	QueuedCommand *qp;

   460

	ClientState *cs;

   461

   462

	if (!(cmd & CMD_NET_INSTANT)) {

   463

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

   464

	} else {

   465

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

   466

		}

   467

	qp->cp.packet_type = PACKET_TYPE_COMMAND;

   468

	qp->cp.tile = tile;

   469

	qp->cp.p1 = p1;

   470

	qp->cp.p2 = p2;

   471

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

   472

	qp->cp.player = _local_player;

   473

	qp->cp.when = 0;

   474

	qp->cmd = cmd;

   475

	qp->callback = callback;

   476

   477

	// so the server knows when to execute it.

   478

	qp->frame = _frame_counter_max - GetNextSyncFrame();

   479

   480

	// calculate the amount of extra bytes.

   481

	nump = 8;

   482

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

   483

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

   484

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

   485

   486

#if defined(TTD_BIG_ENDIAN)

   487

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

   488

	{

   489

		CommandPacket cp;

   490

		cp = qp->cp;

   491

		cp.cmd = TO_LE16(cp.cmd);

   492

		cp.tile = TO_LE16(cp.tile);

   493

		cp.p1 = TO_LE32(cp.p1);

   494

		cp.p2 = TO_LE32(cp.p2);

   495

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

   496

	}

   497

#else

   498

	// send it to the peers

   499

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

   500

   501

#endif

   502

	if (cmd & CMD_NET_INSTANT) {

   503

		free(qp);

   504

	}

   505

}

   506

   507

void NetworkSendEvent(uint16 type, uint16 data_len, void * data)

   508

{

   509

	EventPacket * ep;

   510

	ClientState *cs;