1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "console.h"

     4

#include "debug.h"

     5

#include "engine.h"

     6

#include "functions.h"

     8

#include "string.h"

     9

#include "variables.h"

    10

#include "network_data.h"

    11

#include "network_client.h"

    12

#include "network_server.h"

    13

#include "network_udp.h"

    14

#include "command.h"

    15

#include "settings.h"

    16

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

    17

#include "vehicle.h"

    18

    19

// ** scriptfile handling ** //

    20

static FILE *_script_file;

    21

static bool _script_running;

    22

    23

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

    24

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

    25

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

    26

    27

    28

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

    29

/* variable and command hooks   */

    30

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

    31

    32

#ifdef ENABLE_NETWORK

    33

    34

static inline bool NetworkAvailable(void)

    35

{

    36

	if (!_network_available) {

    37

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

    38

		return false;

    39

	}

    40

	return true;

    41

}

    42

    43

DEF_CONSOLE_HOOK(ConHookServerOnly)

    44

{

    45

	if (!NetworkAvailable()) return false;

    46

    47

	if (!_network_server) {

    48

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

    49

		return false;

    50

	}

    51

	return true;

    52

}

    53

    54

DEF_CONSOLE_HOOK(ConHookClientOnly)

    55

{

    56

	if (!NetworkAvailable()) return false;

    57

    58

	if (_network_server) {

    59

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

    60

		return false;

    61

	}

    62

	return true;

    63

}

    64

    65

DEF_CONSOLE_HOOK(ConHookNeedNetwork)

    66

{

    67

	if (!NetworkAvailable()) return false;

    68

    69

	if (!_networking) {

    70

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

    71

		return false;

    72

	}

    73

	return true;

    74

}

    75

    76

DEF_CONSOLE_HOOK(ConHookNoNetwork)

    77

{

    78

	if (_networking) {

    79

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

    80

		return false;

    81

	}

    82

	return true;

    83

}

    84

    85

#endif /* ENABLE_NETWORK */

    86

    87

static void IConsoleHelp(const char *str)

    88

{

    89

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

    90

}

    91

    92

DEF_CONSOLE_CMD(ConStopAllVehicles)

    93

{

    94

	Vehicle* v;

    95

	if (argc == 0) {

    96

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

    97

		return true;

    98

	}

    99

   100

	FOR_ALL_VEHICLES(v) {

   101

		if (IsValidVehicle(v)) {

   102

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

   103

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

   104

			if (v->type == VEH_Train)

   105

				v->u.rail.days_since_order_progr = 0;

   106

			v->vehstatus |= VS_STOPPED;

   107

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

   108

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   109

		}

   110

	}

   111

	return true;

   112

}

   113

   114

DEF_CONSOLE_CMD(ConResetEngines)

   115

{

   116

	if (argc == 0) {

   117

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

   118

		return true;

   119

	}

   120

   121

	StartupEngines();

   122

	return true;

   123

}

   124

   125

#ifdef _DEBUG

   126

DEF_CONSOLE_CMD(ConResetTile)

   127

{

   128

	if (argc == 0) {

   129

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

   130

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

   131

		return true;

   132

	}

   133

   134

	if (argc == 2) {

   135

		uint32 result;

   136

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

   137

			DoClearSquare((TileIndex)result);

   138

			return true;

   139

		}

   140

	}

   141

   142

	return false;

   143

}

   144

#endif /* _DEBUG */

   145

   146

DEF_CONSOLE_CMD(ConScrollToTile)

   147

{

   148

	if (argc == 0) {

   149

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

   150

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

   151

		return true;

   152

	}

   153

   154

	if (argc == 2) {

   155

		uint32 result;

   156

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

   157

			ScrollMainWindowToTile((TileIndex)result);

   158

			return true;

   159

		}

   160

	}

   161

   162

	return false;

   163

}

   164

   165

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

   166

extern void BuildFileList(void);

   167

