src/console.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file console.cpp Handling of the in-game console. */
   9
  10 #include "stdafx.h"
  11 #include "console_internal.h"
  12 #include "network/network.h"
  13 #include "network/network_func.h"
  14 #include "network/network_admin.h"
  15 #include "debug.h"
  16 #include "console_func.h"
  17 #include "settings_type.h"
  18
  19 #include "safeguards.h"
  20
  21 static const uint ICON_TOKEN_COUNT = 20;     ///< Maximum number of tokens in one command
  22 static const uint ICON_MAX_RECURSE = 10;     ///< Maximum number of recursion
  23
  24 /* console parser */
  25 /* static */ IConsole::CommandList &IConsole::Commands()
  26 {
  27         static IConsole::CommandList cmds;
  28         return cmds;
  29 }
  30
  31 /* static */ IConsole::AliasList &IConsole::Aliases()
  32 {
  33         static IConsole::AliasList aliases;
  34         return aliases;
  35 }
  36
  37 FILE *_iconsole_output_file;
  38
  39 void IConsoleInit()
  40 {
  41         _iconsole_output_file = nullptr;
  42         _redirect_console_to_client = INVALID_CLIENT_ID;
  43         _redirect_console_to_admin  = INVALID_ADMIN_ID;
  44
  45         IConsoleGUIInit();
  46
  47         IConsoleStdLibRegister();
  48 }
  49
  50 static void IConsoleWriteToLogFile(const std::string &string)
  51 {
  52         if (_iconsole_output_file != nullptr) {
  53                 /* if there is an console output file ... also print it there */
  54                 try {
  55                         fmt::print(_iconsole_output_file, "{}{}\n", GetLogPrefix(), string);
  56                 } catch (const std::system_error &) {
  57                         fclose(_iconsole_output_file);
  58                         _iconsole_output_file = nullptr;
  59                         IConsolePrint(CC_ERROR, "Cannot write to console log file; closing the log file.");
  60                 }
  61         }
  62 }
  63
  64 bool CloseConsoleLogIfActive()
  65 {
  66         if (_iconsole_output_file != nullptr) {
  67                 IConsolePrint(CC_INFO, "Console log file closed.");
  68                 fclose(_iconsole_output_file);
  69                 _iconsole_output_file = nullptr;
  70                 return true;
  71         }
  72
  73         return false;
  74 }
  75
  76 void IConsoleFree()
  77 {
  78         IConsoleGUIFree();
  79         CloseConsoleLogIfActive();
  80 }
  81
  82 /**
  83  * Handle the printing of text entered into the console or redirected there
  84  * by any other means. Text can be redirected to other clients in a network game
  85  * as well as to a logfile. If the network server is a dedicated server, all activities
  86  * are also logged. All lines to print are added to a temporary buffer which can be
  87  * used as a history to print them onscreen
  88  * @param colour_code The colour of the command.
  89  * @param string The message to output on the console (notice, error, etc.)
  90  */
  91 void IConsolePrint(TextColour colour_code, const std::string &string)
  92 {
  93         assert(IsValidConsoleColour(colour_code));
  94
  95         if (_redirect_console_to_client != INVALID_CLIENT_ID) {
  96                 /* Redirect the string to the client */
  97                 NetworkServerSendRcon(_redirect_console_to_client, colour_code, string);
  98                 return;
  99         }
 100
 101         if (_redirect_console_to_admin != INVALID_ADMIN_ID) {
 102                 NetworkServerSendAdminRcon(_redirect_console_to_admin, colour_code, string);
 103                 return;
 104         }
 105
 106         /* Create a copy of the string, strip it of colours and invalid
 107          * characters and (when applicable) assign it to the console buffer */
 108         std::string str = StrMakeValid(string, SVS_NONE);
 109
 110         if (_network_dedicated) {
 111                 NetworkAdminConsole("console", str);
 112                 fmt::print("{}{}\n", GetLogPrefix(), str);
 113                 fflush(stdout);
 114                 IConsoleWriteToLogFile(str);
 115                 return;
 116         }
 117
 118         IConsoleWriteToLogFile(str);
 119         IConsoleGUIPrint(colour_code, str);
 120 }
 121
 122 /**
 123  * Change a string into its number representation. Supports
 124  * decimal and hexadecimal numbers as well as 'on'/'off' 'true'/'false'
 125  * @param *value the variable a successful conversion will be put in
 126  * @param *arg the string to be converted
 127  * @return Return true on success or false on failure
 128  */
 129 bool GetArgumentInteger(uint32_t *value, const char *arg)
 130 {
 131         char *endptr;
 132
 133         if (strcmp(arg, "on") == 0 || strcmp(arg, "true") == 0) {
 134                 *value = 1;
 135                 return true;
 136         }
 137         if (strcmp(arg, "off") == 0 || strcmp(arg, "false") == 0) {
 138                 *value = 0;
 139                 return true;
 140         }
 141
 142         *value = std::strtoul(arg, &endptr, 0);
 143         return arg != endptr;
 144 }
 145
 146 /**
 147  * Creates a copy of a string with underscores removed from it
 148  * @param name String to remove the underscores from.
 149  * @return A copy of \a name, without underscores.
 150  */
 151 static std::string RemoveUnderscores(std::string name)
 152 {
 153         name.erase(std::remove(name.begin(), name.end(), '_'), name.end());
 154         return name;
 155 }
 156
 157 /**
 158  * Register a new command to be used in the console
 159  * @param name name of the command that will be used
 160  * @param proc function that will be called upon execution of command
 161  */
 162 /* static */ void IConsole::CmdRegister(const std::string &name, IConsoleCmdProc *proc, IConsoleHook *hook)
 163 {
 164         IConsole::Commands().try_emplace(RemoveUnderscores(name), name, proc, hook);
 165 }
 166
 167 /**
 168  * Find the command pointed to by its string
 169  * @param name command to be found
 170  * @return return Cmdstruct of the found command, or nullptr on failure
 171  */
 172 /* static */ IConsoleCmd *IConsole::CmdGet(const std::string &name)
 173 {
 174         auto item = IConsole::Commands().find(RemoveUnderscores(name));
 175         if (item != IConsole::Commands().end()) return &item->second;
 176         return nullptr;
 177 }
 178
 179 /**
 180  * Register a an alias for an already existing command in the console
 181  * @param name name of the alias that will be used
 182  * @param cmd name of the command that 'name' will be alias of
 183  */
 184 /* static */ void IConsole::AliasRegister(const std::string &name, const std::string &cmd)
 185 {
 186         auto result = IConsole::Aliases().try_emplace(RemoveUnderscores(name), name, cmd);
 187         if (!result.second) IConsolePrint(CC_ERROR, "An alias with the name '{}' already exists.", name);
 188 }
 189
 190 /**
 191  * Find the alias pointed to by its string
 192  * @param name alias to be found
 193  * @return return Aliasstruct of the found alias, or nullptr on failure
 194  */
 195 /* static */ IConsoleAlias *IConsole::AliasGet(const std::string &name)
 196 {
 197         auto item = IConsole::Aliases().find(RemoveUnderscores(name));
 198         if (item != IConsole::Aliases().end()) return &item->second;
 199         return nullptr;
 200 }
 201
 202 /**
 203  * An alias is just another name for a command, or for more commands
 204  * Execute it as well.
 205  * @param *alias is the alias of the command
 206  * @param tokencount the number of parameters passed
 207  * @param *tokens are the parameters given to the original command (0 is the first param)
 208  */
 209 static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT], const uint recurse_count)
 210 {
 211         std::string alias_buffer;
 212
 213         Debug(console, 6, "Requested command is an alias; parsing...");
 214
 215         if (recurse_count > ICON_MAX_RECURSE) {
 216                 IConsolePrint(CC_ERROR, "Too many alias expansions, recursion limit reached.");
 217                 return;
 218         }
 219
 220         for (const char *cmdptr = alias->cmdline.c_str(); *cmdptr != '\0'; cmdptr++) {
 221                 switch (*cmdptr) {
 222                         case '\'': // ' will double for ""
 223                                 alias_buffer += '\"';
 224                                 break;
 225
 226                         case ';': // Cmd separator; execute previous and start new command
 227                                 IConsoleCmdExec(alias_buffer, recurse_count);
 228
 229                                 alias_buffer.clear();
 230
 231                                 cmdptr++;
 232                                 break;
 233
 234                         case '%': // Some or all parameters
 235                                 cmdptr++;
 236                                 switch (*cmdptr) {
 237                                         case '+': { // All parameters separated: "[param 1]" "[param 2]"
 238                                                 for (uint i = 0; i != tokencount; i++) {
 239                                                         if (i != 0) alias_buffer += ' ';
 240                                                         alias_buffer += '\"';
 241                                                         alias_buffer += tokens[i];
 242                                                         alias_buffer += '\"';
 243                                                 }
 244                                                 break;
 245                                         }
 246
 247                                         case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
 248                                                 alias_buffer += '\"';
 249                                                 for (uint i = 0; i != tokencount; i++) {
 250                                                         if (i != 0) alias_buffer += " ";
 251                                                         alias_buffer += tokens[i];
 252                                                 }
 253                                                 alias_buffer += '\"';
 254                                                 break;
 255                                         }
 256
 257                                         default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
 258                                                 int param = *cmdptr - 'A';
 259
 260                                                 if (param < 0 || param >= tokencount) {
 261                                                         IConsolePrint(CC_ERROR, "Too many or wrong amount of parameters passed to alias.");
 262                                                         IConsolePrint(CC_HELP, "Usage of alias '{}': '{}'.", alias->name, alias->cmdline);
 263                                                         return;
 264                                                 }
 265
 266                                                 alias_buffer += '\"';
 267                                                 alias_buffer += tokens[param];
 268                                                 alias_buffer += '\"';
 269                                                 break;
 270                                         }
 271                                 }
 272                                 break;
 273
 274                         default:
 275                                 alias_buffer += *cmdptr;
 276                                 break;
 277                 }
 278
 279                 if (alias_buffer.size() >= ICON_MAX_STREAMSIZE - 1) {
 280                         IConsolePrint(CC_ERROR, "Requested alias execution would overflow execution buffer.");
 281                         return;
 282                 }
 283         }
 284
 285         IConsoleCmdExec(alias_buffer, recurse_count);
 286 }
 287
 288 /**
 289  * Execute a given command passed to us. First chop it up into
 290  * individual tokens (separated by spaces), then execute it if possible
 291  * @param command_string string to be parsed and executed
 292  */
 293 void IConsoleCmdExec(const std::string &command_string, const uint recurse_count)
 294 {
 295         const char *cmdptr;
 296         char *tokens[ICON_TOKEN_COUNT], tokenstream[ICON_MAX_STREAMSIZE];
 297         uint t_index, tstream_i;
 298
 299         bool longtoken = false;
 300         bool foundtoken = false;
 301
 302         if (command_string[0] == '#') return; // comments
 303
 304         for (cmdptr = command_string.c_str(); *cmdptr != '\0'; cmdptr++) {
 305                 if (!IsValidChar(*cmdptr, CS_ALPHANUMERAL)) {
 306                         IConsolePrint(CC_ERROR, "Command '{}' contains malformed characters.", command_string);
 307                         return;
 308                 }
 309         }
 310
 311         Debug(console, 4, "Executing cmdline: '{}'", command_string);
 312
 313         memset(&tokens, 0, sizeof(tokens));
 314         memset(&tokenstream, 0, sizeof(tokenstream));
 315
 316         /* 1. Split up commandline into tokens, separated by spaces, commands
 317          * enclosed in "" are taken as one token. We can only go as far as the amount
 318          * of characters in our stream or the max amount of tokens we can handle */
 319         for (cmdptr = command_string.c_str(), t_index = 0, tstream_i = 0; *cmdptr != '\0'; cmdptr++) {
 320                 if (tstream_i >= lengthof(tokenstream)) {
 321                         IConsolePrint(CC_ERROR, "Command line too long.");
 322                         return;
 323                 }
 324
 325                 switch (*cmdptr) {
 326                 case ' ': // Token separator
 327                         if (!foundtoken) break;
 328
 329                         if (longtoken) {
 330                                 tokenstream[tstream_i] = *cmdptr;
 331                         } else {
 332                                 tokenstream[tstream_i] = '\0';
 333                                 foundtoken = false;
 334                         }
 335
 336                         tstream_i++;
 337                         break;
 338                 case '"': // Tokens enclosed in "" are one token
 339                         longtoken = !longtoken;
 340                         if (!foundtoken) {
 341                                 if (t_index >= lengthof(tokens)) {
 342                                         IConsolePrint(CC_ERROR, "Command line too long.");
 343                                         return;
 344                                 }
 345                                 tokens[t_index++] = &tokenstream[tstream_i];
 346                                 foundtoken = true;
 347                         }
 348                         break;
 349                 case '\\': // Escape character for ""
 350                         if (cmdptr[1] == '"' && tstream_i + 1 < lengthof(tokenstream)) {
 351                                 tokenstream[tstream_i++] = *++cmdptr;
 352                                 break;
 353                         }
 354                         [[fallthrough]];
 355                 default: // Normal character
 356                         tokenstream[tstream_i++] = *cmdptr;
 357
 358                         if (!foundtoken) {
 359                                 if (t_index >= lengthof(tokens)) {
 360                                         IConsolePrint(CC_ERROR, "Command line too long.");
 361                                         return;
 362                                 }
 363                                 tokens[t_index++] = &tokenstream[tstream_i - 1];
 364                                 foundtoken = true;
 365                         }
 366                         break;
 367                 }
 368         }
 369
 370         for (uint i = 0; i < lengthof(tokens) && tokens[i] != nullptr; i++) {
 371                 Debug(console, 8, "Token {} is: '{}'", i, tokens[i]);
 372         }
 373
 374         if (StrEmpty(tokens[0])) return; // don't execute empty commands
 375         /* 2. Determine type of command (cmd or alias) and execute
 376          * First try commands, then aliases. Execute
 377          * the found action taking into account its hooking code
 378          */
 379         IConsoleCmd *cmd = IConsole::CmdGet(tokens[0]);
 380         if (cmd != nullptr) {
 381                 ConsoleHookResult chr = (cmd->hook == nullptr ? CHR_ALLOW : cmd->hook(true));
 382                 switch (chr) {
 383                         case CHR_ALLOW:
 384                                 if (!cmd->proc(t_index, tokens)) { // index started with 0
 385                                         cmd->proc(0, nullptr); // if command failed, give help
 386                                 }
 387                                 return;
 388
 389                         case CHR_DISALLOW: return;
 390                         case CHR_HIDE: break;
 391                 }
 392         }
 393
 394         t_index--;
 395         IConsoleAlias *alias = IConsole::AliasGet(tokens[0]);
 396         if (alias != nullptr) {
 397                 IConsoleAliasExec(alias, t_index, &tokens[1], recurse_count + 1);
 398                 return;
 399         }
 400
 401         IConsolePrint(CC_ERROR, "Command '{}' not found.", tokens[0]);
 402 }