1

/* $Id$ */

     2

     3

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

     4

     5

#include "stdafx.h"

     6

#include "core/alloc_func.hpp"

     7

#include "string_func.h"

     8

#include "strings_type.h"

     9

#include "core/math_func.hpp"

    10

#include "console_internal.h"

    11

#include "network/network.h"

    12

#include "network/network_func.h"

    13

#include "rev.h"

    14

    15

#include <stdarg.h>

    16

    17

#include "table/strings.h"

    18

    19

#define ICON_BUFFER 79

    20

#define ICON_HISTORY_SIZE 20

    21

#define ICON_LINE_HEIGHT 12

    22

#define ICON_RIGHT_BORDERWIDTH 10

    23

#define ICON_BOTTOM_BORDERWIDTH 12

    24

#define ICON_MAX_ALIAS_LINES 40

    25

#define ICON_TOKEN_COUNT 20

    26

    27

/* console parser */

    28

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

    29

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

    30

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

    31

    32

/* ** stdlib ** */

    33

byte _stdlib_developer = 1;

    34

bool _stdlib_con_developer = false;

    35

FILE *_iconsole_output_file;

    36

    37

void IConsoleInit()

    38

{

    39

	_iconsole_output_file = NULL;

    40

#ifdef ENABLE_NETWORK /* Initialize network only variables */

    41

	_redirect_console_to_client = 0;

    42

#endif

    43

    44

	IConsoleGUIInit();

    45

    46

	IConsoleStdLibRegister();

    47

}

    48

    49

static void IConsoleWriteToLogFile(const char *string)

    50

{

    51

	if (_iconsole_output_file != NULL) {

    52

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

    53

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

    54

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

    55

			fclose(_iconsole_output_file);

    56

			_iconsole_output_file = NULL;

    57

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

    58

		}

    59

	}

    60

}

    61

    62

bool CloseConsoleLogIfActive()

    63

{

    64

	if (_iconsole_output_file != NULL) {

    65

		IConsolePrintF(CC_DEFAULT, "file output complete");

    66

		fclose(_iconsole_output_file);

    67

		_iconsole_output_file = NULL;

    68

		return true;

    69

	}

    70

    71

	return false;

    72

}

    73

    74

void IConsoleFree()

    75

{

    76

	IConsoleGUIFree();

    77

	CloseConsoleLogIfActive();

    78

}

    79

    80

/**

    81

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

    82

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

    83

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

    84

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

    85

 * used as a history to print them onscreen

    86

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

    87

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

    88

 */

    89

void IConsolePrint(ConsoleColour color_code, const char *string)

    90

{

    91

	char *str;

    92

#ifdef ENABLE_NETWORK

    93

	if (_redirect_console_to_client != 0) {

    94

		/* Redirect the string to the client */

    95

		NetworkServerSendRcon(_redirect_console_to_client, color_code, string);

    96

		return;

    97

	}

    98

#endif

    99

   100

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

   101

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

   102

	str = strdup(string);

   103

	str_strip_colours(str);

   104

	str_validate(str);

   105

   106

	if (_network_dedicated) {

   107

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

   108

		fflush(stdout);

   109

		IConsoleWriteToLogFile(str);

   110

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

   111

		return;

   112

	}

   113

   114

	IConsoleWriteToLogFile(str);

   115

	IConsoleGUIPrint(color_code, str);

   116

}

   117

   118

/**

   119

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

   120

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

   121

 * at IConsolePrint()

   122

 */

   123

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

   124

{

   125

	va_list va;

   126

	char buf[ICON_MAX_STREAMSIZE];

   127

   128

	va_start(va, s);

   129

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

   130

	va_end(va);

   131

   132

	IConsolePrint(color_code, buf);

   133

}

   134

   135

/**

   136

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

   137

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

   138

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

   139

 * messages to show up

   140

 * @param dbg debugging category

   141

 * @param string debugging message

   142

 */

   143

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

   144

{

   145

	if (_stdlib_developer > 1)

   146

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

   147

}

   148

   149

/**

   150

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

   151

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

   152

 * debugging messages to show up

   153

 */

   154

void IConsoleWarning(const char *string)

   155

{

   156

	if (_stdlib_developer > 0)

   157

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

   158

}

   159

   160

/**

   161

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

   162

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

   163

 */

   164

void IConsoleError(const char *string)

   165

{

   166

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

   167

}

   168

   169

/**

   170

 * Change a string into its number representation. Supports

   171

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

   172

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

   173

 * @param *arg the string to be converted

   174

 * @return Return true on success or false on failure

   175

 */

   176

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

   177

{

   178

	char *endptr;

   179

   180

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

   181

		*value = 1;

   182

		return true;

   183

	}

   184

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

   185

		*value = 0;

   186

		return true;

   187

	}

   188

   189

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

   190

	return arg != endptr;

   191

}

   192

   193

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

   194

    * hooking code            *

   195

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

   196

   197

/**

   198

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

   199

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

   200

 * @param type type access trigger

   201

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

   202

 */

   203

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

   204

{

   205

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

   206

   207

	switch (type) {

   208

		case ICONSOLE_HOOK_ACCESS:

   209

			hooks->access = proc;

   210

			break;

   211

		case ICONSOLE_HOOK_PRE_ACTION:

   212

			hooks->pre = proc;

   213

			break;

   214

		case ICONSOLE_HOOK_POST_ACTION:

   215

			hooks->post = proc;

   216

			break;

   217

		default: NOT_REACHED();

   218

	}

   219

}

   220

   221

/**

   222

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

   223

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

   224

 * @param hooks IConsoleHooks structure that will be checked

   225

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

   226

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

   227

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

   228

 */

   229

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

   230

{

   231

	IConsoleHook *proc = NULL;

   232

	if (hooks == NULL) return false;

   233

   234

	switch (type) {

   235

		case ICONSOLE_HOOK_ACCESS:

   236

			proc = hooks->access;

   237

			break;

   238

		case ICONSOLE_HOOK_PRE_ACTION:

   239

			proc = hooks->pre;

   240

			break;

   241

		case ICONSOLE_HOOK_POST_ACTION:

   242

			proc = hooks->post;

   243

			break;

   244

		default: NOT_REACHED();

   245

	}

   246

   247

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

   248

}

   249

   250

/**

   251

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

   252

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

   253

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

   254

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

   255

 */

   256

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

   257

{

   258

	IConsoleCmd *cmd = IConsoleCmdGet(name);

   259

	if (cmd == NULL) return;

   260

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

   261

}

   262

   263

/**

   264

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

   265

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

   266

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

   267

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

   268

 */

   269

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

   270

{

   271

	IConsoleVar *var = IConsoleVarGet(name);

   272

	if (var == NULL) return;

   273

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

   274

}

   275

   276

/**

   277

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

   278

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

   279

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

   280

 */

   281

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

   282

{                                                                              \

   283

	IConsoleType *item, *item_before;                                            \

   284

	/* first command */                                                          \

   285

	if (_base == NULL) {                                                         \

   286

		_base = item_new;                                                          \

   287

		return;                                                                    \

   288

	}                                                                            \

   289

                                                                               \

   290

	item_before = NULL;                                                          \

   291

	item = _base;                                                                \

   292

                                                                               \

   293

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

   294

	while (item != NULL) {                                                       \

   295

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

   296

		if (i == 0) {                                                              \

   297

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

   298

			free(item_new);                                                          \

   299

			return;                                                                  \

   300

		}                                                                          \

   301

                                                                               \

   302

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

   303

                                                                               \

   304

		item_before = item;                                                        \

   305

		item = item->next;                                                         \

   306

	}                                                                            \

   307

                                                                               \

   308

	if (item_before == NULL) {                                                   \

   309

		_base = item_new;                                                          \

   310

	} else {                                                                     \

   311

		item_before->next = item_new;                                              \

   312

  }                                                                            \

   313

                                                                               \

   314

	item_new->next = item;                                                       \

   315

	/* END - Alphabetical insert */                                              \

   316

}

   317

   318

/**

   319

 * Register a new command to be used in the console

   320

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

   321

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

   322

 */

   323

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

   324

{

   325

	char *new_cmd = strdup(name);

   326

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

   327

   328

	item_new->next = NULL;

   329

	item_new->proc = proc;

   330

	item_new->name = new_cmd;

   331

   332

	item_new->hook.access = NULL;

   333

	item_new->hook.pre = NULL;

   334

	item_new->hook.post = NULL;

   335

   336

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

   337

}

   338

   339

/**

   340

 * Find the command pointed to by its string

   341

 * @param name command to be found

   342

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

   343

 */

   344

IConsoleCmd *IConsoleCmdGet(const char *name)

   345

{

   346

	IConsoleCmd *item;

   347

   348

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

   349

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

   350

	}

   351

	return NULL;

   352

}

   353

   354

/**

   355

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

   356

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

   357

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

   358

 */

   359

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

   360

{

   361

	char *new_alias = strdup(name);

   362

	char *cmd_aliased = strdup(cmd);

   363

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

   364

   365

	item_new->next = NULL;

   366

	item_new->cmdline = cmd_aliased;

   367

	item_new->name = new_alias;

   368

   369

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

   370

}

   371

   372

/**

   373

 * Find the alias pointed to by its string

   374

 * @param name alias to be found

   375

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

   376

 */

   377

IConsoleAlias *IConsoleAliasGet(const char *name)

   378

{

   379

	IConsoleAlias* item;

   380

   381

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

   382

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

   383

	}

   384

   385

	return NULL;

   386

}

   387

   388

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

   389

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

   390

{

   391

	/* len is the amount of bytes to add excluding the '\0'-termination */

   392

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

   393

	strecpy(dst, src, dst + len);

   394

   395

	return len;

   396

}

   397

   398

/**

   399

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

   400

 * Execute it as well.

   401

 * @param *alias is the alias of the command

   402

 * @param tokencount the number of parameters passed

   403

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

   404

 */

   405

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

   406

{

   407

	const char *cmdptr;

   408

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

   409

	uint i;

   410

	uint a_index, astream_i;

   411

   412

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

   413

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

   414

   415

	if (_stdlib_con_developer)

   416

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

   417

   418

	aliases[0] = aliasstream;

   419

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

   420

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

   421

   422

		switch (*cmdptr) {

   423

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

   424

			aliasstream[astream_i++] = '"';

   425

			break;

   426

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

   427

			aliasstream[astream_i] = '\0';

   428

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

   429

			cmdptr++;

   430

			break;

   431

		case '%': // Some or all parameters

   432

			cmdptr++;

   433

			switch (*cmdptr) {

   434

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

   435

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

   436

					aliasstream[astream_i++] = '"';

   437

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

   438

					aliasstream[astream_i++] = '"';

   439

					aliasstream[astream_i++] = ' ';

   440

				}

   441

			} break;

   442

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

   443

				aliasstream[astream_i++] = '"';

   444

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

   445

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

   446

					aliasstream[astream_i++] = ' ';

   447

				}

   448

				aliasstream[astream_i++] = '"';

   449

   450

			} break;

   451

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

   452

				int param = *cmdptr - 'A';

   453

   454

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

   455

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

   456

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

   457

					return;

   458

				}

   459

   460

				aliasstream[astream_i++] = '"';

   461

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

   462

				aliasstream[astream_i++] = '"';

   463

			} break;

   464

			} break;

   465

   466

		default:

   467

			aliasstream[astream_i++] = *cmdptr;

   468

			break;

   469

		}

   470

	}

   471

   472

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

   473

}

   474

   475

/**

   476

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

   477

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

   478

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

   479

 * @param addr memory location the variable will point to

   480

 * @param size the length of the string buffer

   481

 * @param help the help string shown for the variable

   482

 * For more information see IConsoleVarRegister()

   483

 */

   484

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

   485

{