debug.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 <stdarg.h>
#include "console_func.h"
#include "debug.h"
#include "string_func.h"
#include "fileio_func.h"
#include "settings_type.h"
#include <mutex>
 
#if defined(_WIN32)
#include "os/windows/win32.h"
#endif
 
#include "walltime_func.h"
 
#include "network/network_admin.h"
SOCKET _debug_socket = INVALID_SOCKET;
 
#include "safeguards.h"
 
struct QueuedDebugItem {
  std::string level;   
  std::string message; 
};
std::atomic<bool> _debug_remote_console; 
std::mutex _debug_remote_console_mutex; 
std::vector<QueuedDebugItem> _debug_remote_console_queue; 
std::vector<QueuedDebugItem> _debug_remote_console_queue_spare; 
 
int _debug_driver_level;
int _debug_grf_level;
int _debug_map_level;
int _debug_misc_level;
int _debug_net_level;
int _debug_sprite_level;
int _debug_oldloader_level;
int _debug_npf_level;
int _debug_yapf_level;
int _debug_fontcache_level;
int _debug_script_level;
int _debug_sl_level;
int _debug_gamelog_level;
int _debug_desync_level;
int _debug_console_level;
#ifdef RANDOM_DEBUG
int _debug_random_level;
#endif
 
struct DebugLevel {
  const char *name;
  int *level;
};
 
#define DEBUG_LEVEL(x) { #x, &_debug_##x##_level }
  static const DebugLevel debug_level[] = {
  DEBUG_LEVEL(driver),
  DEBUG_LEVEL(grf),
  DEBUG_LEVEL(map),
  DEBUG_LEVEL(misc),
  DEBUG_LEVEL(net),
  DEBUG_LEVEL(sprite),
  DEBUG_LEVEL(oldloader),
  DEBUG_LEVEL(npf),
  DEBUG_LEVEL(yapf),
  DEBUG_LEVEL(fontcache),
  DEBUG_LEVEL(script),
  DEBUG_LEVEL(sl),
  DEBUG_LEVEL(gamelog),
  DEBUG_LEVEL(desync),
  DEBUG_LEVEL(console),
#ifdef RANDOM_DEBUG
  DEBUG_LEVEL(random),
#endif
  };
#undef DEBUG_LEVEL
 
char *DumpDebugFacilityNames(char *buf, char *last)
{
  size_t length = 0;
  for (const DebugLevel *i = debug_level; i != endof(debug_level); ++i) {
    if (length == 0) {
      buf = strecpy(buf, "List of debug facility names:\n", last);
    } else {
      buf = strecpy(buf, ", ", last);
      length += 2;
    }
    buf = strecpy(buf, i->name, last);
    length += strlen(i->name);
  }
  if (length > 0) {
    buf = strecpy(buf, "\n\n", last);
  }
  return buf;
}
 
void DebugPrint(const char *level, const std::string &message)
{
  if (_debug_socket != INVALID_SOCKET) {
    std::string msg = fmt::format("{}dbg: [{}] {}\n", GetLogPrefix(), level, message);
 
    /* Prevent sending a message concurrently, as that might cause interleaved messages. */
    static std::mutex _debug_socket_mutex;
    std::lock_guard<std::mutex> lock(_debug_socket_mutex);
 
    /* Sending out an error when this fails would be nice, however... the error
     * would have to be send over this failing socket which won't work. */
    send(_debug_socket, msg.c_str(), (int)msg.size(), 0);
    return;
  }
  if (strcmp(level, "desync") == 0) {
    static FILE *f = FioFOpenFile("commands-out.log", "wb", AUTOSAVE_DIR);
    if (f == nullptr) return;
 
    fprintf(f, "%s%s\n", GetLogPrefix(), message.c_str());
    fflush(f);
#ifdef RANDOM_DEBUG
  } else if (strcmp(level, "random") == 0) {
    static FILE *f = FioFOpenFile("random-out.log", "wb", AUTOSAVE_DIR);
    if (f == nullptr) return;
 
    fprintf(f, "%s\n", message.c_str());
    fflush(f);
#endif
  } else {
    std::string msg = fmt::format("{}dbg: [{}] {}\n", GetLogPrefix(), level, message);
    fputs(msg.c_str(), stderr);
 
    if (_debug_remote_console.load()) {
      /* Only add to the queue when there is at least one consumer of the data. */
      std::lock_guard<std::mutex> lock(_debug_remote_console_mutex);
      _debug_remote_console_queue.push_back({ level, message });
    }
  }
}
 
