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

    91

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

    92

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

    93

typedef struct CommandPacket {

    94

	byte packet_length;

    95

	byte packet_type;

    96

	uint16 cmd;

    97

	uint32 p1,p2;

    98

	TileIndex tile;

    99

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

   100

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

   101

	uint32 dp[8];

   102

} CommandPacket;

   103

   104

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

   105

   106

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

   107

// and how far the client may progress.

   108

typedef struct SyncPacket {

   109

	byte packet_length;

   110

	byte packet_type;

   111

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

   112

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

   113

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

   114

	uint32 random_seed_2;

   115

} SyncPacket;

   116

   117

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

   118

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

   119

typedef struct AckPacket {

   120

	byte packet_length;

   121

	byte packet_type;

   123

} AckPacket;

   124

   125

typedef struct ReadyPacket {

   126

	byte packet_length;

   127

	byte packet_type;

   128

} ReadyPacket;

   129

   130

typedef struct FilePacketHdr {

   131

	byte packet_length;

   132

	byte packet_type;

   133

} FilePacketHdr;

   134

   135

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

   136

typedef struct WelcomePacket {

   137

	byte packet_length;

   138

	byte packet_type;

   143

} WelcomePacket;

   144

   145

typedef struct Packet Packet;

   146

struct Packet {

   147

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

   148

	uint siz;

   149

	byte buf[SEND_MTU]; // packet payload

   150

};

   151

   152

typedef struct ClientState {

   153

	int socket;

   154

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

   155

	bool writable;

   156

	bool ready;

   157

	uint timeout;

   158

	uint xmitpos;

   159

   160

	uint eaten;

   161

	Packet *head, **last;

   162

   163

	uint buflen;											// receive buffer len

   165

} ClientState;

   166

   167

   168

typedef struct QueuedCommand QueuedCommand;

   169

struct QueuedCommand {

   170

	QueuedCommand *next;

   171

	CommandPacket cp;

   172

	CommandCallback *callback;

   173

	uint32 cmd;

   175

};

   176

   177

typedef struct CommandQueue CommandQueue;

   178

struct CommandQueue {

   179

	QueuedCommand *head, **last;

   180

};

   181

   182

#define MAX_CLIENTS (MAX_PLAYERS + 1)

   183

   184

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

   185

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

   186

static CommandQueue _command_queue;

   187

   188

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

   189

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

   190

static CommandQueue _ack_queue;

   191

   192

static ClientState _clients[MAX_CLIENTS];

   193

static int _num_clients;

   194

   195

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

   196

static uint32 _my_seed_list[16][2];

   197

static bool _network_ready_sent;

   198

static uint16 _network_ready_ahead = 1;

   199

static uint16 _network_client_timeout;

   200

   201

typedef struct FutureSeeds {

   203

	uint32 seed[2];

   204

} FutureSeeds;

   205

   206

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

   207

static FutureSeeds _future_seed[8];

   208

static uint _num_future_seed;

   209

   210

static SOCKET _listensocket; // tcp socket

   211

   212

static SOCKET _udp_client_socket; // udp server socket

   213

static SOCKET _udp_server_socket; // udp client socket

   214

   215

typedef struct UDPPacket {

   216

	byte command_code;

   217

	byte data_len;

   218

	byte command_check;

   219

	byte data[255];

   220

} UDPPacket;

   221

   222

enum {

   223

	NET_UDPCMD_SERVERSEARCH = 1,

   224

	NET_UDPCMD_SERVERACTIVE,

   225

	NET_UDPCMD_GETSERVERINFO,

   226

	NET_UDPCMD_SERVERINFO,

   227

};

   228

   229

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

   232

   233

uint32 _network_ip_list[10]; // network ip list

   234

   235

// this is set to point to the savegame

   236

static byte *_transmit_file;

   237

static size_t _transmit_file_size;

   238

   239

static FILE *_recv_file;

   240

   241

typedef struct NetworkGameInfo {

   242

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

   243

	char server_revision[8];	// server game version

   244

	byte server_lang;					// langid

   245

	byte players_max;					// max players allowed on server

   246

	byte players_on;					// current count of players on server

   247

	uint16 game_date;					// current date

   248

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

   249

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

   250

	uint map_width;						// map width / 8

   251

	uint map_height;					// map height / 8

   252

	byte map_set;							// graphical set

   253

} NetworkGameInfo;

   254

   255

typedef struct NetworkGameList {

   256

	NetworkGameInfo item;

   257

	uint32 ip;

   258

	uint16 port;

   259

	char * _next;

   260

} NetworkGameList;

   261

   262

static NetworkGameInfo _network_game;

   263

static NetworkGameList * _network_game_list = NULL;

   264

   265

   266

/* multi os compatible sleep function */

   267

