1

/* $Id$ */

     2

     3

/** @file console.cpp Handling of the in-game console. */

     4

     5

#include "stdafx.h"

     6

#include "console_internal.h"

     7

#include "network/network_data.h"

     8

#include "network/network_server.h"

     9

#include "core/alloc_func.hpp"

    10

#include "string_func.h"

    11

#include "rev.h"

    12

    13

#include <stdarg.h>

    14

    15

#include "table/strings.h"

    16

    17

#define ICON_BUFFER 79

    18

#define ICON_HISTORY_SIZE 20

    19

#define ICON_LINE_HEIGHT 12

    20

#define ICON_RIGHT_BORDERWIDTH 10

    21

#define ICON_BOTTOM_BORDERWIDTH 12

    22

#define ICON_MAX_ALIAS_LINES 40

    23

#define ICON_TOKEN_COUNT 20

    24

    25

/* console parser */

    26

IConsoleCmd   *_iconsole_cmds;    ///< list of registred commands

    27

IConsoleVar   *_iconsole_vars;    ///< list of registred vars

    28

IConsoleAlias *_iconsole_aliases; ///< list of registred aliases

    29

    30

/* ** stdlib ** */

    31

byte _stdlib_developer = 1;

    32

bool _stdlib_con_developer = false;

    33

FILE *_iconsole_output_file;

    34

    35

void IConsoleInit()

    36

{

    37

	_iconsole_output_file = NULL;

    38

#ifdef ENABLE_NETWORK /* Initialize network only variables */

    39

	_redirect_console_to_client = 0;

    40

#endif

    41

    42

	IConsoleGUIInit();

    43

    44

	IConsoleStdLibRegister();

    45

}

    46

    47

static void IConsoleWriteToLogFile(const char *string)

    48

{

    49

	if (_iconsole_output_file != NULL) {

    50

		/* if there is an console output file ... also print it there */

    51

		if (fwrite(string, strlen(string), 1, _iconsole_output_file) != 1 ||

    52

				fwrite("\n", 1, 1, _iconsole_output_file) != 1) {

    53

			fclose(_iconsole_output_file);

    54

			_iconsole_output_file = NULL;

    55

			IConsolePrintF(CC_DEFAULT, "cannot write to log file");

    56

		}

    57

	}

    58

}

    59

    60

bool CloseConsoleLogIfActive()

    61

{

    62

	if (_iconsole_output_file != NULL) {

    63

		IConsolePrintF(CC_DEFAULT, "file output complete");

    64

		fclose(_iconsole_output_file);

    65

		_iconsole_output_file = NULL;

    66

		return true;

    67

	}

    68

    69

	return false;

    70

}

    71

    72

void IConsoleFree()

    73

{

    74

	IConsoleGUIFree();

    75

	CloseConsoleLogIfActive();

    76

}

    77

    78

/**

    79

 * Handle the printing of text entered into the console or redirected there

    80

 * by any other means. Text can be redirected to other players in a network game

    81

 * as well as to a logfile. If the network server is a dedicated server, all activities

    82

 * are also logged. All lines to print are added to a temporary buffer which can be

    83

 * used as a history to print them onscreen

    84

 * @param color_code the colour of the command. Red in case of errors, etc.

    85

 * @param string the message entered or output on the console (notice, error, etc.)

    86

 */

    87

void IConsolePrint(ConsoleColour color_code, const char *string)

    88

{

    89

	char *str;

    90

#ifdef ENABLE_NETWORK

    91

	if (_redirect_console_to_client != 0) {

    92

		/* Redirect the string to the client */

    93

		SEND_COMMAND(PACKET_SERVER_RCON)(NetworkFindClientStateFromIndex(_redirect_console_to_client), color_code, string);

    94

		return;

    95

	}

    96

#endif

    97

    98

	/* Create a copy of the string, strip if of colours and invalid

    99

	 * characters and (when applicable) assign it to the console buffer */

   100

	str = strdup(string);

   101

	str_strip_colours(str);

   102

	str_validate(str);

   103

   104

	if (_network_dedicated) {

   105

		fprintf(stdout, "%s\n", str);

   106

		fflush(stdout);

   107

		IConsoleWriteToLogFile(str);

   108

		free(str); // free duplicated string since it's not used anymore

   109

		return;

   110

	}

   111

   112

	IConsoleWriteToLogFile(str);

   113

	IConsoleGUIPrint(color_code, str);

   114

}

   115

   116

/**

   117

 * Handle the printing of text entered into the console or redirected there

   118

 * by any other means. Uses printf() style format, for more information look

   119

 * at IConsolePrint()

   120

 */

   121

void CDECL IConsolePrintF(ConsoleColour color_code, const char *s, ...)

   122

