Public Member Functions
	server_commandscript ()

std::vector< ChatCommand >	GetCommands () const override

Public Member Functions inherited from ScriptObject
const std::string &	GetName () const

Static Public Member Functions
static bool	HandleServerCorpsesCommand (ChatHandler , char const )

static bool	HandleServerInfoCommand (ChatHandler handler, char const )

static bool	HandleServerMotdCommand (ChatHandler handler, char const )

static bool	HandleServerPLimitCommand (ChatHandler handler, char const args)

static bool	HandleServerShutDownCancelCommand (ChatHandler , char const )

static bool	HandleServerShutDownCommand (ChatHandler , char const args)

static bool	HandleServerRestartCommand (ChatHandler , char const args)

static bool	HandleServerIdleRestartCommand (ChatHandler , char const args)

static bool	HandleServerIdleShutDownCommand (ChatHandler , char const args)

static bool	HandleServerExitCommand (ChatHandler handler, char const )

static bool	HandleServerSetMotdCommand (ChatHandler handler, char const args)

static bool	HandleServerSetClosedCommand (ChatHandler handler, char const args)

static bool	HandleServerSetLogLevelCommand (ChatHandler , char const args)

static bool	HandleServerSetDiffTimeCommand (ChatHandler , char const args)

Static Private Member Functions
static bool	ParseExitCode (char const *exitCodeStr, int32 &exitCode)

static bool	ShutdownServer (char const *args, uint32 shutdownMask, int32 defaultExitCode)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)

Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name)

virtual	~ScriptObject ()

Constructor & Destructor Documentation

server_commandscript::server_commandscript ( )

inline

36 : CommandScript("server_commandscript") { }

CommandScript::CommandScript

CommandScript(const char *name)

Definition: ScriptMgr.cpp:1616

Member Function Documentation

std::vector<ChatCommand> server_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

  {
  static std::vector<ChatCommand> serverIdleRestartCommandTable =
  {
  { "cancel", rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART_CANCEL, true, &HandleServerShutDownCancelCommand, "" },
  { "" , rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART, true, &HandleServerIdleRestartCommand, "" },
  };
 
  static std::vector<ChatCommand> serverIdleShutdownCommandTable =
  {
  { "cancel", rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN_CANCEL, true, &HandleServerShutDownCancelCommand, "" },
  { "" , rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN, true, &HandleServerIdleShutDownCommand, "" },
  };
 
  static std::vector<ChatCommand> serverRestartCommandTable =
  {
  { "cancel", rbac::RBAC_PERM_COMMAND_SERVER_RESTART_CANCEL, true, &HandleServerShutDownCancelCommand, "" },
  { "" , rbac::RBAC_PERM_COMMAND_SERVER_RESTART, true, &HandleServerRestartCommand, "" },
  };
 
  static std::vector<ChatCommand> serverShutdownCommandTable =
  {
  { "cancel", rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN_CANCEL, true, &HandleServerShutDownCancelCommand, "" },
  { "" , rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN, true, &HandleServerShutDownCommand, "" },
  };
 
  static std::vector<ChatCommand> serverSetCommandTable =
  {
  { "difftime", rbac::RBAC_PERM_COMMAND_SERVER_SET_DIFFTIME, true, &HandleServerSetDiffTimeCommand, "" },
  { "loglevel", rbac::RBAC_PERM_COMMAND_SERVER_SET_LOGLEVEL, true, &HandleServerSetLogLevelCommand, "" },
  { "motd", rbac::RBAC_PERM_COMMAND_SERVER_SET_MOTD, true, &HandleServerSetMotdCommand, "" },
  { "closed", rbac::RBAC_PERM_COMMAND_SERVER_SET_CLOSED, true, &HandleServerSetClosedCommand, "" },
  };
 
  static std::vector<ChatCommand> serverCommandTable =
  {
  { "corpses", rbac::RBAC_PERM_COMMAND_SERVER_CORPSES, true, &HandleServerCorpsesCommand, "" },
  { "exit", rbac::RBAC_PERM_COMMAND_SERVER_EXIT, true, &HandleServerExitCommand, "" },
  { "idlerestart", rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART, true, NULL, "", serverIdleRestartCommandTable },
  { "idleshutdown", rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN, true, NULL, "", serverIdleShutdownCommandTable },
  { "info", rbac::RBAC_PERM_COMMAND_SERVER_INFO, true, &HandleServerInfoCommand, "" },
  { "motd", rbac::RBAC_PERM_COMMAND_SERVER_MOTD, true, &HandleServerMotdCommand, "" },
  { "plimit", rbac::RBAC_PERM_COMMAND_SERVER_PLIMIT, true, &HandleServerPLimitCommand, "" },
  { "restart", rbac::RBAC_PERM_COMMAND_SERVER_RESTART, true, NULL, "", serverRestartCommandTable },
  { "shutdown", rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN, true, NULL, "", serverShutdownCommandTable },
  { "set", rbac::RBAC_PERM_COMMAND_SERVER_SET, true, NULL, "", serverSetCommandTable },
  };
 
  static std::vector<ChatCommand> commandTable =
  {
  { "server", rbac::RBAC_PERM_COMMAND_SERVER, true, NULL, "", serverCommandTable },
  };
  return commandTable;
  }

