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

     9

#ifdef ENABLE_NETWORK

    10

    11

#include "table/strings.h"

    12

#include "functions.h"

    13

#include "network_server.h"

    14

#include "network_udp.h"

    15

#include "console.h"

    16

#include "command.h"

    17

#include "gfx.h"

    18

#include "saveload.h"

    19

#include "vehicle.h"

    20

#include "station.h"

    21

#include "settings.h"

    22

#include "variables.h"

    23

    24

// This file handles all the server-commands

    25

    26

void NetworkHandleCommandQueue(NetworkClientState *cs);

    27

void NetworkPopulateCompanyInfo(void);

    28

void NetworkSendPatchSettings(NetworkClientState *cs);

    29

    30

// Is the network enabled?

    31

    32

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

    33

// Sending functions

    34

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

    35

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

    36

    37

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CLIENT_INFO)(NetworkClientState *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

	Packet *p;

    50

    51

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    52

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    53

		NetworkSend_uint16(p, ci->client_index);

    54

		NetworkSend_uint8 (p, ci->client_playas);

    55

		NetworkSend_string(p, ci->client_name);

    56

		NetworkSend_string(p, ci->unique_id);

    57

    58

		NetworkSend_Packet(p, cs);

    59

	}

    60

}

    61

    62

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    63

{

    64

//

    65

	// Packet: SERVER_COMPANY_INFO

    66

	// Function: Sends info about the companies

    67

	// Data:

    68

	//

    69

    70

	int i;

    71

    72

	Player *player;

    73

	Packet *p;

    74

    75

	byte active = 0;

    76

    77

	FOR_ALL_PLAYERS(player) {

    78

		if (player->is_active)

    79

			active++;

    80

	}

    81

    82

	if (active == 0) {

    83

		Packet *p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    84

    85

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    86

		NetworkSend_uint8 (p, active);

    87

    88

		NetworkSend_Packet(p, cs);

    89

		return;

    90

	}

    91

    92

	NetworkPopulateCompanyInfo();

    93

    94

	FOR_ALL_PLAYERS(player) {

    95

		if (!player->is_active)

    96

			continue;

    97

    98

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    99

   100

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   101

		NetworkSend_uint8 (p, active);

   102

		NetworkSend_uint8 (p, player->index);

   103

   104

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

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

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

   112

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

   113

			NetworkSend_uint8 (p, 1);

   114

		} else {

   115

			NetworkSend_uint8 (p, 0);

   116

		}

   117

   118

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

   119

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

   120

   121

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

   122

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

   123

   124

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

   125

			NetworkSend_string(p, "<none>");

   126

		else

   127

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

   128

   129

		NetworkSend_Packet(p, cs);

   130

	}

   131

   132

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   133

   134

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   135

	NetworkSend_uint8 (p, 0);

   136

   137

	NetworkSend_Packet(p, cs);

   138

}

   139

   140

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

   141

{

   142

	//

   143

	// Packet: SERVER_ERROR

   144

	// Function: The client made an error

   145

	// Data:

   146

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

   147

	//

   148

   149

	NetworkClientState *new_cs;

   150

	char str[100];

   151

	char client_name[NETWORK_CLIENT_NAME_LENGTH];

   152

   153

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   154

	NetworkSend_uint8(p, error);

   155

	NetworkSend_Packet(p, cs);

   156

   157

	// Only send when the current client was in game

   158

	if (cs->status > STATUS_AUTH) {

   159

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

   160

   161

		GetString(str, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   162

   163

		DEBUG(net, 2)("[NET] %s made an error (%s) and his connection is closed", client_name, str);

   164

   165

		NetworkTextMessage(NETWORK_ACTION_LEAVE, 1, false, client_name, str);

   166

   167

		FOR_ALL_CLIENTS(new_cs) {

   168

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

   169

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

   170

				//  reason a joining failed.

   171

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

   172

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   173

   174

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

   175

			}

   176

		}

   177

	} else {

   178

		DEBUG(net, 2)("[NET] Clientno %d has made an error and his connection is closed", cs->index);

   179

	}

   180

   181

	cs->quited = true;

   182

   183

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

   184

	NetworkSend_Packets(cs);

   185

   186

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

   187

	NetworkCloseClient(cs);

   188

}

   189

   190

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

   191

{

   192

	//

   193

	// Packet: SERVER_NEED_PASSWORD

   194

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

   195

	// Data:

   196

	//    uint8:  Type of password

   197

	//

   198

   199

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   200

	NetworkSend_uint8(p, type);

   201

	NetworkSend_Packet(p, cs);

   202

}

   203

   204

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   205

