1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "debug.h"

     5

#include "string.h"

     6

#include "strings.h"

     7

#include "network_data.h"

     8

#include "train.h"

     9

    10

#ifdef ENABLE_NETWORK

    11

    12

#include "table/strings.h"

    13

#include "functions.h"

    14

#include "network_server.h"

    15

#include "network_udp.h"

    16

#include "console.h"

    17

#include "command.h"

    18

#include "gfx.h"

    19

#include "saveload.h"

    20

#include "vehicle.h"

    21

#include "station.h"

    22

#include "settings.h"

    23

#include "variables.h"

    24

    25

// This file handles all the server-commands

    26

    27

static void NetworkHandleCommandQueue(NetworkClientState* cs);

    28

static void NetworkSendPatchSettings(NetworkClientState* cs);

    29

    30

void NetworkPopulateCompanyInfo(void);

    31

    32

// Is the network enabled?

    33

    34

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

    35

// Sending functions

    36

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

    37

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

    38

    39

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

    40

{

    41

	//

    42

	// Packet: SERVER_CLIENT_INFO

    43

	// Function: Sends info about a client

    44

	// Data:

    45

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

    46

	//    uint8:  As which player the client is playing

    47

	//    String: The name of the client

    48

	//    String: The unique id of the client

    49

	//

    50

    51

	Packet *p;

    52

    53

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    54

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    55

		NetworkSend_uint16(p, ci->client_index);

    56

		NetworkSend_uint8 (p, ci->client_playas);

    57

		NetworkSend_string(p, ci->client_name);

    58

		NetworkSend_string(p, ci->unique_id);

    59

    60

		NetworkSend_Packet(p, cs);

    61

	}

    62

}

    63

    64

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    65

{

    66

//

    67

	// Packet: SERVER_COMPANY_INFO

    68

	// Function: Sends info about the companies

    69

	// Data:

    70

	//

    71

    72

	int i;

    73

    74

	Player *player;

    75

	Packet *p;

    76

    77

	byte active = 0;

    78

    79

	FOR_ALL_PLAYERS(player) {

    80

		if (player->is_active)

    81

			active++;

    82

	}

    83

    84

	if (active == 0) {

    85

		Packet *p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    86

    87

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    88

		NetworkSend_uint8 (p, active);

    89

    90

		NetworkSend_Packet(p, cs);

    91

		return;

    92

	}

    93

    94

	NetworkPopulateCompanyInfo();

    95

    96

	FOR_ALL_PLAYERS(player) {

    97

		if (!player->is_active)

    98

			continue;

    99

   100

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   101

   102

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   103

		NetworkSend_uint8 (p, active);

   104

		NetworkSend_uint8 (p, player->index);

   105

   106

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

   107

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

   108

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

   109

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

   110

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

   111

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

   112

   113

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

   114

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

   115

			NetworkSend_uint8 (p, 1);

   116

		} else {

   117

			NetworkSend_uint8 (p, 0);

   118

		}

   119

   120

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

   121

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

   122

   123

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

   124

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

   125

   126

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

   127

			NetworkSend_string(p, "<none>");

   128

		else

   129

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

   130

   131

		NetworkSend_Packet(p, cs);

   132

	}

   133

   134

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   135

   136

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   137

	NetworkSend_uint8 (p, 0);

   138

   139

	NetworkSend_Packet(p, cs);

   140

}

   141

   142

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

   143

{

   144

	//

   145

	// Packet: SERVER_ERROR

   146

	// Function: The client made an error

   147

	// Data:

   148

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

   149

	//

   150

   151

	NetworkClientState *new_cs;

   152

	char str[100];

   153

	char client_name[NETWORK_CLIENT_NAME_LENGTH];

   154

   155

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   156

	NetworkSend_uint8(p, error);

   157

	NetworkSend_Packet(p, cs);

   158

   159

	GetString(str, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   160

   161

	// Only send when the current client was in game

   162

	if (cs->status > STATUS_AUTH) {

   163

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

   164

   165

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

   166

   167

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

   168

   169

		FOR_ALL_CLIENTS(new_cs) {

   170

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

   171

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

   172

				//  reason a joining failed.

   173

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

   174

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   175

   176

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

   177

			}

   178

		}

   179

	} else {

   180

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

   181

	}

   182

   183

	cs->quited = true;

   184

   185

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

   186

	NetworkSend_Packets(cs);

   187

   188

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

   189

	NetworkCloseClient(cs);

   190

}

   191

   192

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

   193

{

   194

	//

   195

	// Packet: SERVER_NEED_PASSWORD

   196

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

   197

	// Data:

   198

	//    uint8:  Type of password

   199

	//

   200

   201

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   202

	NetworkSend_uint8(p, type);

   203

	NetworkSend_Packet(p, cs);

   204

}

   205

   206

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   207

