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

     9

#include "console.h"

    10

#include "command.h"

    11

#include "gfx.h"

    12

#include "vehicle.h"

    13

#include "station.h"

    14

#include "settings.h"

    15

    16

// This file handles all the server-commands

    17

    18

void NetworkHandleCommandQueue(ClientState *cs);

    19

void NetworkPopulateCompanyInfo(void);

    20

void NetworkSendPatchSettings(ClientState *cs);

    21

    22

// Is the network enabled?

    23

    24

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

    25

// Sending functions

    26

//   DEF_SERVER_SEND_COMMAND has parameter: ClientState *cs

    27

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

    28

    29

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

    30

{

    31

	//

    32

	// Packet: SERVER_CLIENT_INFO

    33

	// Function: Sends info about a client

    34

	// Data:

    35

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

    36

	//    uint8:  As which player the client is playing

    37

	//    String: The name of the client

    38

	//    String: The unique id of the client

    39

	//

    40

    41

	Packet *p;

    42

    43

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    44

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    45

		NetworkSend_uint16(p, ci->client_index);

    46

		NetworkSend_uint8 (p, ci->client_playas);

    47

		NetworkSend_string(p, ci->client_name);

    48

		NetworkSend_string(p, ci->unique_id);

    49

    50

		NetworkSend_Packet(p, cs);

    51

	}

    52

}

    53

    54

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    55

{

    56

//

    57

	// Packet: SERVER_COMPANY_INFO

    58

	// Function: Sends info about the companies

    59

	// Data:

    60

	//

    61

    62

	int i;

    63

    64

	Player *player;

    65

	Packet *p;

    66

    67

	byte active = 0;

    68

	byte current = 0;

    69

    70

    71

	FOR_ALL_PLAYERS(player) {

    72

		if (player->is_active)

    73

			active++;

    74

	}

    75

    76

	if (active == 0) {

    77

		Packet *p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    78

    79

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    80

		NetworkSend_uint8 (p, active);

    81

    82

		NetworkSend_Packet(p, cs);

    83

		return;

    84

	}

    85

    86

	NetworkPopulateCompanyInfo();

    87

    88

	FOR_ALL_PLAYERS(player) {

    89

		if (!player->is_active)

    90

			continue;

    91

    92

		current++;

    93

    94

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    95

    96

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    97

		NetworkSend_uint8 (p, active);

    98

		NetworkSend_uint8 (p, current);

    99

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

   107

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

   108

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

   109

   110

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

   111

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

   112

   113

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

   114

			NetworkSend_string(p, "<none>");

   115

		else

   116

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

   117

   118

		NetworkSend_Packet(p, cs);

   119

	}

   120

}

   121

   122

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

   123

{

   124

	//

   125

	// Packet: SERVER_ERROR

   126

	// Function: The client made an error

   127

	// Data:

   128

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

   129

	//

   130

   131

	ClientState *new_cs;

   132

	char str1[100], str2[100];

   133

	char client_name[NETWORK_NAME_LENGTH];

   134

   135

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   136

	NetworkSend_uint8(p, error);

   137

	NetworkSend_Packet(p, cs);

   138

   139

	// Only send when the current client was in game

   140

	if (cs->status > STATUS_AUTH) {

   141

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

   142

   143

		GetString(str1, STR_NETWORK_ERR_LEFT);

   144

		GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   145

   146

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

   147

   148

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

   149

   150

		FOR_ALL_CLIENTS(new_cs) {

   151

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

   152

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

   153

				//  reason a joining failed.

   154

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

   155

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   156

   157

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

   158

			}

   159

		}

   160

	} else {

   161

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

   162

	}

   163

   164

	cs->quited = true;

   165

   166

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

   167

	NetworkSend_Packets(cs);

   168

   169

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

   170

	CloseClient(cs);

   171

}

   172

   173

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

   174

{

   175

	//

   176

	// Packet: SERVER_NEED_PASSWORD

   177

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

   178

	// Data:

   179

	//    uint8:  Type of password

   180

	//

   181

   182

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   183

	NetworkSend_uint8(p, type);

   184

	NetworkSend_Packet(p, cs);

   185

}

   186

   187

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   188

