src/console.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file console.cpp Handling of the in-game console. */
  11
  12 #include "stdafx.h"
  13 #include "console_internal.h"
  14 #include "network/network.h"
  15 #include "network/network_func.h"
  16 #include "network/network_admin.h"
  17 #include "debug.h"
  18 #include "console_func.h"
  19 #include "settings_type.h"
  20
  21 #include <stdarg.h>
  22
  23 static const uint ICON_TOKEN_COUNT = 20;     ///< Maximum number of tokens in one command
  24
  25 /* console parser */
  26 IConsoleCmd   *_iconsole_cmds;    ///< list of registered commands
  27 IConsoleAlias *_iconsole_aliases; ///< list of registered aliases
  28
  29 FILE *_iconsole_output_file;
  30
  31 void IConsoleInit()
  32 {
  33         _iconsole_output_file = NULL;
  34 #ifdef ENABLE_NETWORK /* Initialize network only variables */
  35         _redirect_console_to_client = INVALID_CLIENT_ID;
  36         _redirect_console_to_admin  = INVALID_ADMIN_ID;
  37 #endif
  38
  39         IConsoleGUIInit();
  40
  41         IConsoleStdLibRegister();
  42 }
  43
  44 static void IConsoleWriteToLogFile(const char *string)
  45 {
  46         if (_iconsole_output_file != NULL) {
  47                 /* if there is an console output file ... also print it there */
  48                 const char *header = GetLogPrefix();
  49                 if ((strlen(header) != 0 && fwrite(header, strlen(header), 1, _iconsole_output_file) != 1) ||
  50                                 fwrite(string, strlen(string), 1, _iconsole_output_file) != 1 ||
  51                                 fwrite("\n", 1, 1, _iconsole_output_file) != 1) {
  52                         fclose(_iconsole_output_file);
  53                         _iconsole_output_file = NULL;
  54                         IConsolePrintF(CC_DEFAULT, "cannot write to log file");
  55                 }
  56         }
  57 }
  58
  59 bool CloseConsoleLogIfActive()
  60 {
  61         if (_iconsole_output_file != NULL) {
  62                 IConsolePrintF(CC_DEFAULT, "file output complete");
  63                 fclose(_iconsole_output_file);
  64                 _iconsole_output_file = NULL;
  65                 return true;
  66         }
  67
  68         return false;
  69 }
  70
  71 void IConsoleFree()
  72 {
  73         IConsoleGUIFree();
  74         CloseConsoleLogIfActive();
  75 }
  76
  77 /**
  78  * Handle the printing of text entered into the console or redirected there
  79  * by any other means. Text can be redirected to other clients in a network game
  80  * as well as to a logfile. If the network server is a dedicated server, all activities
  81  * are also logged. All lines to print are added to a temporary buffer which can be
  82  * used as a history to print them onscreen
  83  * @param colour_code the colour of the command. Red in case of errors, etc.
  84  * @param string the message entered or output on the console (notice, error, etc.)
  85  */
  86 void IConsolePrint(TextColour colour_code, const char *string)
  87 {
  88         assert(IsValidConsoleColour(colour_code));
  89
  90         char *str;
  91 #ifdef ENABLE_NETWORK
  92         if (_redirect_console_to_client != INVALID_CLIENT_ID) {
  93                 /* Redirect the string to the client */
  94                 NetworkServerSendRcon(_redirect_console_to_client, colour_code, string);
  95                 return;
  96         }
  97
  98         if (_redirect_console_to_admin != INVALID_ADMIN_ID) {
  99                 NetworkServerSendAdminRcon(_redirect_console_to_admin, colour_code, string);
 100                 return;
 101         }
 102 #endif
 103
 104         /* Create a copy of the string, strip if of colours and invalid
 105          * characters and (when applicable) assign it to the console buffer */
 106         str = strdup(string);
 107         str_strip_colours(str);
 108         str_validate(str, str + strlen(str));
 109
 110         if (_network_dedicated) {
 111 #ifdef ENABLE_NETWORK
 112                 NetworkAdminConsole("console", str);
 113 #endif /* ENABLE_NETWORK */
 114                 fprintf(stdout, "%s%s\n", GetLogPrefix(), str);
 115                 fflush(stdout);
 116                 IConsoleWriteToLogFile(str);
 117                 free(str); // free duplicated string since it's not used anymore
 118                 return;
 119         }
 120
 121         IConsoleWriteToLogFile(str);
 122         IConsoleGUIPrint(colour_code, str);
 123 }
 124
 125 /**
 126  * Handle the printing of text entered into the console or redirected there
 127  * by any other means. Uses printf() style format, for more information look
 128  * at IConsolePrint()
 129  */
 130 void CDECL IConsolePrintF(TextColour colour_code, const char *format, ...)
 131 {
 132         assert(IsValidConsoleColour(colour_code));
 133
 134         va_list va;
 135         char buf[ICON_MAX_STREAMSIZE];
 136
 137         va_start(va, format);
 138         vsnprintf(buf, sizeof(buf), format, va);
 139         va_end(va);
 140
 141         IConsolePrint(colour_code, buf);
 142 }
 143
 144 /**
 145  * It is possible to print debugging information to the console,
 146  * which is achieved by using this function. Can only be used by
 147  * debug() in debug.cpp. You need at least a level 2 (developer) for debugging
 148  * messages to show up
 149  * @param dbg debugging category
 150  * @param string debugging message
 151  */
 152 void IConsoleDebug(const char *dbg, const char *string)
 153 {
 154         if (_settings_client.gui.developer <= 1) return;
 155         IConsolePrintF(CC_DEBUG, "dbg: [%s] %s", dbg, string);
 156 }
 157
 158 /**
 159  * It is possible to print warnings to the console. These are mostly
 160  * errors or mishaps, but non-fatal. You need at least a level 1 (developer) for
 161  * debugging messages to show up
 162  */
 163 void IConsoleWarning(const char *string)
 164 {
 165         if (_settings_client.gui.developer == 0) return;
 166         IConsolePrintF(CC_WARNING, "WARNING: %s", string);
 167 }
 168
 169 /**
 170  * It is possible to print error information to the console. This can include
 171  * game errors, or errors in general you would want the user to notice
 172  */
 173 void IConsoleError(const char *string)
 174 {
 175         IConsolePrintF(CC_ERROR, "ERROR: %s", string);
 176 }
 177
 178 /**
 179  * Change a string into its number representation. Supports
 180  * decimal and hexadecimal numbers as well as 'on'/'off' 'true'/'false'
 181  * @param *value the variable a successful conversion will be put in
 182  * @param *arg the string to be converted
 183  * @return Return true on success or false on failure
 184  */
 185 bool GetArgumentInteger(uint32 *value, const char *arg)
 186 {
 187         char *endptr;
 188
 189         if (strcmp(arg, "on") == 0 || strcmp(arg, "true") == 0) {
 190                 *value = 1;
 191                 return true;
 192         }
 193         if (strcmp(arg, "off") == 0 || strcmp(arg, "false") == 0) {
 194                 *value = 0;
 195                 return true;
 196         }
 197
 198         *value = strtoul(arg, &endptr, 0);
 199         return arg != endptr;
 200 }
 201
 202 /**
 203  * Add an item to an alphabetically sorted list.
 204  * @param base first item of the list
 205  * @param item_new the item to add
 206  */
 207 template<class T>
 208 void IConsoleAddSorted(T **base, T *item_new)
 209 {
 210         if (*base == NULL) {
 211                 *base = item_new;
 212                 return;
 213         }
 214
 215         T *item_before = NULL;
 216         T *item = *base;
 217         /* The list is alphabetically sorted, insert the new item at the correct location */
 218         while (item != NULL) {
 219                 if (strcmp(item->name, item_new->name) > 0) break; // insert here
 220
 221                 item_before = item;
 222                 item = item->next;
 223         }
 224
 225         if (item_before == NULL) {
 226                 *base = item_new;
 227         } else {
 228                 item_before->next = item_new;
 229         }
 230
 231         item_new->next = item;
 232 }
 233
 234 /**
 235  * Remove underscores from a string; the string will be modified!
 236  * @param name The string to remove the underscores from.
 237  * @return #name.
 238  */
 239 char *RemoveUnderscores(char *name)
 240 {
 241         char *q = name;
 242         for (const char *p = name; *p != '\0'; p++) {
 243                 if (*p != '_') *q++ = *p;
 244         }
 245         *q = '\0';
 246         return name;
 247 }
 248
 249 /**
 250  * Register a new command to be used in the console
 251  * @param name name of the command that will be used
 252  * @param proc function that will be called upon execution of command
 253  */
 254 void IConsoleCmdRegister(const char *name, IConsoleCmdProc *proc, IConsoleHook *hook)
 255 {
 256         IConsoleCmd *item_new = MallocT<IConsoleCmd>(1);
 257         item_new->name = RemoveUnderscores(strdup(name));
 258         item_new->next = NULL;
 259         item_new->proc = proc;
 260         item_new->hook = hook;
 261
 262         IConsoleAddSorted(&_iconsole_cmds, item_new);
 263 }
 264
 265 /**
 266  * Find the command pointed to by its string
 267  * @param name command to be found
 268  * @return return Cmdstruct of the found command, or NULL on failure
 269  */
 270 IConsoleCmd *IConsoleCmdGet(const char *name)
 271 {
 272         IConsoleCmd *item;
 273
 274         for (item = _iconsole_cmds; item != NULL; item = item->next) {
 275                 if (strcmp(item->name, name) == 0) return item;
 276         }
 277         return NULL;
 278 }
 279
 280 /**
 281  * Register a an alias for an already existing command in the console
 282  * @param name name of the alias that will be used
 283  * @param cmd name of the command that 'name' will be alias of
 284  */
 285 void IConsoleAliasRegister(const char *name, const char *cmd)
 286 {
 287         if (IConsoleAliasGet(name) != NULL) {
 288                 IConsoleError("an alias with this name already exists; insertion aborted");
 289                 return;
 290         }
 291
 292         char *new_alias = RemoveUnderscores(strdup(name));
 293         char *cmd_aliased = strdup(cmd);
 294         IConsoleAlias *item_new = MallocT<IConsoleAlias>(1);
 295
 296         item_new->next = NULL;
 297         item_new->cmdline = cmd_aliased;
 298         item_new->name = new_alias;
 299
 300         IConsoleAddSorted(&_iconsole_aliases, item_new);
 301 }
 302
 303 /**
 304  * Find the alias pointed to by its string
 305  * @param name alias to be found
 306  * @return return Aliasstruct of the found alias, or NULL on failure
 307  */
 308 IConsoleAlias *IConsoleAliasGet(const char *name)
 309 {
 310         IConsoleAlias *item;
 311
 312         for (item = _iconsole_aliases; item != NULL; item = item->next) {
 313                 if (strcmp(item->name, name) == 0) return item;
 314         }
 315
 316         return NULL;
 317 }
 318 /**
 319  * An alias is just another name for a command, or for more commands
 320  * Execute it as well.
 321  * @param *alias is the alias of the command
 322  * @param tokencount the number of parameters passed
 323  * @param *tokens are the parameters given to the original command (0 is the first param)
 324  */
 325 static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT])
 326 {
 327         char  alias_buffer[ICON_MAX_STREAMSIZE] = { '\0' };
 328         char *alias_stream = alias_buffer;
 329
 330         DEBUG(console, 6, "Requested command is an alias; parsing...");
 331
 332         for (const char *cmdptr = alias->cmdline; *cmdptr != '\0'; cmdptr++) {
 333                 switch (*cmdptr) {
 334                         case '\'': // ' will double for ""
 335                                 alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 336                                 break;
 337
 338                         case ';': // Cmd separator; execute previous and start new command
 339                                 IConsoleCmdExec(alias_buffer);
 340
 341                                 alias_stream = alias_buffer;
 342                                 *alias_stream = '\0'; // Make sure the new command is terminated.
 343
 344                                 cmdptr++;
 345                                 break;
 346
 347                         case '%': // Some or all parameters
 348                                 cmdptr++;
 349                                 switch (*cmdptr) {
 350                                         case '+': { // All parameters separated: "[param 1]" "[param 2]"
 351                                                 for (uint i = 0; i != tokencount; i++) {
 352                                                         if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
 353                                                         alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 354                                                         alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
 355                                                         alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 356                                                 }
 357                                                 break;
 358                                         }
 359
 360                                         case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
 361                                                 alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 362                                                 for (uint i = 0; i != tokencount; i++) {
 363                                                         if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
 364                                                         alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
 365                                                 }
 366                                                 alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 367                                                 break;
 368                                         }
 369
 370                                         default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
 371                                                 int param = *cmdptr - 'A';
 372
 373                                                 if (param < 0 || param >= tokencount) {
 374                                                         IConsoleError("too many or wrong amount of parameters passed to alias, aborting");
 375                                                         IConsolePrintF(CC_WARNING, "Usage of alias '%s': %s", alias->name, alias->cmdline);
 376                                                         return;
 377                                                 }
 378
 379                                                 alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 380                                                 alias_stream = strecpy(alias_stream, tokens[param], lastof(alias_buffer));
 381                                                 alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
 382                                                 break;
 383                                         }
 384                                 }
 385                                 break;
 386
 387                         default:
 388                                 *alias_stream++ = *cmdptr;
 389                                 *alias_stream = '\0';
 390                                 break;
 391                 }
 392
 393                 if (alias_stream >= lastof(alias_buffer) - 1) {
 394                         IConsoleError("Requested alias execution would overflow execution buffer");
 395                         return;
 396                 }
 397         }
 398
 399         IConsoleCmdExec(alias_buffer);
 400 }
 401
 402 /**
 403  * Execute a given command passed to us. First chop it up into
 404  * individual tokens (separated by spaces), then execute it if possible
 405  * @param cmdstr string to be parsed and executed
 406  */
 407 void IConsoleCmdExec(const char *cmdstr)
 408 {
 409         const char *cmdptr;
 410         char *tokens[ICON_TOKEN_COUNT], tokenstream[ICON_MAX_STREAMSIZE];
 411         uint t_index, tstream_i;
 412
 413         bool longtoken = false;
 414         bool foundtoken = false;
 415
 416         if (cmdstr[0] == '#') return; // comments
 417
 418         for (cmdptr = cmdstr; *cmdptr != '\0'; cmdptr++) {
 419                 if (!IsValidChar(*cmdptr, CS_ALPHANUMERAL)) {
 420                         IConsoleError("command contains malformed characters, aborting");
 421                         IConsolePrintF(CC_ERROR, "ERROR: command was: '%s'", cmdstr);
 422                         return;
 423                 }
 424         }
 425
 426         DEBUG(console, 4, "Executing cmdline: '%s'", cmdstr);
 427
 428         memset(&tokens, 0, sizeof(tokens));
 429         memset(&tokenstream, 0, sizeof(tokenstream));
 430
 431         /* 1. Split up commandline into tokens, separated by spaces, commands
 432          * enclosed in "" are taken as one token. We can only go as far as the amount
 433          * of characters in our stream or the max amount of tokens we can handle */
 434         for (cmdptr = cmdstr, t_index = 0, tstream_i = 0; *cmdptr != '\0'; cmdptr++) {
 435                 if (t_index >= lengthof(tokens) || tstream_i >= lengthof(tokenstream)) break;
 436
 437                 switch (*cmdptr) {
 438                 case ' ': // Token separator
 439                         if (!foundtoken) break;
 440
 441                         if (longtoken) {
 442                                 tokenstream[tstream_i] = *cmdptr;
 443                         } else {
 444                                 tokenstream[tstream_i] = '\0';
 445                                 foundtoken = false;
 446                         }
 447
 448                         tstream_i++;
 449                         break;
 450                 case '"': // Tokens enclosed in "" are one token
 451                         longtoken = !longtoken;
 452                         if (!foundtoken) {
 453                                 tokens[t_index++] = &tokenstream[tstream_i];
 454                                 foundtoken = true;
 455                         }
 456                         break;
 457                 case '\\': // Escape character for ""
 458                         if (cmdptr[1] == '"' && tstream_i + 1 < lengthof(tokenstream)) {
 459                                 tokenstream[tstream_i++] = *++cmdptr;
 460                                 break;
 461                         }
 462                         /* FALL THROUGH */
 463                 default: // Normal character
 464                         tokenstream[tstream_i++] = *cmdptr;
 465
 466                         if (!foundtoken) {
 467                                 tokens[t_index++] = &tokenstream[tstream_i - 1];
 468                                 foundtoken = true;
 469                         }
 470                         break;
 471                 }
 472         }
 473
 474         for (uint i = 0; tokens[i] != NULL; i++) {
 475                 DEBUG(console, 8, "Token %d is: '%s'", i, tokens[i]);
 476         }
 477
 478         if (tokens[0] == '\0') return; // don't execute empty commands
 479         /* 2. Determine type of command (cmd or alias) and execute
 480          * First try commands, then aliases. Execute
 481          * the found action taking into account its hooking code
 482          */
 483         RemoveUnderscores(tokens[0]);
 484         IConsoleCmd *cmd = IConsoleCmdGet(tokens[0]);
 485         if (cmd != NULL) {
 486                 ConsoleHookResult chr = (cmd->hook == NULL ? CHR_ALLOW : cmd->hook(true));
 487                 switch (chr) {
 488                         case CHR_ALLOW:
 489                                 if (!cmd->proc(t_index, tokens)) { // index started with 0
 490                                         cmd->proc(0, NULL); // if command failed, give help
 491                                 }
 492                                 return;
 493
 494                         case CHR_DISALLOW: return;
 495                         case CHR_HIDE: break;
 496                 }
 497         }
 498
 499         t_index--;
 500         IConsoleAlias *alias = IConsoleAliasGet(tokens[0]);
 501         if (alias != NULL) {
 502                 IConsoleAliasExec(alias, t_index, &tokens[1]);
 503                 return;
 504         }
 505
 506         IConsoleError("command not found");
 507 }