1

#include "stdafx.h"

     2

#include "network_data.h"

     3

     4

#ifdef ENABLE_NETWORK

     5

     6

#include "table/strings.h"

     7

#include "network_server.h"

     8

#include "console.h"

     9

#include "command.h"

    10

#include "gfx.h"

    11

#include "vehicle.h"

    12

#include "station.h"

    13

#include "settings.h"

    14

    15

// This file handles all the server-commands

    16

    17

void NetworkHandleCommandQueue(ClientState *cs);

    18

void NetworkPopulateCompanyInfo(void);

    19

void NetworkSendPatchSettings(ClientState *cs);

    20

    21

// Is the network enabled?

    22

    23

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

    24

// Sending functions

    25

//   DEF_SERVER_SEND_COMMAND has parameter: ClientState *cs

    26

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

    27

    28

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

    29

{

    30

	//

    31

	// Packet: SERVER_CLIENT_INFO

    32

	// Function: Sends info about a client

    33

	// Data:

    34

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

    35

	//    uint8:  As which player the client is playing

    36

	//    String: The name of the client

    37

	//    String: The unique id of the client

    38

	//

    39

    40

	Packet *p;

    41

    42

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    43

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    44

		NetworkSend_uint16(p, ci->client_index);

    45

		NetworkSend_uint8 (p, ci->client_playas);

    46

		NetworkSend_string(p, ci->client_name);

    47

		NetworkSend_string(p, ci->unique_id);

    48

    49

		NetworkSend_Packet(p, cs);

    50

	}

    51

}

    52

    53

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    54

{

    55

//

    56

	// Packet: SERVER_COMPANY_INFO

    57

	// Function: Sends info about the companies

    58

	// Data:

    59

	//

    60

    61

	int i;

    62

    63

	Player *player;

    64

	Packet *p;

    65

    66

	byte active = 0;

    67

	byte current = 0;

    68

    69

    70

	FOR_ALL_PLAYERS(player) {

    71

		if (player->is_active)

    72

			active++;

    73

	}

    74

    75

	if (active == 0) {

    76

		Packet *p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    77

    78

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    79

		NetworkSend_uint8 (p, active);

    80

    81

		NetworkSend_Packet(p, cs);

    82

		return;

    83

	}

    84

    85

	NetworkPopulateCompanyInfo();

    86

    87

	FOR_ALL_PLAYERS(player) {

    88

		if (!player->is_active)

    89

			continue;

    90

    91

		current++;

    92

    93

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    94

    95

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    96

		NetworkSend_uint8 (p, active);

    97

		NetworkSend_uint8 (p, current);

    98

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

   106

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

   107

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

   108

   109

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

   110

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

   111

   112

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

   113

			NetworkSend_string(p, "<none>");

   114

		else

   115

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

   116

   117

		NetworkSend_Packet(p, cs);

   118

	}

   119

}

   120

   121

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

   122

{

   123

	//

   124

	// Packet: SERVER_ERROR

   125

	// Function: The client made an error

   126

	// Data:

   127

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

   128

	//

   129

   130

	ClientState *new_cs;

   131

	char str1[100], str2[100];

   132

	char client_name[NETWORK_NAME_LENGTH];

   133

   134

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   135

	NetworkSend_uint8(p, error);

   136

	NetworkSend_Packet(p, cs);

   137

   138

	// Only send when the current client was in game

   139

	if (cs->status > STATUS_AUTH) {

   140

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

   141

   142

		GetString(str1, STR_NETWORK_ERR_LEFT);

   143

		GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   144

   145

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

   146

   147

		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, client_name, "%s (%s)", str1, str2);

   148

   149

		FOR_ALL_CLIENTS(new_cs) {

   150

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

   151

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

   152

				//  reason a joining failed.

   153

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

   154

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   155

   156

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

   157

			}

   158

		}

   159

	} else {

   160

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

   161

	}

   162

   163

	cs->quited = true;

   164

   165

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

   166

	NetworkSend_Packets(cs);

   167

   168

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

   169

	CloseClient(cs);

   170

}

   171

   172

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

   173

{

   174

	//

   175

	// Packet: SERVER_NEED_PASSWORD

   176

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

   177

	// Data:

   178

	//    uint8:  Type of password

   179

	//

   180

   181

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   182

	NetworkSend_uint8(p, type);

   183

	NetworkSend_Packet(p, cs);

   184

}

   185

   186

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   187

{

   188

	//

   189

	// Packet: SERVER_WELCOME

   190

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

   191

	// Data:

   192

	//    uint16:  Own ClientID

   193

	//

   194

   195

	Packet *p;

   196

	ClientState *new_cs;

   197

   198

	// Invalid packet when status is AUTH or higher

   199

	if (cs->status >= STATUS_AUTH)

   200

		return;

   201

   202

	cs->status = STATUS_AUTH;

   203

	_network_game_info.clients_on++;

   204

   205

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   206

	NetworkSend_uint16(p, cs->index);

   207

	NetworkSend_Packet(p, cs);

   208

   209

		// Transmit info about all the active clients

   210

	FOR_ALL_CLIENTS(new_cs) {

   211

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

   212

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

   213

	}

   214

	// Also send the info of the server

   215

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

   216

}

   217

   218

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   219

