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(NetworkClientState *cs);

    19

void NetworkPopulateCompanyInfo(void);

    20

void NetworkSendPatchSettings(NetworkClientState *cs);

    21

    22

extern const char _openttd_revision[];

    23

    24

// Is the network enabled?

    25

    26

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

    27

// Sending functions

    28

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

    29

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

    30

    31

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

    32

{

    33

	//

    34

	// Packet: SERVER_CLIENT_INFO

    35

	// Function: Sends info about a client

    36

	// Data:

    37

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

    38

	//    uint8:  As which player the client is playing

    39

	//    String: The name of the client

    40

	//    String: The unique id of the client

    41

	//

    42

    43

	Packet *p;

    44

    45

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    46

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    47

		NetworkSend_uint16(p, ci->client_index);

    48

		NetworkSend_uint8 (p, ci->client_playas);

    49

		NetworkSend_string(p, ci->client_name);

    50

		NetworkSend_string(p, ci->unique_id);

    51

    52

		NetworkSend_Packet(p, cs);

    53

	}

    54

}

    55

    56

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    57

{

    58

//

    59

	// Packet: SERVER_COMPANY_INFO

    60

	// Function: Sends info about the companies

    61

	// Data:

    62

	//

    63

    64

	int i;

    65

    66

	Player *player;

    67

	Packet *p;

    68

    69

	byte active = 0;

    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

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    93

    94

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    95

		NetworkSend_uint8 (p, active);

    96

		NetworkSend_uint8 (p, player->index);

    97

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

   105

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

   106

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

   107

   108

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

   109

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

   110

   111

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

   112

			NetworkSend_string(p, "<none>");

   113

		else

   114

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

   115

   116

		NetworkSend_Packet(p, cs);

   117

	}

   118

   119

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   120

   121

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   122

	NetworkSend_uint8 (p, 0);

   123

   124

	NetworkSend_Packet(p, cs);

   125

}

   126

   127

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

   128

{

   129

	//

   130

	// Packet: SERVER_ERROR

   131

	// Function: The client made an error

   132

	// Data:

   133

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

   134

	//

   135

   136

	NetworkClientState *new_cs;

   137

	char str[100];

   138

	char client_name[NETWORK_NAME_LENGTH];

   139

   140

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   141

	NetworkSend_uint8(p, error);

   142

	NetworkSend_Packet(p, cs);

   143

   144

	// Only send when the current client was in game

   145

	if (cs->status > STATUS_AUTH) {

   146

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

   147

   148

		GetString(str, STR_NETWORK_ERR_CLIENT_GENERAL + error);

   149

   150

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

   151

   152

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

   153

   154

		FOR_ALL_CLIENTS(new_cs) {

   155

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

   156

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

   157

				//  reason a joining failed.

   158

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

   159

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   160

   161

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

   162

			}

   163

		}

   164

	} else {

   165

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

   166

	}

   167

   168

	cs->quited = true;

   169

   170

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

   171

	NetworkSend_Packets(cs);

   172

   173

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

   174

	NetworkCloseClient(cs);

   175

}

   176

   177

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

   178

{

   179

	//

   180

	// Packet: SERVER_NEED_PASSWORD

   181

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

   182

	// Data:

   183

	//    uint8:  Type of password

   184

	//

   185

   186

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   187

	NetworkSend_uint8(p, type);

   188

	NetworkSend_Packet(p, cs);

   189

}

   190

   191

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   192

{

   193

	//

   194

	// Packet: SERVER_WELCOME

   195

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

   196

	// Data:

   197

	//    uint16:  Own ClientID

   198

	//

   199

   200

	Packet *p;

   201

	NetworkClientState *new_cs;

   202

   203

	// Invalid packet when status is AUTH or higher

   204

	if (cs->status >= STATUS_AUTH)

   205

		return;

   206

   207

	cs->status = STATUS_AUTH;

   208

	_network_game_info.clients_on++;

   209

   210

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   211

	NetworkSend_uint16(p, cs->index);

   212

	NetworkSend_Packet(p, cs);

   213

   214

		// Transmit info about all the active clients

   215

	FOR_ALL_CLIENTS(new_cs) {

   216

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

   217

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

   218

	}

   219

	// Also send the info of the server

   220

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

   221

}

   222

   223

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   224

{

   225

	//

   226

	// Packet: PACKET_SERVER_WAIT

   227

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

   228

	//             someone else is already receiving the map

   229

	// Data:

   230

	//    uint8:  Clients awaiting map

   231

	//

   232

	int waiting = 0;

   233

	NetworkClientState *new_cs;

   234

	Packet *p;

   235

   236

	// Count how many players are waiting in the queue

   237

	FOR_ALL_CLIENTS(new_cs) {

   238

		if (new_cs->status == STATUS_MAP_WAIT)

   239

			waiting++;

   240

	}

   241

   242

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   243

	NetworkSend_uint8(p, waiting);

   244

	NetworkSend_Packet(p, cs);

   245

}

   246

   247

// This sends the map to the client

   248

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   249

