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 "train.h"

    12

#include "date.h"

    13

#include "table/strings.h"

    14

#include "functions.h"

    15

#include "network_server.h"

    16

#include "network_udp.h"

    17

#include "console.h"

    18

#include "command.h"

    19

#include "saveload.h"

    20

#include "vehicle.h"

    21

#include "station.h"

    22

#include "variables.h"

    23

#include "genworld.h"

    24

    25

// This file handles all the server-commands

    26

    27

static void NetworkHandleCommandQueue(NetworkClientState* cs);

    28

    29

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

    30

// Sending functions

    31

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

    32

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

    33

    34

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

    35

{

    36

	//

    37

	// Packet: SERVER_CLIENT_INFO

    38

	// Function: Sends info about a client

    39

	// Data:

    40

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

    41

	//    uint8:  As which player the client is playing

    42

	//    String: The name of the client

    43

	//    String: The unique id of the client

    44

	//

    45

    46

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    47

		Packet *p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    48

		NetworkSend_uint16(p, ci->client_index);

    49

		NetworkSend_uint8 (p, ci->client_playas);

    50

		NetworkSend_string(p, ci->client_name);

    51

		NetworkSend_string(p, ci->unique_id);

    52

    53

		NetworkSend_Packet(p, cs);

    54

	}

    55

}

    56

    57

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    58

{

    59

//

    60

	// Packet: SERVER_COMPANY_INFO

    61

	// Function: Sends info about the companies

    62

	// Data:

    63

	//

    64

    65

	int i;

    66

    67

	Player *player;

    68

	Packet *p;

    69

    70

	byte active = ActivePlayerCount();

    71

    72

	if (active == 0) {

    73

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    74

    75

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    76

		NetworkSend_uint8 (p, active);

    77

    78

		NetworkSend_Packet(p, cs);

    79

		return;

    80

	}

    81

    82

	NetworkPopulateCompanyInfo();

    83

    84

	FOR_ALL_PLAYERS(player) {

    85

		if (!player->is_active) continue;

    86

    87

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    88

    89

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    90

		NetworkSend_uint8 (p, active);

    91

		NetworkSend_uint8 (p, player->index);

    92

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

   100

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

   101

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

   102

			NetworkSend_uint8(p, 1);

   103

		} else {

   104

			NetworkSend_uint8(p, 0);

   105

		}

   106

   107

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

   108

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

   109

		}

   110

   111

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

   112

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

   113

		}

   114

   115

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

   116

			NetworkSend_string(p, "<none>");

   117

		} else {

   118

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

   119

		}

   120

   121

		NetworkSend_Packet(p, cs);

   122

	}

   123

   124

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   125

   126

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   127

	NetworkSend_uint8 (p, 0);

   128

   129

	NetworkSend_Packet(p, cs);

   130

}

   131

   132

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

   133

{

   134

	//

   135

	// Packet: SERVER_ERROR

   136

	// Function: The client made an error

   137

	// Data:

   138

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

   139

	//

   140

   141

	char str[100];

   142

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   143

   144

	NetworkSend_uint8(p, error);

   145

	NetworkSend_Packet(p, cs);

   146

   147

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

   148

   149

	// Only send when the current client was in game

   150

	if (cs->status > STATUS_AUTH) {

   151

		NetworkClientState *new_cs;

   152

		char client_name[NETWORK_CLIENT_NAME_LENGTH];

   153

   154

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

   155

   156

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

   157

   158

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

   159

   160

		FOR_ALL_CLIENTS(new_cs) {

   161

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

   162

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

   163

				//  reason a joining failed.

   164

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

   165

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   166

   167

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

   168

			}

   169

		}

   170

	} else {

   171

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

   172

	}

   173

   174

	cs->has_quit = true;

   175

   176

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

   177

	NetworkSend_Packets(cs);

   178

   179

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

   180

	NetworkCloseClient(cs);

   181

}

   182

   183

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHECK_NEWGRFS)(NetworkClientState *cs)

   184

{

   185

	//

   186

	// Packet: PACKET_SERVER_CHECK_NEWGRFS

   187

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

   188

	// Data:

   189

	//      uint8:  Amount of GRFs

   190

	//    And then for each GRF:

   191

	//      uint32: GRF ID

   192

	// 16 * uint8:  MD5 checksum of the GRF

   193

	//

   194

   195

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHECK_NEWGRFS);

   196

	const GRFConfig *c;

   197

	uint grf_count = 0;

   198

   199

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

   200

   201

	NetworkSend_uint8 (p, grf_count);

   202

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

   203

		NetworkSend_GRFIdentifier(p, c);

   204

	}

   205

   206

	NetworkSend_Packet(p, cs);

   207

}

   208

   209

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

   210

