1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "debug.h"

     5

#include "network_data.h"

     6

     7

// Is the network enabled?

     8

#ifdef ENABLE_NETWORK

     9

    10

#include "functions.h"

    11

#include "string.h"

    12

#include "table/strings.h"

    13

#include "network_client.h"

    14

#include "command.h"

    15

#include "callback_table.h"

    16

#include "variables.h"

    17

    18

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

    19

    20

// Create a packet for sending

    21

Packet *NetworkSend_Init(PacketType type)

    22

{

    23

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

    24

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

    25

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

    26

    27

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

    28

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

    29

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

    30

	packet->pos = 0;

    31

    32

	return packet;

    33

}

    34

    35

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

    36

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

    37

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

    38

//

    39

//  1 2 3 4

    40

//

    41

    42

void NetworkSend_uint8(Packet *packet, uint8 data)

    43

{

    44

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

    46

}

    47

    48

void NetworkSend_uint16(Packet *packet, uint16 data)

    49

{

    50

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

    51

	packet->buffer[packet->size++] = GB(data, 0, 8);

    52

	packet->buffer[packet->size++] = GB(data, 8, 8);

    53

}

    54

    55

void NetworkSend_uint32(Packet *packet, uint32 data)

    56

{

    57

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

    58

	packet->buffer[packet->size++] = GB(data,  0, 8);

    59

	packet->buffer[packet->size++] = GB(data,  8, 8);

    60

	packet->buffer[packet->size++] = GB(data, 16, 8);

    61

	packet->buffer[packet->size++] = GB(data, 24, 8);

    62

}

    63

    64

void NetworkSend_uint64(Packet *packet, uint64 data)

    65

{

    66

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

    67

	packet->buffer[packet->size++] = GB(data,  0, 8);

    68

	packet->buffer[packet->size++] = GB(data,  8, 8);

    69

	packet->buffer[packet->size++] = GB(data, 16, 8);

    70

	packet->buffer[packet->size++] = GB(data, 24, 8);

    71

	packet->buffer[packet->size++] = GB(data, 32, 8);

    72

	packet->buffer[packet->size++] = GB(data, 40, 8);

    73

	packet->buffer[packet->size++] = GB(data, 48, 8);

    74

	packet->buffer[packet->size++] = GB(data, 56, 8);

    75

}

    76

    77

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

    78

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

    79

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

    80

{

    81

	assert(data != NULL);

    82

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

    83

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

    84

}

    85

    86

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

    87

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

    88

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

    89

assert_compile(sizeof(PacketSize) == 2);

    90

    91

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

    92

//  as soon as possible

    93

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

    94

//   OS-network-buffer is full)

    95

void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)

    96

{

    97

	Packet *p;

    98

	assert(packet != NULL);

    99

   100

	packet->pos = 0;

   101

	packet->next = NULL;

   102

   103

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

   104

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

   105

   106

	// Locate last packet buffered for the client

   107

	p = cs->packet_queue;

   108

	if (p == NULL) {

   109

		// No packets yet

   110

		cs->packet_queue = packet;

   111

	} else {

   112

		// Skip to the last packet

   113

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

   114

		p->next = packet;

   115

	}

   116

}

   117

   118

// Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

   119

//  A socket can make errors. When that happens

   120

//  this handles what to do.

   121

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

   122

// For servers: close connection and that is it

   123

static NetworkRecvStatus CloseConnection(NetworkClientState *cs)

   124

{

   125

	NetworkCloseClient(cs);

   126

   127

	// Clients drop back to the main menu

   128

	if (!_network_server) {

   129

		_switch_mode = SM_MENU;

   130

		_networking = false;

   131

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   132

   133

		return NETWORK_RECV_STATUS_CONN_LOST;

   134

	}

   135

   136

	return NETWORK_RECV_STATUS_OKAY;

   137

}

   138

   139

// Sends all the buffered packets out for this client

   140

//  it stops when:

   141

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

   142

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

   143

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

   144

