1

#include "stdafx.h"

     2

#include "debug.h"

     3

#include "network_data.h"

     4

     5

// Is the network enabled?

     6

#ifdef ENABLE_NETWORK

     7

     8

#include "string.h"

     9

#include "table/strings.h"

    10

#include "network_client.h"

    11

#include "command.h"

    12

#include "callback_table.h"

    13

    14

// This files handles the send/receive of all packets

    15

    16

// Create a packet for sending

    17

Packet *NetworkSend_Init(PacketType type)

    18

{

    19

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

    20

	// An error is inplace here, because it simply means we ran out of memory.

    21

	if (packet == NULL) error("Failed to allocate Packet");

    22

    23

	// Skip the size so we can write that in before sending the packet

    24

	packet->size = sizeof(packet->size);

    25

	packet->buffer[packet->size++] = type;

    26

	packet->pos = 0;

    27

    28

	return packet;

    29

}

    30

    31

// The next couple of functions make sure we can send

    32

//  uint8, uint16, uint32 and uint64 endian-safe

    33

//  over the network. The order it uses is:

    34

//

    35

//  1 2 3 4

    36

//

    37

    38

void NetworkSend_uint8(Packet *packet, uint8 data)

    39

{

    40

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    41

	packet->buffer[packet->size++] = data & 0xFF;

    42

}

    43

    44

void NetworkSend_uint16(Packet *packet, uint16 data)

    45

{

    46

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    49

}

    50

    51

void NetworkSend_uint32(Packet *packet, uint32 data)

    52

{

    53

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    58

}

    59

    60

void NetworkSend_uint64(Packet *packet, uint64 data)

    61

{

    62

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    71

}

    72

    73

// Sends a string over the network. It sends out

    74

//  the string + '\0'. No size-byte or something.

    75

void NetworkSend_string(Packet *packet, const char* data)

    76

{

    77

	assert(data != NULL);

    78

	assert(packet->size < sizeof(packet->buffer) - strlen(data) - 1);

    79

	while ((packet->buffer[packet->size++] = *data++) != '\0') {}

    80

}

    81

    82

// If PacketSize changes of size, you have to change the 2 packet->size

    83

//   lines below matching the size of packet->size/PacketSize!

    84

// (line 'packet->buffer[0] = packet->size & 0xFF;'  and below)

    85

assert_compile(sizeof(PacketSize) == 2);

    86

    87

// This function puts the packet in the send-queue and it is send

    88

//  as soon as possible

    89

// (that is: the next tick, or maybe one tick later if the

    90

//   OS-network-buffer is full)

    91

void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)

    92

{

    93

	Packet *p;

    94

	assert(packet != NULL);

    95

    96

	packet->pos = 0;

    97

	packet->next = NULL;

    98

    99

	packet->buffer[0] = packet->size & 0xFF;

   100

	packet->buffer[1] = packet->size >> 8;

   101

   102

	// Locate last packet buffered for the client

   103

	p = cs->packet_queue;

   104

	if (p == NULL) {

   105

		// No packets yet

   106

		cs->packet_queue = packet;

   107

	} else {

   108

		// Skip to the last packet

   109

		while (p->next != NULL) p = p->next;

   110

		p->next = packet;

   111

	}

   112

}

   113

   114

// Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

   115

//  A socket can make errors. When that happens

   116

//  this handles what to do.

   117

// For clients: close connection and drop back to main-menu

   118

// For servers: close connection and that is it

   119

static NetworkRecvStatus CloseConnection(NetworkClientState *cs)

   120

{

   121

	NetworkCloseClient(cs);

   122

   123

	// Clients drop back to the main menu

   124

	if (!_network_server) {

   125

		_switch_mode = SM_MENU;

   126

		_networking = false;

   127

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   128

   129

		return NETWORK_RECV_STATUS_CONN_LOST;

   130

	}

   131

   132

	return NETWORK_RECV_STATUS_OKAY;

   133

}

   134

   135

// Sends all the buffered packets out for this client

   136

//  it stops when:

   137

//   1) all packets are send (queue is empty)

   138

//   2) the OS reports back that it can not send any more

   139

//        data right now (full network-buffer, it happens ;))

   140