void SetDebugString(const char *s, void (*error_func)(const char *))
{
  int v;
  char *end;
  const char *t;
 
  /* Store planned changes into map during parse */
  std::map<const char *, int> new_levels;
 
  /* Global debugging level? */
  if (*s >= '0' && *s <= '9') {
    const DebugLevel *i;
 
    v = strtoul(s, &end, 0);
    s = end;
 
    for (i = debug_level; i != endof(debug_level); ++i) {
      new_levels[i->name] = v;
    }
  }
 
  /* Individual levels */
  for (;;) {
    /* skip delimiters */
    while (*s == ' ' || *s == ',' || *s == '\t') s++;
    if (*s == '\0') break;
 
    t = s;
    while (*s >= 'a' && *s <= 'z') s++;
 
    /* check debugging levels */
    const DebugLevel *found = nullptr;
    for (const DebugLevel *i = debug_level; i != endof(debug_level); ++i) {
      if (s == t + strlen(i->name) && strncmp(t, i->name, s - t) == 0) {
        found = i;
        break;
      }
    }
 
    if (*s == '=') s++;
    v = strtoul(s, &end, 0);
    s = end;
    if (found != nullptr) {
      new_levels[found->name] = v;
    } else {
      std::string error_string = fmt::format("Unknown debug level '{}'", std::string(t, s - t));
      error_func(error_string.c_str());
      return;
    }
  }
 
  /* Apply the changes after parse is successful */
  for (const DebugLevel *i = debug_level; i != endof(debug_level); ++i) {
    const auto &nl = new_levels.find(i->name);
    if (nl != new_levels.end()) {
      *i->level = nl->second;
    }
  }
}
 
const char *GetDebugString()
{
  const DebugLevel *i;
  static char dbgstr[150];
  char dbgval[20];
 
  memset(dbgstr, 0, sizeof(dbgstr));
  i = debug_level;
  seprintf(dbgstr, lastof(dbgstr), "%s=%d", i->name, *i->level);
 
  for (i++; i != endof(debug_level); i++) {
    seprintf(dbgval, lastof(dbgval), ", %s=%d", i->name, *i->level);
    strecat(dbgstr, dbgval, lastof(dbgstr));
  }
 
  return dbgstr;
}
 
const char *GetLogPrefix()
{
  static char _log_prefix[24];
  if (_settings_client.gui.show_date_in_logs) {
    LocalTime::Format(_log_prefix, lastof(_log_prefix), "[%Y-%m-%d %H:%M:%S] ");
  } else {
    *_log_prefix = '\0';
  }
  return _log_prefix;
}
 
void DebugSendRemoteMessages()
{
  if (!_debug_remote_console.load()) return;
 
  {
    std::lock_guard<std::mutex> lock(_debug_remote_console_mutex);
    std::swap(_debug_remote_console_queue, _debug_remote_console_queue_spare);
  }
 
  for (auto &item : _debug_remote_console_queue_spare) {
    NetworkAdminConsole(item.level, item.message);
    if (_settings_client.gui.developer >= 2) IConsolePrint(CC_DEBUG, "dbg: [{}] {}", item.level, item.message);
  }
 
  _debug_remote_console_queue_spare.clear();
}
 
void DebugReconsiderSendRemoteMessages()
{
  bool enable = _settings_client.gui.developer >= 2;
 
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[ADMIN_UPDATE_CONSOLE] & ADMIN_FREQUENCY_AUTOMATIC) {
      enable = true;
      break;
    }
  }
 
  _debug_remote_console.store(enable);
}