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

#include "train.h"

     9

#include "date.h"

    10

    11

#ifdef ENABLE_NETWORK

    12

    13

#include "table/strings.h"

    14

#include "functions.h"

    15

#include "network_server.h"

    16

#include "network_udp.h"

    17

#include "console.h"

    18

#include "command.h"

    19

#include "saveload.h"

    20

#include "vehicle.h"

    21

#include "station.h"

    22

#include "variables.h"

    23

#include "genworld.h"

    24

    25

// This file handles all the server-commands

    26

    27

static void NetworkHandleCommandQueue(NetworkClientState* cs);

    28

void NetworkPopulateCompanyInfo(void);

    29

    30

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

    31

// Sending functions

    32

//   DEF_SERVER_SEND_COMMAND has parameter: NetworkClientState *cs

    33

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

    34

    35

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

    36

{

    37

	//

    38

	// Packet: SERVER_CLIENT_INFO

    39

	// Function: Sends info about a client

    40

	// Data:

    41

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

    42

	//    uint8:  As which player the client is playing

    43

	//    String: The name of the client

    44

	//    String: The unique id of the client

    45

	//

    46

    47

	Packet *p;

    48

    49

	if (ci->client_index != NETWORK_EMPTY_INDEX) {

    50

		p = NetworkSend_Init(PACKET_SERVER_CLIENT_INFO);

    51

		NetworkSend_uint16(p, ci->client_index);

    52

		NetworkSend_uint8 (p, ci->client_playas);

    53

		NetworkSend_string(p, ci->client_name);

    54

		NetworkSend_string(p, ci->unique_id);

    55

    56

		NetworkSend_Packet(p, cs);

    57

	}

    58

}

    59

    60

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_COMPANY_INFO)

    61

{

    62

//

    63

	// Packet: SERVER_COMPANY_INFO

    64

	// Function: Sends info about the companies

    65

	// Data:

    66

	//

    67

    68

	int i;

    69

    70

	Player *player;

    71

	Packet *p;

    72

    73

	byte active = ActivePlayerCount();

    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) continue;

    89

    90

		p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

    91

    92

		NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

    93

		NetworkSend_uint8 (p, active);

    94

		NetworkSend_uint8 (p, player->index);

    95

    96

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

    97

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

    98

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

    99

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

   100

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

   101

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

   102

   103

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

   104

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

   105

			NetworkSend_uint8(p, 1);

   106

		} else {

   107

			NetworkSend_uint8(p, 0);

   108

		}

   109

   110

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

   111

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

   112

		}

   113

   114

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

   115

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

   116

		}

   117

   118

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

   119

			NetworkSend_string(p, "<none>");

   120

		} else {

   121

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

   122

		}

   123

   124

		NetworkSend_Packet(p, cs);

   125

	}

   126

   127

	p = NetworkSend_Init(PACKET_SERVER_COMPANY_INFO);

   128

   129

	NetworkSend_uint8 (p, NETWORK_COMPANY_INFO_VERSION);

   130

	NetworkSend_uint8 (p, 0);

   131

   132

	NetworkSend_Packet(p, cs);

   133

}

   134

   135

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

   136

{

   137

	//

   138

	// Packet: SERVER_ERROR

   139

	// Function: The client made an error

   140

	// Data:

   141

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

   142

	//

   143

   144

	NetworkClientState *new_cs;

   145

	char str[100];

   146

	char client_name[NETWORK_CLIENT_NAME_LENGTH];

   147

   148

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR);

   149

   150

	NetworkSend_uint8(p, error);

   151

	NetworkSend_Packet(p, cs);

   152

   153

	GetNetworkErrorMsg(str, error);

   154

   155

	// Only send when the current client was in game

   156

	if (cs->status > STATUS_AUTH) {

   157

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

   158

   159

		DEBUG(net, 2) ("[NET] '%s' made an error and has been disconnected. Reason: %s", client_name, str);

   160

   161

		NetworkTextMessage(NETWORK_ACTION_LEAVE, 1, false, client_name, "%s", str);

   162

   163

		FOR_ALL_CLIENTS(new_cs) {

   164

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

   165

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

   166

				//  reason a joining failed.

   167

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

   168

					error = NETWORK_ERROR_ILLEGAL_PACKET;

   169

   170

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

   171

			}

   172

		}

   173

	} else {

   174

		DEBUG(net, 2) ("[NET] Client %d made an error and has been disconnected. Reason: %s", cs->index, str);

   175

	}

   176

   177

	cs->quited = true;

   178

   179

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

   180

	NetworkSend_Packets(cs);

   181

   182

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

   183

	NetworkCloseClient(cs);

   184

}

   185

   186

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

   187

{

   188

	//

   189

	// Packet: SERVER_NEED_PASSWORD

   190

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

   191

	// Data:

   192

	//    uint8:  Type of password

   193

	//

   194

   195

	Packet *p = NetworkSend_Init(PACKET_SERVER_NEED_PASSWORD);

   196

	NetworkSend_uint8(p, type);

   197

	NetworkSend_Packet(p, cs);

   198

}

   199

   200

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WELCOME)

   201

{

   202

	//

   203

	// Packet: SERVER_WELCOME

   204

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

   205

	// Data:

   206

	//    uint16:  Own ClientID

   207

	//

   208

   209

	Packet *p;

   210

	const NetworkClientState *new_cs;

   211

   212

	// Invalid packet when status is AUTH or higher

   213

	if (cs->status >= STATUS_AUTH) return;

   214

   215

	cs->status = STATUS_AUTH;

   216

	_network_game_info.clients_on++;

   217

   218

	p = NetworkSend_Init(PACKET_SERVER_WELCOME);

   219

	NetworkSend_uint16(p, cs->index);

   220

	NetworkSend_Packet(p, cs);

   221

   222

		// Transmit info about all the active clients

   223

	FOR_ALL_CLIENTS(new_cs) {

   224

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

   225

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

   226

	}

   227

	// Also send the info of the server

   228

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

   229

}

   230

   231

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_WAIT)

   232

{

   233

	//

   234

	// Packet: PACKET_SERVER_WAIT

   235

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

   236

	//             someone else is already receiving the map

   237

	// Data:

   238

	//    uint8:  Clients awaiting map

   239

	//

   240

	int waiting = 0;

   241

	NetworkClientState *new_cs;

   242

	Packet *p;

   243

   244

	// Count how many players are waiting in the queue

   245

	FOR_ALL_CLIENTS(new_cs) {

   246

		if (new_cs->status == STATUS_MAP_WAIT) waiting++;

   247

	}

   248

   249

	p = NetworkSend_Init(PACKET_SERVER_WAIT);

   250

	NetworkSend_uint8(p, waiting);

   251

	NetworkSend_Packet(p, cs);

   252

}

   253

   254

// This sends the map to the client

   255

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_MAP)

   256

{

   257

	//

   258

	// Packet: SERVER_MAP

   259

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

   260

	//   a lot of multiple packets)

   261

	// Data:

   262

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

   263

	//  if MAP_PACKET_START:

   264

	//    uint32: The current FrameCounter

   265

	//  if MAP_PACKET_NORMAL:

   266

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

   267

	//  if MAP_PACKET_END:

   268

	//    uint32: seed0 of player

   269

	//    uint32: seed1 of player

   270

	//      last 2 are repeated MAX_PLAYERS time

   271

	//

   272

   273

	char filename[256];

   274

	static FILE *file_pointer;

   275

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

   276

   277

	if (cs->status < STATUS_AUTH) {

   278

		// Illegal call, return error and ignore the packet

   279

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_AUTHORIZED);

   280

		return;

   281

	}

   282

	if (cs->status == STATUS_AUTH) {

   283

		Packet *p;

   284

   285

		// Make a dump of the current game

   286

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

   287

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

   288

   289

		file_pointer = fopen(filename, "rb");

   290

		fseek(file_pointer, 0, SEEK_END);

   291

   292

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

   293

		p = NetworkSend_Init(PACKET_SERVER_MAP);

   294

		NetworkSend_uint8(p, MAP_PACKET_START);

   295

		NetworkSend_uint32(p, _frame_counter);

   296

		NetworkSend_uint32(p, ftell(file_pointer));

   297

		NetworkSend_Packet(p, cs);

   298

   299

		fseek(file_pointer, 0, SEEK_SET);

   300

   301

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

   302

   303

		cs->status = STATUS_MAP;

   304

		/* Mark the start of download */

   305

		cs->last_frame = _frame_counter;

   306

		cs->last_frame_server = _frame_counter;

   307

	}

   308

   309

	if (cs->status == STATUS_MAP) {

   310

		uint i;

   311

		int res;

   312

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

   313

			Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   314

			NetworkSend_uint8(p, MAP_PACKET_NORMAL);

   315

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

   316

			if (ferror(file_pointer)) {

   317

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

   318

			}

   319

			p->size += res;

   320

			NetworkSend_Packet(p, cs);

   321

			if (feof(file_pointer)) {

   322

				// Done reading!

   323

				Packet *p = NetworkSend_Init(PACKET_SERVER_MAP);

   324

				NetworkSend_uint8(p, MAP_PACKET_END);

   325

				NetworkSend_Packet(p, cs);

   326

   327

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

   328

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

   329

				cs->status = STATUS_DONE_MAP;

   330

				fclose(file_pointer);

   331

   332

				{

   333

					NetworkClientState *new_cs;

   334

					bool new_map_client = false;

   335

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

   336

					//  and start sending him the map

   337

					FOR_ALL_CLIENTS(new_cs) {

   338

						if (new_cs->status == STATUS_MAP_WAIT) {

   339

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

   340

							if (!new_map_client) {

   341

								// If not, this client will get the map

   342

								new_cs->status = STATUS_AUTH;

   343

								new_map_client = true;

   344

								SEND_COMMAND(PACKET_SERVER_MAP)(new_cs);

   345

							} else {

   346

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

   347

								SEND_COMMAND(PACKET_SERVER_WAIT)(new_cs);

   348

							}

   349

						}

   350

					}

   351

				}

   352

   353

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

   354

				break;

   355

			}

   356

		}

   357

   358

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

   359

		NetworkSend_Packets(cs);

   360

		if (cs->packet_queue == NULL) {

   361

			// All are sent, increase the sent_packets

   362

			sent_packets *= 2;

   363

		} else {

   364

			// Not everything is sent, decrease the sent_packets

   365

			if (sent_packets > 1) sent_packets /= 2;

   366

		}

   367

	}

   368

}

   369

   370

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

   371