{

   189

	//

   190

	// Packet: SERVER_WELCOME

   191

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

   192

	// Data:

   193

	//    uint16:  Own ClientID

   194

	//

   195

   196

	Packet *p;

   197

	ClientState *new_cs;

   198

   199

	// Invalid packet when status is AUTH or higher

   200

	if (cs->status >= STATUS_AUTH)

   201

		return;

   202

   203

	cs->status = STATUS_AUTH;

   204

	_network_game_info.clients_on++;

   205

   206

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   207

	NetworkSend_uint16(p, cs->index);

   208

	NetworkSend_Packet(p, cs);

   209

   210

		// Transmit info about all the active clients

   211

	FOR_ALL_CLIENTS(new_cs) {

   212

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

   213

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

   214

	}

   215

	// Also send the info of the server

   216

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

   217

}

   218

   219

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   220

{

   221

	//

   222

	// Packet: PACKET_SERVER_WAIT

   223

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

   224

	//             someone else is already receiving the map

   225

	// Data:

   226

	//    uint8:  Clients awaiting map

   227

	//

   228

	int waiting = 0;

   229

	ClientState *new_cs;

   230

	Packet *p;

   231

   232

	// Count how many players are waiting in the queue

   233

	FOR_ALL_CLIENTS(new_cs) {

   234

		if (new_cs->status == STATUS_MAP_WAIT)

   235

			waiting++;

   236

	}

   237

   238

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   239

	NetworkSend_uint8(p, waiting);

   240

	NetworkSend_Packet(p, cs);

   241

}

   242

   243

// This sends the map to the client

   244

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   245

{

   246

	//

   247

	// Packet: SERVER_MAP

   248

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

   249

	//   a lot of multiple packets)

   250

	// Data:

   251

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

   252

	//  if MAP_PACKET_START:

   253

	//    uint32: The current FrameCounter

   254

	//  if MAP_PACKET_NORMAL:

   255

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

   256

	//  if MAP_PACKET_END:

   257

	//    uint32: seed0 of player

   258

	//    uint32: seed1 of player

   259

	//      last 2 are repeated MAX_PLAYERS time

   260

	//

   261

   262

	char filename[256];

   263

	static FILE *file_pointer;

   264

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

   265

   266

	if (cs->status < STATUS_AUTH) {

   267

		// Illegal call, return error and ignore the packet

   268

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   269

		return;

   270

	}

   271

	if (cs->status == STATUS_AUTH) {

   272

		Packet *p;

   273

   274

		// Make a dump of the current game

   275

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

   276

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

   277

   278

		file_pointer = fopen(filename, "rb");

   279

		fseek(file_pointer, 0, SEEK_END);

   280

   281

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

   282

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   283

		NetworkSend_uint8(p, MAP_PACKET_START);

   284

		NetworkSend_uint32(p, _frame_counter);

   285

		NetworkSend_uint32(p, ftell(file_pointer));

   286

		NetworkSend_Packet(p, cs);

   287

   288

		fseek(file_pointer, 0, SEEK_SET);

   289

   290

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

   291

   292

		cs->status = STATUS_MAP;

   293

	}

   294

   295

	if (cs->status == STATUS_MAP) {

   296

		uint i;

   297

		int res;

   298

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

   299

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   300

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   301

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

   302

			if (ferror(file_pointer)) {

   303

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

   304

			}

   305

			p->size += res;

   306

			NetworkSend_Packet(p, cs);

   307

			if (feof(file_pointer)) {

   308

				// Done reading!

   309

				int i;

   310

				Packet *p;

   311

   312

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

   313

				NetworkSendPatchSettings(cs);

   314

   315

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   316

				NetworkSend_uint8(p, MAP_PACKET_END);

   317

				// Send the player_seeds in this packet

   318

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

   319

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

   320

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

   321

				}

   322

				NetworkSend_Packet(p, cs);

   323

   324

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

   325

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

   326

				cs->status = STATUS_DONE_MAP;

   327

				fclose(file_pointer);

   328

   329

				{

   330

					ClientState *new_cs;

   331

					bool new_map_client = false;

   332

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

   333

					//  and start sending him the map

   334

					FOR_ALL_CLIENTS(new_cs) {

   335

						if (new_cs->status == STATUS_MAP_WAIT) {

   336

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

   337

							if (!new_map_client) {

   338

								// If not, this client will get the map

   339

								new_cs->status = STATUS_AUTH;

   340

								new_map_client = true;

   341

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   342

							} else {

   343

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

   344

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   345

							}

   346

						}

   347

					}

   348

				}

   349

   350

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

   351

				break;

   352

			}

   353

		}

   354

   355

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

   356

		NetworkSend_Packets(cs);

   357

		if (cs->packet_queue == NULL) {

   358

			// All are sent, increase the sent_packets

   359

			sent_packets *= 2;

   360

		} else {

   361

			// Not everything is sent, decrease the sent_packets

   362

			if (sent_packets > 1) sent_packets /= 2;

   363

		}

   364

	}

   365

}

   366

   367

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

   368