void CSleep(int milliseconds) {

   268

#if defined(WIN32)

   269

Sleep(milliseconds);

   270

#endif

   271

#if defined(UNIX)

   272

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

   273

usleep(milliseconds*1000);

   274

#endif

   275

#ifdef __BEOS__

   276

snooze(milliseconds*1000);

   277

#endif

   278

#if defined(__MORPHOS__)

   279

usleep(milliseconds*1000);

   280

#endif

   281

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

   282

{

   283

	ULONG signals;

   284

	ULONG TimerSigBit = 1 << TimerPort->mp_SigBit;

   285

   286

	// send IORequest

   287

	TimerRequest->tr_node.io_Command = TR_ADDREQUEST;

   288

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

   289

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

   290

	SendIO((struct IORequest *)TimerRequest);

   291

   292

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

   293

		AbortIO((struct IORequest *)TimerRequest);

   294

	}

   295

	WaitIO((struct IORequest *)TimerRequest);

   296

}

   297

#endif // __AMIGAOS__ && !__MORPHOS__

   298

#endif

   299

}

   300

   301

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

   302

   303

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

   304

// * Network Error Handlers     * //

   305

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

   306

   307

static void NetworkHandleSaveGameError()

   308

{

   309

		_networking_sync = false;

   310

		_networking_queuing = true;

   311

		_switch_mode = SM_MENU;

   312

		_switch_mode_errorstr = STR_NETWORK_ERR_SAVEGAMEERROR;

   313

}

   314

   315

static void NetworkHandleConnectionLost()

   316

{

   317

		_networking_sync = false;

   318

		_networking_queuing = true;

   319

		_switch_mode = SM_MENU;

   320

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   321

}

   322

static void NetworkHandleDeSync()

   323

{

   324

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

   325

	{

   326

		int i;

   327

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

   328

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

   329

	}

   330

	_networking_sync = false;

   331

	_networking_queuing = true;

   332

	_switch_mode = SM_MENU;

   333

	_switch_mode_errorstr = STR_NETWORK_ERR_DESYNC;

   334

}

   335

   336

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

   337

// * TCP Packets and Handlers   * //

   338

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

   339

   340

static QueuedCommand *AllocQueuedCommand(CommandQueue *nq)

   341

{

   342

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

   343

	assert(qp);

   344

	*nq->last = qp;

   345

	nq->last = &qp->next;

   346

	return qp;

   347

}

   348

   359

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

   360

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

   361

void NetworkProcessCommands()

   362

{

   363

	CommandQueue *nq;

   364

	QueuedCommand *qp;

   365

   366

	// queue mode ?

   367

	if (_networking_queuing)

   368

		return;

   369

   370

	nq = &_command_queue;

   371

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

   372

		// unlink it.

   373

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

   374

   375

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

   376

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

   377

		}

   378

   379

		// run the command

   380

		_current_player = qp->cp.player;

   381

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

   382

   383

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

   384

		free(qp);

   385

	}

   386

   387

	if (!_networking_server) {

   388

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

   389

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

   390

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

   391

   392

		while (_num_future_seed) {

   393

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

   394

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

   395

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

   396

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

   397

		}

   398

	}

   399

}

   400

   401

// send a packet to a client

   402

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

   403

{

   404

	byte *b = (byte*)bytes;

   405

	uint n;

   406

	Packet *p;

   407

   408

	assert(len != 0);

   409

   410

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

   411

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

   412

		p = NULL;

   413

   414

	do {

   415

		if (!p) {

   416

			// need to allocate a new packet buffer.

   417

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

   418

   419

			// insert at the end of the linked list.

   420

			*cs->last = p;

   421

			cs->last = &p->next;

   422

			p->next = NULL;

   423

			p->siz = 0;

   424

		}

   425

   426

		// copy bytes to packet.

   427

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

   428

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

   429

		p->siz += n;

   430

		b += n;

   431

		p = NULL;

   432

	} while (len -= n);

   433

}

   434

   449

// client:

   450

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

   451

// server:

   452

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

   453

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

   454

{

   455

	int nump;

   456

	QueuedCommand *qp;

   457

	ClientState *cs;

   458

   459

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

   461

	qp->cp.tile = tile;

   462

	qp->cp.p1 = p1;

   463

	qp->cp.p2 = p2;

   464

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

   465

	qp->cp.player = _local_player;

   466

	qp->cp.when = 0;

   467

	qp->cmd = cmd;

   468

	qp->callback = callback;

   469

   470

	// so the server knows when to execute it.

   472

   473

	// calculate the amount of extra bytes.

   474

	nump = 8;

   475

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

   476

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

   477

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

   478

   479

#if defined(TTD_BIG_ENDIAN)

   480

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

   481

	{

   482

		CommandPacket cp;

   483

		cp = qp->cp;

   484

		cp.cmd = TO_LE16(cp.cmd);

   485

		cp.tile = TO_LE16(cp.tile);

   486

		cp.p1 = TO_LE32(cp.p1);

   487

		cp.p2 = TO_LE32(cp.p2);

   488

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

   489

	}

   490

#else

   491

	// send it to the peers

   492

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

   493

   494

#endif

   495

}

   496

   497

// client:

   498

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

   499

//   put it in the command queue.

   500

//

   501

// server:

   502

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

   503

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

   504

//   put it in the appropriate player queue.

   505

//   send it to all other clients.

   506

//   send an ack packet to the actual client.

   507

   508

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

   509

{

   510

	QueuedCommand *qp;

   511

	ClientState *c;

   512

	AckPacket ap;