//   3) sending took too long

   145

bool NetworkSend_Packets(NetworkClientState *cs)

   146

{

   147

	ssize_t res;

   148

	Packet *p;

   149

   150

	// We can not write to this socket!!

   151

	if (!cs->writable) return false;

   152

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

   153

   154

	p = cs->packet_queue;

   155

	while (p != NULL) {

   156

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

   157

		if (res == -1) {

   158

			int err = GET_LAST_ERROR();

   159

			if (err != EWOULDBLOCK) {

   160

				// Something went wrong.. close client!

   161

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

   162

				CloseConnection(cs);

   163

				return false;

   164

			}

   165

			return true;

   166

		}

   167

		if (res == 0) {

   168

			// Client/server has left us :(

   169

			CloseConnection(cs);

   170

			return false;

   171

		}

   172

   173

		p->pos += res;

   174

   175

		// Is this packet sent?

   176

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

   177

			// Go to the next packet

   178

			cs->packet_queue = p->next;

   179

			free(p);

   180

			p = cs->packet_queue;

   181

		} else

   182

			return true;

   183

	}

   184

   185

	return true;

   186

}

   187

   188

   189

// Receiving commands

   190

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

   191

//  see the comment around NetworkSend_uint8 for more info.

   192

uint8 NetworkRecv_uint8(NetworkClientState *cs, Packet *packet)

   193

{

   194

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

   195

	if (cs->quited)

   196

		return 0;

   197

   198

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

   199

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

   200

		CloseConnection(cs);

   201

		return 0;

   202

	}

   203

   204

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

   205

}

   206

   207

uint16 NetworkRecv_uint16(NetworkClientState *cs, Packet *packet)

   208

{

   209

	uint16 n;

   210

   211

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

   212

	if (cs->quited)

   213

		return 0;

   214

   215

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

   216

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

   217

		CloseConnection(cs);

   218

		return 0;

   219

	}

   220

   221

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

   222

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

   223

	return n;

   224

}

   225

   226

uint32 NetworkRecv_uint32(NetworkClientState *cs, Packet *packet)

   227

{

   228

	uint32 n;

   229

   230

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

   231

	if (cs->quited)

   232

		return 0;

   233

   234

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

   235

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

   236

		CloseConnection(cs);

   237

		return 0;

   238

	}

   239

   240

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

   241

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

   242

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

   243

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

   244

	return n;

   245

}

   246

   247

uint64 NetworkRecv_uint64(NetworkClientState *cs, Packet *packet)

   248

{

   249

	uint64 n;

   250

   251

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

   252

	if (cs->quited)

   253

		return 0;

   254

   255

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

   256

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

   257

		CloseConnection(cs);

   258

		return 0;

   259

	}

   260

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

	return n;

   270

}

   271

   272

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

   273

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

   274

{

   275

	int pos;

   276

   277

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

   278

	if (cs->quited)

   279

		return;

   280

   281

	pos = p->pos;

   282

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

   283

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

   284

	{

   285

		*buffer = '\0';

   286

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

   287

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

   288

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

   289

		++pos;

   290

	}

   291

	p->pos = pos;

   292

}

   293

   294

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

   295

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

   296

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

   297

assert_compile(sizeof(PacketSize) == 2);

   298

   299

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

   300