{

   220

	//

   221

	// Packet: PACKET_SERVER_WAIT

   222

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

   223

	//             someone else is already receiving the map

   224

	// Data:

   225

	//    uint8:  Clients awaiting map

   226

	//

   227

	int waiting = 0;

   228

	ClientState *new_cs;

   229

	Packet *p;

   230

   231

	// Count how many players are waiting in the queue

   232

	FOR_ALL_CLIENTS(new_cs) {

   233

		if (new_cs->status == STATUS_MAP_WAIT)

   234

			waiting++;

   235

	}

   236

   237

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   238

	NetworkSend_uint8(p, waiting);

   239

	NetworkSend_Packet(p, cs);

   240

}

   241

   242

// This sends the map to the client

   243

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   244

{

   245

	//

   246

	// Packet: SERVER_MAP

   247

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

   248

	//   a lot of multiple packets)

   249

	// Data:

   250

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

   251

	//  if MAP_PACKET_START:

   252

	//    uint32: The current FrameCounter

   253

	//  if MAP_PACKET_NORMAL:

   254

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

   255

	//  if MAP_PACKET_END:

   256

	//    uint32: seed0 of player

   257

	//    uint32: seed1 of player

   258

	//      last 2 are repeated MAX_PLAYERS time

   259

	//

   260

   261

	char filename[256];

   262

	static FILE *file_pointer;

   263

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

   264

   265

	if (cs->status < STATUS_AUTH) {

   266

		// Illegal call, return error and ignore the packet

   267

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   268

		return;

   269

	}

   270

	if (cs->status == STATUS_AUTH) {

   271

		Packet *p;

   272

   273

		// Make a dump of the current game

   274

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

   275

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

   276

   277

		file_pointer = fopen(filename, "rb");

   278

		fseek(file_pointer, 0, SEEK_END);

   279

   280

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

   281

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   282

		NetworkSend_uint8(p, MAP_PACKET_START);

   283

		NetworkSend_uint32(p, _frame_counter);

   284

		NetworkSend_uint32(p, ftell(file_pointer));

   285

		NetworkSend_Packet(p, cs);

   286

   287

		fseek(file_pointer, 0, SEEK_SET);

   288

   289

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

   290

   291

		cs->status = STATUS_MAP;

   292

	}

   293

   294

	if (cs->status == STATUS_MAP) {

   295

		uint i;

   296

		int res;

   297

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

   298

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   299

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   300

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

   301

			if (ferror(file_pointer)) {

   302

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

   303

			}

   304

			p->size += res;

   305

			NetworkSend_Packet(p, cs);

   306

			if (feof(file_pointer)) {

   307

				// Done reading!

   308

				int i;

   309

				Packet *p;

   310

   311

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

   312

				NetworkSendPatchSettings(cs);

   313

   314

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   315

				NetworkSend_uint8(p, MAP_PACKET_END);

   316

				// Send the player_seeds in this packet

   317

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

   318

					NetworkSend_uint32(p, _player_seeds[i][0]);

   319

					NetworkSend_uint32(p, _player_seeds[i][1]);

   320

				}

   321

				NetworkSend_Packet(p, cs);

   322

   323

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

   324

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

   325

				cs->status = STATUS_DONE_MAP;

   326

				fclose(file_pointer);

   327

   328

				{

   329

					ClientState *new_cs;

   330

					bool new_map_client = false;

   331

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

   332

					//  and start sending him the map

   333

					FOR_ALL_CLIENTS(new_cs) {

   334

						if (new_cs->status == STATUS_MAP_WAIT) {

   335

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

   336

							if (!new_map_client) {

   337

								// If not, this client will get the map

   338

								new_cs->status = STATUS_AUTH;

   339

								new_map_client = true;

   340

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   341

							} else {

   342

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

   343

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   344

							}

   345

						}

   346

					}

   347

				}

   348

   349

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

   350

				break;

   351

			}

   352

		}

   353

   354

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

   355

		NetworkSend_Packets(cs);

   356

		if (cs->packet_queue == NULL) {

   357

			// All are sent, increase the sent_packets

   358

			sent_packets *= 2;

   359

		} else {

   360

			// Not everything is sent, decrease the sent_packets

   361

			if (sent_packets > 1) sent_packets /= 2;

   362

		}

   363

	}

   364

}

   365

   366

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

   367

