1

#include "stdafx.h"

     2

#include "debug.h"

     3

#include "string.h"

     4

#include "strings.h"

     5

#include "network_data.h"

     6

     7

#ifdef ENABLE_NETWORK

     8

     9

#include "table/strings.h"

    10

#include "network_server.h"

    11

#include "network_udp.h"

    12

#include "console.h"

    13

#include "command.h"

    14

#include "gfx.h"

    15

#include "vehicle.h"

    16

#include "station.h"

    17

#include "settings.h"

    18

    19

// This file handles all the server-commands

    20

    21

void NetworkHandleCommandQueue(NetworkClientState *cs);

    22

void NetworkPopulateCompanyInfo(void);

    23

void NetworkSendPatchSettings(NetworkClientState *cs);

    24

    25

extern const char _openttd_revision[];

    26

    27

// Is the network enabled?

    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

	Packet *p;

    47

    48

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    49

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    50

		NetworkSend_uint16(p, ci->client_index);

    51

		NetworkSend_uint8 (p, ci->client_playas);

    52

		NetworkSend_string(p, ci->client_name);

    53

		NetworkSend_string(p, ci->unique_id);

    54

    55

		NetworkSend_Packet(p, cs);

    56

	}

    57

}

    58

    59

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    60

{

    61

//

    62

	// Packet: SERVER_COMPANY_INFO

    63

	// Function: Sends info about the companies

    64

	// Data:

    65

	//

    66

    67

	int i;

    68

    69

	Player *player;

    70

	Packet *p;

    71

    72

	byte active = 0;

    73

    74

	FOR_ALL_PLAYERS(player) {

    75

		if (player->is_active)

    76

			active++;

    77

	}

    78

    79

	if (active == 0) {

    80

		Packet *p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    81

    82

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    83

		NetworkSend_uint8 (p, active);

    84

    85

		NetworkSend_Packet(p, cs);

    86

		return;

    87

	}

    88

    89

	NetworkPopulateCompanyInfo();

    90

    91

	FOR_ALL_PLAYERS(player) {

    92

		if (!player->is_active)

    93

			continue;

    94

    95

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    96

    97

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    98

		NetworkSend_uint8 (p, active);

    99

		NetworkSend_uint8 (p, player->index);

   100

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

   108

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

   109

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

   110

			NetworkSend_uint8 (p, 1);

   111

		} else {

   112

			NetworkSend_uint8 (p, 0);

   113

		}

   114

   115

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

   116

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

   117

   118

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

   119

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

   120

   121

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

   122

			NetworkSend_string(p, "<none>");

   123

		else

   124

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

   125

   126

		NetworkSend_Packet(p, cs);

   127

	}

   128

   129

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   130

   131

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   132

	NetworkSend_uint8 (p, 0);

   133

   134

	NetworkSend_Packet(p, cs);

   135

}

   136

   137

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

   138

{

   139

	//

   140

	// Packet: SERVER_ERROR

   141

	// Function: The client made an error

   142

	// Data:

   143

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

   144

	//

   145

   146

	NetworkClientState *new_cs;

   147

	char str[100];

   148

	char client_name[NETWORK_CLIENT_NAME_LENGTH];

   149

   150

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   151

	NetworkSend_uint8(p, error);

   152

	NetworkSend_Packet(p, cs);

   153

   154

	// Only send when the current client was in game

   155

	if (cs->status > STATUS_AUTH) {

   156

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

   157

   158

		GetString(str, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   159

   160

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

   161

   162

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

   163

   164

		FOR_ALL_CLIENTS(new_cs) {

   165

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

   166

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

   167

				//  reason a joining failed.

   168

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

   169

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   170

   171

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

   172

			}

   173

		}

   174

	} else {

   175

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

   176

	}

   177

   178

	cs->quited = true;

   179

   180

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

   181

	NetworkSend_Packets(cs);

   182

   183

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

   184

	NetworkCloseClient(cs);

   185

}

   186

   187

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

   188

{

   189

	//

   190

	// Packet: SERVER_NEED_PASSWORD

   191

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

   192

	// Data:

   193

	//    uint8:  Type of password

   194

	//

   195

   196

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   197

	NetworkSend_uint8(p, type);

   198

	NetworkSend_Packet(p, cs);

   199

}

   200

   201

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   202

{

   203

	//

   204

	// Packet: SERVER_WELCOME

   205

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

   206

	// Data:

   207

	//    uint16:  Own ClientID

   208

	//

   209

   210

	Packet *p;

   211

	NetworkClientState *new_cs;

   212

   213

	// Invalid packet when status is AUTH or higher

   214

	if (cs->status >= STATUS_AUTH)

   215

		return;

   216

   217

	cs->status = STATUS_AUTH;

   218

	_network_game_info.clients_on++;

   219

   220

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   221

	NetworkSend_uint16(p, cs->index);

   222

	NetworkSend_Packet(p, cs);

   223

   224

		// Transmit info about all the active clients

   225

	FOR_ALL_CLIENTS(new_cs) {

   226

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

   227

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

   228

	}

   229

	// Also send the info of the server

   230

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

   231

}

   232

   233

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   234

{

   235

	//

   236

	// Packet: PACKET_SERVER_WAIT

   237

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

   238

	//             someone else is already receiving the map

   239

	// Data:

   240

	//    uint8:  Clients awaiting map

   241

	//

   242

	int waiting = 0;

   243

	NetworkClientState *new_cs;

   244

	Packet *p;

   245

   246

	// Count how many players are waiting in the queue

   247

	FOR_ALL_CLIENTS(new_cs) {

   248

		if (new_cs->status == STATUS_MAP_WAIT)

   249

			waiting++;

   250

	}

   251

   252

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   253

	NetworkSend_uint8(p, waiting);

   254

	NetworkSend_Packet(p, cs);

   255

}

   256

   257

// This sends the map to the client

   258

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   259

{

   260

	//

   261

	// Packet: SERVER_MAP

   262

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

   263

	//   a lot of multiple packets)

   264

	// Data:

   265

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

   266

	//  if MAP_PACKET_START:

   267

	//    uint32: The current FrameCounter

   268

	//  if MAP_PACKET_NORMAL:

   269

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

   270

	//  if MAP_PACKET_END:

   271

	//    uint32: seed0 of player

   272

	//    uint32: seed1 of player

   273

	//      last 2 are repeated MAX_PLAYERS time

   274

	//

   275

   276

	char filename[256];

   277

	static FILE *file_pointer;

   278

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

   279

   280

	if (cs->status < STATUS_AUTH) {

   281

		// Illegal call, return error and ignore the packet

   282

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   283

		return;

   284

	}

   285

	if (cs->status == STATUS_AUTH) {

   286

		Packet *p;

   287

   288

		// Make a dump of the current game

   289

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

   290

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

   291

   292

		file_pointer = fopen(filename, "rb");

   293

		fseek(file_pointer, 0, SEEK_END);

   294

   295

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

   296

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   297

		NetworkSend_uint8(p, MAP_PACKET_START);

   298

		NetworkSend_uint32(p, _frame_counter);

   299

		NetworkSend_uint32(p, ftell(file_pointer));

   300

		NetworkSend_Packet(p, cs);

   301

   302

		fseek(file_pointer, 0, SEEK_SET);

   303

   304

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

   305

   306

		cs->status = STATUS_MAP;

   307

		/* Mark the start of download */

   308

		cs->last_frame = _frame_counter;

   309

		cs->last_frame_server = _frame_counter;

   310

	}

   311

   312

	if (cs->status == STATUS_MAP) {

   313

		uint i;

   314

		int res;

   315

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

   316

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   317

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   318

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

   319

			if (ferror(file_pointer)) {

   320

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

   321

			}

   322

			p->size += res;

   323

			NetworkSend_Packet(p, cs);

   324

			if (feof(file_pointer)) {

   325

				// Done reading!

   326

				int i;

   327

				Packet *p;

   328

   329

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

   330

				NetworkSendPatchSettings(cs);

   331

   332

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   333

				NetworkSend_uint8(p, MAP_PACKET_END);

   334

				// Send the player_seeds in this packet

   335

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

   336

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

   337

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

   338

				}

   339

				NetworkSend_Packet(p, cs);

   340

   341

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

   342

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

   343

				cs->status = STATUS_DONE_MAP;

   344

				fclose(file_pointer);

   345

   346

				{

   347

					NetworkClientState *new_cs;

   348

					bool new_map_client = false;

   349

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

   350

					//  and start sending him the map

   351

					FOR_ALL_CLIENTS(new_cs) {

   352

						if (new_cs->status == STATUS_MAP_WAIT) {

   353

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

   354

							if (!new_map_client) {

   355

								// If not, this client will get the map

   356

								new_cs->status = STATUS_AUTH;

   357

								new_map_client = true;

   358

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   359

							} else {

   360

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

   361

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   362

							}

   363

						}

   364

					}

   365

				}

   366

   367

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

   368

				break;

   369

			}

   370

		}

   371

   372

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

   373

		NetworkSend_Packets(cs);

   374

		if (cs->packet_queue == NULL) {

   375

			// All are sent, increase the sent_packets

   376

			sent_packets *= 2;

   377

		} else {

   378

			// Not everything is sent, decrease the sent_packets

   379

			if (sent_packets > 1) sent_packets /= 2;

   380

		}

   381

	}

   382

}

   383

   384

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

   385