Here is the call graph for this function:

static bool server_commandscript::HandleServerCorpsesCommand	(	ChatHandler *	,
		char const *
	)

inlinestatic

  {
  sWorld->RemoveOldCorpses();
  return true;
  }

Here is the caller graph for this function:

static bool server_commandscript::HandleServerExitCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  handler->SendSysMessage(LANG_COMMAND_EXIT);
  World::StopNow(SHUTDOWN_EXIT_CODE);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerIdleRestartCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  return ShutdownServer(args, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, RESTART_EXIT_CODE);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerIdleShutDownCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  return ShutdownServer(args, SHUTDOWN_MASK_IDLE, SHUTDOWN_EXIT_CODE);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerInfoCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  uint32 playersNum = sWorld->GetPlayerCount();
  uint32 maxPlayersNum = sWorld->GetMaxPlayerCount();
  uint32 activeClientsNum = sWorld->GetActiveSessionCount();
  uint32 queuedClientsNum = sWorld->GetQueuedSessionCount();
  uint32 maxActiveClientsNum = sWorld->GetMaxActiveSessionCount();
  uint32 maxQueuedClientsNum = sWorld->GetMaxQueuedSessionCount();
  std::string uptime = secsToTimeString(sWorld->GetUptime());
  uint32 updateTime = sWorld->GetUpdateTime();
 
  handler->SendSysMessage(GitRevision::GetFullVersion());
  handler->PSendSysMessage(LANG_CONNECTED_PLAYERS, playersNum, maxPlayersNum);
  handler->PSendSysMessage(LANG_CONNECTED_USERS, activeClientsNum, maxActiveClientsNum, queuedClientsNum, maxQueuedClientsNum);
  handler->PSendSysMessage(LANG_UPTIME, uptime.c_str());
  handler->PSendSysMessage(LANG_UPDATE_DIFF, updateTime);
  // Can't use sWorld->ShutdownMsg here in case of console command
  if (sWorld->IsShuttingDown())
  handler->PSendSysMessage(LANG_SHUTDOWN_TIMELEFT, secsToTimeString(sWorld->GetShutDownTimeLeft()).c_str());
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerMotdCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  std::string motd;
  for (std::string const& line : sWorld->GetMotd())
  motd += line;
  handler->PSendSysMessage(LANG_MOTD_CURRENT, motd.c_str());
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerPLimitCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (*args)
  {
  char* paramStr = strtok((char*)args, " ");
  if (!paramStr)
  return false;
 
  int32 limit = strlen(paramStr);
 
  if (strncmp(paramStr, "player", limit) == 0)
  sWorld->SetPlayerSecurityLimit(SEC_PLAYER);
  else if (strncmp(paramStr, "moderator", limit) == 0)
  sWorld->SetPlayerSecurityLimit(SEC_MODERATOR);
  else if (strncmp(paramStr, "gamemaster", limit) == 0)
  sWorld->SetPlayerSecurityLimit(SEC_GAMEMASTER);
  else if (strncmp(paramStr, "administrator", limit) == 0)
  sWorld->SetPlayerSecurityLimit(SEC_ADMINISTRATOR);
  else if (strncmp(paramStr, "reset", limit) == 0)
  {
  sWorld->SetPlayerAmountLimit(sConfigMgr->GetIntDefault("PlayerLimit", 100));
  sWorld->LoadDBAllowedSecurityLevel();
  }
  else
  {
  int32 value = atoi(paramStr);
  if (value < 0)
  sWorld->SetPlayerSecurityLimit(AccountTypes(-value));
  else
  sWorld->SetPlayerAmountLimit(uint32(value));
  }
  }
 
  uint32 playerAmountLimit = sWorld->GetPlayerAmountLimit();
  AccountTypes allowedAccountType = sWorld->GetPlayerSecurityLimit();
  char const* secName = "";
  switch (allowedAccountType)
  {
  case SEC_PLAYER:
  secName = "Player";
  break;
  case SEC_MODERATOR:
  secName = "Moderator";
  break;
  case SEC_GAMEMASTER:
  secName = "Gamemaster";
  break;
  case SEC_ADMINISTRATOR:
  secName = "Administrator";
  break;
  default:
  secName = "<unknown>";
  break;
  }
  handler->PSendSysMessage("Player limits: amount %u, min. security level %s.", playerAmountLimit, secName);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerRestartCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  return ShutdownServer(args, SHUTDOWN_MASK_RESTART, RESTART_EXIT_CODE);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerSetClosedCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (strncmp(args, "on", 3) == 0)
  {
  handler->SendSysMessage(LANG_WORLD_CLOSED);
  sWorld->SetClosed(true);
  return true;
  }
  else if (strncmp(args, "off", 4) == 0)
  {
  handler->SendSysMessage(LANG_WORLD_OPENED);
  sWorld->SetClosed(false);
  return true;
  }
 
  handler->SendSysMessage(LANG_USE_BOL);
  handler->SetSentErrorMessage(true);
  return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerSetDiffTimeCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  char* newTimeStr = strtok((char*)args, " ");
  if (!newTimeStr)
  return false;
 
  int32 newTime = atoi(newTimeStr);
  if (newTime < 0)
  return false;
 
  sWorld->SetRecordDiffInterval(newTime);
  printf("Record diff every %i ms\n", newTime);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerSetLogLevelCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  char* type = strtok((char*)args, " ");
  char* name = strtok(NULL, " ");
  char* level = strtok(NULL, " ");
 
  if (!type || !name || !level || *name == '\0' || *level == '\0' || (*type != 'a' && *type != 'l'))
  return false;
 
  sLog->SetLogLevel(name, level, *type == 'l');
  return true;
  }

Here is the caller graph for this function:

static bool server_commandscript::HandleServerSetMotdCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  sWorld->SetMotd(args);
  handler->PSendSysMessage(LANG_MOTD_NEW, args);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::HandleServerShutDownCancelCommand	(	ChatHandler *	,
		char const *
	)

inlinestatic

  {
  sWorld->ShutdownCancel();
 
  return true;
  }

Here is the caller graph for this function:

static bool server_commandscript::HandleServerShutDownCommand	(	ChatHandler *	,
		char const *	args
	)

inlinestatic

  {
  return ShutdownServer(args, 0, SHUTDOWN_EXIT_CODE);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool server_commandscript::ParseExitCode	(	char const *	exitCodeStr,
		int32 &	exitCode
	)

inlinestaticprivate

  {
  exitCode = atoi(exitCodeStr);
 
  // Handle atoi() errors
  if (exitCode == 0 && (exitCodeStr[0] != '0' || exitCodeStr[1] != '\0'))
  return false;
 
  // Exit code should be in range of 0-125, 126-255 is used
  // in many shells for their own return codes and code > 255
  // is not supported in many others
  if (exitCode < 0 || exitCode > 125)
  return false;
 
  return true;
  }

Here is the caller graph for this function:

static bool server_commandscript::ShutdownServer	(	char const *	args,
		uint32	shutdownMask,
		int32	defaultExitCode
	)

inlinestaticprivate

  {
  if (!*args)
  return false;
 
  if (strlen(args) > 255)
  return false;
 
  // #delay [#exit_code] [reason]
  char* delayStr = strtok((char*)args, " ");
  if (!delayStr || !isNumeric(delayStr))
  return false;
 
  char* exitCodeStr = nullptr;
 
  char reason[256] = { 0 };
 
  while (char* nextToken = strtok(nullptr, " "))
  {
  if (isNumeric(nextToken))
  exitCodeStr = nextToken;
  else
  {
  strcat(reason, nextToken);
  if (char* remainingTokens = strtok(nullptr, "\0"))
  {
  strcat(reason, " ");
  strcat(reason, remainingTokens);
  }
  break;
  }
  }
 
  int32 delay = atoi(delayStr);
 
  // Prevent interpret wrong arg value as 0 secs shutdown time
  if ((delay == 0 && (delayStr[0] != '0' || delayStr[1] != '\0')) || delay < 0)
  return false;
 
  int32 exitCode = defaultExitCode;
  if (exitCodeStr)
  if (!ParseExitCode(exitCodeStr, exitCode))
  return false;
 
  sWorld->ShutdownServ(delay, shutdownMask, static_cast<uint8>(exitCode), std::string(reason));
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

src/server/scripts/Commands/cs_server.cpp

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation