1

/* $Id$ */

     2

     3

#ifdef ENABLE_NETWORK

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h" // XXX StringID

     7

#include "../debug.h"

     8

#include "../string.h"

     9

#include "../strings.h"

    10

#include "network_data.h"

    11

#include "core/tcp.h"

    12

#include "../train.h"

    13

#include "../aircraft.h"

    14

#include "../date.h"

    15

#include "table/strings.h"

    16

#include "../functions.h"

    17

#include "network_server.h"

    18

#include "network_udp.h"

    19

#include "../console.h"

    20

#include "../command.h"

    21

#include "../saveload.h"

    22

#include "../vehicle.h"

    23

#include "../station.h"

    24

#include "../variables.h"

    25

#include "../genworld.h"

    26

#include "../helpers.hpp"

    27

    28

// This file handles all the server-commands

    29

    30

static void NetworkHandleCommandQueue(NetworkTCPSocketHandler* cs);

    31

    32

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

    33

// Sending functions

    34

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkTCPSocketHandler *cs

    35

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

    36

    37

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CLIENT_INFO)(NetworkTCPSocketHandler *cs, NetworkClientInfo *ci)

    38

{

    39

	//

    40

	// Packet: SERVER_CLIENT_INFO

    41

	// Function: Sends info about a client

    42

	// Data:

    43

	//    uint16:  The index of the client (always unique on a server. 1 = server)

    44

	//    uint8:  As which player the client is playing

    45

	//    String: The name of the client

    46

	//    String: The unique id of the client

    47

	//

    48

    49

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    50

		Packet *p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    51

		p->Send_uint16(ci->client_index);

    52

		p->Send_uint8 (ci->client_playas);

    53

		p->Send_string(ci->client_name);

    54

		p->Send_string(ci->unique_id);

    55

    56

		cs->Send_Packet(p);

    57

	}

    58

}

    59

    60

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    61

{

    62

//

    63

	// Packet: SERVER_COMPANY_INFO

    64

	// Function: Sends info about the companies

    65

	// Data:

    66

	//

    67

    68

	int i;

    69

    70

	Player *player;

    71

	Packet *p;

    72

    73

	byte active = ActivePlayerCount();

    74

    75

	if (active == 0) {

    76

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    77

    78

		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

    79

		p->Send_uint8 (active);

    80

    81

		cs->Send_Packet(p);

    82

		return;

    83

	}

    84

    85

	NetworkPopulateCompanyInfo();

    86

    87

	FOR_ALL_PLAYERS(player) {

    88

		if (!player->is_active) continue;

    89

    90

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    91

    92

		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

    93

		p->Send_uint8 (active);

    94

		p->Send_uint8 (player->index);

    95

    96

		p->Send_string(_network_player_info[player->index].company_name);

    97

		p->Send_uint32(_network_player_info[player->index].inaugurated_year);

    98

		p->Send_uint64(_network_player_info[player->index].company_value);

    99

		p->Send_uint64(_network_player_info[player->index].money);

   100

		p->Send_uint64(_network_player_info[player->index].income);

   101

		p->Send_uint16(_network_player_info[player->index].performance);

   102

   103

		/* Send 1 if there is a passord for the company else send 0 */

   104

		p->Send_bool(StrEmpty(_network_player_info[player->index].password));

   105

   106

		for (i = 0; i < NETWORK_VEHICLE_TYPES; i++) {

   107

			p->Send_uint16(_network_player_info[player->index].num_vehicle[i]);

   108

		}

   109

   110

		for (i = 0; i < NETWORK_STATION_TYPES; i++) {

   111

			p->Send_uint16(_network_player_info[player->index].num_station[i]);

   112

		}

   113

   114

		if (_network_player_info[player->index].players[0] == '\0') {

   115

			p->Send_string("<none>");

   116

		} else {

   117

			p->Send_string(_network_player_info[player->index].players);

   118

		}

   119

   120

		cs->Send_Packet(p);

   121

	}

   122

   123

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   124

   125

	p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

   126

	p->Send_uint8 (0);

   127

   128

	cs->Send_Packet(p);

   129

}

   130

   131

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR)(NetworkTCPSocketHandler *cs, NetworkErrorCode error)

   132