{

   206

	//

   207

	// Packet: SERVER_WELCOME

   208

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

   209

	// Data:

   210

	//    uint16:  Own ClientID

   211

	//

   212

   213

	Packet *p;

   214

	NetworkClientState *new_cs;

   215

   216

	// Invalid packet when status is AUTH or higher

   217

	if (cs->status >= STATUS_AUTH)

   218

		return;

   219

   220

	cs->status = STATUS_AUTH;

   221

	_network_game_info.clients_on++;

   222

   223

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   224

	NetworkSend_uint16(p, cs->index);

   225

	NetworkSend_Packet(p, cs);

   226

   227

		// Transmit info about all the active clients

   228

	FOR_ALL_CLIENTS(new_cs) {

   229

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

   230

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

   231

	}

   232

	// Also send the info of the server

   233

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

   234

}

   235

   236

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   237

{

   238

	//

   239

	// Packet: PACKET_SERVER_WAIT

   240

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

   241

	//             someone else is already receiving the map

   242

	// Data:

   243

	//    uint8:  Clients awaiting map

   244

	//

   245

	int waiting = 0;

   246

	NetworkClientState *new_cs;

   247

	Packet *p;

   248

   249

	// Count how many players are waiting in the queue

   250

	FOR_ALL_CLIENTS(new_cs) {

   251

		if (new_cs->status == STATUS_MAP_WAIT)

   252

			waiting++;

   253

	}

   254

   255

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   256

	NetworkSend_uint8(p, waiting);

   257

	NetworkSend_Packet(p, cs);

   258

}

   259

   260

// This sends the map to the client

   261

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   262

{

   263

	//

   264

	// Packet: SERVER_MAP

   265

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

   266

	//   a lot of multiple packets)

   267

	// Data:

   268

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

   269

	//  if MAP_PACKET_START:

   270

	//    uint32: The current FrameCounter

   271

	//  if MAP_PACKET_NORMAL:

   272

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

   273

	//  if MAP_PACKET_END:

   274

	//    uint32: seed0 of player

   275

	//    uint32: seed1 of player

   276

	//      last 2 are repeated MAX_PLAYERS time

   277

	//

   278

   279

	char filename[256];

   280

	static FILE *file_pointer;

   281

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

   282

   283

	if (cs->status < STATUS_AUTH) {

   284

		// Illegal call, return error and ignore the packet

   285

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   286

		return;

   287

	}

   288

	if (cs->status == STATUS_AUTH) {

   289

		Packet *p;

   290

   291

		// Make a dump of the current game

   292

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

   293

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

   294

   295

		file_pointer = fopen(filename, "rb");

   296

		fseek(file_pointer, 0, SEEK_END);

   297

   298

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

   299

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   300

		NetworkSend_uint8(p, MAP_PACKET_START);

   301

		NetworkSend_uint32(p, _frame_counter);

   302

		NetworkSend_uint32(p, ftell(file_pointer));

   303

		NetworkSend_Packet(p, cs);

   304

   305

		fseek(file_pointer, 0, SEEK_SET);

   306

   307

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

   308

   309

		cs->status = STATUS_MAP;

   310

		/* Mark the start of download */

   311

		cs->last_frame = _frame_counter;

   312

		cs->last_frame_server = _frame_counter;

   313

	}

   314

   315

	if (cs->status == STATUS_MAP) {

   316

		uint i;

   317

		int res;

   318

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

   319

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   320

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   321

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

   322

			if (ferror(file_pointer)) {

   323

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

   324

			}

   325

			p->size += res;

   326

			NetworkSend_Packet(p, cs);

   327

			if (feof(file_pointer)) {

   328

				// Done reading!

   329

				Packet *p;

   330

   331

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

   332

				NetworkSendPatchSettings(cs);

   333

   334

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   335

				NetworkSend_uint8(p, MAP_PACKET_END);

   336

				NetworkSend_Packet(p, cs);

   337

   338

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

   339

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

   340

				cs->status = STATUS_DONE_MAP;

   341

				fclose(file_pointer);

   342

   343

				{

   344

					NetworkClientState *new_cs;

   345

					bool new_map_client = false;

   346

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

   347

					//  and start sending him the map

   348

					FOR_ALL_CLIENTS(new_cs) {

   349

						if (new_cs->status == STATUS_MAP_WAIT) {

   350

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

   351

							if (!new_map_client) {

   352

								// If not, this client will get the map

   353

								new_cs->status = STATUS_AUTH;

   354

								new_map_client = true;

   355

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   356

							} else {

   357

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

   358

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   359

							}

   360

						}

   361

					}

   362

				}

   363

   364

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

   365

				break;

   366

			}

   367

		}

   368

   369

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

   370

		NetworkSend_Packets(cs);

   371

		if (cs->packet_queue == NULL) {

   372

			// All are sent, increase the sent_packets

   373

			sent_packets *= 2;

   374

		} else {

   375

			// Not everything is sent, decrease the sent_packets

   376

			if (sent_packets > 1) sent_packets /= 2;

   377

		}

   378

	}

   379

}

   380

   381

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

   382