{

   123

	va_list va;

   124

	char buf[ICON_MAX_STREAMSIZE];

   125

   126

	va_start(va, s);

   127

	vsnprintf(buf, sizeof(buf), s, va);

   128

	va_end(va);

   129

   130

	IConsolePrint(color_code, buf);

   131

}

   132

   133

/**

   134

 * It is possible to print debugging information to the console,

   135

 * which is achieved by using this function. Can only be used by

   136

 * debug() in debug.cpp. You need at least a level 2 (developer) for debugging

   137

 * messages to show up

   138

 * @param dbg debugging category

   139

 * @param string debugging message

   140

 */

   141

void IConsoleDebug(const char *dbg, const char *string)

   142

{

   143

	if (_stdlib_developer > 1)

   144

		IConsolePrintF(CC_DEBUG, "dbg: [%s] %s", dbg, string);

   145

}

   146

   147

/**

   148

 * It is possible to print warnings to the console. These are mostly

   149

 * errors or mishaps, but non-fatal. You need at least a level 1 (developer) for

   150

 * debugging messages to show up

   151

 */

   152

void IConsoleWarning(const char *string)

   153

{

   154

	if (_stdlib_developer > 0)

   155

		IConsolePrintF(CC_WARNING, "WARNING: %s", string);

   156

}

   157

   158

/**

   159

 * It is possible to print error information to the console. This can include

   160

 * game errors, or errors in general you would want the user to notice

   161

 */

   162

void IConsoleError(const char *string)

   163

{

   164

	IConsolePrintF(CC_ERROR, "ERROR: %s", string);

   165

}

   166

   167

/**

   168

 * Change a string into its number representation. Supports

   169

 * decimal and hexadecimal numbers as well as 'on'/'off' 'true'/'false'

   170

 * @param *value the variable a successful conversion will be put in

   171

 * @param *arg the string to be converted

   172

 * @return Return true on success or false on failure

   173

 */

   174

bool GetArgumentInteger(uint32 *value, const char *arg)

   175

{

   176

	char *endptr;

   177

   178

	if (strcmp(arg, "on") == 0 || strcmp(arg, "true") == 0) {

   179

		*value = 1;

   180

		return true;

   181

	}

   182

	if (strcmp(arg, "off") == 0 || strcmp(arg, "false") == 0) {

   183

		*value = 0;

   184

		return true;

   185

	}

   186

   187

	*value = strtoul(arg, &endptr, 0);

   188

	return arg != endptr;

   189

}

   190

   191

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

   192

    * hooking code            *

   193

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

   194

   195

/**

   196

 * General internal hooking code that is the same for both commands and variables

   197

 * @param hooks IConsoleHooks structure that will be set according to

   198

 * @param type type access trigger

   199

 * @param proc function called when the hook criteria is met

   200

 */

   201

static void IConsoleHookAdd(IConsoleHooks *hooks, IConsoleHookTypes type, IConsoleHook *proc)

   202

{

   203

	if (hooks == NULL || proc == NULL) return;

   204

   205

	switch (type) {

   206

		case ICONSOLE_HOOK_ACCESS:

   207

			hooks->access = proc;

   208

			break;

   209

		case ICONSOLE_HOOK_PRE_ACTION:

   210

			hooks->pre = proc;

   211

			break;

   212

		case ICONSOLE_HOOK_POST_ACTION:

   213

			hooks->post = proc;

   214

			break;

   215

		default: NOT_REACHED();

   216

	}

   217

}

   218

   219

/**

   220

 * Handle any special hook triggers. If the hook type is met check if

   221

 * there is a function associated with that and if so, execute it

   222

 * @param hooks IConsoleHooks structure that will be checked

   223

 * @param type type of hook, trigger that needs to be activated

   224

 * @return true on a successful execution of the hook command or if there

   225

 * is no hook/trigger present at all. False otherwise

   226

 */

   227

static bool IConsoleHookHandle(const IConsoleHooks *hooks, IConsoleHookTypes type)

   228

{

   229

	IConsoleHook *proc = NULL;

   230

	if (hooks == NULL) return false;

   231

   232

	switch (type) {

   233

		case ICONSOLE_HOOK_ACCESS:

   234

			proc = hooks->access;

   235

			break;

   236

		case ICONSOLE_HOOK_PRE_ACTION:

   237

			proc = hooks->pre;

   238

			break;

   239

		case ICONSOLE_HOOK_POST_ACTION:

   240

			proc = hooks->post;

   241

			break;

   242

		default: NOT_REACHED();

   243

	}

   244

   245

	return (proc == NULL) ? true : proc();

   246

}

   247

   248

/**

   249

 * Add a hook to a command that will be triggered at certain points

   250

 * @param name name of the command that the hook is added to

   251

 * @param type type of hook that is added (ACCESS, BEFORE and AFTER change)

   252

 * @param proc function called when the hook criteria is met

   253

 */

   254