//   3) sending took too long

   141

bool NetworkSend_Packets(NetworkClientState *cs)

   142

{

   143

	ssize_t res;

   144

	Packet *p;

   145

   146

	// We can not write to this socket!!

   147

	if (!cs->writable) return false;

   148

	if (cs->socket == INVALID_SOCKET) return false;

   149

   150

	p = cs->packet_queue;

   151

	while (p != NULL) {

   152

		res = send(cs->socket, p->buffer + p->pos, p->size - p->pos, 0);

   153

		if (res == -1) {

   154

			int err = GET_LAST_ERROR();

   155

			if (err != EWOULDBLOCK) {

   156

				// Something went wrong.. close client!

   157

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

   158

				CloseConnection(cs);

   159

				return false;

   160

			}

   161

			return true;

   162

		}

   163

		if (res == 0) {

   164

			// Client/server has left us :(

   165

			CloseConnection(cs);

   166

			return false;

   167

		}

   168

   169

		p->pos += res;

   170

   171

		// Is this packet sent?

   172

		if (p->pos == p->size) {

   173

			// Go to the next packet

   174

			cs->packet_queue = p->next;

   175

			free(p);

   176

			p = cs->packet_queue;

   177

		} else

   178

			return true;

   179

	}

   180

   181

	return true;

   182

}

   183

   184

   185

// Receiving commands

   186

// Again, the next couple of functions are endian-safe

   187

//  see the comment around NetworkSend_uint8 for more info.

   188

uint8 NetworkRecv_uint8(NetworkClientState *cs, Packet *packet)

   189

{

   190

	/* Don't allow reading from a closed socket */

   191

	if (cs->quited)

   192

		return 0;

   193

   194

	/* Check if variable is within packet-size */

   195

	if (packet->pos + 1 > packet->size) {

   196

		CloseConnection(cs);

   197

		return 0;

   198

	}

   199

   200

	return packet->buffer[packet->pos++];

   201

}

   202

   203

uint16 NetworkRecv_uint16(NetworkClientState *cs, Packet *packet)

   204

{

   205

	uint16 n;

   206

   207

	/* Don't allow reading from a closed socket */

   208

	if (cs->quited)

   209

		return 0;

   210

   211

	/* Check if variable is within packet-size */

   212

	if (packet->pos + 2 > packet->size) {

   213

		CloseConnection(cs);

   214

		return 0;

   215

	}

   216

   217

	n  = (uint16)packet->buffer[packet->pos++];

   218

	n += (uint16)packet->buffer[packet->pos++] << 8;

   219

	return n;

   220

}

   221

   222

uint32 NetworkRecv_uint32(NetworkClientState *cs, Packet *packet)

   223

{

   224

	uint32 n;

   225

   226

	/* Don't allow reading from a closed socket */

   227

	if (cs->quited)

   228

		return 0;

   229

   230

	/* Check if variable is within packet-size */

   231

	if (packet->pos + 4 > packet->size) {

   232

		CloseConnection(cs);

   233

		return 0;

   234

	}

   235

   236

	n  = (uint32)packet->buffer[packet->pos++];

   237

	n += (uint32)packet->buffer[packet->pos++] << 8;

   238

	n += (uint32)packet->buffer[packet->pos++] << 16;

   239

	n += (uint32)packet->buffer[packet->pos++] << 24;

   240

	return n;

   241

}

   242

   243

uint64 NetworkRecv_uint64(NetworkClientState *cs, Packet *packet)

   244

{

   245

	uint64 n;

   246

   247

	/* Don't allow reading from a closed socket */

   248

	if (cs->quited)

   249

		return 0;

   250

   251

	/* Check if variable is within packet-size */

   252

	if (packet->pos + 8 > packet->size) {

   253

		CloseConnection(cs);

   254

		return 0;

   255

	}

   256

   257

	n  = (uint64)packet->buffer[packet->pos++];

   258

	n += (uint64)packet->buffer[packet->pos++] << 8;

   259

	n += (uint64)packet->buffer[packet->pos++] << 16;

   260

	n += (uint64)packet->buffer[packet->pos++] << 24;

   261

	n += (uint64)packet->buffer[packet->pos++] << 32;

   262

	n += (uint64)packet->buffer[packet->pos++] << 40;

   263

	n += (uint64)packet->buffer[packet->pos++] << 48;

   264

	n += (uint64)packet->buffer[packet->pos++] << 56;

   265

	return n;

   266

}

   267

   268

