1

/* $Id$ */

     2

     3

#ifdef ENABLE_NETWORK

     4

     5

#include "stdafx.h"

     6

#include "debug.h"

     7

#include "network_data.h"

     8

#include "functions.h"

     9

#include "string.h"

    10

#include "table/strings.h"

    11

#include "network_client.h"

    12

#include "command.h"

    13

#include "callback_table.h"

    14

#include "variables.h"

    15

    16

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

    17

    18

// Create a packet for sending

    19

Packet *NetworkSend_Init(PacketType type)

    20

{

    21

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

    22

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

    23

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

    24

    25

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

    26

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

    27

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

    28

	packet->pos = 0;

    29

    30

	return packet;

    31

}

    32

    33

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

    34

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

    35

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

    36

//

    37

//  1 2 3 4

    38

//

    39

    40

void NetworkSend_uint8(Packet *packet, uint8 data)

    41

{

    42

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

    43

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

    44

}

    45

    46

void NetworkSend_uint16(Packet *packet, uint16 data)

    47

{

    48

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

    49

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

    50

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

    51

}

    52

    53

void NetworkSend_uint32(Packet *packet, uint32 data)

    54

{

    55

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

    56

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

    57

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

    58

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

    59

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

    60

}

    61

    62

void NetworkSend_uint64(Packet *packet, uint64 data)

    63

{

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

}

    74

    75

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

    76

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

    77

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

    78

{

    79

	assert(data != NULL);

    80

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

    81

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

    82

}

    83

    84

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

    85

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

    86

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

    87

assert_compile(sizeof(PacketSize) == 2);

    88

    89

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

    90

//  as soon as possible

    91

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

    92

//   OS-network-buffer is full)

    93

void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)

    94

{

    95

	Packet *p;

    96

	assert(packet != NULL);

    97

    98

	packet->pos = 0;

    99

	packet->next = NULL;

   100

   101

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

   102

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

   103

   104

	// Locate last packet buffered for the client

   105

	p = cs->packet_queue;

   106

	if (p == NULL) {

   107

		// No packets yet

   108

		cs->packet_queue = packet;

   109

	} else {

   110

		// Skip to the last packet

   111

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

   112

		p->next = packet;

   113

	}

   114

}

   115

   116

// Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

   117

//  A socket can make errors. When that happens

   118

//  this handles what to do.

   119

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

   120

// For servers: close connection and that is it

   121

static NetworkRecvStatus CloseConnection(NetworkClientState *cs)

   122

{

   123

	NetworkCloseClient(cs);

   124

   125

	// Clients drop back to the main menu

   126

	if (!_network_server && _networking) {

   127

		_switch_mode = SM_MENU;

   128

		_networking = false;

   129

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   130

   131

		return NETWORK_RECV_STATUS_CONN_LOST;

   132

	}

   133

   134

	return NETWORK_RECV_STATUS_OKAY;

   135

}

   136

   137

// Sends all the buffered packets out for this client

   138

//  it stops when:

   139

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

   140

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

   141

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

   142

//   3) sending took too long

   143

bool NetworkSend_Packets(NetworkClientState *cs)

   144

{

   145

	ssize_t res;

   146

	Packet *p;

   147

   148

	// We can not write to this socket!!

   149

	if (!cs->writable) return false;

   150

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

   151

   152

	p = cs->packet_queue;

   153

	while (p != NULL) {

   154

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

   155

		if (res == -1) {

   156

			int err = GET_LAST_ERROR();

   157

			if (err != EWOULDBLOCK) {

   158

				// Something went wrong.. close client!

   159

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

   160

				CloseConnection(cs);

   161

				return false;

   162

			}

   163

			return true;

   164

		}

   165

		if (res == 0) {

   166

			// Client/server has left us :(

   167

			CloseConnection(cs);

   168

			return false;

   169

		}

   170

   171

		p->pos += res;

   172

   173

		// Is this packet sent?

   174

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

   175

			// Go to the next packet

   176

			cs->packet_queue = p->next;

   177

			free(p);

   178

			p = cs->packet_queue;

   179

		} else {

   180

			return true;

   181

		}

   182

	}

   183

   184

	return true;

   185

}

   186

   187

   188

// Receiving commands

   189

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

   190

//  see the comment around NetworkSend_uint8 for more info.

   191

uint8 NetworkRecv_uint8(NetworkClientState *cs, Packet *packet)

   192

{

   193

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

   194

	if (cs->quited) return 0;

   195

   196

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

   197

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

   198

		CloseConnection(cs);

   199

		return 0;

   200

	}

   201

   202

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

   203

}

   204

   205

uint16 NetworkRecv_uint16(NetworkClientState *cs, Packet *packet)

   206

{

   207

	uint16 n;

   208

   209

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

   210

	if (cs->quited) return 0;

   211

   212

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

   213

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

   214

		CloseConnection(cs);

   215

		return 0;

   216

	}

   217

   218

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

   219

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

   220

	return n;

   221

}

   222

   223

uint32 NetworkRecv_uint32(NetworkClientState *cs, Packet *packet)

   224

{

   225

	uint32 n;

   226

   227

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

   228

	if (cs->quited) 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) return 0;

   249

   250

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

   251

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

   252

		CloseConnection(cs);

   253

		return 0;

   254

	}

   255

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

	return n;

   265

}

   266

   267

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

   268

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

   269