{

   208

	//

   209

	// Packet: SERVER_WELCOME

   210

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

   211

	// Data:

   212

	//    uint16:  Own ClientID

   213

	//

   214

   215

	Packet *p;

   216

	const NetworkClientState *new_cs;

   217

	const NetworkClientInfo *ci = DEREF_CLIENT_INFO(cs);

   218

   219

	// Invalid packet when status is AUTH or higher

   220

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

   221

   222

	cs->status = STATUS_AUTH;

   223

	_network_game_info.clients_on++;

   224

	/* increment spectator; defer company addition for when player is actually created */

   225

	if (ci->client_playas == OWNER_SPECTATOR) _network_game_info.spectators_on++;

   226

   227

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   228

	NetworkSend_uint16(p, cs->index);

   229

	NetworkSend_Packet(p, cs);

   230

   231

		// Transmit info about all the active clients

   232

	FOR_ALL_CLIENTS(new_cs) {

   233

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

   234

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

   235

	}

   236

	// Also send the info of the server

   237

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

   238

}

   239

   240

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   241

{

   242

	//

   243

	// Packet: PACKET_SERVER_WAIT

   244

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

   245

	//             someone else is already receiving the map

   246

	// Data:

   247

	//    uint8:  Clients awaiting map

   248

	//

   249

	int waiting = 0;

   250

	NetworkClientState *new_cs;

   251

	Packet *p;

   252

   253

	// Count how many players are waiting in the queue

   254

	FOR_ALL_CLIENTS(new_cs) {

   255

		if (new_cs->status == STATUS_MAP_WAIT)

   256

			waiting++;

   257

	}

   258

   259

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   260

	NetworkSend_uint8(p, waiting);

   261

	NetworkSend_Packet(p, cs);

   262

}

   263

   264

// This sends the map to the client

   265

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   266

{

   267

	//

   268

	// Packet: SERVER_MAP

   269

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

   270

	//   a lot of multiple packets)

   271

	// Data:

   272

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

   273

	//  if MAP_PACKET_START:

   274

	//    uint32: The current FrameCounter

   275

	//  if MAP_PACKET_NORMAL:

   276

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

   277

	//  if MAP_PACKET_END:

   278

	//    uint32: seed0 of player

   279

	//    uint32: seed1 of player

   280

	//      last 2 are repeated MAX_PLAYERS time

   281

	//

   282

   283

	char filename[256];

   284

	static FILE *file_pointer;

   285

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

   286

   287

	if (cs->status < STATUS_AUTH) {

   288

		// Illegal call, return error and ignore the packet

   289

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   290

		return;

   291

	}

   292

	if (cs->status == STATUS_AUTH) {

   293

		Packet *p;

   294

   295

		// Make a dump of the current game

   296

		sprintf(filename, "%s%snetwork_server.tmp",  _path.autosave_dir, PATHSEP);

   297

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

   298

   299

		file_pointer = fopen(filename, "rb");

   300

		fseek(file_pointer, 0, SEEK_END);

   301

   302

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

   303

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   304

		NetworkSend_uint8(p, MAP_PACKET_START);

   305

		NetworkSend_uint32(p, _frame_counter);

   306

		NetworkSend_uint32(p, ftell(file_pointer));

   307

		NetworkSend_Packet(p, cs);

   308

   309

		fseek(file_pointer, 0, SEEK_SET);

   310

   311

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

   312

   313

		cs->status = STATUS_MAP;

   314

		/* Mark the start of download */

   315

		cs->last_frame = _frame_counter;

   316

		cs->last_frame_server = _frame_counter;

   317

	}

   318

   319

	if (cs->status == STATUS_MAP) {

   320

		uint i;

   321

		int res;

   322

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

   323

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   324

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   325

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

   326

			if (ferror(file_pointer)) {

   327

				error("Error reading temporary network savegame!");

   328

			}

   329

			p->size += res;

   330

			NetworkSend_Packet(p, cs);

   331

			if (feof(file_pointer)) {

   332

				// Done reading!

   333

				Packet *p;

   334

   335

				// XXX - Delete this when patch-settings are saved in-game

   336

				NetworkSendPatchSettings(cs);

   337

   338

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   339

				NetworkSend_uint8(p, MAP_PACKET_END);

   340

				NetworkSend_Packet(p, cs);

   341

   342

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

   343

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

   344

				cs->status = STATUS_DONE_MAP;

   345

				fclose(file_pointer);

   346

   347

				{

   348

					NetworkClientState *new_cs;

   349

					bool new_map_client = false;

   350

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

   351

					//  and start sending him the map

   352

					FOR_ALL_CLIENTS(new_cs) {

   353

						if (new_cs->status == STATUS_MAP_WAIT) {

   354

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

   355

							if (!new_map_client) {

   356

								// If not, this client will get the map

   357

								new_cs->status = STATUS_AUTH;

   358

								new_map_client = true;

   359

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   360

							} else {

   361

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

   362

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   363

							}

   364

						}

   365

					}

   366

				}

   367

   368

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

   369

				break;

   370

			}

   371

		}

   372

   373

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

   374

		NetworkSend_Packets(cs);

   375

		if (cs->packet_queue == NULL) {

   376

			// All are sent, increase the sent_packets

   377

			sent_packets *= 2;

   378

		} else {

   379

			// Not everything is sent, decrease the sent_packets

   380

			if (sent_packets > 1) sent_packets /= 2;

   381

		}

   382

	}

   383

}

   384

   385

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

   386