// Reads a string till it finds a '\0' in the stream

   269

void NetworkRecv_string(NetworkClientState *cs, Packet *p, char* buffer, size_t size)

   270

{

   271

	int pos;

   272

   273

	/* Don't allow reading from a closed socket */

   274

	if (cs->quited)

   275

		return;

   276

   277

	pos = p->pos;

   278

	while (--size > 0 && pos < p->size && (*buffer++ = p->buffer[pos++]) != '\0') {}

   279

	if (size == 0 || pos == p->size)

   280

	{

   281

		*buffer = '\0';

   282

		// If size was sooner to zero then the string in the stream

   283

		//  skip till the \0, so the packet can be read out correctly for the rest

   284

		while (pos < p->size && p->buffer[pos] != '\0') ++pos;

   285

		++pos;

   286

	}

   287

	p->pos = pos;

   288

}

   289

   290

// If PacketSize changes of size, you have to change the 2 packet->size

   291

//   lines below matching the size of packet->size/PacketSize!

   292

// (the line: 'p->size = (uint16)p->buffer[0];' and below)

   293

assert_compile(sizeof(PacketSize) == 2);

   294

   295

Packet *NetworkRecv_Packet(NetworkClientState *cs, NetworkRecvStatus *status)

   296

{

   297

	ssize_t res;

   298

	Packet *p;

   299

   300

	*status = NETWORK_RECV_STATUS_OKAY;

   301

   302

	if (cs->socket == INVALID_SOCKET) return NULL;

   303

   304

	if (cs->packet_recv == NULL) {

   305

		cs->packet_recv = malloc(sizeof(Packet));

   306

		if (cs->packet_recv == NULL) error("Failed to allocate packet");

   307

		// Set pos to zero!

   308

		cs->packet_recv->pos = 0;

   309

		cs->packet_recv->size = 0; // Can be ommited, just for safety reasons

   310

	}

   311

   312

	p = cs->packet_recv;

   313

   314

	// Read packet size

   315

	if (p->pos < sizeof(PacketSize)) {

   316

		while (p->pos < sizeof(PacketSize)) {

   317

			// Read the size of the packet

   318

			res = recv(cs->socket, p->buffer + p->pos, sizeof(PacketSize) - p->pos, 0);

   319

			if (res == -1) {

   320

				int err = GET_LAST_ERROR();

   321

				if (err != EWOULDBLOCK) {

   322

					// Something went wrong..

   323

					if (err != 104) // 104 is Connection Reset by Peer

   324

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

   325

					*status = CloseConnection(cs);

   326

					return NULL;

   327

				}

   328

				// Connection would block, so stop for now

   329

				return NULL;

   330

			}

   331

			if (res == 0) {

   332

				// Client/server has left us :(

   333

				*status = CloseConnection(cs);

   334

				return NULL;

   335

			}

   336

			p->pos += res;

   337

		}

   338

   339

		p->size = (uint16)p->buffer[0];

   340

		p->size += (uint16)p->buffer[1] << 8;

   341

   342

		if (p->size > SEND_MTU) {

   343

			*status = CloseConnection(cs);

   344

			return NULL;

   345

		}

   346

	}

   347

   348

	// Read rest of packet

   349

	while (p->pos < p->size) {

   350

		res = recv(cs->socket, p->buffer + p->pos, p->size - p->pos, 0);

   351

		if (res == -1) {

   352

			int err = GET_LAST_ERROR();

   353

			if (err != EWOULDBLOCK) {

   354

				// Something went wrong..

   355

				if (err != 104) // 104 is Connection Reset by Peer

   356

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

   357

				*status = CloseConnection(cs);

   358

				return NULL;

   359

			}

   360

			// Connection would block

   361

			return NULL;

   362

		}

   363

		if (res == 0) {

   364

			// Client/server has left us :(

   365

			*status = CloseConnection(cs);

   366

			return NULL;

   367

		}

   368

   369

		p->pos += res;

   370

	}

   371

   372

	// We have a complete packet, return it!

   373

	p->pos = 2;

   374

	p->next = NULL; // Should not be needed, but who knows...

   375

   376

	// Prepare for receiving a new packet

   377

	cs->packet_recv = NULL;

   378

   379

	return p;

   380

}

   381

   382