{

   211

	//

   212

	// Packet: SERVER_NEED_PASSWORD

   213

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

   214

	// Data:

   215

	//    uint8:  Type of password

   216

	//

   217

   218

	Packet *p;

   219

   220

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

   221

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

   222

   223

	cs->status = STATUS_AUTHORIZING;

   224

   225

	p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   226

	NetworkSend_uint8(p, type);

   227

	NetworkSend_Packet(p, cs);

   228

}

   229

   230

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   231

{

   232

	//

   233

	// Packet: SERVER_WELCOME

   234

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

   235

	// Data:

   236

	//    uint16:  Own ClientID

   237

	//

   238

   239

	Packet *p;

   240

	const NetworkClientState *new_cs;

   241

   242

	// Invalid packet when status is AUTH or higher

   243

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

   244

   245

	cs->status = STATUS_AUTH;

   246

	_network_game_info.clients_on++;

   247

   248

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   249

	NetworkSend_uint16(p, cs->index);

   250

	NetworkSend_Packet(p, cs);

   251

   252

		// Transmit info about all the active clients

   253

	FOR_ALL_CLIENTS(new_cs) {

   254

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

   255

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

   256

	}

   257

	// Also send the info of the server

   258

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

   259

}

   260

   261

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   262

{

   263

	//

   264

	// Packet: PACKET_SERVER_WAIT

   265

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

   266

	//             someone else is already receiving the map

   267

	// Data:

   268

	//    uint8:  Clients awaiting map

   269

	//

   270

	int waiting = 0;

   271

	NetworkClientState *new_cs;

   272

	Packet *p;

   273

   274

	// Count how many players are waiting in the queue

   275

	FOR_ALL_CLIENTS(new_cs) {

   276

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

   277

	}

   278

   279

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   280

	NetworkSend_uint8(p, waiting);

   281

	NetworkSend_Packet(p, cs);

   282

}

   283

   284

// This sends the map to the client

   285

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   286

{

   287

	//

   288

	// Packet: SERVER_MAP

   289

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

   290

	//   a lot of multiple packets)

   291

	// Data:

   292

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

   293

	//  if MAP_PACKET_START:

   294

	//    uint32: The current FrameCounter

   295

	//  if MAP_PACKET_NORMAL:

   296

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

   297

	//  if MAP_PACKET_END:

   298

	//    uint32: seed0 of player

   299

	//    uint32: seed1 of player

   300

	//      last 2 are repeated MAX_PLAYERS time

   301

	//

   302

   303

	static FILE *file_pointer;

   304

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

   305

   306

	if (cs->status < STATUS_AUTH) {

   307

		// Illegal call, return error and ignore the packet

   308

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   309

		return;

   310

	}

   311

   312

	if (cs->status == STATUS_AUTH) {

   313

		char filename[256];

   314

		Packet *p;

   315

   316

		// Make a dump of the current game

   317

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

   318

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

   319

   320

		file_pointer = fopen(filename, "rb");

   321

		fseek(file_pointer, 0, SEEK_END);

   322

   323

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

   324

   325

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

   326

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   327

		NetworkSend_uint8(p, MAP_PACKET_START);

   328

		NetworkSend_uint32(p, _frame_counter);

   329

		NetworkSend_uint32(p, ftell(file_pointer));

   330

		NetworkSend_Packet(p, cs);

   331

   332

		fseek(file_pointer, 0, SEEK_SET);

   333

   334

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

   335

   336

		cs->status = STATUS_MAP;

   337

		/* Mark the start of download */

   338

		cs->last_frame = _frame_counter;

   339

		cs->last_frame_server = _frame_counter;

   340

	}

   341

   342

	if (cs->status == STATUS_MAP) {

   343

		uint i;

   344

		int res;

   345

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

   346

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   347

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   348

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

   349

   350

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

   351

   352

			p->size += res;

   353

			NetworkSend_Packet(p, cs);

   354

			if (feof(file_pointer)) {

   355

				// Done reading!

   356

				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   357

				NetworkSend_uint8(p, MAP_PACKET_END);

   358

				NetworkSend_Packet(p, cs);

   359

   360

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

   361

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

   362

				cs->status = STATUS_DONE_MAP;

   363

				fclose(file_pointer);

   364

   365

				{

   366

					NetworkClientState *new_cs;

   367

					bool new_map_client = false;

   368

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

   369

					//  and start sending him the map

   370

					FOR_ALL_CLIENTS(new_cs) {

   371

						if (new_cs->status == STATUS_MAP_WAIT) {

   372

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

   373

							if (!new_map_client) {

   374

								// If not, this client will get the map

   375

								new_cs->status = STATUS_AUTH;

   376

								new_map_client = true;

   377

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   378

							} else {

   379

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

   380

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   381

							}

   382

						}

   383

					}

   384

				}

   385

   386

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

   387

				break;

   388

			}

   389

		}

   390

   391

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

   392

		NetworkSend_Packets(cs);

   393

		if (cs->packet_queue == NULL) {

   394

			// All are sent, increase the sent_packets

   395

			sent_packets *= 2;

   396

		} else {

   397

			// Not everything is sent, decrease the sent_packets

   398

			if (sent_packets > 1) sent_packets /= 2;

   399

		}

   400

	}

   401

}

   402

   403

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

   404

{

   405

	//

   406

	// Packet: SERVER_JOIN

   407

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

   408

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   409

	//     PACKET_SERVER_CLIENT_INFO

   410

	// Data:

   411

	//    uint16:  Client-Index

   412

	//

   413

   414

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   415

   416

	NetworkSend_uint16(p, client_index);

   417

   418

	NetworkSend_Packet(p, cs);

   419

}

   420

   421

   422

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   423

{

   424

	//

   425

	// Packet: SERVER_FRAME

   426

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

   427

	// Data:

   428

	//    uint32: Frame Counter

   429

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

   430

	//    [uint32: general-seed-1]

   431

	//    [uint32: general-seed-2]

   432

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

   433

	//

   434

   435

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   436

	NetworkSend_uint32(p, _frame_counter);

   437

	NetworkSend_uint32(p, _frame_counter_max);

   438

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   439

	NetworkSend_uint32(p, _sync_seed_1);

   440

#ifdef NETWORK_SEND_DOUBLE_SEED

   441

	NetworkSend_uint32(p, _sync_seed_2);

   442

#endif

   443

#endif

   444

	NetworkSend_Packet(p, cs);

   445

}

   446

   447

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   448

{

   449

	//

   450

	// Packet: SERVER_SYNC

   451

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

   452

	// Data:

   453

	//    uint32: Frame Counter

   454

	//    uint32: General-seed-1

   455

	//    [uint32: general-seed-2]

   456

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

   457

	//

   458

   459

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   460

	NetworkSend_uint32(p, _frame_counter);

   461

	NetworkSend_uint32(p, _sync_seed_1);

   462

   463

#ifdef NETWORK_SEND_DOUBLE_SEED

   464

	NetworkSend_uint32(p, _sync_seed_2);

   465

#endif

   466

	NetworkSend_Packet(p, cs);

   467

}

   468

   469

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

   470

{

   471

	//

   472

	// Packet: SERVER_COMMAND

   473

	// Function: Sends a DoCommand to the client

   474

	// Data:

   475

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

   476

	//    uint32: CommandID (see command.h)

   477

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

   478

	//    uint32: P2

   479

	//    uint32: Tile

   480

	//    string: text

   481

	//    uint8:  CallBackID (see callback_table.c)

   482

	//    uint32: Frame of execution

   483

	//

   484

   485

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   486

   487

	NetworkSend_uint8(p, cp->player);

   488

	NetworkSend_uint32(p, cp->cmd);

   489

	NetworkSend_uint32(p, cp->p1);

   490

	NetworkSend_uint32(p, cp->p2);

   491

	NetworkSend_uint32(p, cp->tile);

   492

	NetworkSend_string(p, cp->text);

   493

	NetworkSend_uint8(p, cp->callback);

   494

	NetworkSend_uint32(p, cp->frame);

   495

   496

	NetworkSend_Packet(p, cs);

   497

}

   498

   499

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

   500

{

   501

	//

   502

	// Packet: SERVER_CHAT

   503

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

   504

	// Data:

   505

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

   506

	//    uint16:  Client-index

   507

	//    String: Message (max MAX_TEXT_MSG_LEN)

   508

	//

   509

   510

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   511

   512

	NetworkSend_uint8(p, action);

   513

	NetworkSend_uint16(p, client_index);