{

   133

	//

   134

	// Packet: SERVER_ERROR

   135

	// Function: The client made an error

   136

	// Data:

   137

	//    uint8:  ErrorID (see network_data.h, NetworkErrorCode)

   138

	//

   139

   140

	char str[100];

   141

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   142

   143

	p->Send_uint8(error);

   144

	cs->Send_Packet(p);

   145

   146

	GetNetworkErrorMsg(str, error, lastof(str));

   147

   148

	// Only send when the current client was in game

   149

	if (cs->status > STATUS_AUTH) {

   150

		NetworkTCPSocketHandler *new_cs;

   151

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

   152

   153

		NetworkGetClientName(client_name, sizeof(client_name), cs);

   154

   155

		DEBUG(net, 1, "'%s' made an error and has been disconnected. Reason: '%s'", client_name, str);

   156

   157

		NetworkTextMessage(NETWORK_ACTION_LEAVE, 1, false, client_name, "%s", str);

   158

   159

		FOR_ALL_CLIENTS(new_cs) {

   160

			if (new_cs->status > STATUS_AUTH && new_cs != cs) {

   161

				// Some errors we filter to a more general error. Clients don't have to know the real

   162

				//  reason a joining failed.

   163

				if (error == NETWORK_ERROR_NOT_AUTHORIZED || error == NETWORK_ERROR_NOT_EXPECTED || error == NETWORK_ERROR_WRONG_REVISION)

   164

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   165

   166

				SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->index, error);

   167

			}

   168

		}

   169

	} else {

   170

		DEBUG(net, 1, "Client %d made an error and has been disconnected. Reason: '%s'", cs->index, str);

   171

	}

   172

   173

	cs->has_quit = true;

   174

   175

	// Make sure the data get's there before we close the connection

   176

	cs->Send_Packets();

   177

   178

	// The client made a mistake, so drop his connection now!

   179

	NetworkCloseClient(cs);

   180

}

   181

   182

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHECK_NEWGRFS)(NetworkTCPSocketHandler *cs)

   183

{

   184

	//

   185

	// Packet: PACKET_SERVER_CHECK_NEWGRFS

   186

	// Function: Sends info about the used GRFs to the client

   187

	// Data:

   188

	//      uint8:  Amount of GRFs

   189

	//    And then for each GRF:

   190

	//      uint32: GRF ID

   191

	// 16 * uint8:  MD5 checksum of the GRF

   192

	//

   193

   194

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHECK_NEWGRFS);

   195

	const GRFConfig *c;

   196

	uint grf_count = 0;

   197

   198

	for (c = _grfconfig; c != NULL; c = c->next) grf_count++;

   199

   200

	p->Send_uint8 (grf_count);

   201

	for (c = _grfconfig; c != NULL; c = c->next) {

   202

		cs->Send_GRFIdentifier(p, c);

   203

	}

   204

   205

	cs->Send_Packet(p);

   206

}

   207

   208

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_PASSWORD)(NetworkTCPSocketHandler *cs, NetworkPasswordType type)

   209

{

   210

	//

   211

	// Packet: SERVER_NEED_PASSWORD

   212

	// Function: Indication to the client that the server needs a password

   213

	// Data:

   214

	//    uint8:  Type of password

   215

	//

   216

   217

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   218

	p->Send_uint8(type);

   219

	cs->Send_Packet(p);

   220

}

   221

   222

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   223

{

   224

	//

   225

	// Packet: SERVER_WELCOME

   226

	// Function: The client is joined and ready to receive his map

   227

	// Data:

   228

	//    uint16:  Own ClientID

   229

	//

   230

   231

	Packet *p;

   232

	NetworkTCPSocketHandler *new_cs;

   233

   234

	// Invalid packet when status is AUTH or higher

   235

	if (cs->status >= STATUS_AUTH) return;

   236

   237

	cs->status = STATUS_AUTH;

   238

	_network_game_info.clients_on++;

   239

   240

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   241

	p->Send_uint16(cs->index);

   242

	cs->Send_Packet(p);

   243

   244

		// Transmit info about all the active clients

   245

	FOR_ALL_CLIENTS(new_cs) {

   246

		if (new_cs != cs && new_cs->status > STATUS_AUTH)

   247

			SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, DEREF_CLIENT_INFO(new_cs));

   248

	}

   249

	// Also send the info of the server

   250

	SEND_COMMAND(PACKET_SERVER_CLIENT_INFO)(cs, NetworkFindClientInfoFromIndex(NETWORK_SERVER_INDEX));

   251

}

   252

   253

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   254

{

   255

	//

   256

	// Packet: PACKET_SERVER_WAIT

   257

	// Function: The client can not receive the map at the moment because

   258

	//             someone else is already receiving the map

   259

	// Data:

   260

	//    uint8:  Clients awaiting map

   261

	//

   262

	int waiting = 0;

   263

	NetworkTCPSocketHandler *new_cs;

   264

	Packet *p;

   265

   266

	// Count how many players are waiting in the queue

   267

	FOR_ALL_CLIENTS(new_cs) {

   268

		if (new_cs->status == STATUS_MAP_WAIT) waiting++;

   269

	}

   270

   271

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   272

	p->Send_uint8(waiting);

   273

	cs->Send_Packet(p);

   274

}

   275

   276

// This sends the map to the client

   277

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   278

{

   279

	//

   280

	// Packet: SERVER_MAP

   281

	// Function: Sends the map to the client, or a part of it (it is splitted in

   282

	//   a lot of multiple packets)

   283

	// Data:

   284

	//    uint8:  packet-type (MAP_PACKET_START, MAP_PACKET_NORMAL and MAP_PACKET_END)

   285

	//  if MAP_PACKET_START:

   286

	//    uint32: The current FrameCounter

   287

	//  if MAP_PACKET_NORMAL:

   288

	//    piece of the map (till max-size of packet)

   289

	//  if MAP_PACKET_END:

   290

	//    uint32: seed0 of player

   291

	//    uint32: seed1 of player

   292

	//      last 2 are repeated MAX_PLAYERS time

   293

	//

   294

   295

	static FILE *file_pointer;

   296

	static uint sent_packets; // How many packets we did send succecfully last time

   297

   298

	if (cs->status < STATUS_AUTH) {

   299

		// Illegal call, return error and ignore the packet

   300

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   301

		return;

   302

	}

   303

   304

	if (cs->status == STATUS_AUTH) {

   305

		char filename[256];

   306

		Packet *p;

   307

   308

		// Make a dump of the current game

   309

		snprintf(filename, lengthof(filename), "%s%snetwork_server.tmp",  _paths.autosave_dir, PATHSEP);

   310

		if (SaveOrLoad(filename, SL_SAVE) != SL_OK) error("network savedump failed");

   311

   312

		file_pointer = fopen(filename, "rb");

   313

		fseek(file_pointer, 0, SEEK_END);

   314

   315

		if (ftell(file_pointer) == 0) error("network savedump failed - zero sized savegame?");

   316

   317

		// Now send the _frame_counter and how many packets are coming

   318

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   319

		p->Send_uint8 (MAP_PACKET_START);

   320

		p->Send_uint32(_frame_counter);

   321

		p->Send_uint32(ftell(file_pointer));

   322

		cs->Send_Packet(p);

   323

   324

		fseek(file_pointer, 0, SEEK_SET);

   325

   326

		sent_packets = 4; // We start with trying 4 packets

   327

   328

		cs->status = STATUS_MAP;

   329

		/* Mark the start of download */

   330

		cs->last_frame = _frame_counter;

   331

		cs->last_frame_server = _frame_counter;

   332

	}

   333

   334

	if (cs->status == STATUS_MAP) {

   335

		uint i;

   336

		int res;

   337

		for (i = 0; i < sent_packets; i++) {

   338

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   339

			p->Send_uint8(MAP_PACKET_NORMAL);

   340

			res = (int)fread(p->buffer + p->size, 1, SEND_MTU - p->size, file_pointer);

   341

   342

			if (ferror(file_pointer)) error("Error reading temporary network savegame!");

   343

   344

			p->size += res;

   345

			cs->Send_Packet(p);

   346

			if (feof(file_pointer)) {

   347

				// Done reading!

   348

				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   349

				p->Send_uint8(MAP_PACKET_END);

   350

				cs->Send_Packet(p);

   351

   352

				// Set the status to DONE_MAP, no we will wait for the client

   353

				//  to send it is ready (maybe that happens like never ;))

   354

				cs->status = STATUS_DONE_MAP;

   355

				fclose(file_pointer);

   356

   357

				{

   358

					NetworkTCPSocketHandler *new_cs;

   359

					bool new_map_client = false;

   360

					// Check if there is a client waiting for receiving the map

   361

					//  and start sending him the map

   362

					FOR_ALL_CLIENTS(new_cs) {

   363

						if (new_cs->status == STATUS_MAP_WAIT) {

   364

							// Check if we already have a new client to send the map to

   365

							if (!new_map_client) {

   366

								// If not, this client will get the map

   367

								new_cs->status = STATUS_AUTH;

   368

								new_map_client = true;

   369

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   370

							} else {

   371

								// Else, send the other clients how many clients are in front of them

   372

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   373

							}

   374

						}

   375

					}

   376

				}

   377

   378

				// There is no more data, so break the for

   379

				break;

   380

			}

   381

		}

   382

   383

		// Send all packets (forced) and check if we have send it all

   384

		cs->Send_Packets();

   385

		if (cs->IsPacketQueueEmpty()) {

   386

			// All are sent, increase the sent_packets

   387

			sent_packets *= 2;

   388

		} else {

   389

			// Not everything is sent, decrease the sent_packets

   390

			if (sent_packets > 1) sent_packets /= 2;

   391

		}

   392

	}

   393

}

   394

   395

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_JOIN)(NetworkTCPSocketHandler *cs, uint16 client_index)

   396

{

   397

	//

   398

	// Packet: SERVER_JOIN

   399

	// Function: A client is joined (all active clients receive this after a

   400

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   401

	//     PACKET_SERVER_CLIENT_INFO

   402

	// Data:

   403

	//    uint16:  Client-Index

   404

	//

   405

   406

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   407

   408

	p->Send_uint16(client_index);

   409

   410

	cs->Send_Packet(p);

   411

}

   412

   413

   414

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   415

{

   416

	//

   417

	// Packet: SERVER_FRAME

   418

	// Function: Sends the current frame-counter to the client

   419

	// Data:

   420

	//    uint32: Frame Counter

   421

	//    uint32: Frame Counter Max (how far may the client walk before the server?)

   422

	//    [uint32: general-seed-1]

   423

	//    [uint32: general-seed-2]

   424

	//      (last two depends on compile-settings, and are not default settings)

   425

	//

   426

   427

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   428

	p->Send_uint32(_frame_counter);

   429

	p->Send_uint32(_frame_counter_max);

   430

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   431

	p->Send_uint32(_sync_seed_1);

   432

#ifdef NETWORK_SEND_DOUBLE_SEED

   433

	p->Send_uint32(_sync_seed_2);

   434

#endif

   435

#endif

   436

	cs->Send_Packet(p);

   437

}

   438

   439

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   440

{

   441

	//

   442

	// Packet: SERVER_SYNC

   443

	// Function: Sends a sync-check to the client

   444

	// Data:

   445

	//    uint32: Frame Counter

   446

	//    uint32: General-seed-1

   447

	//    [uint32: general-seed-2]

   448

	//      (last one depends on compile-settings, and are not default settings)

   449

	//

   450

   451

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   452

	p->Send_uint32(_frame_counter);

   453

	p->Send_uint32(_sync_seed_1);

   454

   455

#ifdef NETWORK_SEND_DOUBLE_SEED

   456

	p->Send_uint32(_sync_seed_2);

   457

#endif

   458

	cs->Send_Packet(p);

   459

}

   460

   461

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_COMMAND)(NetworkTCPSocketHandler *cs, CommandPacket *cp)

   462

{

   463

	//

   464

	// Packet: SERVER_COMMAND

   465

	// Function: Sends a DoCommand to the client

   466

	// Data:

   467

	//    uint8:  PlayerID (0..MAX_PLAYERS-1)

   468

	//    uint32: CommandID (see command.h)

   469

	//    uint32: P1 (free variables used in DoCommand)

   470

	//    uint32: P2

   471

	//    uint32: Tile

   472

	//    string: text

   473

	//    uint8:  CallBackID (see callback_table.c)

   474

	//    uint32: Frame of execution

   475

	//

   476

   477

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   478

   479

	p->Send_uint8 (cp->player);

   480

	p->Send_uint32(cp->cmd);

   481

	p->Send_uint32(cp->p1);

   482

	p->Send_uint32(cp->p2);

   483

	p->Send_uint32(cp->tile);

   484

	p->Send_string(cp->text);

   485

	p->Send_uint8 (cp->callback);

   486

	p->Send_uint32(cp->frame);

   487

   488

	cs->Send_Packet(p);

   489

}

   490

   491

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(NetworkTCPSocketHandler *cs, NetworkAction action, uint16 client_index, bool self_send, const char *msg)

   492

{

   493

	//

   494

	// Packet: SERVER_CHAT

   495

	// Function: Sends a chat-packet to the client

   496

	// Data:

   497

	//    uint8:  ActionID (see network_data.h, NetworkAction)

   498

	//    uint16:  Client-index

   499

	//    String: Message (max MAX_TEXT_MSG_LEN)

   500

	//

   501

   502

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   503

   504

	p->Send_uint8 (action);

   505

	p->Send_uint16(client_index);

   506