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 "table/strings.h"

     9

#include "network_client.h"

    10

#include "command.h"

    11

#include "callback_table.h"

    12

    13

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

    14

    15

// Create a packet for sending

    16

Packet *NetworkSend_Init(PacketType type)

    17

{

    18

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

    19

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

    20

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

    21

    22

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

    23

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

    24

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

    25

	packet->pos = 0;

    26

    27

	return packet;

    28

}

    29

    30

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

    31

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

    32

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

    33

//

    34

//  1 2 3 4

    35

//

    36

    37

void NetworkSend_uint8(Packet *packet, uint8 data)

    38

{

    39

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

    40

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

    41

}

    42

    43

void NetworkSend_uint16(Packet *packet, uint16 data)

    44

{

    45

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

    46

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

    47

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

    48

}

    49

    50

void NetworkSend_uint32(Packet *packet, uint32 data)

    51

{

    52

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

    53

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

    54

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

    55

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

    56

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

    57

}

    58

    59

void NetworkSend_uint64(Packet *packet, uint64 data)

    60

{

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

}

    71

    72

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

    73

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

    74

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

    75

{

    76

	assert(data != NULL);

    77

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

    78

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

    79

}

    80

    81

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

    82

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

    83

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

    84

assert_compile(sizeof(PacketSize) == 2);

    85

    86

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

    87

//  as soon as possible

    88

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

    89

//   OS-network-buffer is full)

    90

void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)

    91

{

    92

	Packet *p;

    93

	assert(packet != NULL);

    94

    95

	packet->pos = 0;

    96

	packet->next = NULL;

    97

    98

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

    99

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

   100

   101

	// Locate last packet buffered for the client

   102

	p = cs->packet_queue;

   103

	if (p == NULL) {

   104

		// No packets yet

   105

		cs->packet_queue = packet;

   106

	} else {

   107

		// Skip to the last packet

   108

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

   109

		p->next = packet;

   110

	}

   111

}

   112

   113

// Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

   114

//  A socket can make errors. When that happens

   115

//  this handles what to do.

   116

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

   117

// For servers: close connection and that is it

   118

static NetworkRecvStatus CloseConnection(NetworkClientState *cs)

   119

{

   120

	NetworkCloseClient(cs);

   121

   122

	// Clients drop back to the main menu

   123

	if (!_network_server) {

   124

		_switch_mode = SM_MENU;

   125

		_networking = false;

   126

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

   127

   128

		return NETWORK_RECV_STATUS_CONN_LOST;

   129

	}

   130

   131

	return NETWORK_RECV_STATUS_OKAY;

   132

}

   133

   134

// Sends all the buffered packets out for this client

   135

//  it stops when:

   136

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

   137

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

   138

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

   139

//   3) sending took too long

   140

bool NetworkSend_Packets(NetworkClientState *cs)

   141

{

   142

	ssize_t res;

   143

	Packet *p;

   144

   145

	// We can not write to this socket!!

   146

	if (!cs->writable) return false;

   147

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

   148

   149

	p = cs->packet_queue;

   150

	while (p != NULL) {

   151

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

   152

		if (res == -1) {

   153

			int err = GET_LAST_ERROR();

   154

			if (err != EWOULDBLOCK) {

   155

				// Something went wrong.. close client!

   156

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

   157

				CloseConnection(cs);

   158

				return false;

   159

			}

   160

			return true;

   161

		}

   162

		if (res == 0) {

   163

			// Client/server has left us :(

   164

			CloseConnection(cs);

   165

			return false;

   166

		}

   167

   168

		p->pos += res;

   169

   170

		// Is this packet sent?

   171

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

   172

			// Go to the next packet

   173

			cs->packet_queue = p->next;

   174

			free(p);

   175

			p = cs->packet_queue;

   176

		} else

   177

			return true;

   178

	}

   179

   180

	return true;

   181

}

   182

   183

   184

// Receiving commands

   185

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

   186

//  see the comment around NetworkSend_uint8 for more info.

   187

uint8 NetworkRecv_uint8(NetworkClientState *cs, Packet *packet)

   188

{

   189

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

   190

	if (cs->quited)

   191

		return 0;

   192

   193

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

   194

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

   195

		CloseConnection(cs);

   196

		return 0;

   197

	}

   198

   199

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

   200

}

   201

   202

uint16 NetworkRecv_uint16(NetworkClientState *cs, Packet *packet)

   203

{

   204

	uint16 n;

   205

   206

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

   207

	if (cs->quited)

   208

		return 0;

   209

   210

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

   211

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

   212

		CloseConnection(cs);

   213

		return 0;

   214

	}

   215

   216

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

   217

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

   218

	return n;

   219

}

   220

   221

uint32 NetworkRecv_uint32(NetworkClientState *cs, Packet *packet)

   222

{

   223

	uint32 n;

   224

   225

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

   226

	if (cs->quited)

   227

		return 0;

   228

   229

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

   230

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

   231

		CloseConnection(cs);

   232

		return 0;

   233

	}

   234

   235

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

   236

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

   237

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

   238

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

   239

	return n;

   240

}

   241

   242

uint64 NetworkRecv_uint64(NetworkClientState *cs, Packet *packet)

   243