{

   368

	//

   369

	// Packet: SERVER_JOIN

   370

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

   371

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   372

	//     PACKET_SERVER_CLIENT_INFO

   373

	// Data:

   374

	//    uint16:  Client-Index

   375

	//

   376

   377

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   378

   379

	NetworkSend_uint16(p, client_index);

   380

   381

	NetworkSend_Packet(p, cs);

   382

}

   383

   384

   385

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   386

{

   387

	//

   388

	// Packet: SERVER_FRAME

   389

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

   390

	// Data:

   391

	//    uint32: Frame Counter

   392

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

   393

	//    [uint32: general-seed-1]

   394

	//    [uint32: general-seed-2]

   395

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

   396

	//

   397

   398

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   399

	NetworkSend_uint32(p, _frame_counter);

   400

	NetworkSend_uint32(p, _frame_counter_max);

   401

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   402

	NetworkSend_uint32(p, _sync_seed_1);

   403

#ifdef NETWORK_SEND_DOUBLE_SEED

   404

	NetworkSend_uint32(p, _sync_seed_2);

   405

#endif

   406

#endif

   407

	NetworkSend_Packet(p, cs);

   408

}

   409

   410

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   411

{

   412

	//

   413

	// Packet: SERVER_SYNC

   414

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

   415

	// Data:

   416

	//    uint32: Frame Counter

   417

	//    uint32: General-seed-1

   418

	//    [uint32: general-seed-2]

   419

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

   420

	//

   421

   422

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   423

	NetworkSend_uint32(p, _frame_counter);

   424

	NetworkSend_uint32(p, _sync_seed_1);

   425

   426

#ifdef NETWORK_SEND_DOUBLE_SEED

   427

	NetworkSend_uint32(p, _sync_seed_2);

   428

#endif

   429

	NetworkSend_Packet(p, cs);

   430

}

   431

   432

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

   433

{

   434

	//

   435

	// Packet: SERVER_COMMAND

   436

	// Function: Sends a DoCommand to the client

   437

	// Data:

   438

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

   439

	//    uint32: CommandID (see command.h)

   440

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

   441

	//    uint32: P2

   442

	//    uint32: Tile

   443

	//    uint32: decode_params

   444

	//      10 times the last one (lengthof(cp->dp))

   445

	//    uint8:  CallBackID (see callback_table.c)

   446

	//    uint32: Frame of execution

   447

	//

   448

   449

	int i;

   450

	char *dparam_char;

   451

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   452

   453

	NetworkSend_uint8(p, cp->player);

   454

	NetworkSend_uint32(p, cp->cmd);

   455

	NetworkSend_uint32(p, cp->p1);

   456

	NetworkSend_uint32(p, cp->p2);

   457

	NetworkSend_uint32(p, cp->tile);

   458

	/* We are going to send them byte by byte, because dparam is misused

   459

	    for chars (if it is used), and else we have a BigEndian / LittleEndian

   460

	    problem.. we should fix the misuse of dparam... -- TrueLight */

   461

	dparam_char = (char *)&cp->dp[0];

   462

	for (i = 0; i < lengthof(cp->dp) * 4; i++) {

   463

		NetworkSend_uint8(p, *dparam_char);

   464

		dparam_char++;

   465

	}

   466

	NetworkSend_uint8(p, cp->callback);

   467

	NetworkSend_uint32(p, cp->frame);

   468

   469

	NetworkSend_Packet(p, cs);

   470

}

   471

   472

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHAT)(ClientState *cs, NetworkAction action, uint16 client_index, const char *msg)

   473

{

   474

	//

   475

	// Packet: SERVER_CHAT

   476

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

   477

	// Data:

   478

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

   479

	//    uint16:  Client-index

   480

	//    String: Message (max MAX_TEXT_MSG_LEN)

   481

	//

   482

   483

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   484

   485

	NetworkSend_uint8(p, action);

   486

	NetworkSend_uint16(p, client_index);

   487

	NetworkSend_string(p, msg);

   488

   489

	NetworkSend_Packet(p, cs);

   490

}

   491

   492

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

   493

{

   494

	//

   495

	// Packet: SERVER_ERROR_QUIT

   496

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

   497

	//      This packet informs the other clients of that.

   498

	// Data:

   499

	//    uint16:  Client-index

   500

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

   501

	//

   502

   503

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

   504

   505

	NetworkSend_uint16(p, client_index);

   506

	NetworkSend_uint8(p, errorno);

   507

   508

	NetworkSend_Packet(p, cs);

   509

}

   510

   511

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

   512

{

   513

	//

   514

	// Packet: SERVER_ERROR_QUIT

   515

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

   516

	//      of that.

   517

	// Data:

   518

	//    uint16:  Client-index

   519

	//    String: leave-message

   520

	//

   521

   522

	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);

   523

   524

	NetworkSend_uint16(p, client_index);

   525

	NetworkSend_string(p, leavemsg);

   526

   527

	NetworkSend_Packet(p, cs);

   528

}