1

/* $Id$ */

     2

     3

/** @file network_server.cpp Server part of the network protocol. */

     4

     5

#ifdef ENABLE_NETWORK

     6

     7

#include "../stdafx.h"

     8

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

     9

#include "../debug.h"

    10

#include "../strings_func.h"

    11

#include "network_internal.h"

    12

#include "core/tcp.h"

    13

#include "../vehicle_base.h"

    14

#include "../vehicle_func.h"

    15

#include "../date_func.h"

    16

#include "network_server.h"

    17

#include "network_udp.h"

    18

#include "../console_func.h"

    19

#include "../command_func.h"

    20

#include "../saveload.h"

    21

#include "../station_base.h"

    22

#include "../variables.h"

    23

#include "../genworld.h"

    24

#include "../core/alloc_func.hpp"

    25

#include "../fileio.h"

    26

#include "../string_func.h"

    27

#include "../player_base.h"

    28

#include "../player_func.h"

    29

#include "../player_gui.h"

    30

#include "../settings_type.h"

    31

    32

#include "table/strings.h"

    33

    34

// This file handles all the server-commands

    35

    36

static void NetworkHandleCommandQueue(NetworkTCPSocketHandler* cs);

    37

    38

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

    39

// Sending functions

    40

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkTCPSocketHandler *cs

    41

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

    42

    43

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

    44

{

    45

	//

    46

	// Packet: SERVER_CLIENT_INFO

    47

	// Function: Sends info about a client

    48

	// Data:

    49

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

    50

	//    uint8:  As which player the client is playing

    51

	//    String: The name of the client

    52

	//    String: The unique id of the client

    53

	//

    54

    55

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    56

		Packet *p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    57

		p->Send_uint16(ci->client_index);

    58

		p->Send_uint8 (ci->client_playas);

    59

		p->Send_string(ci->client_name);

    60

		p->Send_string(ci->unique_id);

    61

    62

		cs->Send_Packet(p);

    63

	}

    64

}

    65

    66

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    67

{

    68

//

    69

	// Packet: SERVER_COMPANY_INFO

    70

	// Function: Sends info about the companies

    71

	// Data:

    72

	//

    73

    74

	int i;

    75

    76

	Player *player;

    77

	Packet *p;

    78

    79

	byte active = ActivePlayerCount();

    80

    81

	if (active == 0) {

    82

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    83

    84

		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

    85

		p->Send_uint8 (active);

    86

    87

		cs->Send_Packet(p);

    88

		return;

    89

	}

    90

    91

	NetworkPopulateCompanyInfo();

    92

    93

	FOR_ALL_PLAYERS(player) {

    94

		if (!player->is_active) continue;

    95

    96

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    97

    98

		p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

    99

		p->Send_uint8 (active);

   100

		p->Send_uint8 (player->index);

   101

   102

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

   103

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

   104

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

   105

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

   106

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

   107

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

   108

   109

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

   110

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

   111

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

   112

   113

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

   114

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

   115

		}

   116

   117

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

   118

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

   119

		}

   120

   121

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

   122

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

   123

		} else {

   124

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

   125

		}

   126

   127

		cs->Send_Packet(p);

   128

	}

   129

   130

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   131

   132

	p->Send_uint8 (NETWORK_COMPANY_INFO_VERSION);

   133

	p->Send_uint8 (0);

   134

   135

	cs->Send_Packet(p);

   136

}

   137

   138

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

   139

{

   140

	//

   141

	// Packet: SERVER_ERROR

   142

	// Function: The client made an error

   143

	// Data:

   144

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

   145

	//

   146

   147

	char str[100];

   148

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   149

   150

	p->Send_uint8(error);

   151

	cs->Send_Packet(p);

   152

   153

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

   154

   155

	// Only send when the current client was in game

   156

	if (cs->status > STATUS_AUTH) {

   157

		NetworkTCPSocketHandler *new_cs;

   158

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

   159

   160

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

   161

   162

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

   163

   164

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

   165

   166

		FOR_ALL_CLIENTS(new_cs) {

   167

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

   168

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

   169

				//  reason a joining failed.

   170

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

   171

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   172

   173

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

   174

			}

   175

		}

   176

	} else {

   177

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

   178

	}

   179

   180

	cs->has_quit = true;

   181

   182

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

   183

	cs->Send_Packets();

   184

   185

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

   186

	NetworkCloseClient(cs);

   187

}

   188

   189

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHECK_NEWGRFS)(NetworkTCPSocketHandler *cs)

   190