{

   383

	//

   384

	// Packet: SERVER_JOIN

   385

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

   386

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   387

	//     PACKET_SERVER_CLIENT_INFO

   388

	// Data:

   389

	//    uint16:  Client-Index

   390

	//

   391

   392

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   393

   394

	NetworkSend_uint16(p, client_index);

   395

   396

	NetworkSend_Packet(p, cs);

   397

}

   398

   399

   400

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   401

{

   402

	//

   403

	// Packet: SERVER_FRAME

   404

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

   405

	// Data:

   406

	//    uint32: Frame Counter

   407

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

   408

	//    [uint32: general-seed-1]

   409

	//    [uint32: general-seed-2]

   410

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

   411

	//

   412

   413

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   414

	NetworkSend_uint32(p, _frame_counter);

   415

	NetworkSend_uint32(p, _frame_counter_max);

   416

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   417

	NetworkSend_uint32(p, _sync_seed_1);

   418

#ifdef NETWORK_SEND_DOUBLE_SEED

   419

	NetworkSend_uint32(p, _sync_seed_2);

   420

#endif

   421

#endif

   422

	NetworkSend_Packet(p, cs);

   423

}

   424

   425

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   426

{

   427

	//

   428

	// Packet: SERVER_SYNC

   429

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

   430

	// Data:

   431

	//    uint32: Frame Counter

   432

	//    uint32: General-seed-1

   433

	//    [uint32: general-seed-2]

   434

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

   435

	//

   436

   437

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   438

	NetworkSend_uint32(p, _frame_counter);

   439

	NetworkSend_uint32(p, _sync_seed_1);

   440

   441

#ifdef NETWORK_SEND_DOUBLE_SEED

   442

	NetworkSend_uint32(p, _sync_seed_2);

   443

#endif

   444

	NetworkSend_Packet(p, cs);

   445

}

   446

   447

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

   448

{

   449

	//

   450

	// Packet: SERVER_COMMAND

   451

	// Function: Sends a DoCommand to the client

   452

	// Data:

   453

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

   454

	//    uint32: CommandID (see command.h)

   455

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

   456

	//    uint32: P2

   457

	//    uint32: Tile

   458

	//    string: text

   459

	//    uint8:  CallBackID (see callback_table.c)

   460

	//    uint32: Frame of execution

   461

	//

   462

   463

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   464

   465

	NetworkSend_uint8(p, cp->player);

   466

	NetworkSend_uint32(p, cp->cmd);

   467

	NetworkSend_uint32(p, cp->p1);

   468

	NetworkSend_uint32(p, cp->p2);

   469

	NetworkSend_uint32(p, cp->tile);

   470

	NetworkSend_string(p, cp->text);

   471

	NetworkSend_uint8(p, cp->callback);

   472

	NetworkSend_uint32(p, cp->frame);

   473

   474

	NetworkSend_Packet(p, cs);

   475

}

   476

   477

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

   478

{

   479

	//

   480

	// Packet: SERVER_CHAT

   481

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

   482

	// Data:

   483

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

   484

	//    uint16:  Client-index

   485

	//    String: Message (max MAX_TEXT_MSG_LEN)

   486

	//

   487

   488

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   489

   490

	NetworkSend_uint8(p, action);

   491

	NetworkSend_uint16(p, client_index);

   492

	NetworkSend_uint8(p, self_send);

   493

	NetworkSend_string(p, msg);

   494

   495

	NetworkSend_Packet(p, cs);

   496

}

   497

   498

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

   499

{

   500

	//

   501

	// Packet: SERVER_ERROR_QUIT

   502

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

   503

	//      This packet informs the other clients of that.

   504

	// Data:

   505

	//    uint16:  Client-index

   506

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

   507

	//

   508

   509

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

   510

   511

	NetworkSend_uint16(p, client_index);

   512

	NetworkSend_uint8(p, errorno);

   513

   514

	NetworkSend_Packet(p, cs);

   515

}

   516

   517

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_QUIT)(NetworkClientState *cs, uint16 client_index, const char *leavemsg)

   518

{

   519

	//

   520

	// Packet: SERVER_ERROR_QUIT

   521

	// Function: A client left the game, and this packets informs the other clients