{

   244

	uint64 n;

   245

   246

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

   247

	if (cs->quited)

   248

		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

	int pos;

   271

   272

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

   273

	if (cs->quited)

   274

		return;

   275

   276

	pos = p->pos;

   277

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

   278

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

   279

	{

   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

   289

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

   290

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

   291

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

   292

assert_compile(sizeof(PacketSize) == 2);

   293

   294

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

   295

{

   296

	ssize_t res;

   297

	Packet *p;

   298

   299

	*status = NETWORK_RECV_STATUS_OKAY;

   300

   301

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

   302

   303

	if (cs->packet_recv == NULL) {

   304

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

   305

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

   306

		// Set pos to zero!

   307

		cs->packet_recv->pos = 0;

   308

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

   309

	}

   310

   311

	p = cs->packet_recv;

   312

   313

	// Read packet size

   314

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

   315

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

   316

			// Read the size of the packet

   317

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

   318

			if (res == -1) {

   319

				int err = GET_LAST_ERROR();

   320

				if (err != EWOULDBLOCK) {

   321

					// Something went wrong..

   322

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

   323

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

   324

					*status = CloseConnection(cs);

   325

					return NULL;

   326

				}

   327

				// Connection would block, so stop for now

   328

				return NULL;

   329

			}

   330

			if (res == 0) {

   331

				// Client/server has left us :(

   332

				*status = CloseConnection(cs);

   333

				return NULL;

   334

			}

   335

			p->pos += res;

   336

		}

   337

   338

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

   339

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

   340

   341

		if (p->size > SEND_MTU) {

   342

			*status = CloseConnection(cs);

   343

			return NULL;

   344

		}

   345

	}

   346

   347

	// Read rest of packet

   348

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

   349

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

   350

		if (res == -1) {

   351

			int err = GET_LAST_ERROR();

   352

			if (err != EWOULDBLOCK) {

   353

				// Something went wrong..

   354

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

   355

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

   356

				*status = CloseConnection(cs);

   357

				return NULL;

   358

			}

   359

			// Connection would block

   360

			return NULL;

   361

		}

   362

		if (res == 0) {

   363

			// Client/server has left us :(

   364

			*status = CloseConnection(cs);

   365

			return NULL;

   366

		}

   367

   368

		p->pos += res;

   369

	}

   370

   371

	// We have a complete packet, return it!

   372

	p->pos = 2;

   373

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

   374

   375

	// Prepare for receiving a new packet

   376

	cs->packet_recv = NULL;

   377

   378

	return p;

   379

}

   380

   381

// Add a command to the local command queue

   382

void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp)

   383

{

   384

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

   385

   386

	*new_cp = *cp;

   387

   388

	if (cs->command_queue == NULL)

   389

		cs->command_queue = new_cp;

   390

	else {

   391

		CommandPacket *c = cs->command_queue;

   392

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

   393

		c->next = new_cp;

   394

	}

   395

}

   396

   397

// If this fails, make sure you change the following line below:

   398

//   'memcpy(qp->dp, _decode_parameters, 10 * sizeof(uint32));'

   399

// Also, in network_data.h, change the size of CommandPacket->dp!

   400

// (this protection is there to make sure in network.h dp is of the right size!)

   401

assert_compile(sizeof(_decode_parameters) == 20 * sizeof(uint32));

   402

   403

// Prepare a DoCommand to be send over the network

   404

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

   405

{

   406

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

   407

	byte temp_callback;

   408

   409

	c->player = _local_player;

   410

	c->next = NULL;

   411

	c->tile = tile;

   412

	c->p1 = p1;

   413

	c->p2 = p2;

   414

	c->cmd = cmd;

   415

	c->callback = 0;

   416

   417

	temp_callback = 0;

   418

   419

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

   420

		temp_callback++;

   421

	if (temp_callback == _callback_table_count) {

   422

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

   423

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

   424

	}

   425

   426

	if (_network_server) {

   427

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

   428

		c->frame = _frame_counter_max + 1;

   429

	} else {

   430

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

   431

	}

   432

   433

	// Copy the _decode_parameters to dp

   434

	memcpy(c->dp, _decode_parameters, 20 * sizeof(uint32));

   435

   436

	if (_network_server) {

   437

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

   438

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

   439

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

   440

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

   441

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

   442

		NetworkClientState *cs;

   443

   444

		// And we queue it for delivery to the clients

   445

		FOR_ALL_CLIENTS(cs) {

   446

			if (cs->status > STATUS_AUTH) {

   447

				NetworkAddCommandQueue(cs, c);

   448

			}

   449

		}

   450

   451

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

   452

		c->callback = temp_callback;

   453

		if (_local_command_queue == NULL) {

   454

			_local_command_queue = c;

   455

		} else {

   456

			// Find last packet

   457

			CommandPacket *cp = _local_command_queue;

   458

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

   459

			cp->next = c;

   460

		}

   461

   462

		return;

   463

	}

   464

   465

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

   466

	c->callback = temp_callback;

   467

	SEND_COMMAND(PACKET_CLIENT_COMMAND)(c);

   468

}

   469

   470

// Execute a DoCommand we received from the network

   471

void NetworkExecuteCommand(CommandPacket *cp)

   472

{

   473

	_current_player = cp->player;

   474

	memcpy(_decode_parameters, cp->dp, sizeof(cp->dp));

   475

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

   476

	if (cp->callback > _callback_table_count) {

   477

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

   478

		cp->callback = 0;

   479

	}

   480

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

   481

}

   482

   483

#endif /* ENABLE_NETWORK */