{

   191

	//

   192

	// Packet: PACKET_SERVER_CHECK_NEWGRFS

   193

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

   194

	// Data:

   195

	//      uint8:  Amount of GRFs

   196

	//    And then for each GRF:

   197

	//      uint32: GRF ID

   198

	// 16 * uint8:  MD5 checksum of the GRF

   199

	//

   200

   201

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHECK_NEWGRFS);

   202

	const GRFConfig *c;

   203

	uint grf_count = 0;

   204

   205

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

   206

		if (!HasBit(c->flags, GCF_STATIC)) grf_count++;

   207

	}

   208

   209

	p->Send_uint8 (grf_count);

   210

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

   211

		if (!HasBit(c->flags, GCF_STATIC)) cs->Send_GRFIdentifier(p, c);

   212

	}

   213

   214

	cs->Send_Packet(p);

   215

}

   216

   217

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

   218

{

   219

	//

   220

	// Packet: SERVER_NEED_PASSWORD

   221

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

   222

	// Data:

   223

	//    uint8:  Type of password

   224

	//

   225

   226

	/* Invalid packet when status is AUTH or higher */

   227

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

   228

   229

	cs->status = STATUS_AUTHORIZING;

   230

   231

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   232

	p->Send_uint8(type);

   233

	p->Send_uint32(_settings_game.game_creation.generation_seed);

   234

	p->Send_string(_settings_client.network.network_id);

   235

	cs->Send_Packet(p);

   236

}

   237

   238

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   239

{

   240

	//

   241

	// Packet: SERVER_WELCOME

   242

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

   243

	// Data:

   244

	//    uint16:  Own ClientID

   245

	//

   246

   247

	Packet *p;

   248

	NetworkTCPSocketHandler *new_cs;

   249

   250

	// Invalid packet when status is AUTH or higher

   251

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

   252

   253

	cs->status = STATUS_AUTH;

   254

	_network_game_info.clients_on++;

   255

   256

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   257

	p->Send_uint16(cs->index);

   258

	p->Send_uint32(_settings_game.game_creation.generation_seed);

   259

	p->Send_string(_settings_client.network.network_id);

   260

	cs->Send_Packet(p);

   261

   262

		// Transmit info about all the active clients

   263

	FOR_ALL_CLIENTS(new_cs) {

   264

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

   265

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

   266

	}

   267

	// Also send the info of the server

   268

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

   269

}

   270

   271

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   272

{

   273

	//

   274

	// Packet: PACKET_SERVER_WAIT

   275

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

   276

	//             someone else is already receiving the map

   277

	// Data:

   278

	//    uint8:  Clients awaiting map

   279

	//

   280

	int waiting = 0;

   281

	NetworkTCPSocketHandler *new_cs;

   282

	Packet *p;

   283

   284

	// Count how many players are waiting in the queue

   285

	FOR_ALL_CLIENTS(new_cs) {

   286

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

   287

	}

   288

   289

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   290

	p->Send_uint8(waiting);

   291

	cs->Send_Packet(p);

   292

}

   293

   294

// This sends the map to the client

   295

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   296