void IConsoleCmdHookAdd(const char *name, IConsoleHookTypes type, IConsoleHook *proc)

   255

{

   256

	IConsoleCmd *cmd = IConsoleCmdGet(name);

   257

	if (cmd == NULL) return;

   258

	IConsoleHookAdd(&cmd->hook, type, proc);

   259

}

   260

   261

/**

   262

 * Add a hook to a variable that will be triggered at certain points

   263

 * @param name name of the variable that the hook is added to

   264

 * @param type type of hook that is added (ACCESS, BEFORE and AFTER change)

   265

 * @param proc function called when the hook criteria is met

   266

 */

   267

void IConsoleVarHookAdd(const char *name, IConsoleHookTypes type, IConsoleHook *proc)

   268

{

   269

	IConsoleVar *var = IConsoleVarGet(name);

   270

	if (var == NULL) return;

   271

	IConsoleHookAdd(&var->hook, type, proc);

   272

}

   273

   274

/**

   275

 * Perhaps ugly macro, but this saves us the trouble of writing the same function

   276

 * three types, just with different variables. Yes, templates would be handy. It was

   277

 * either this define or an even more ugly void* magic function

   278

 */

   279

#define IConsoleAddSorted(_base, item_new, IConsoleType, type)                 \

   280

{                                                                              \

   281

	IConsoleType *item, *item_before;                                            \

   282

	/* first command */                                                          \

   283

	if (_base == NULL) {                                                         \

   284

		_base = item_new;                                                          \

   285

		return;                                                                    \

   286

	}                                                                            \

   287

                                                                               \

   288

	item_before = NULL;                                                          \

   289

	item = _base;                                                                \

   290

                                                                               \

   291

	/* BEGIN - Alphabetically insert the commands into the linked list */        \

   292

	while (item != NULL) {                                                       \

   293

		int i = strcmp(item->name, item_new->name);                                \

   294

		if (i == 0) {                                                              \

   295

			IConsoleError(type " with this name already exists; insertion aborted"); \

   296

			free(item_new);                                                          \

   297

			return;                                                                  \

   298

		}                                                                          \

   299

                                                                               \

   300

		if (i > 0) break; /* insert at this position */                            \

   301

                                                                               \

   302

		item_before = item;                                                        \

   303

		item = item->next;                                                         \

   304

	}                                                                            \

   305

                                                                               \

   306

	if (item_before == NULL) {                                                   \

   307

		_base = item_new;                                                          \

   308

	} else {                                                                     \

   309

		item_before->next = item_new;                                              \

   310

  }                                                                            \

   311

                                                                               \

   312

	item_new->next = item;                                                       \

   313

	/* END - Alphabetical insert */                                              \

   314

}

   315

   316

/**

   317

 * Register a new command to be used in the console

   318

 * @param name name of the command that will be used

   319

 * @param proc function that will be called upon execution of command

   320

 */

   321

void IConsoleCmdRegister(const char *name, IConsoleCmdProc *proc)

   322

{

   323

	char *new_cmd = strdup(name);

   324

	IConsoleCmd *item_new = MallocT<IConsoleCmd>(1);

   325

   326

	item_new->next = NULL;

   327

	item_new->proc = proc;

   328

	item_new->name = new_cmd;

   329

   330

	item_new->hook.access = NULL;

   331

	item_new->hook.pre = NULL;

   332

	item_new->hook.post = NULL;

   333

   334

	IConsoleAddSorted(_iconsole_cmds, item_new, IConsoleCmd, "a command");

   335

}

   336

   337

/**

   338

 * Find the command pointed to by its string

   339

 * @param name command to be found

   340

 * @return return Cmdstruct of the found command, or NULL on failure

   341

 */

   342

IConsoleCmd *IConsoleCmdGet(const char *name)

   343

{

   344

	IConsoleCmd *item;

   345

   346

	for (item = _iconsole_cmds; item != NULL; item = item->next) {

   347

		if (strcmp(item->name, name) == 0) return item;

   348

	}

   349

	return NULL;

   350

}

   351

   352

/**

   353

 * Register a an alias for an already existing command in the console

   354

 * @param name name of the alias that will be used

   355

 * @param cmd name of the command that 'name' will be alias of

   356

 */

   357

void IConsoleAliasRegister(const char *name, const char *cmd)

   358

{

   359

	char *new_alias = strdup(name);

   360

	char *cmd_aliased = strdup(cmd);

   361

	IConsoleAlias *item_new = MallocT<IConsoleAlias>(1);

   362

   363

	item_new->next = NULL;

   364

	item_new->cmdline = cmd_aliased;

   365

	item_new->name = new_alias;

   366

   367

	IConsoleAddSorted(_iconsole_aliases, item_new, IConsoleAlias, "an alias");

   368

}

   369

   370