{

   387

	//

   388

	// Packet: SERVER_JOIN

   389

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

   390

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   391

	//     PACKET_SERVER_CLIENT_INFO

   392

	// Data:

   393

	//    uint16:  Client-Index

   394

	//

   395

   396

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   397

   398

	NetworkSend_uint16(p, client_index);

   399

   400

	NetworkSend_Packet(p, cs);

   401

}

   402

   403

   404

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   405

{

   406

	//

   407

	// Packet: SERVER_FRAME

   408

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

   409

	// Data:

   410

	//    uint32: Frame Counter

   411

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

   412

	//    [uint32: general-seed-1]

   413

	//    [uint32: general-seed-2]

   414

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

   415

	//

   416

   417

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   418

	NetworkSend_uint32(p, _frame_counter);

   419

	NetworkSend_uint32(p, _frame_counter_max);

   420

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   421

	NetworkSend_uint32(p, _sync_seed_1);

   422

#ifdef NETWORK_SEND_DOUBLE_SEED

   423

	NetworkSend_uint32(p, _sync_seed_2);

   424

#endif

   425

#endif

   426

	NetworkSend_Packet(p, cs);

   427

}

   428

   429

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   430

{

   431

	//

   432

	// Packet: SERVER_SYNC

   433

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

   434

	// Data:

   435

	//    uint32: Frame Counter

   436

	//    uint32: General-seed-1

   437

	//    [uint32: general-seed-2]

   438

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

   439

	//

   440

   441

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   442

	NetworkSend_uint32(p, _frame_counter);

   443

	NetworkSend_uint32(p, _sync_seed_1);

   444

   445

#ifdef NETWORK_SEND_DOUBLE_SEED

   446

	NetworkSend_uint32(p, _sync_seed_2);

   447

#endif

   448

	NetworkSend_Packet(p, cs);

   449

}

   450

   451

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

   452

{

   453

	//

   454

	// Packet: SERVER_COMMAND

   455

	// Function: Sends a DoCommand to the client

   456

	// Data:

   457

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

   458

	//    uint32: CommandID (see command.h)

   459

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

   460

	//    uint32: P2

   461

	//    uint32: Tile

   462

	//    string: text

   463

	//    uint8:  CallBackID (see callback_table.c)

   464

	//    uint32: Frame of execution

   465

	//

   466

   467

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   468

   469

	NetworkSend_uint8(p, cp->player);

   470

	NetworkSend_uint32(p, cp->cmd);

   471

	NetworkSend_uint32(p, cp->p1);

   472

	NetworkSend_uint32(p, cp->p2);

   473

	NetworkSend_uint32(p, cp->tile);

   474

	NetworkSend_string(p, cp->text);

   475

	NetworkSend_uint8(p, cp->callback);

   476

	NetworkSend_uint32(p, cp->frame);

   477

   478

	NetworkSend_Packet(p, cs);

   479

}

   480

   481

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

   482

{

   483

	//

   484

	// Packet: SERVER_CHAT

   485

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

   486

	// Data:

   487

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

   488

	//    uint16:  Client-index

   489

	//    String: Message (max MAX_TEXT_MSG_LEN)

   490

	//

   491

   492

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   493

   494

	NetworkSend_uint8(p, action);

   495

	NetworkSend_uint16(p, client_index);

   496

	NetworkSend_uint8(p, self_send);

   497

	NetworkSend_string(p, msg);

   498

   499

	NetworkSend_Packet(p, cs);

   500

}

   501

   502

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_ERROR_QUIT)(NetworkClientState *cs, uint16 client_index, NetworkErrorCode errorno)

   503

{

   504

	//

   505

	// Packet: SERVER_ERROR_QUIT

   506

	// Function: One of the clients made an error and is quiting the game

   507

	//      This packet informs the other clients of that.

   508

	// Data:

   509

	//    uint16:  Client-index

   510

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

   511

	//

   512

   513

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

   514

   515

	NetworkSend_uint16(p, client_index);

   516

	NetworkSend_uint8(p, errorno);

   517

   518

	NetworkSend_Packet(p, cs);

   519

}

   520