// Add a command to the local command queue

   383

void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp)

   384

{

   385

	CommandPacket *new_cp = malloc(sizeof(CommandPacket));

   386

   387

	*new_cp = *cp;

   388

   389

	if (cs->command_queue == NULL)

   390

		cs->command_queue = new_cp;

   391

	else {

   392

		CommandPacket *c = cs->command_queue;

   393

		while (c->next != NULL) c = c->next;

   394

		c->next = new_cp;

   395

	}

   396

}

   397

   398

// Prepare a DoCommand to be send over the network

   399

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

   400

{

   401

	CommandPacket *c = malloc(sizeof(CommandPacket));

   402

	byte temp_callback;

   403

   404

	c->player = _local_player;

   405

	c->next = NULL;

   406

	c->tile = tile;

   407

	c->p1 = p1;

   408

	c->p2 = p2;

   409

	c->cmd = cmd;

   410

	c->callback = 0;

   411

   412

	temp_callback = 0;

   413

   414

	while (temp_callback < _callback_table_count && _callback_table[temp_callback] != callback)

   415

		temp_callback++;

   416

	if (temp_callback == _callback_table_count) {

   417

		DEBUG(net, 0) ("[NET] Unknown callback. (Pointer: %p) No callback sent.", callback);

   418

		temp_callback = 0; /* _callback_table[0] == NULL */

   419

	}

   420

   421

	if (_network_server) {

   422

		// We are the server, so set the command to be executed next possible frame

   423

		c->frame = _frame_counter_max + 1;

   424

	} else {

   425

		c->frame = 0; // The client can't tell which frame, so just make it 0

   426

	}

   427

   428

	ttd_strlcpy(c->text, (_cmd_text != NULL) ? _cmd_text : "", lengthof(c->text));

   429

   430

	if (_network_server) {

   431

		// If we are the server, we queue the command in our 'special' queue.

   432

		//   In theory, we could execute the command right away, but then the

   433

		//   client on the server can do everything 1 tick faster than others.

   434

		//   So to keep the game fair, we delay the command with 1 tick

   435

		//   which gives about the same speed as most clients.

   436

		NetworkClientState *cs;

   437

   438

		// And we queue it for delivery to the clients

   439

		FOR_ALL_CLIENTS(cs) {

   440

			if (cs->status > STATUS_AUTH) {

   441

				NetworkAddCommandQueue(cs, c);

   442

			}

   443

		}

   444

   445

		// Only the server gets the callback, because clients should not get them

   446

		c->callback = temp_callback;

   447

		if (_local_command_queue == NULL) {

   448

			_local_command_queue = c;

   449

		} else {

   450

			// Find last packet

   451

			CommandPacket *cp = _local_command_queue;

   452

			while (cp->next != NULL) cp = cp->next;

   453

			cp->next = c;

   454

		}

   455

   456

		return;

   457

	}

   458

   459

	// Clients send their command to the server and forget all about the packet

   460

	c->callback = temp_callback;

   461

	SEND_COMMAND(PACKET_CLIENT_COMMAND)(c);

   462

}

   463

   464

// Execute a DoCommand we received from the network

   465

void NetworkExecuteCommand(CommandPacket *cp)

   466

{

   467

	_current_player = cp->player;

   468

	_cmd_text = cp->text;

   469

	/* cp->callback is unsigned. so we don't need to do lower bounds checking. */

   470

	if (cp->callback > _callback_table_count) {

   471

		DEBUG(net,0) ("[NET] Received out-of-bounds callback! (%d)", cp->callback);

   472

		cp->callback = 0;

   473

	}

   474

	DoCommandP(cp->tile, cp->p1, cp->p2, _callback_table[cp->callback], cp->cmd | CMD_NETWORK_COMMAND);

   475

}

   476

   477

#endif /* ENABLE_NETWORK */