{

   270

	PacketSize pos;

   271

	char *bufp = buffer;

   272

   273

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

   274

	if (cs->quited) return;

   275

   276

	pos = p->pos;

   277

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

   278

   279

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

   280

		*buffer = '\0';

   281

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

   282

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

   283

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

   284

		pos++;

   285

	}

   286

	p->pos = pos;

   287

   288

	str_validate(bufp);

   289

}

   290

   291

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

   292

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

   293

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

   294

assert_compile(sizeof(PacketSize) == 2);

   295

   296

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

   297

{

   298

	ssize_t res;

   299

	Packet *p;

   300

   301

	*status = NETWORK_RECV_STATUS_OKAY;

   302

   303

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

   304

   305

	if (cs->packet_recv == NULL) {

   306

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

   307

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

   308

		// Set pos to zero!

   309

		cs->packet_recv->pos = 0;

   310

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

   311

	}

   312

   313

	p = cs->packet_recv;

   314

   315

	// Read packet size

   316

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

   317

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

   318

			// Read the size of the packet

   319

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

   320

			if (res == -1) {

   321

				int err = GET_LAST_ERROR();

   322

				if (err != EWOULDBLOCK) {

   323

					// Something went wrong..

   324

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

   325

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

   326

					*status = CloseConnection(cs);

   327

					return NULL;

   328

				}

   329

				// Connection would block, so stop for now

   330

				return NULL;

   331

			}

   332

			if (res == 0) {

   333

				// Client/server has left us :(

   334

				*status = CloseConnection(cs);

   335

				return NULL;

   336

			}

   337

			p->pos += res;

   338

		}

   339

   340

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

   341

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

   342

   343

		if (p->size > SEND_MTU) {

   344

			*status = CloseConnection(cs);

   345

			return NULL;

   346

		}

   347

	}

   348

   349

	// Read rest of packet

   350

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

   351

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

   352

		if (res == -1) {

   353

			int err = GET_LAST_ERROR();

   354

			if (err != EWOULDBLOCK) {

   355

				// Something went wrong..

   356

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

   357

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

   358

				*status = CloseConnection(cs);

   359

				return NULL;

   360

			}

   361

			// Connection would block

   362

			return NULL;

   363

		}

   364

		if (res == 0) {

   365

			// Client/server has left us :(

   366

			*status = CloseConnection(cs);

   367

			return NULL;

   368

		}

   369

   370

		p->pos += res;

   371

	}

   372

   373

	// We have a complete packet, return it!

   374

	p->pos = 2;

   375

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

   376

   377

	// Prepare for receiving a new packet

   378

	cs->packet_recv = NULL;

   379

   380

	return p;

   381

}

   382

   383

// Add a command to the local command queue

   384

void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp)

   385

{

   386

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

   387

   388

	*new_cp = *cp;

   389

   390

	if (cs->command_queue == NULL) {

   391

		cs->command_queue = new_cp;

   392

	} else {

   393

		CommandPacket *c = cs->command_queue;

   394

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

   395

		c->next = new_cp;

   396

	}

   397

}

   398

   399

// Prepare a DoCommand to be send over the network

   400

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

   401

{

   402

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

   403

	byte temp_callback;

   404

   405

	c->player = _local_player;

   406

	c->next = NULL;

   407

	c->tile = tile;

   408

	c->p1 = p1;

   409

	c->p2 = p2;

   410

	c->cmd = cmd;

   411

	c->callback = 0;

   412

   413

	temp_callback = 0;

   414

   415

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

   416

		temp_callback++;

   417

	if (temp_callback == _callback_table_count) {

   418

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

   419

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

   420

	}

   421

   422

	if (_network_server) {

   423

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

   424

		c->frame = _frame_counter_max + 1;

   425

	} else {

   426

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

   427

	}

   428

   429

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

   430

   431

	if (_network_server) {

   432

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

   433

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

   434

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

   435

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

   436

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

   437

		NetworkClientState *cs;

   438

   439

		// And we queue it for delivery to the clients

   440

		FOR_ALL_CLIENTS(cs) {

   441

			if (cs->status > STATUS_AUTH) NetworkAddCommandQueue(cs, c);

   442

		}

   443

   444

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

   445

		c->callback = temp_callback;

   446

		if (_local_command_queue == NULL) {

   447

			_local_command_queue = c;

   448

		} else {

   449

			// Find last packet

   450

			CommandPacket *cp = _local_command_queue;

   451

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

   452

			cp->next = c;

   453

		}

   454

   455

		return;

   456

	}

   457

   458

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

   459

	c->callback = temp_callback;

   460

	SEND_COMMAND(PACKET_CLIENT_COMMAND)(c);

   461

}

   462

   463

// Execute a DoCommand we received from the network

   464

void NetworkExecuteCommand(CommandPacket *cp)

   465

{

   466

	_current_player = cp->player;

   467

	_cmd_text = cp->text;

   468

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

   469

	if (cp->callback > _callback_table_count) {

   470

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

   471

		cp->callback = 0;

   472

	}

   473

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

   474

}

   475

   476

#endif /* ENABLE_NETWORK */