{

   372

	//

   373

	// Packet: SERVER_JOIN

   374

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

   375

	//     PACKET_CLIENT_MAP_OK) Mostly what directly follows is a

   376

	//     PACKET_SERVER_CLIENT_INFO

   377

	// Data:

   378

	//    uint16:  Client-Index

   379

	//

   380

   381

	Packet *p = NetworkSend_Init(PACKET_SERVER_JOIN);

   382

   383

	NetworkSend_uint16(p, client_index);

   384

   385

	NetworkSend_Packet(p, cs);

   386

}

   387

   388

   389

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_FRAME)

   390

{

   391

	//

   392

	// Packet: SERVER_FRAME

   393

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

   394

	// Data:

   395

	//    uint32: Frame Counter

   396

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

   397

	//    [uint32: general-seed-1]

   398

	//    [uint32: general-seed-2]

   399

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

   400

	//

   401

   402

	Packet *p = NetworkSend_Init(PACKET_SERVER_FRAME);

   403

	NetworkSend_uint32(p, _frame_counter);

   404

	NetworkSend_uint32(p, _frame_counter_max);

   405

#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME

   406

	NetworkSend_uint32(p, _sync_seed_1);

   407

#ifdef NETWORK_SEND_DOUBLE_SEED

   408

	NetworkSend_uint32(p, _sync_seed_2);

   409

#endif

   410

#endif

   411

	NetworkSend_Packet(p, cs);

   412

}

   413

   414

DEF_SERVER_SEND_COMMAND(PACKET_SERVER_SYNC)

   415

{

   416

	//

   417

	// Packet: SERVER_SYNC

   418

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

   419

	// Data:

   420

	//    uint32: Frame Counter

   421

	//    uint32: General-seed-1

   422

	//    [uint32: general-seed-2]

   423

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

   424

	//

   425

   426

	Packet *p = NetworkSend_Init(PACKET_SERVER_SYNC);

   427

	NetworkSend_uint32(p, _frame_counter);

   428

	NetworkSend_uint32(p, _sync_seed_1);

   429

   430

#ifdef NETWORK_SEND_DOUBLE_SEED

   431

	NetworkSend_uint32(p, _sync_seed_2);

   432

#endif

   433

	NetworkSend_Packet(p, cs);

   434

}

   435

   436

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

   437

{

   438

	//

   439

	// Packet: SERVER_COMMAND

   440

	// Function: Sends a DoCommand to the client

   441

	// Data:

   442

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

   443

	//    uint32: CommandID (see command.h)

   444

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

   445

	//    uint32: P2

   446

	//    uint32: Tile

   447

	//    string: text

   448

	//    uint8:  CallBackID (see callback_table.c)

   449

	//    uint32: Frame of execution

   450

	//

   451

   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

	NetworkSend_string(p, cp->text);

   460

	NetworkSend_uint8(p, cp->callback);

   461

	NetworkSend_uint32(p, cp->frame);

   462

   463

	NetworkSend_Packet(p, cs);

   464

}

   465

   466

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

   467

{

   468

	//

   469

	// Packet: SERVER_CHAT

   470

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

   471

	// Data:

   472

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

   473

	//    uint16:  Client-index

   474

	//    String: Message (max MAX_TEXT_MSG_LEN)

   475

	//

   476

   477

	Packet *p = NetworkSend_Init(PACKET_SERVER_CHAT);

   478

   479

	NetworkSend_uint8(p, action);

   480

	NetworkSend_uint16(p, client_index);

   481

	NetworkSend_uint8(p, self_send);

   482

	NetworkSend_string(p, msg);

   483

   484

	NetworkSend_Packet(p, cs);

   485

}

   486

   487

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

   488

{

   489

	//

   490

	// Packet: SERVER_ERROR_QUIT

   491

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

   492

	//      This packet informs the other clients of that.

   493

	// Data:

   494

	//    uint16:  Client-index

   495

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

   496

	//

   497

   498

	Packet *p = NetworkSend_Init(PACKET_SERVER_ERROR_QUIT);

   499

   500

	NetworkSend_uint16(p, client_index);

   501

	NetworkSend_uint8(p, errorno);

   502

   503

	NetworkSend_Packet(p, cs);

   504

}

   505

   506

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

   507

{

   508

	//

   509

	// Packet: SERVER_ERROR_QUIT

   510

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

   511

	//      of that.

   512

	// Data:

   513

	//    uint16:  Client-index

   514

	//    String: leave-message

   515

	//

   516

   517

	Packet *p = NetworkSend_Init(PACKET_SERVER_QUIT);