extern void SetFiosType(const byte fiostype);

   168

   169

/* Save the map to a file */

   170

DEF_CONSOLE_CMD(ConSave)

   171

{

   172

	if (argc == 0) {

   173

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

   174

		return true;

   175

	}

   176

   177

	if (argc == 2) {

   178

		char buf[200];

   179

   180

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

   181

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

   182

   183

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

   184

			IConsolePrint(_icolour_err, "SaveMap failed");

   185

		} else

   186

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

   187

		return true;

   188

	}

   189

   190

	return false;

   191

}

   192

   193

static const FiosItem* GetFiosItem(const char* file)

   194

{

   195

	int i;

   196

   197

	_saveload_mode = SLD_LOAD_GAME;

   198

	BuildFileList();

   199

   200

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

   201

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

   202

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

   203

	}

   204

   205

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

   206

		char* endptr;

   207

   208

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

   209

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

   210

	}

   211

   212

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

   213

}

   214

   215

   216

DEF_CONSOLE_CMD(ConLoad)

   217

{

   218

	const FiosItem *item;

   219

	const char *file;

   220

   221

	if (argc == 0) {

   222

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

   223

		return true;

   224

	}

   225

   226

	if (argc != 2) return false;

   227

   228

	file = argv[1];

   229

	item = GetFiosItem(file);

   230

	if (item != NULL) {

   231

		switch (item->type) {

   232

			case FIOS_TYPE_FILE: case FIOS_TYPE_OLDFILE: {

   233

				_switch_mode = SM_LOAD;

   234

				SetFiosType(item->type);

   235

   236

				ttd_strlcpy(_file_to_saveload.name, FiosBrowseTo(item), sizeof(_file_to_saveload.name));

   237

				ttd_strlcpy(_file_to_saveload.title, item->title, sizeof(_file_to_saveload.title));

   238

			} break;

   239

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

   240

		}

   241

	} else

   242

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

   243

   244

	FiosFreeSavegameList();

   245

	return true;

   246

}

   247

   248

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

   249

DEF_CONSOLE_CMD(ConListFiles)

   250

{

   251

	int i;

   252

   253

	if (argc == 0) {

   254

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

   255

		return true;

   256

	}

   257

   258

	BuildFileList();

   259

   260

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

   261

		const FiosItem *item = &_fios_list[i];

   262

		IConsolePrintF(_icolour_def, "%d) %s", i, item->title);

   263

	}

   264

   265

	FiosFreeSavegameList();

   266

	return true;

   267

}

   268

   269

/* Change the dir via console */

   270

DEF_CONSOLE_CMD(ConChangeDirectory)

   271

{

   272

	const FiosItem *item;

   273

	const char *file;

   274

   275

	if (argc == 0) {

   276

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

   277

		return true;

   278

	}

   279

   280

	if (argc != 2) return false;

   281

   282

	file = argv[1];

   283

	item = GetFiosItem(file);

   284

	if (item != NULL) {

   285

		switch (item->type) {

   286

			case FIOS_TYPE_DIR: case FIOS_TYPE_DRIVE: case FIOS_TYPE_PARENT:

   287

				FiosBrowseTo(item);

   288

				break;

   289

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

   290

		}

   291

	} else

   292

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

   293

   294

	FiosFreeSavegameList();

   295

	return true;

   296

}

   297

   298

DEF_CONSOLE_CMD(ConPrintWorkingDirectory)

   299

{

   300

	const char *path;

   301

   302

	if (argc == 0) {

   303

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

   304

		return true;

   305

	}

   306

   307

	// XXX - Workaround for broken file handling

   308

	FiosGetSavegameList(&_fios_num, SLD_LOAD_GAME);

   309

	FiosFreeSavegameList();

   310

   311

	FiosGetDescText(&path, NULL);

   312

	IConsolePrint(_icolour_def, path);

   313

	return true;

   314

}

   315

   316

DEF_CONSOLE_CMD(ConClearBuffer)

   317

{

   318

	if (argc == 0) {

   319

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

   320

		return true;

   321

	}

   322

   323

	IConsoleClearBuffer();

   324

	InvalidateWindow(WC_CONSOLE, 0);

   325

	return true;

   326

}

   327

   328

   329

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

   330

// * Network Core Console Commands * //

   331

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

   332

#ifdef ENABLE_NETWORK

   333

   334

DEF_CONSOLE_CMD(ConBan)

   335

{

   336

	NetworkClientInfo *ci;

   337

	uint32 index;

   338

   339

	if (argc == 0) {

   340

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

   341

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

   342

		return true;

   343

	}

   344

   345

	if (argc != 2) return false;

   346

   347

	index = atoi(argv[1]);

   348

   349

	if (index == NETWORK_SERVER_INDEX) {

   350

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

   351

		return true;

   352

	}

   353

	if (index == 0) {

   354

		IConsoleError("Invalid Client-ID");

   355

		return true;

   356

	}

   357

   358

	ci = NetworkFindClientInfoFromIndex(index);

   359

   360

	if (ci != NULL) {

   361

		uint i;

   362

		/* Add user to ban-list */

   363

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

   364

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

   365

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

   366

				break;

   367

			}

   368

		}

   369

   370

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

   371

	} else

   372

		IConsoleError("Client-ID not found");

   373

   374

	return true;

   375

}

   376

   377

DEF_CONSOLE_CMD(ConUnBan)

   378

{

   379

	uint i;

   380

   381

	if (argc == 0) {

   382

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

   383

		return true;

   384

	}

   385

   386

	if (argc != 2) return false;

   387

   388

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

   389

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

   390

			continue;

   391

   392

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

   393

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

   394

			IConsolePrint(_icolour_def, "IP unbanned.");

   395

			return true;

   396

		}

   397

	}

   398

   399

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

   400

	return true;

   401

}

   402

   403

DEF_CONSOLE_CMD(ConBanList)

   404

{

   405

	uint i;

   406

   407

	if (argc == 0) {

   408

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

   409

		return true;

   410

	}

   411

   412

	IConsolePrint(_icolour_def, "Banlist: ");

   413

   414

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

   415

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

   416

			continue;

   417

   418

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

   419

	}

   420

   421

	return true;

   422

}

   423

   424

DEF_CONSOLE_CMD(ConPauseGame)

   425

{

   426

	if (argc == 0) {

   427

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

   428

		return true;

   429

	}

   430

   431

	if (_pause == 0) {

   432

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

   433

		IConsolePrint(_icolour_def, "Game paused.");

   434

	} else

   435

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

   436

   437

	return true;

   438

}

   439

   440

DEF_CONSOLE_CMD(ConUnPauseGame)

   441

{

   442

	if (argc == 0) {

   443

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

   444

		return true;

   445

	}

   446

   447

	if (_pause != 0) {

   448

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

   449

		IConsolePrint(_icolour_def, "Game unpaused.");

   450

	} else

   451

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

   452

   453

	return true;

   454

}

   455

   456

DEF_CONSOLE_CMD(ConRcon)

   457

{

   458

	if (argc == 0) {

   459

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

   460

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

   461

		return true;

   462

	}

   463

   464

	if (argc < 3) return false;

   465

   466

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

   467

	return true;

   468

}

   469

   470

DEF_CONSOLE_CMD(ConStatus)

   471

{

   472

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

   473

	const char *status;

   474

	const NetworkClientState *cs;

   475

   476

	if (argc == 0) {

   477

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

   478

		return true;

   479

	}

   480

   481

	FOR_ALL_CLIENTS(cs) {

   482

		int lag = NetworkCalculateLag(cs);

   483

		const NetworkClientInfo *ci = DEREF_CLIENT_INFO(cs);