1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "console.h"

     4

#include "debug.h"

     5

#include "engine.h"

     6

#include "functions.h"

     7

#include "string.h"

     8

#include "variables.h"

     9

#include "network_data.h"

    10

#include "network_client.h"

    11

#include "network_server.h"

    12

#include "network_udp.h"

    13

#include "command.h"

    14

#include "settings.h"

    15

#include "hal.h" /* for file list */

    16

#include "vehicle.h"

    17

    18

// ** scriptfile handling ** //

    19

static FILE *_script_file;

    20

static bool _script_running;

    21

    22

// ** console command / variable defines ** //

    23

#define DEF_CONSOLE_CMD(function) static bool function(byte argc, char *argv[])

    24

#define DEF_CONSOLE_HOOK(function) static bool function(void)

    25

    26

    27

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

    28

/* variable and command hooks   */

    29

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

    30

    31

#ifdef ENABLE_NETWORK

    32

    33

static inline bool NetworkAvailable(void)

    34

{

    35

	if (!_network_available) {

    36

		IConsoleError("You cannot use this command because there is no network available.");

    37

		return false;

    38

	}

    39

	return true;

    40

}

    41

    42

DEF_CONSOLE_HOOK(ConHookServerOnly)

    43

{

    44

	if (!NetworkAvailable()) return false;

    45

    46

	if (!_network_server) {

    47

		IConsoleError("This command/variable is only available to a network server.");

    48

		return false;

    49

	}

    50

	return true;

    51

}

    52

    53

DEF_CONSOLE_HOOK(ConHookClientOnly)

    54

{

    55

	if (!NetworkAvailable()) return false;

    56

    57

	if (_network_server) {

    58

		IConsoleError("This command/variable is not available to a network server.");

    59

		return false;

    60

	}

    61

	return true;

    62

}

    63

    64

DEF_CONSOLE_HOOK(ConHookNeedNetwork)

    65

{

    66

	if (!NetworkAvailable()) return false;

    67

    68

	if (!_networking) {

    69

		IConsoleError("Not connected. This command/variable is only available in multiplayer.");

    70

		return false;

    71

	}

    72

	return true;

    73

}

    74

    75

DEF_CONSOLE_HOOK(ConHookNoNetwork)

    76

{

    77

	if (_networking) {

    78

		IConsoleError("This command/variable is forbidden in multiplayer.");

    79

		return false;

    80

	}

    81

	return true;

    82

}

    83

    84

#endif /* ENABLE_NETWORK */

    85

    86

static void IConsoleHelp(const char *str)

    87

{

    88

	IConsolePrintF(_icolour_warn, "- %s", str);

    89

}

    90

    91

DEF_CONSOLE_CMD(ConStopAllVehicles)

    92

{

    93

	Vehicle* v;

    94

	if (argc == 0) {

    95

		IConsoleHelp("Stops all vehicles in the game. For debugging only! Use at your own risk... Usage: 'stopall'");

    96

		return true;

    97

	}

    98

    99

	FOR_ALL_VEHICLES(v) {

   100

		if (IsValidVehicle(v)) {

   101

			/* Code ripped from CmdStartStopTrain. Can't call it, because of

   102

			 * ownership problems, so we'll duplicate some code, for now */

   103

			if (v->type == VEH_Train)

   104

				v->u.rail.days_since_order_progr = 0;

   105

			v->vehstatus |= VS_STOPPED;

   106

			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

   107

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   108

		}

   109

	}

   110

	return true;

   111

}

   112

   113

DEF_CONSOLE_CMD(ConResetEngines)

   114

{

   115

	if (argc == 0) {

   116

		IConsoleHelp("Reset status data of all engines. This might solve some issues with 'lost' engines. Usage: 'resetengines'");

   117

		return true;

   118

	}

   119

   120

	StartupEngines();

   121

	return true;

   122

}

   123

   124

#ifdef _DEBUG

   125

DEF_CONSOLE_CMD(ConResetTile)

   126

{

   127

	if (argc == 0) {

   128

		IConsoleHelp("Reset a tile to bare land. Usage: 'resettile <tile>'");

   129

		IConsoleHelp("Tile can be either decimal (34161) or hexadecimal (0x4a5B)");

   130

		return true;

   131

	}

   132

   133

	if (argc == 2) {

   134

		uint32 result;

   135

		if (GetArgumentInteger(&result, argv[1])) {

   136

			DoClearSquare((TileIndex)result);

   137

			return true;

   138

		}

   139

	}

   140

   141

	return false;

   142

}

   143

#endif /* _DEBUG */

   144

   145

DEF_CONSOLE_CMD(ConScrollToTile)

   146

{

   147

	if (argc == 0) {

   148

		IConsoleHelp("Center the screen on a given tile. Usage: 'scrollto <tile>'");

   149

		IConsoleHelp("Tile can be either decimal (34161) or hexadecimal (0x4a5B)");

   150

		return true;

   151

	}

   152

   153

	if (argc == 2) {

   154

		uint32 result;

   155

		if (GetArgumentInteger(&result, argv[1])) {

   156

			ScrollMainWindowToTile((TileIndex)result);

   157

			return true;

   158

		}

   159

	}

   160

   161

	return false;

   162

}

   163

   164

extern bool SafeSaveOrLoad(const char *filename, int mode, int newgm);

   165

extern void BuildFileList(void);

   166

extern void SetFiosType(const byte fiostype);

   167

   168

/* Save the map to a file */

   169

DEF_CONSOLE_CMD(ConSave)

   170

{

   171

	if (argc == 0) {

   172

		IConsoleHelp("Save the current game. Usage: 'save <filename>'");

   173

		return true;

   174

	}

   175

   176

	if (argc == 2) {

   177

		char buf[200];

   178

   179

		snprintf(buf, lengthof(buf), "%s%s%s.sav", _path.save_dir, PATHSEP, argv[1]);

   180

		IConsolePrint(_icolour_def, "Saving map...");

   181

   182

		if (SaveOrLoad(buf, SL_SAVE) != SL_OK) {

   183

			IConsolePrint(_icolour_err, "SaveMap failed");

   184

		} else

   185

			IConsolePrintF(_icolour_def, "Map sucessfully saved to %s", buf);

   186

		return true;

   187

	}

   188

   189

	return false;

   190

}

   191

   192

static const FiosItem* GetFiosItem(const char* file)

   193

{

   194

	int i;

   195

   196

	_saveload_mode = SLD_LOAD_GAME;

   197

	BuildFileList();

   198

   199

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

   200

		if (strcmp(file, _fios_list[i].name) == 0) break;

   202

	}

   203

   204

	if (i == _fios_num) { /* If no name matches, try to parse it as number */

   205

		char* endptr;

   206

   207

		i = strtol(file, &endptr, 10);

   208

		if (file == endptr || *endptr != '\0') i = -1;

   209

	}

   210

   211

	return IS_INT_INSIDE(i, 0, _fios_num) ? &_fios_list[i] : NULL;

   212

}

   213

   214

   215

DEF_CONSOLE_CMD(ConLoad)

   216

{

   217

	const FiosItem *item;

   218

	const char *file;

   219

   220

	if (argc == 0) {

   221

		IConsoleHelp("Load a game by name or index. Usage: 'load <file \\ number>'");

   222

		return true;

   223

	}

   224

   225

	if (argc != 2) return false;

   226

   227

	file = argv[1];

   228

	item = GetFiosItem(file);

   229

	if (item != NULL) {

   230

		switch (item->type) {

   232

				_switch_mode = SM_LOAD;

   233

				SetFiosType(item->type);

   238

			default: IConsolePrintF(_icolour_err, "%s: Not a savegame.", file);

   239

		}

   240

	} else

   241

		IConsolePrintF(_icolour_err, "%s: No such file or directory.", file);

   242

   243

	FiosFreeSavegameList();

   244

	return true;

   245

}

   246

   247

/* List all the files in the current dir via console */

   248

DEF_CONSOLE_CMD(ConListFiles)

   249

{

   250

	int i;

   251

   252

	if (argc == 0) {

   253

		IConsoleHelp("List all loadable savegames and directories in the current dir via console. Usage: 'ls \\ dir'");

   254

		return true;

   255

	}

   256

   257

	BuildFileList();

   258

   259

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

   260

		const FiosItem *item = &_fios_list[i];

   262

	}

   263

   264

	FiosFreeSavegameList();

   265

	return true;

   266

}

   267

   268

/* Change the dir via console */

   269

DEF_CONSOLE_CMD(ConChangeDirectory)

   270

{

   271

	const FiosItem *item;

   272

	const char *file;

   273

   274

	if (argc == 0) {

   275

		IConsoleHelp("Change the dir via console. Usage: 'cd <directory \\ number>'");

   276

		return true;

   277

	}

   278

   279

	if (argc != 2) return false;

   280

   281

	file = argv[1];

   282

	item = GetFiosItem(file);

   283

	if (item != NULL) {

   284

		switch (item->type) {

   285

			case FIOS_TYPE_DIR: case FIOS_TYPE_DRIVE: case FIOS_TYPE_PARENT:

   286

				FiosBrowseTo(item);

   287

				break;

   288

			default: IConsolePrintF(_icolour_err, "%s: Not a directory.", file);

   289

		}

   290

	} else

   291

		IConsolePrintF(_icolour_err, "%s: No such file or directory.", file);

   292

   293

	FiosFreeSavegameList();

   294

	return true;

   295

}

   296

   297

DEF_CONSOLE_CMD(ConPrintWorkingDirectory)

   298

{

   299

	const char *path;

   300

   301

	if (argc == 0) {

   302

		IConsoleHelp("Print out the current working directory. Usage: 'pwd'");

   303

		return true;

   304

	}

   305

   306

	// XXX - Workaround for broken file handling

   307

	FiosGetSavegameList(&_fios_num, SLD_LOAD_GAME);

   308

	FiosFreeSavegameList();

   309

   310

	FiosGetDescText(&path, NULL);

   311

	IConsolePrint(_icolour_def, path);

   312

	return true;

   313

}

   314

   315

DEF_CONSOLE_CMD(ConClearBuffer)

   316

{

   317

	if (argc == 0) {

   318

		IConsoleHelp("Clear the console buffer. Usage: 'clear'");

   319

		return true;

   320

	}

   321

   322

	IConsoleClearBuffer();

   323

	InvalidateWindow(WC_CONSOLE, 0);

   324

	return true;

   325

}

   326

   327

   328

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

   329

// * Network Core Console Commands * //

   330

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

   331

#ifdef ENABLE_NETWORK

   332

   333

DEF_CONSOLE_CMD(ConBan)

   334

{

   335

	NetworkClientInfo *ci;

   336

	uint32 index;

   337

   338

	if (argc == 0) {

   339

		IConsoleHelp("Ban a player from a network game. Usage: 'ban <client-id>'");

   340

		IConsoleHelp("For client-id's, see the command 'clients'");

   341

		return true;

   342

	}

   343

   344

	if (argc != 2) return false;

   345

   346

	index = atoi(argv[1]);

   347

   348

	if (index == NETWORK_SERVER_INDEX) {

   349

		IConsolePrint(_icolour_def, "Silly boy, you can not ban yourself!");

   350

		return true;

   351

	}

   352

	if (index == 0) {

   353

		IConsoleError("Invalid Client-ID");

   354

		return true;

   355

	}

   356

   357

	ci = NetworkFindClientInfoFromIndex(index);

   358

   359

	if (ci != NULL) {

   360

		uint i;

   361

		/* Add user to ban-list */

   362

		for (i = 0; i < lengthof(_network_ban_list); i++) {

   363

			if (_network_ban_list[i] == NULL || _network_ban_list[i][0] == '\0') {

   364

				_network_ban_list[i] = strdup(inet_ntoa(*(struct in_addr *)&ci->client_ip));

   365

				break;

   366

			}

   367

		}

   368

   369

		SEND_COMMAND(PACKET_SERVER_ERROR)(NetworkFindClientStateFromIndex(index), NETWORK_ERROR_KICKED);

   370

	} else

   371

		IConsoleError("Client-ID not found");

   372

   373

	return true;

   374

}

   375

   376

DEF_CONSOLE_CMD(ConUnBan)

   377

{

   378

	uint i;

   379

   380

	if (argc == 0) {

   381

		IConsoleHelp("Unban a player from a network game. Usage: 'unban <ip>'");

   382

		return true;

   383

	}

   384

   385

	if (argc != 2) return false;

   386

   387

	for (i = 0; i < lengthof(_network_ban_list); i++) {

   388

		if (_network_ban_list[i] == NULL || _network_ban_list[i][0] == '\0')

   389

			continue;

   390

   391

		if (strncmp(_network_ban_list[i], argv[1], strlen(_network_ban_list[i])) == 0) {

   392

			_network_ban_list[i][0] = '\0';

   393

			IConsolePrint(_icolour_def, "IP unbanned.");

   394

			return true;

   395

		}

   396

	}

   397

   398

	IConsolePrint(_icolour_def, "IP not in ban-list.");

   399

	return true;

   400

}

   401

   402

DEF_CONSOLE_CMD(ConBanList)

   403

{

   404

	uint i;

   405

   406

	if (argc == 0) {

   407

		IConsoleHelp("List the IP's of banned clients: Usage 'banlist'");

   408

		return true;

   409

	}

   410

   411

	IConsolePrint(_icolour_def, "Banlist: ");

   412

   413

	for (i = 0; i < lengthof(_network_ban_list); i++) {

   414

		if (_network_ban_list[i] == NULL || _network_ban_list[i][0] == '\0')

   415

			continue;

   416

   417

		IConsolePrintF(_icolour_def, "  %d) %s", i + 1, _network_ban_list[i]);

   418

	}

   419

   420

	return true;

   421

}

   422

   423

DEF_CONSOLE_CMD(ConPauseGame)

   424

{

   425

	if (argc == 0) {

   426

		IConsoleHelp("Pause a network game. Usage: 'pause'");

   427

		return true;

   428

	}

   429

   430

	if (_pause == 0) {

   431

		DoCommandP(0, 1, 0, NULL, CMD_PAUSE);

   432

		IConsolePrint(_icolour_def, "Game paused.");

   433

	} else

   434

		IConsolePrint(_icolour_def, "Game is already paused.");

   435

   436

	return true;

   437

}

   438

   439

DEF_CONSOLE_CMD(ConUnPauseGame)

   440

{

   441

	if (argc == 0) {

   442

		IConsoleHelp("Unpause a network game. Usage: 'unpause'");

   443

		return true;

   444

	}

   445

   446

	if (_pause != 0) {

   447

		DoCommandP(0, 0, 0, NULL, CMD_PAUSE);

   448

		IConsolePrint(_icolour_def, "Game unpaused.");

   449

	} else

   450

		IConsolePrint(_icolour_def, "Game is already unpaused.");

   451

   452

	return true;

   453

}

   454

   455

DEF_CONSOLE_CMD(ConRcon)

   456

{

   457

	if (argc == 0) {

   458

		IConsoleHelp("Remote control the server from another client. Usage: 'rcon <password> <command>'");

   459

		IConsoleHelp("Remember to enclose the command in quotes, otherwise only the first parameter is sent");

   460

		return true;

   461

	}

   462

   463

	if (argc < 3) return false;

   464

   465

	SEND_COMMAND(PACKET_CLIENT_RCON)(argv[1], argv[2]);

   466

	return true;

   467

}

   468

   469

DEF_CONSOLE_CMD(ConStatus)

   470

{

   471

	static const char *stat_str[] = {"inactive", "authorized", "waiting", "loading map", "map done", "ready", "active"};

   472

	const char *status;

   473

	const NetworkClientState *cs;

   474

   475

	if (argc == 0) {

   476

		IConsoleHelp("List the status of all clients connected to the server: Usage 'status'");

   477

		return true;

   478

	}

   479

   480

	FOR_ALL_CLIENTS(cs) {

   481

		int lag = NetworkCalculateLag(cs);

   482

		const NetworkClientInfo *ci = DEREF_CLIENT_INFO(cs);

   483