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

     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;

    64

    65

#if !defined(__MORPHOS__)

    66

// usleep() implementation

    67

#include <devices/timer.h>

    68

#include <dos/dos.h>

    69

    70

struct Device       *TimerBase    = NULL;

    71

struct MsgPort      *TimerPort    = NULL;

    72

struct timerequest  *TimerRequest = NULL;

    73

#endif

    74

    75

#endif /* __MORPHOS__ || __AMIGA__ */

    76

    77

    78

#define SEND_MTU 1460

    79

    80

#if defined(ENABLE_NETWORK)

    81

    82

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

    83

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

    84

typedef struct CommandPacket {

    85

	byte packet_length;

    86

	byte packet_type;

    87

	uint16 cmd;

    88

	uint32 p1,p2;

    89

	TileIndex tile;

    90

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

    91

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

    92

	uint32 dp[8];

    93

} CommandPacket;

    94

    95

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

    96

    97

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

    98

    99

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

   100

// and how far the client may progress.

   101

typedef struct SyncPacket {

   102

	byte packet_length;

   103

	byte packet_type;

   104

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

   105

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

   106

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

   107

	uint32 random_seed_2;

   108

} SyncPacket;

   109

   110

assert_compile(sizeof(SyncPacket) == 12);

   111

   112

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

   113

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

   114

typedef struct AckPacket {

   115

	byte packet_length;

   116

	byte packet_type;

   117

} AckPacket;

   118

   119

typedef struct ReadyPacket {

   120

	byte packet_length;

   121

	byte packet_type;

   122

} ReadyPacket;

   123

   124

typedef struct FilePacketHdr {

   125

	byte packet_length;

   126

	byte packet_type;

   127

	byte unused[2];

   128

} FilePacketHdr;

   129

   130

assert_compile(sizeof(FilePacketHdr) == 4);

   131

   132

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

   133

typedef struct WelcomePacket {

   134

	byte packet_length;

   135

	byte packet_type;

   136

	byte unused[2];

   137

} WelcomePacket;

   138

   139

typedef struct Packet Packet;

   140

struct Packet {

   141

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

   142

	uint siz;

   143

	byte buf[SEND_MTU]; // packet payload

   144

};

   145

   146

typedef struct ClientState {

   147

	int socket;

   148

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

   149

	bool writable;

   150

	bool ready;

   151

	uint timeout;

   152

	uint xmitpos;

   153

   154

	uint eaten;

   155

	Packet *head, **last;

   156

   157

	uint buflen;											// receive buffer len

   158

	byte buf[256];										// receive buffer

   159

} ClientState;

   160

   161

   162

static uint _not_packet;

   163

   164

typedef struct QueuedCommand QueuedCommand;

   165

struct QueuedCommand {

   166

	QueuedCommand *next;

   167

	CommandPacket cp;

   168

	CommandCallback *callback;

   169

	uint32 cmd;

   170

	int32 frame;

   171

};

   172

   173

typedef struct CommandQueue CommandQueue;

   174

struct CommandQueue {

   175

	QueuedCommand *head, **last;

   176

};

   177

   178

#define MAX_CLIENTS (MAX_PLAYERS + 1)

   179

   180

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

   181

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

   182

static CommandQueue _command_queue;

   183

   184

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

   185

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

   186

static CommandQueue _ack_queue;

   187

   188

static ClientState _clients[MAX_CLIENTS];

   189

static int _num_clients;

   190

   191

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

   192

static uint32 _my_seed_list[16][2];

   193

static bool _network_ready_sent;

   194

static uint16 _network_ready_ahead = 1;

   195

static uint16 _network_client_timeout;

   196

   197

typedef struct FutureSeeds {

   198

	int32 frame;

   199

	uint32 seed[2];

   200

} FutureSeeds;

   201

   202

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

   203

static FutureSeeds _future_seed[8];

   204

static uint _num_future_seed;

   205

   206

static SOCKET _listensocket; // tcp socket

   207

   208

static SOCKET _udp_client_socket; // udp server socket

   209

static SOCKET _udp_server_socket; // udp client socket

   210

   211

typedef struct UDPPacket {

   212

	byte command_code;

   213

	byte data_len;

   214

	byte command_check;

   215

	byte data[255];

   216

} UDPPacket;

   217

   218

enum {

   219

	NET_UDPCMD_SERVERSEARCH = 1,

   220

	NET_UDPCMD_SERVERACTIVE,

   221

	NET_UDPCMD_GETSERVERINFO,

   222

	NET_UDPCMD_SERVERINFO,

   223

};

   224

   225

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

   226

   227

uint32 _network_ip_list[10]; // network ip list

   228

   229

// this is set to point to the savegame

   230

static byte *_transmit_file;

   231

static size_t _transmit_file_size;

   232

   233

static FILE *_recv_file;

   234

   236

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

   237

	char server_revision[8];	// server game version

   238

	byte server_lang;					// langid

   239

	byte players_max;					// max players allowed on server

   240

	byte players_on;					// current count of players on server

   241

	uint16 game_date;					// current date

   242

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

   243

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

   244

	uint map_width;						// map width / 8

   245

	uint map_height;					// map height / 8

   246

	byte map_set;							// graphical set

   247

} NetworkGameInfo;

   248

   249

typedef struct NetworkGameList {

   250

	NetworkGameInfo item;

   251

	uint32 ip;

   252

	uint16 port;

   253

	char * _next;

   254

} NetworkGameList;

   255

   256

static NetworkGameInfo _network_game;

   257

static NetworkGameList * _network_game_list = NULL;

   258

   259

   260

/* multi os compatible sleep function */

   261

void CSleep(int milliseconds) {

   262

#if defined(WIN32)

   263

Sleep(milliseconds);

   264

#endif

   265

#if defined(UNIX)

   267

usleep(milliseconds*1000);

   268

#endif

   269

#ifdef __BEOS__

   270

snooze(milliseconds*1000);

   271

#endif

   273

usleep(milliseconds*1000);

   274

#endif

   277

	ULONG signals;

   278

	ULONG TimerSigBit = 1 << TimerPort->mp_SigBit;

   279

   280

	// send IORequest

   281

	TimerRequest->tr_node.io_Command = TR_ADDREQUEST;

   282

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

   283

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

   284

	SendIO((struct IORequest *)TimerRequest);

   285

   286

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

   287

		AbortIO((struct IORequest *)TimerRequest);

   288

	}

   289

	WaitIO((struct IORequest *)TimerRequest);

   290

}

   291

#endif // __AMIGAOS__ && !__MORPHOS__

   292

#endif

   293

}

   294

   295

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

   296

   297

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

   298

// * Network Error Handlers     * //

   299

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

   300

   301

static void NetworkHandleSaveGameError()

   302

{

   303

		_networking_sync = false;

   304

		_networking_queuing = true;

   305

		_switch_mode = SM_MENU;

   306

		_switch_mode_errorstr = STR_NETWORK_ERR_SAVEGAMEERROR;

   307

}

   308

   309

static void NetworkHandleConnectionLost()

   310

{

   311

		_networking_sync = false;

   312

		_networking_queuing = true;

   313

		_switch_mode = SM_MENU;

   314

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   315

}

   316

static void NetworkHandleDeSync()

   317

{

   318

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

   319

	{

   320

		int i;

   321

		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]);

   322

		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]);

   323

	}

   324

	_networking_sync = false;

   325

	_networking_queuing = true;

   326

	_switch_mode = SM_MENU;

   327

	_switch_mode_errorstr = STR_NETWORK_ERR_DESYNC;

   328

}

   329

   330

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

   331

// * TCP Packets and Handlers   * //

   332

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

   333

   334

static QueuedCommand *AllocQueuedCommand(CommandQueue *nq)

   335

{

   336

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

   337

	assert(qp);

   338

	*nq->last = qp;

   339

	nq->last = &qp->next;

   340

	return qp;

   341

}

   342

   343

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

   344

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

   345

void NetworkProcessCommands()

   346

{

   347

	CommandQueue *nq;

   348

	QueuedCommand *qp;

   349

   350

	// queue mode ?

   351

	if (_networking_queuing)

   352

		return;

   353

   354

	nq = &_command_queue;

   355

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

   356

		// unlink it.

   357

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

   358

   359

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

   360

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

   361

		}

   362

   363

		// run the command

   364

		_current_player = qp->cp.player;

   365

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

   366

   367

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

   368

		free(qp);

   369

	}

   370

   371

	if (!_networking_server) {

   372

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

   373

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

   374

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

   375

   376

		while (_num_future_seed) {

   377

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

   378

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

   379

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

   380

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

   381

		}

   382

	}

   383

}

   384

   385

// send a packet to a client

   386

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

   387

{

   388

	byte *b = (byte*)bytes;

   389

	uint n;

   390

	Packet *p;

   391

   392

	assert(len != 0);

   393

   394

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

   395

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

   396

		p = NULL;

   397

   398

	do {

   399

		if (!p) {

   400

			// need to allocate a new packet buffer.

   401

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

   402

   403

			// insert at the end of the linked list.

   404

			*cs->last = p;

   405

			cs->last = &p->next;

   406

			p->next = NULL;

   407

			p->siz = 0;

   408

		}

   409

   410

		// copy bytes to packet.

   411

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

   412

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

   413

		p->siz += n;

   414

		b += n;

   415

		p = NULL;

   416

	} while (len -= n);

   417

}

   418

   419

// client:

   420

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

   421

// server:

   422

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

   423

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

   424

{

   425

	int nump;

   426

	QueuedCommand *qp;

   427

	ClientState *cs;

   428

   429

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

   430

	qp->cp.packet_type = 0;

   431

	qp->cp.tile = tile;

   432

	qp->cp.p1 = p1;

   433

	qp->cp.p2 = p2;

   434

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

   435

	qp->cp.player = _local_player;

   436

	qp->cp.when = 0;

   437

	qp->cmd = cmd;

   438

	qp->callback = callback;

   439

   440

	// so the server knows when to execute it.

   441

	qp->frame = _frame_counter_max;

   442

   443

	// calculate the amount of extra bytes.

   444

	nump = 8;

   445

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

   446

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

   447

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

   448

   449

#if defined(TTD_BIG_ENDIAN)

   450

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

   451

	{

   452

		CommandPacket cp;

   453

		cp = qp->cp;

   454

		cp.cmd = TO_LE16(cp.cmd);

   455

		cp.tile = TO_LE16(cp.tile);

   456

		cp.p1 = TO_LE32(cp.p1);

   457

		cp.p2 = TO_LE32(cp.p2);

   458

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

   459

	}

   460

#else

   461

	// send it to the peers

   462

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

   463

   464

#endif

   465

}

   466

   467

// client:

   468

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

   469

//   put it in the command queue.

   470

//

   471

// server:

   472

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

   473

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

   474

//   put it in the appropriate player queue.

   475

//   send it to all other clients.

   476

//   send an ack packet to the actual client.

   477

   478

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

   479

{

   480

	QueuedCommand *qp;

   481

	ClientState *c;

   482

	AckPacket ap;

   483

   484

	DEBUG(net, 2) ("[NET] cmd size %d", np->packet_length);

   485

   486

	assert(np->packet_length >= COMMAND_PACKET_BASE_SIZE);

   487

   488

	// put it into the command queue

   489

	qp = AllocQueuedCommand(&_command_queue);

   490

	qp->cp = *np;

   491

   492

	qp->frame = _frame_counter_max;

   493

   494

	qp->callback = NULL;

   495

   496

	// extra params

   497

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

   498

   499

	ap.packet_type = 2;

   500

	ap.packet_length = 2;

   501

   502

	// send it to the peers

   503

	if (_networking_server) {

   504

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

   505

			if (c == cs) {

   506

				SendBytes(c, &ap, 2);

   507

			} else {

   508

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

   509

			}

   510

		}

   511

	}

   512

   513

// convert from little endian to big endian?

   514

#if defined(TTD_BIG_ENDIAN)

   515

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

   516

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

   517