{

   369

	//

   370

	// Packet: SERVER_JOIN

   371

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

   372

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   373

	//     PACKET_SERVER_CLIENT_INFO

   374

	// Data:

   375

	//    uint16:  Client-Index

   376

	//

   377

   378

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   379

   380

	NetworkSend_uint16(p, client_index);

   381

   382

	NetworkSend_Packet(p, cs);

   383

}

   384

   385

   386

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   387

{

   388

	//

   389

	// Packet: SERVER_FRAME

   390

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

   391

	// Data:

   392

	//    uint32: Frame Counter

   393

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

   394

	//    [uint32: general-seed-1]

   395

	//    [uint32: general-seed-2]

   396

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

   397

	//

   398

   399

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   400

	NetworkSend_uint32(p, _frame_counter);

   401

	NetworkSend_uint32(p, _frame_counter_max);

   402

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   403

	NetworkSend_uint32(p, _sync_seed_1);

   404

#ifdef NETWORK_SEND_DOUBLE_SEED

   405

	NetworkSend_uint32(p, _sync_seed_2);

   406

#endif

   407

#endif

   408

	NetworkSend_Packet(p, cs);

   409

}

   410

   411

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   412

{

   413

	//

   414

	// Packet: SERVER_SYNC

   415

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

   416

	// Data:

   417

	//    uint32: Frame Counter

   418

	//    uint32: General-seed-1

   419

	//    [uint32: general-seed-2]

   420

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

   421

	//

   422

   423

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   424

	NetworkSend_uint32(p, _frame_counter);

   425

	NetworkSend_uint32(p, _sync_seed_1);

   426

   427

#ifdef NETWORK_SEND_DOUBLE_SEED

   428

	NetworkSend_uint32(p, _sync_seed_2);

   429

#endif

   430

	NetworkSend_Packet(p, cs);

   431

}

   432

   433

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

   434

{

   435

	//

   436

	// Packet: SERVER_COMMAND

   437

	// Function: Sends a DoCommand to the client

   438

	// Data:

   439

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

   440

	//    uint32: CommandID (see command.h)

   441

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

   442

	//    uint32: P2

   443

	//    uint32: Tile

   444

	//    uint32: decode_params

   445

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

   446

	//    uint8:  CallBackID (see callback_table.c)

   447

	//    uint32: Frame of execution

   448

	//

   449

   450

	int i;

   451

	char *dparam_char;

   452

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   453

   454

	NetworkSend_uint8(p, cp->player);

   455

	NetworkSend_uint32(p, cp->cmd);

   456

	NetworkSend_uint32(p, cp->p1);

   457

	NetworkSend_uint32(p, cp->p2);

   458

	NetworkSend_uint32(p, cp->tile);

   459

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

   460

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

   461

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

   462

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

   463

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

   464

		NetworkSend_uint8(p, *dparam_char);

   465

		dparam_char++;

   466

	}

   467

	NetworkSend_uint8(p, cp->callback);

   468

	NetworkSend_uint32(p, cp->frame);

   469

   470

	NetworkSend_Packet(p, cs);

   471

}

   472

   473

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

   474

{

   475

	//

   476

	// Packet: SERVER_CHAT

   477

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

   478

	// Data:

   479

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

   480

	//    uint16:  Client-index

   481

	//    String: Message (max MAX_TEXT_MSG_LEN)

   482

	//

   483

   484

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   485

   486

	NetworkSend_uint8(p, action);

   487

	NetworkSend_uint16(p, client_index);

   488

	NetworkSend_string(p, msg);

   489

   490

	NetworkSend_Packet(p, cs);

   491

}

   492

   493

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

   494

{

   495

	//

   496

	// Packet: SERVER_ERROR_QUIT

   497

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

   498

	//      This packet informs the other clients of that.

   499

	// Data:

   500

	//    uint16:  Client-index

   501

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

   502

	//

   503

   504

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

   505

   506

	NetworkSend_uint16(p, client_index);

   507

	NetworkSend_uint8(p, errorno);

   508

   509

	NetworkSend_Packet(p, cs);

   510

}

   511

   512

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

   513

{

   514

	//

   515

	// Packet: SERVER_ERROR_QUIT

   516

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

   517

	//      of that.

   518

	// Data:

   519

	//    uint16:  Client-index

   520

	//    String: leave-message

   521

	//

   522

   523

	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);

   524

   525

	NetworkSend_uint16(p, client_index);

   526

	NetworkSend_string(p, leavemsg);

   527

   528

	NetworkSend_Packet(p, cs);