{

   297

	//

   298

	// Packet: SERVER_MAP

   299

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

   300

	//   a lot of multiple packets)

   301

	// Data:

   302

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

   303

	//  if MAP_PACKET_START:

   304

	//    uint32: The current FrameCounter

   305

	//  if MAP_PACKET_NORMAL:

   306

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

   307

	//  if MAP_PACKET_END:

   308

	//    uint32: seed0 of player

   309

	//    uint32: seed1 of player

   310

	//      last 2 are repeated MAX_PLAYERS time

   311

	//

   312

   313

	static FILE *file_pointer;

   314

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

   315

   316

	if (cs->status < STATUS_AUTH) {

   317

		// Illegal call, return error and ignore the packet

   318

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   319

		return;

   320

	}

   321

   322

	if (cs->status == STATUS_AUTH) {

   323

		const char *filename = "network_server.tmp";

   324

		Packet *p;

   325

   326

		// Make a dump of the current game

   327

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

   328

   329

		file_pointer = FioFOpenFile(filename, "rb", AUTOSAVE_DIR);

   330

		fseek(file_pointer, 0, SEEK_END);

   331

   332

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

   333

   334

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

   335

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   336

		p->Send_uint8 (MAP_PACKET_START);

   337

		p->Send_uint32(_frame_counter);

   338

		p->Send_uint32(ftell(file_pointer));

   339

		cs->Send_Packet(p);

   340

   341

		fseek(file_pointer, 0, SEEK_SET);

   342

   343

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

   344

   345

		cs->status = STATUS_MAP;

   346

		/* Mark the start of download */

   347

		cs->last_frame = _frame_counter;

   348

		cs->last_frame_server = _frame_counter;

   349

	}

   350

   351

	if (cs->status == STATUS_MAP) {

   352

		uint i;

   353

		int res;

   354

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

   355

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   356

			p->Send_uint8(MAP_PACKET_NORMAL);

   357

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

   358

   359

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

   360

   361

			p->size += res;

   362

			cs->Send_Packet(p);

   363

			if (feof(file_pointer)) {

   364

				// Done reading!

   365

				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   366

				p->Send_uint8(MAP_PACKET_END);

   367

				cs->Send_Packet(p);

   368

   369

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

   370

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

   371

				cs->status = STATUS_DONE_MAP;

   372

				fclose(file_pointer);

   373

   374

				{

   375

					NetworkTCPSocketHandler *new_cs;

   376

					bool new_map_client = false;

   377

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

   378

					//  and start sending him the map

   379

					FOR_ALL_CLIENTS(new_cs) {

   380

						if (new_cs->status == STATUS_MAP_WAIT) {

   381

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

   382

							if (!new_map_client) {

   383

								// If not, this client will get the map

   384

								new_cs->status = STATUS_AUTH;

   385

								new_map_client = true;

   386

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   387

							} else {

   388

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

   389

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   390

							}

   391

						}

   392

					}

   393

				}

   394

   395

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

   396

				break;

   397

			}

   398

		}

   399

   400

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

   401

		cs->Send_Packets();

   402

		if (cs->IsPacketQueueEmpty()) {

   403

			// All are sent, increase the sent_packets

   404

			sent_packets *= 2;

   405

		} else {

   406

			// Not everything is sent, decrease the sent_packets

   407

			if (sent_packets > 1) sent_packets /= 2;

   408

		}

   409

	}

   410

}

   411

   412

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

   413

{

   414

	//

   415

	// Packet: SERVER_JOIN

   416

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

   417

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   418

	//     PACKET_SERVER_CLIENT_INFO

   419

	// Data:

   420

	//    uint16:  Client-Index

   421

	//

   422

   423

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   424

   425

	p->Send_uint16(client_index);

   426

   427

	cs->Send_Packet(p);

   428

}

   429

   430

   431

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   432

{

   433

	//

   434

	// Packet: SERVER_FRAME

   435

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

   436

	// Data:

   437

	//    uint32: Frame Counter

   438

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

   439

	//    [uint32: general-seed-1]

   440

	//    [uint32: general-seed-2]

   441

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

   442

	//

   443

   444

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   445

	p->Send_uint32(_frame_counter);

   446

	p->Send_uint32(_frame_counter_max);

   447

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   448

	p->Send_uint32(_sync_seed_1);

   449

#ifdef NETWORK_SEND_DOUBLE_SEED

   450

	p->Send_uint32(_sync_seed_2);

   451

#endif

   452

#endif

   453

	cs->Send_Packet(p);

   454

}

   455

   456

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   457

{

   458

	//

   459

	// Packet: SERVER_SYNC

   460

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

   461

	// Data:

   462

	//    uint32: Frame Counter

   463

	//    uint32: General-seed-1

   464

	//    [uint32: general-seed-2]

   465

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

   466

	//

   467

   468

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   469

	p->Send_uint32(_frame_counter);

   470

	p->Send_uint32(_sync_seed_1);

   471

   472

#ifdef NETWORK_SEND_DOUBLE_SEED

   473

	p->Send_uint32(_sync_seed_2);

   474

#endif

   475

	cs->Send_Packet(p);

   476

}

   477

   478

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

   479

{

   480

	//

   481

	// Packet: SERVER_COMMAND

   482

	// Function: Sends a DoCommand to the client

   483

	// Data:

   484

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

   485

	//    uint32: CommandID (see command.h)

   486

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

   487

	//    uint32: P2

   488

	//    uint32: Tile

   489

	//    string: text

   490

	//    uint8:  CallBackID (see callback_table.c)

   491

	//    uint32: Frame of execution

   492

	//

   493

   494

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   495

   496

	p->Send_uint8 (cp->player);

   497

	p->Send_uint32(cp->cmd);

   498

	p->Send_uint32(cp->p1);

   499

	p->Send_uint32(cp->p2);

   500

	p->Send_uint32(cp->tile);

   501

	p->Send_string(cp->text);

   502

	p->Send_uint8 (cp->callback);

   503

	p->Send_uint32(cp->frame);

   504

	p->Send_bool  (cp->my_cmd);