void CommandHandler::HandleTeleportAtCommand()
{
int x, y;
ExtractArg(x);
ExtractArg(y);
pPlayer->Teleport(x, y);
}
bool CommandHandler::ExecuteCommand()
{
std::string Command;
ExtractArg(Command);
// Is it a command?
if (Command.empty())
return false;
// Is there such command?
ChatCommand* pCommand;
for (pCommand = GetCommandTable(); pCommand->Name != nullptr; ++pCommand)
if (Command.compare(pCommand->Name) == 0)
break;
if (pCommand->Name == nullptr)
throw BadCommand();
while (!pCommand->Handler)
{
ExtractArg(Command);
if (pCommand->ChildCommands == nullptr)
throw BadCommand();
for (pCommand = pCommand->ChildCommands; pCommand->Name != nullptr; ++pCommand)
{
if (Command.compare(pCommand->Name) == 0)
break;
}
}
if (Console)
{
if (pCommand->AllowConsole)
{
(this->*pCommand->Handler)();
}
else
{
sLog.Write(LEVEL_INFO, LOG_CONSOLE, "You can't do this from console!");
}
}
else
{
if (pPlayer->GetSecLevel() >= pCommand->SecurityLevel)
{
(this->*pCommand->Handler)();
}
else
{
pPlayer->SendCommandReponse("You don't have the level for executing this command!");
return false;
}
}
return true;
}
void CommandHandler::HandleTeleportAtCommand()
{
uint16 x, y;
uint64 MapGUID;
ExtractArg(x);
ExtractArg(y);
ExtractArg(MapGUID);
pPlayer->Teleport(ObjectAccessor::GetInstance()->FindMap(MapGUID), x, y);
}
void CommandHandler::HandleAccountSetSecLevelCommand()
{
std::string Username;
ExtractArg(Username);
uint32 SecLevel;
ExtractArg(SecLevel);
if (SecLevel > SEC_ADMIN || SecLevel < SEC_PLAYER)
throw BadCommand();
CharactersDB->PExecute("UPDATE `players` SET `seclevel` = %u WHERE `username` = '%s'", SecLevel, Username.c_str());
}
void CommandHandler::HandleAccountSetPasswordCommand()
{
std::string Username;
std::string Password;
if (Console)
ExtractArg(Username);
else
Username = pPlayer->GetUsername();
ExtractArg(Password);
sDatabase.PExecute("UPDATE `players` SET `password` = '%s' WHERE `username` = '%s'", Password.c_str(), Username.c_str());
}
void CommandHandler::HandleKillCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = ObjectAccessor::GetInstance()->FindPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
pTargetPlayer->Kill();
else
{
if (Console)
sLog.Write(LEVEL_INFO, LOG_CONSOLE, "Player is not in world!");
else
pPlayer->SendCommandReponse("Player is not in world!");
}
}
else
{
if (Console)
sLog.Write(LEVEL_INFO, LOG_CONSOLE, "Unknown player!");
else
pPlayer->SendCommandReponse("Unknown player!");
}
}
void CommandHandler::HandleAccountSetPasswordCommand()
{
std::string Username;
std::string Password;
if (Console)
ExtractArg(Username);
else
Username = pPlayer->GetName();
ExtractArg(Password);
Password = HashSHA512AndEncodeHex(Password);
CharactersDB->PExecute("UPDATE `players` SET `hash` = '%s' WHERE `username` = '%s'", Password.c_str(), Username.c_str());
}
ChatCommand* CommandHandler::SubCommandHelper(std::string const& CommandBaseName)
{
ChatCommand* pCommand;
for (pCommand = GetCommandTable() ; pCommand->Name != nullptr ; ++pCommand)
if (pCommand->Name == CommandBaseName)
break;
if (pCommand->Name == nullptr)
return nullptr;
if (pCommand->ChildCommands == nullptr)
return pCommand;
else if (!IsEndArgument())
{
while (!IsEndArgument())
{
std::string SubCommand;
ExtractArg(SubCommand);
for (pCommand = pCommand->ChildCommands ; pCommand->Name != nullptr ; ++pCommand)
if (pCommand->Name == SubCommand)
break;
if (pCommand->Name == nullptr)
return nullptr;
if (pCommand->ChildCommands == nullptr)
return pCommand;
}
}
return pCommand;
}
void CommandHandler::HandleKillCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = sObjectMgr.GetPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
pTargetPlayer->Kill();
else
{
if (Console)
sLog.Write("Player is not in world!");
else
pPlayer->SendCommandReponse("Player is not in world!");
}
}
else
{
if (Console)
sLog.Write("Unknown player!");
else
pPlayer->SendCommandReponse("Unknown player!");
}
}
int
handle_set_command(char *cmd)
{
#if 0
ConfigCommandStruct *cmdstruct;
ConfigCommandFn fn;
char *param;
if (ExtractArg(cmd, ¶m, &cmd) < 0)
{
return -1;
}
/* lookup the command */
cmdstruct = lookupconfigcmd(param);
if (cmdstruct == NULL)
{
return -1;
}
fn = cmdstruct->set_func;
if (fn == NULL)
{
return -1;
}
/* call the function */
fn(param, cmdstruct->cmd, cmd, CONFIG_VERBOSE, &config_change[0]);
#endif
return(0);
}
int
handle_reset_command(char *cmd)
{
char *param;
char fn[] = "handle_reset_command():";
if (ExtractArg(cmd, ¶m, &cmd) < 0)
{
return -1;
}
if (!strcmp(param, "stats"))
{
return ThreadStatsReset();
}
if ( param != (char*) NULL )
{
NETERROR(MINIT, ("%s invalid command %s specified\n", fn, param ));
}
else
{
NETERROR(MINIT, ("%s no command specified\n", fn ));
}
return(-1);
}
/* Extracts and, if present, removes the 'exact' argument from the
argument list. An integer code giving the desired exact matching
behavior is returned:
0 not exact
1 exact
-1 not exact, but warn when partial matching is used
*/
static int ExtractExactArg(SEXP args)
{
SEXP argval = ExtractArg(args, R_ExactSymbol);
int exact;
if(isNull(argval)) return 1; /* Default is true as from R 2.7.0 */
exact = asLogical(argval);
if (exact == NA_LOGICAL) exact = -1;
return exact;
}
void CommandHandler::HandleAccountCreateCommand()
{
std::string Username, Password;
ExtractArg(Username);
ExtractArg(Password);
sDatabase.PExecute("INSERT INTO `players` VALUES (%llu, '%s', '%s', 'none', 0, 0, 'dg_classm32.gif', 0, 0, 0, 0, 0)", sDatabase.Generate64BitsGUID(), Username.c_str(), Password.c_str());
if (Console)
sLog.Write("Account %s successfully created.", Username.c_str());
else
{
std::string Msg = "Account ";
Msg += Username;
Msg += " successfully created.";
pPlayer->SendCommandReponse(Msg);
}
}
void CommandHandler::HandleAccountCreateCommand()
{
std::string Username, Password;
ExtractArg(Username);
ExtractArg(Password);
Password = HashSHA512AndEncodeHex(Password);
CharactersDB->PExecute("INSERT INTO `players` VALUES (%llu, '%s', '%s', 'none', 0, 0, 'dg_classm32.gif', 0, 0, 0, 0, 0)", Database::GenerateGUID(), Username.c_str(), Password.c_str());
if (Console)
sLog.Write(LEVEL_INFO, LOG_CONSOLE, "Account %s successfully created.", Username.c_str());
else
{
std::string Msg = "Account ";
Msg += Username;
Msg += " successfully created.";
// pPlayer->SendCommandReponse(Msg);
}
}
void CommandHandler::HandleAccountDeleteCommand()
{
std::string Username;
ExtractArg(Username);
Player* pPlayer = sObjectMgr.GetPlayer(Username);
if (pPlayer->IsInWorld())
pPlayer->LogOut();
sDatabase.PExecute("DELETE FROM `players` WHERE `username` = '%s'", Username.c_str());
}
void CommandHandler::HandleAccountDeleteCommand()
{
std::string Username;
ExtractArg(Username);
Player* pPlayer = ObjectAccessor::GetInstance()->FindPlayer(Username);
if (pPlayer->IsInWorld())
pPlayer->LogOut();
CharactersDB->PExecute("DELETE FROM `players` WHERE `username` = '%s'", Username.c_str());
}
int
handle_cli_command(char *buffer)
{
// First we form arguments out of this buffer
int argc = 0;
char* argv[100] = { 0 };
while (ExtractArg(buffer, &argv[argc++], &buffer) >= 0);
#if 0
ProcessCommand(argc, argv, 0x0002);
#endif
return(0);
}
void CommandHandler::HandleBringCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = sObjectMgr.GetPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
{
pTargetPlayer->Teleport(pPlayer->GetPosition());
}
else
{
pPlayer->SendCommandReponse("Player is not in world !");
}
}
else
pPlayer->SendCommandReponse("Player doesn't exist !");
}
void CommandHandler::HandleTeleportToCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = ObjectAccessor::GetInstance()->FindPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
{
pPlayer->Teleport((Map*)pTargetPlayer->GetContainer(), pTargetPlayer->GetPosition());
}
else
{
pPlayer->SendCommandReponse("Player is not in world !");
}
}
else
{
pPlayer->SendCommandReponse("Player doesn't exist !");
}
}
void CommandHandler::HandleHelpCommand()
{
std::string Command, Help;
ExtractArg(Command);
ChatCommand* pCommand = SubCommandHelper(Command);
if (pCommand == nullptr)
{
if (Console)
sLog.Write(LEVEL_INFO, LOG_CONSOLE, "There is not a such command !");
else
pPlayer->SendCommandReponse("There is not a such command !");
return;
}
else
Help = pCommand->Help;
if (Console)
sLog.Write(LEVEL_INFO, LOG_CONSOLE, Help);
else
pPlayer->SendCommandReponse(Help);
}
/* Extracts the drop argument, if present, from the argument list.
The object being subsetted must be the first argument. */
static void ExtractDropArg(SEXP el, int *drop)
{
SEXP dropArg = ExtractArg(el, R_DropSymbol);
*drop = asLogical(dropArg);
if (*drop == NA_LOGICAL) *drop = 1;
}
void CommandHandler::HandleShutdownCommand()
{
uint32 Time;
ExtractArg(Time);
}
bool ChatHandler::HandlePunishCommand(char *args)
{
Player *plr = NULL;
std::string pname;
uint64 plr_guid = 0;
uint32 accid = 0;
if(!ExtractPlayerTarget(&args, &plr, NULL, &pname))
return false;
if(plr)
accid = plr->GetSession()->GetAccountId();
else
{
std::string pname_esc(pname);
CharacterDatabase.escape_string(pname_esc);
QueryResult *result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'", pname_esc.c_str());
if(!result)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
Field *fields = result->Fetch();
accid = fields[0].GetUInt32();
delete result;
}
// extra check, not sure if really necessary, but we better be on the safe side!
if(!accid)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
// find only player from same account if any
if (!plr)
{
if (WorldSession* session = sWorld.FindSession(accid))
{
plr = session->GetPlayer();
pname = plr->GetName();
}
}
char *what = ExtractArg(&args);
char *reason = ExtractArg(&args);
std::string strWhat(what ? what : "");
bool handled = sPunishMgr.Handle(accid, plr, m_session->GetPlayer(), pname, strWhat, reason ? reason : GetMangosString(LANG_NO_REASON_GIVEN));
if(!handled)
{
PSendSysMessage(LANG_NO_RECORD_IN_DB, strWhat.c_str());
SetSentErrorMessage(true);
return false;
}
return true;
}
int
handle_command(char *buffer)
{
int rc = 1;
char *op;
int cmdtype;
static unsigned long mark;
if (ExtractArg(buffer, &op, &buffer) < 0)
{
return -1;
}
cmdtype = type_command(op);
switch (cmdtype)
{
case COMMAND_GET:
handle_get_command(buffer);
break;
case COMMAND_SET:
handle_set_command(buffer);
break;
case COMMAND_RESET:
handle_reset_command(buffer);
break;
case COMMAND_BYE:
handle_bye_command(buffer);
rc = 0;
break;
case COMMAND_CLI:
handle_cli_command(buffer);
break;
case COMMAND_MEMSTART:
#ifdef _DMALLOC_
dmalloc_message("starting new log");
mark = dmalloc_mark();
#elif _DBMALLOC_
if(malloc_chain_check(0)!=0)
{
int fd;
fd = open("/usr/local/nextone/logs/malloc.inuse", O_CREAT|O_RDWR
);
malloc_dump(fd );
close(fd);
}
orig_size = malloc_inuse(&histid1);
#endif
break;
case COMMAND_MEMSTOP:
#ifdef _DMALLOC_
dmalloc_log_changed(mark, 1, 0, 1);
dmalloc_message("end of log");
#elif _DBMALLOC_
current_size = malloc_inuse(&histid2);
if(current_size != orig_size)
{
int fd;
fd = open("/usr/local/nextone/logs/malloc.inuse", O_CREAT|O_RDWR
);
malloc_list(fd, histid1, histid2);
close(fd);
}
#endif
break;
case COMMAND_NONE:
default:
break;
}
return rc;
}