{

   386

	//

   387

	// Packet: SERVER_JOIN

   388

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

   389

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   390

	//     PACKET_SERVER_CLIENT_INFO

   391

	// Data:

   392

	//    uint16:  Client-Index

   393

	//

   394

   395

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   396

   397

	NetworkSend_uint16(p, client_index);

   398

   399

	NetworkSend_Packet(p, cs);

   400

}

   401

   402

   403

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   404

{

   405

	//

   406

	// Packet: SERVER_FRAME

   407

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

   408

	// Data:

   409

	//    uint32: Frame Counter

   410

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

   411

	//    [uint32: general-seed-1]

   412

	//    [uint32: general-seed-2]

   413

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

   414

	//

   415

   416

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   417

	NetworkSend_uint32(p, _frame_counter);

   418

	NetworkSend_uint32(p, _frame_counter_max);

   419

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   420

	NetworkSend_uint32(p, _sync_seed_1);

   421

#ifdef NETWORK_SEND_DOUBLE_SEED

   422

	NetworkSend_uint32(p, _sync_seed_2);

   423

#endif

   424

#endif

   425

	NetworkSend_Packet(p, cs);

   426

}

   427

   428

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   429

{

   430

	//

   431

	// Packet: SERVER_SYNC

   432

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

   433

	// Data:

   434

	//    uint32: Frame Counter

   435

	//    uint32: General-seed-1

   436

	//    [uint32: general-seed-2]

   437

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

   438

	//

   439

   440

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   441

	NetworkSend_uint32(p, _frame_counter);

   442

	NetworkSend_uint32(p, _sync_seed_1);

   443

   444

#ifdef NETWORK_SEND_DOUBLE_SEED

   445

	NetworkSend_uint32(p, _sync_seed_2);

   446

#endif

   447

	NetworkSend_Packet(p, cs);

   448

}

   449

   450

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

   451

{

   452

	//

   453

	// Packet: SERVER_COMMAND

   454

	// Function: Sends a DoCommand to the client

   455

	// Data:

   456

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

   457

	//    uint32: CommandID (see command.h)

   458

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

   459

	//    uint32: P2

   460

	//    uint32: Tile

   461

	//    uint32: decode_params

   462

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

   463

	//    uint8:  CallBackID (see callback_table.c)

   464

	//    uint32: Frame of execution

   465

	//

   466

   467

	uint i;

   468

	char *dparam_char;

   469

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   470

   471

	NetworkSend_uint8(p, cp->player);

   472

	NetworkSend_uint32(p, cp->cmd);

   473

	NetworkSend_uint32(p, cp->p1);

   474

	NetworkSend_uint32(p, cp->p2);

   475

	NetworkSend_uint32(p, cp->tile);

   476

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

   477

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

   478

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

   479

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

   480

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

   481

		NetworkSend_uint8(p, *dparam_char);

   482

		dparam_char++;

   483

	}

   484

	NetworkSend_uint8(p, cp->callback);

   485

	NetworkSend_uint32(p, cp->frame);

   486

   487

	NetworkSend_Packet(p, cs);

   488

}

   489

   490

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

   491

{

   492

	//

   493

	// Packet: SERVER_CHAT

   494

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

   495

	// Data:

   496

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

   497

	//    uint16:  Client-index

   498

	//    String: Message (max MAX_TEXT_MSG_LEN)

   499

	//

   500

   501

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   502

   503

	NetworkSend_uint8(p, action);

   504

	NetworkSend_uint16(p, client_index);

   505

	NetworkSend_uint8(p, self_send);

   506

	NetworkSend_string(p, msg);

   507

   508

	NetworkSend_Packet(p, cs);

   509

}

   510

   511

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

   512

{

   513

	//

   514

	// Packet: SERVER_ERROR_QUIT

   515

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

   516

	//      This packet informs the other clients of that.

   517

	// Data:

   518

	//    uint16:  Client-index

   519

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

   520

	//

   521

   522