/**

   371

 * Find the alias pointed to by its string

   372

 * @param name alias to be found

   373

 * @return return Aliasstruct of the found alias, or NULL on failure

   374

 */

   375

IConsoleAlias *IConsoleAliasGet(const char *name)

   376

{

   377

	IConsoleAlias* item;

   378

   379

	for (item = _iconsole_aliases; item != NULL; item = item->next) {

   380

		if (strcmp(item->name, name) == 0) return item;

   381

	}

   382

   383

	return NULL;

   384

}

   385

   386

/** copy in an argument into the aliasstream */

   387

static inline int IConsoleCopyInParams(char *dst, const char *src, uint bufpos)

   388

{

   389

	int len = min(ICON_MAX_STREAMSIZE - bufpos, (uint)strlen(src));

   390

	strncpy(dst, src, len);

   391

   392

	return len;

   393

}

   394

   395

/**

   396

 * An alias is just another name for a command, or for more commands

   397

 * Execute it as well.

   398

 * @param *alias is the alias of the command

   399

 * @param tokencount the number of parameters passed

   400

 * @param *tokens are the parameters given to the original command (0 is the first param)

   401

 */

   402

static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT])

   403

{

   404

	const char *cmdptr;

   405

	char *aliases[ICON_MAX_ALIAS_LINES], aliasstream[ICON_MAX_STREAMSIZE];

   406

	uint i;

   407

	uint a_index, astream_i;

   408

   409

	memset(&aliases, 0, sizeof(aliases));

   410

	memset(&aliasstream, 0, sizeof(aliasstream));

   411

   412

	if (_stdlib_con_developer)

   413

		IConsolePrintF(CC_DEBUG, "condbg: requested command is an alias; parsing...");

   414

   415

	aliases[0] = aliasstream;

   416

	for (cmdptr = alias->cmdline, a_index = 0, astream_i = 0; *cmdptr != '\0'; cmdptr++) {

   417

		if (a_index >= lengthof(aliases) || astream_i >= lengthof(aliasstream)) break;

   418

   419

		switch (*cmdptr) {

   420

		case '\'': // ' will double for ""

   421

			aliasstream[astream_i++] = '"';

   422

			break;

   423

		case ';': // Cmd seperator, start new command

   424

			aliasstream[astream_i] = '\0';

   425

			aliases[++a_index] = &aliasstream[++astream_i];

   426

			cmdptr++;

   427

			break;

   428

		case '%': // Some or all parameters

   429

			cmdptr++;

   430

			switch (*cmdptr) {

   431

			case '+': { // All parameters seperated: "[param 1]" "[param 2]"

   432

				for (i = 0; i != tokencount; i++) {

   433

					aliasstream[astream_i++] = '"';

   434

					astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[i], astream_i);

   435

					aliasstream[astream_i++] = '"';

   436

					aliasstream[astream_i++] = ' ';

   437

				}

   438

			} break;

   439

			case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"

   440

				aliasstream[astream_i++] = '"';

   441

				for (i = 0; i != tokencount; i++) {

   442

					astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[i], astream_i);

   443

					aliasstream[astream_i++] = ' ';

   444

				}

   445

				aliasstream[astream_i++] = '"';

   446

   447

			} break;

   448

				default: { // One specific parameter: %A = [param 1] %B = [param 2] ...

   449

				int param = *cmdptr - 'A';

   450

   451

				if (param < 0 || param >= tokencount) {

   452

					IConsoleError("too many or wrong amount of parameters passed to alias, aborting");

   453

					IConsolePrintF(CC_WARNING, "Usage of alias '%s': %s", alias->name, alias->cmdline);

   454

					return;

   455

				}

   456

   457

				aliasstream[astream_i++] = '"';

   458

				astream_i += IConsoleCopyInParams(&aliasstream[astream_i], tokens[param], astream_i);

   459

				aliasstream[astream_i++] = '"';

   460

			} break;

   461

			} break;

   462

   463

		default:

   464

			aliasstream[astream_i++] = *cmdptr;

   465

			break;

   466

		}

   467

	}

   468

   469

	for (i = 0; i <= a_index; i++) IConsoleCmdExec(aliases[i]); // execute each alias in turn

   470

}

   471

   472

/**

   473

 * Special function for adding string-type variables. They in addition

   474

 * also need a 'size' value saying how long their string buffer is.

   475

 * @param name name of the variable that will be used

   476

 * @param addr memory location the variable will point to

   477

 * @param size the length of the string buffer

   478

 * @param help the help string shown for the variable

   479

 * For more information see IConsoleVarRegister()

   480

 */

   481

void IConsoleVarStringRegister(const char *name, void *addr, uint32 size, const char *help)

   482

{

   483

	IConsoleVar *var;

   484

	IConsoleVarRegister(name, addr, ICONSOLE_VAR_STRING, help);

   485

	var = IConsoleVarGet(name);