{

   250

	//

   251

	// Packet: SERVER_MAP

   252

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

   253

	//   a lot of multiple packets)

   254

	// Data:

   255

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

   256

	//  if MAP_PACKET_START:

   257

	//    uint32: The current FrameCounter

   258

	//  if MAP_PACKET_NORMAL:

   259

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

   260

	//  if MAP_PACKET_END:

   261

	//    uint32: seed0 of player

   262

	//    uint32: seed1 of player

   263

	//      last 2 are repeated MAX_PLAYERS time

   264

	//

   265

   266

	char filename[256];

   267

	static FILE *file_pointer;

   268

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

   269

   270

	if (cs->status < STATUS_AUTH) {

   271

		// Illegal call, return error and ignore the packet

   272

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   273

		return;

   274

	}

   275

	if (cs->status == STATUS_AUTH) {

   276

		Packet *p;

   277

   278

		// Make a dump of the current game

   279

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

   280

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

   281

   282

		file_pointer = fopen(filename, "rb");

   283

		fseek(file_pointer, 0, SEEK_END);

   284

   285

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

   286

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   287

		NetworkSend_uint8(p, MAP_PACKET_START);

   288

		NetworkSend_uint32(p, _frame_counter);

   289

		NetworkSend_uint32(p, ftell(file_pointer));

   290

		NetworkSend_Packet(p, cs);

   291

   292

		fseek(file_pointer, 0, SEEK_SET);

   293

   294

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

   295

   296

		cs->status = STATUS_MAP;

   297

	}

   298

   299

	if (cs->status == STATUS_MAP) {

   300

		uint i;

   301

		int res;

   302

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

   303

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   304

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   305

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

   306

			if (ferror(file_pointer)) {

   307

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

   308

			}

   309

			p->size += res;

   310

			NetworkSend_Packet(p, cs);

   311

			if (feof(file_pointer)) {

   312

				// Done reading!

   313

				int i;

   314

				Packet *p;

   315

   316

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

   317

				NetworkSendPatchSettings(cs);

   318

   319

				p = NetworkSend_Init(PACKET_SERVER_MAP);

   320

				NetworkSend_uint8(p, MAP_PACKET_END);

   321

				// Send the player_seeds in this packet

   322

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

   323

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

   324

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

   325

				}

   326

				NetworkSend_Packet(p, cs);

   327

   328

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

   329

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

   330

				cs->status = STATUS_DONE_MAP;

   331

				fclose(file_pointer);

   332

   333

				{

   334

					NetworkClientState *new_cs;

   335

					bool new_map_client = false;

   336

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

   337

					//  and start sending him the map

   338

					FOR_ALL_CLIENTS(new_cs) {

   339

						if (new_cs->status == STATUS_MAP_WAIT) {

   340

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

   341

							if (!new_map_client) {

   342

								// If not, this client will get the map

   343

								new_cs->status = STATUS_AUTH;

   344

								new_map_client = true;

   345

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   346

							} else {

   347

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

   348

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   349

							}

   350

						}

   351

					}

   352

				}

   353

   354

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

   355

				break;

   356

			}

   357

		}

   358

   359

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

   360

		NetworkSend_Packets(cs);

   361

		if (cs->packet_queue == NULL) {

   362

			// All are sent, increase the sent_packets

   363

			sent_packets *= 2;

   364

		} else {

   365

			// Not everything is sent, decrease the sent_packets

   366

			if (sent_packets > 1) sent_packets /= 2;

   367

		}

   368

	}

   369

}

   370

   371

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

   372

{

   373

	//

   374

	// Packet: SERVER_JOIN

   375

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

   376

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   377

	//     PACKET_SERVER_CLIENT_INFO

   378

	// Data:

   379

	//    uint16:  Client-Index

   380

	//

   381

   382

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   383

   384

	NetworkSend_uint16(p, client_index);

   385

   386

	NetworkSend_Packet(p, cs);

   387

}

   388

   389

   390

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   391

{

   392

	//

   393

	// Packet: SERVER_FRAME

   394

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

   395

	// Data:

   396

	//    uint32: Frame Counter

   397

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

   398

	//    [uint32: general-seed-1]

   399

	//    [uint32: general-seed-2]

   400

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

   401

	//

   402

   403

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   404

	NetworkSend_uint32(p, _frame_counter);

   405

	NetworkSend_uint32(p, _frame_counter_max);

   406

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   407

	NetworkSend_uint32(p, _sync_seed_1);

   408

#ifdef NETWORK_SEND_DOUBLE_SEED

   409

	NetworkSend_uint32(p, _sync_seed_2);

   410

#endif

   411

#endif

   412

	NetworkSend_Packet(p, cs);

   413

}

   414

   415

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   416

{

   417

	//

   418

	// Packet: SERVER_SYNC

   419

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

   420

	// Data:

   421

	//    uint32: Frame Counter

   422

	//    uint32: General-seed-1

   423

	//    [uint32: general-seed-2]

   424

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

   425

	//

   426

   427

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   428

	NetworkSend_uint32(p, _frame_counter);

   429

	NetworkSend_uint32(p, _sync_seed_1);

   430

   431

#ifdef NETWORK_SEND_DOUBLE_SEED

   432

	NetworkSend_uint32(p, _sync_seed_2);

   433

#endif

   434

	NetworkSend_Packet(p, cs);

   435

}

   436

   437

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

   438

{

   439

	//

   440

	// Packet: SERVER_COMMAND

   441

	// Function: Sends a DoCommand to the client

   442

	// Data:

   443

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

   444

	//    uint32: CommandID (see command.h)

   445

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

   446

	//    uint32: P2

   447

	//    uint32: Tile

   448

	//    uint32: decode_params

   449

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

   450

	//    uint8:  CallBackID (see callback_table.c)

   451

	//    uint32: Frame of execution

   452

	//

   453

   454

	int i;

   455

	char *dparam_char;

   456

	Packet *p = NetworkSend_Init(PACKET_SERVER_COMMAND);

   457

   458

	NetworkSend_uint8(p, cp->player);

   459

	NetworkSend_uint32(p, cp->cmd);

   460

	NetworkSend_uint32(p, cp->p1);

   461

	NetworkSend_uint32(p, cp->p2);

   462

	NetworkSend_uint32(p, cp->tile);

   463

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

   464

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

   465

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

   466

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

   467

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

   468

		NetworkSend_uint8(p, *dparam_char);

   469

		dparam_char++;

   470

	}

   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

   522

	//      of that.

   523

	// Data: