console.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "console_internal.h"
#include "network/network.h"
#include "network/network_func.h"
#include "network/network_admin.h"
#include "debug.h"
#include "console_func.h"
#include "settings_type.h"
 
#include <stdarg.h>
 
#include "safeguards.h"
 
static const uint ICON_TOKEN_COUNT = 20;     
static const uint ICON_MAX_RECURSE = 10;     
 
/* console parser */
/* static */ IConsole::CommandList &IConsole::Commands()
{
  static IConsole::CommandList cmds;
  return cmds;
}
 
/* static */ IConsole::AliasList &IConsole::Aliases()
{
  static IConsole::AliasList aliases;
  return aliases;
}
 
FILE *_iconsole_output_file;
 
void IConsoleInit()
{
  _iconsole_output_file = nullptr;
  _redirect_console_to_client = INVALID_CLIENT_ID;
  _redirect_console_to_admin  = INVALID_ADMIN_ID;
 
  IConsoleGUIInit();
 
  IConsoleStdLibRegister();
}
 
static void IConsoleWriteToLogFile(const char *string)
{
  if (_iconsole_output_file != nullptr) {
    /* if there is an console output file ... also print it there */
    const char *header = GetLogPrefix();
    if ((strlen(header) != 0 && fwrite(header, strlen(header), 1, _iconsole_output_file) != 1) ||
        fwrite(string, strlen(string), 1, _iconsole_output_file) != 1 ||
        fwrite("\n", 1, 1, _iconsole_output_file) != 1) {
      fclose(_iconsole_output_file);
      _iconsole_output_file = nullptr;
      IConsolePrint(CC_ERROR, "Cannot write to console log file; closing the log file.");
    }
  }
}
 
bool CloseConsoleLogIfActive()
{
  if (_iconsole_output_file != nullptr) {
    IConsolePrint(CC_INFO, "Console log file closed.");
    fclose(_iconsole_output_file);
    _iconsole_output_file = nullptr;
    return true;
  }
 
  return false;
}
 
void IConsoleFree()
{
  IConsoleGUIFree();
  CloseConsoleLogIfActive();
}
 
void IConsolePrint(TextColour colour_code, const std::string &string)
{
  assert(IsValidConsoleColour(colour_code));
 
  if (_redirect_console_to_client != INVALID_CLIENT_ID) {
    /* Redirect the string to the client */
    NetworkServerSendRcon(_redirect_console_to_client, colour_code, string);
    return;
  }
 
  if (_redirect_console_to_admin != INVALID_ADMIN_ID) {
    NetworkServerSendAdminRcon(_redirect_console_to_admin, colour_code, string);
    return;
  }
 
  /* Create a copy of the string, strip if of colours and invalid
   * characters and (when applicable) assign it to the console buffer */
  char *str = stredup(string.c_str());
  str_strip_colours(str);
  StrMakeValidInPlace(str);
 
  if (_network_dedicated) {
    NetworkAdminConsole("console", str);
    fprintf(stdout, "%s%s\n", GetLogPrefix(), str);
    fflush(stdout);
    IConsoleWriteToLogFile(str);
    free(str); // free duplicated string since it's not used anymore
    return;
  }
 
  IConsoleWriteToLogFile(str);
  IConsoleGUIPrint(colour_code, str);
  free(str);
}
 
bool GetArgumentInteger(uint32 *value, const char *arg)
{
  char *endptr;
 
  if (strcmp(arg, "on") == 0 || strcmp(arg, "true") == 0) {
    *value = 1;
    return true;
  }
  if (strcmp(arg, "off") == 0 || strcmp(arg, "false") == 0) {
    *value = 0;
    return true;
  }
 
  *value = strtoul(arg, &endptr, 0);
  return arg != endptr;
}
 
static std::string RemoveUnderscores(std::string name)
{
  name.erase(std::remove(name.begin(), name.end(), '_'), name.end());
  return name;
}
 
/* static */ void IConsole::CmdRegister(const std::string &name, IConsoleCmdProc *proc, IConsoleHook *hook)
{
  IConsole::Commands().try_emplace(RemoveUnderscores(name), name, proc, hook);
}
 
/* static */ IConsoleCmd *IConsole::CmdGet(const std::string &name)
{
  auto item = IConsole::Commands().find(RemoveUnderscores(name));
  if (item != IConsole::Commands().end()) return &item->second;
  return nullptr;
}
 
/* static */ void IConsole::AliasRegister(const std::string &name, const std::string &cmd)
{
  auto result = IConsole::Aliases().try_emplace(RemoveUnderscores(name), name, cmd);
  if (!result.second) IConsolePrint(CC_ERROR, "An alias with the name '{}' already exists.", name);
}
 
/* static */ IConsoleAlias *IConsole::AliasGet(const std::string &name)
{
  auto item = IConsole::Aliases().find(RemoveUnderscores(name));
  if (item != IConsole::Aliases().end()) return &item->second;
  return nullptr;
}
 
static void IConsoleAliasExec(const IConsoleAlias *alias, byte tokencount, char *tokens[ICON_TOKEN_COUNT], const uint recurse_count)
{
  char  alias_buffer[ICON_MAX_STREAMSIZE] = { '\0' };
  char *alias_stream = alias_buffer;
 
  Debug(console, 6, "Requested command is an alias; parsing...");
 
  if (recurse_count > ICON_MAX_RECURSE) {
    IConsolePrint(CC_ERROR, "Too many alias expansions, recursion limit reached.");
    return;
  }
 
  for (const char *cmdptr = alias->cmdline.c_str(); *cmdptr != '\0'; cmdptr++) {
    switch (*cmdptr) {
      case '\'': // ' will double for ""
        alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
        break;
 
      case ';': // Cmd separator; execute previous and start new command
        IConsoleCmdExec(alias_buffer, recurse_count);
 
        alias_stream = alias_buffer;
        *alias_stream = '\0'; // Make sure the new command is terminated.
 
        cmdptr++;
        break;
 
      case '%': // Some or all parameters
        cmdptr++;
        switch (*cmdptr) {
          case '+': { // All parameters separated: "[param 1]" "[param 2]"
            for (uint i = 0; i != tokencount; i++) {
              if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
              alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
              alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
              alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
            }
            break;
          }
 
          case '!': { // Merge the parameters to one: "[param 1] [param 2] [param 3...]"
            alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
            for (uint i = 0; i != tokencount; i++) {
              if (i != 0) alias_stream = strecpy(alias_stream, " ", lastof(alias_buffer));
              alias_stream = strecpy(alias_stream, tokens[i], lastof(alias_buffer));
            }
            alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
            break;
          }
 
          default: { // One specific parameter: %A = [param 1] %B = [param 2] ...
            int param = *cmdptr - 'A';
 
            if (param < 0 || param >= tokencount) {
              IConsolePrint(CC_ERROR, "Too many or wrong amount of parameters passed to alias.");
              IConsolePrint(CC_HELP, "Usage of alias '{}': '{}'.", alias->name, alias->cmdline);
              return;
            }
 
            alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
            alias_stream = strecpy(alias_stream, tokens[param], lastof(alias_buffer));
            alias_stream = strecpy(alias_stream, "\"", lastof(alias_buffer));
            break;
          }
        }
        break;
 
      default:
        *alias_stream++ = *cmdptr;
        *alias_stream = '\0';
        break;
    }
 
    if (alias_stream >= lastof(alias_buffer) - 1) {
      IConsolePrint(CC_ERROR, "Requested alias execution would overflow execution buffer.");
      return;
    }
  }
 
  IConsoleCmdExec(alias_buffer, recurse_count);
}
 
void IConsoleCmdExec(const char *cmdstr, const uint recurse_count)
{
  const char *cmdptr;
  char *tokens[ICON_TOKEN_COUNT], tokenstream[ICON_MAX_STREAMSIZE];
  uint t_index, tstream_i;
 
  bool longtoken = false;
  bool foundtoken = false;
 
  if (cmdstr[0] == '#') return; // comments
 
  for (cmdptr = cmdstr; *cmdptr != '\0'; cmdptr++) {
    if (!IsValidChar(*cmdptr, CS_ALPHANUMERAL)) {
      IConsolePrint(CC_ERROR, "Command '{}' contains malformed characters.", cmdstr);
      return;
    }
  }
 
  Debug(console, 4, "Executing cmdline: '{}'", cmdstr);
 
  memset(&tokens, 0, sizeof(tokens));
  memset(&tokenstream, 0, sizeof(tokenstream));
 
  /* 1. Split up commandline into tokens, separated by spaces, commands
   * enclosed in "" are taken as one token. We can only go as far as the amount
   * of characters in our stream or the max amount of tokens we can handle */
  for (cmdptr = cmdstr, t_index = 0, tstream_i = 0; *cmdptr != '\0'; cmdptr++) {
    if (tstream_i >= lengthof(tokenstream)) {
      IConsolePrint(CC_ERROR, "Command line too long.");
      return;
    }
 
    switch (*cmdptr) {
    case ' ': // Token separator
      if (!foundtoken) break;
 
      if (longtoken) {
        tokenstream[tstream_i] = *cmdptr;
      } else {
        tokenstream[tstream_i] = '\0';
        foundtoken = false;
      }
 
      tstream_i++;
      break;
    case '"': // Tokens enclosed in "" are one token
      longtoken = !longtoken;
      if (!foundtoken) {
        if (t_index >= lengthof(tokens)) {
          IConsolePrint(CC_ERROR, "Command line too long.");
          return;
        }
        tokens[t_index++] = &tokenstream[tstream_i];
        foundtoken = true;
      }
      break;
    case '\\': // Escape character for ""
      if (cmdptr[1] == '"' && tstream_i + 1 < lengthof(tokenstream)) {
        tokenstream[tstream_i++] = *++cmdptr;
        break;
      }
      FALLTHROUGH;
    default: // Normal character
      tokenstream[tstream_i++] = *cmdptr;
 
      if (!foundtoken) {
        if (t_index >= lengthof(tokens)) {
          IConsolePrint(CC_ERROR, "Command line too long.");
          return;
        }
        tokens[t_index++] = &tokenstream[tstream_i - 1];
        foundtoken = true;
      }
      break;
    }
  }
 
  for (uint i = 0; i < lengthof(tokens) && tokens[i] != nullptr; i++) {
    Debug(console, 8, "Token {} is: '{}'", i, tokens[i]);
  }
 
  if (StrEmpty(tokens[0])) return; // don't execute empty commands
  /* 2. Determine type of command (cmd or alias) and execute
   * First try commands, then aliases. Execute
   * the found action taking into account its hooking code
   */
  IConsoleCmd *cmd = IConsole::CmdGet(tokens[0]);
  if (cmd != nullptr) {
    ConsoleHookResult chr = (cmd->hook == nullptr ? CHR_ALLOW : cmd->hook(true));
    switch (chr) {
      case CHR_ALLOW:
        if (!cmd->proc(t_index, tokens)) { // index started with 0
          cmd->proc(0, nullptr); // if command failed, give help
        }
        return;
 
      case CHR_DISALLOW: return;
      case CHR_HIDE: break;
    }
  }
 
  t_index--;
  IConsoleAlias *alias = IConsole::AliasGet(tokens[0]);
  if (alias != nullptr) {
    IConsoleAliasExec(alias, t_index, &tokens[1], recurse_count + 1);
    return;
  }
 
  IConsolePrint(CC_ERROR, "Command '{}' not found.", tokens[0]);
}