{

   301

	ssize_t res;

   302

	Packet *p;

   303

   304

	*status = NETWORK_RECV_STATUS_OKAY;

   305

   306

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

   307

   308

	if (cs->packet_recv == NULL) {

   309

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

   310

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

   311

		// Set pos to zero!

   312

		cs->packet_recv->pos = 0;

   313

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

   314

	}

   315

   316

	p = cs->packet_recv;

   317

   318

	// Read packet size

   319

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

   320

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

   321

			// Read the size of the packet

   322

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

   323

			if (res == -1) {

   324

				int err = GET_LAST_ERROR();

   325

				if (err != EWOULDBLOCK) {

   326

					// Something went wrong..

   327

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

   328

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

   329

					*status = CloseConnection(cs);

   330

					return NULL;

   331

				}

   332

				// Connection would block, so stop for now

   333

				return NULL;

   334

			}

   335

			if (res == 0) {

   336

				// Client/server has left us :(

   337

				*status = CloseConnection(cs);

   338

				return NULL;

   339

			}

   340

			p->pos += res;

   341

		}

   342

   343

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

   344

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

   345

   346

		if (p->size > SEND_MTU) {

   347

			*status = CloseConnection(cs);

   348

			return NULL;

   349

		}

   350

	}

   351

   352

	// Read rest of packet

   353

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

   354

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

   355

		if (res == -1) {

   356

			int err = GET_LAST_ERROR();

   357

			if (err != EWOULDBLOCK) {

   358

				// Something went wrong..

   359

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

   360

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

   361

				*status = CloseConnection(cs);

   362

				return NULL;

   363

			}

   364

			// Connection would block

   365

			return NULL;

   366

		}

   367

		if (res == 0) {

   368

			// Client/server has left us :(

   369

			*status = CloseConnection(cs);

   370

			return NULL;

   371

		}

   372

   373

		p->pos += res;

   374

	}

   375

   376

	// We have a complete packet, return it!

   377

	p->pos = 2;

   378

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

   379

   380

	// Prepare for receiving a new packet

   381

	cs->packet_recv = NULL;

   382

   383

	return p;

   384

}

   385

   386

// Add a command to the local command queue

   387

void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp)

   388

{

   389

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

   390

   391

	*new_cp = *cp;

   392

   393

	if (cs->command_queue == NULL)

   394

		cs->command_queue = new_cp;

   395

	else {

   396

		CommandPacket *c = cs->command_queue;

   397

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

   398

		c->next = new_cp;

   399

	}

   400

}

   401

   402

// Prepare a DoCommand to be send over the network

   403

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

   404

{

   405

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

   406

	byte temp_callback;

   407

   408

	c->player = _local_player;

   409

	c->next = NULL;

   410

	c->tile = tile;

   411

	c->p1 = p1;

   412

	c->p2 = p2;

   413

	c->cmd = cmd;

   414

	c->callback = 0;

   415

   416

	temp_callback = 0;

   417

   418

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

   419

		temp_callback++;

   420

	if (temp_callback == _callback_table_count) {

   421

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

   422

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

   423

	}

   424

   425

	if (_network_server) {

   426

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

   427

		c->frame = _frame_counter_max + 1;

   428

	} else {

   429

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

   430

	}

   431

   432

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

   433

   434

	if (_network_server) {

   435

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

   436

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

   437

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

   438

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

   439

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

   440

		NetworkClientState *cs;

   441

   442

		// And we queue it for delivery to the clients

   443

		FOR_ALL_CLIENTS(cs) {

   444

			if (cs->status > STATUS_AUTH) {

   445

				NetworkAddCommandQueue(cs, c);

   446

			}

   447

		}

   448

   449

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

   450

		c->callback = temp_callback;

   451

		if (_local_command_queue == NULL) {

   452

			_local_command_queue = c;

   453

		} else {

   454

			// Find last packet

   455

			CommandPacket *cp = _local_command_queue;

   456

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

   457

			cp->next = c;

   458

		}

   459

   460

		return;

   461

	}

   462

   463

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

   464

	c->callback = temp_callback;

   465

	SEND_COMMAND(PACKET_CLIENT_COMMAND)(c);

   466

}

   467

   468

// Execute a DoCommand we received from the network

   469

void NetworkExecuteCommand(CommandPacket *cp)

   470

{

   471

	_current_player = cp->player;

   472

	_cmd_text = cp->text;

   473

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

   474

	if (cp->callback > _callback_table_count) {

   475

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

   476

		cp->callback = 0;

   477

	}

   478

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

   479

}

   480

   481

#endif /* ENABLE_NETWORK */