/**

* vim: set ts=4 sw=4 tw=99 noet :

* =============================================================================

* SourceMod

* Copyright (C) 2004-2010 AlliedModders LLC. All rights reserved.

* =============================================================================

*

* This program is free software; you can redistribute it and/or modify it under

* the terms of the GNU General Public License, version 3.0, as published by the

* Free Software Foundation.

*

* This program 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

* this program. If not, see <http://www.gnu.org/licenses/>.

*

* As a special exception, AlliedModders LLC gives you permission to link the

* code of this program (as well as its derivative works) to "Half-Life 2," the

* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

* by the Valve Corporation. You must obey the GNU General Public License in

* all respects for all other code used. Additionally, AlliedModders LLC grants

* this exception to all derivative works. AlliedModders LLC defines further

* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

* or <http://www.sourcemod.net/license.php>.

*

* Version: $Id$

*/

#include "sm_globals.h"

#include "sourcemod.h"

#include "HalfLife2.h"

#include "sourcemm_api.h"

#include "ConVarManager.h"

#include "ConCmdManager.h"

#include "sm_stringutil.h"

#include "PlayerManager.h"

#include "ChatTriggers.h"

#include <inetchannel.h>

#include <bitbuf.h>

#include <tier0/dbg.h>

#include "Logger.h"

#include "ConsoleDetours.h"

#include "ConCommandBaseIterator.h"

#include "logic_bridge.h"

#include <sm_namehashset.h>

#include "smn_keyvalues.h"

#include <bridge/include/IScriptManager.h>

#include <bridge/include/ILogger.h>

#include <ITranslator.h>

#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE || SOURCE_ENGINE == SE_MCV || SOURCE_ENGINE == SE_OUTBREAK

#ifdef GetMessage

#undef GetMessage

#endif

#include <netmessages.pb.h>

#endif

#if SOURCE_ENGINE >= SE_EYE

#define NETMSG_BITS 6

#else

#define NETMSG_BITS 5

#endif

#if SOURCE_ENGINE >= SE_LEFT4DEAD

#define NET_SETCONVAR 6

#else

#define NET_SETCONVAR 5

#endif

// SourcePawn exposes command and convar flags as a 32-bit int. Outbreak's

// engine stores the native mask as uint64, so keep the conversion at this API

// boundary and preserve the low 32-bit bit pattern.

static int GetConCommandBaseFlags(const ConCommandBase *cmd)

{

#if SOURCE_ENGINE == SE_OUTBREAK

return static_cast<int>(static_cast<uint32>(cmd->GetFlags()));

#else

return cmd->m_nFlags;

#endif

}

static void SetConCommandBaseFlags(ConCommandBase *cmd, int flags)

{

#if SOURCE_ENGINE == SE_OUTBREAK

uint64 newFlags = static_cast<uint32>(flags);

cmd->RemoveFlags(~newFlags);

cmd->AddFlags(newFlags);

#else

cmd->m_nFlags = flags;

#endif

}

enum ConVarBounds

{

ConVarBound_Upper = 0,

ConVarBound_Lower

};

HandleType_t hCmdIterType = 0;

HandleType_t htConCmdIter = 0;

struct GlobCmdIter

{

bool started;

std::list<ConCmdInfo *>::iterator iter;

};

class ConsoleHelpers :

public SMGlobalClass,

public IHandleTypeDispatch

{

public:

virtual void OnSourceModAllInitialized()

{

HandleAccess access;

handlesys->InitAccessDefaults(NULL, &access);

htConCmdIter = handlesys->CreateType("ConCmdIter", this, 0, NULL, &access, g_pCoreIdent, NULL);

access.access[HandleAccess_Clone] = HANDLE_RESTRICT_OWNER | HANDLE_RESTRICT_IDENTITY;

hCmdIterType = handlesys->CreateType("CmdIter", this, 0, NULL, &access, g_pCoreIdent, NULL);

}

virtual void OnHandleDestroy(HandleType_t type, void *object)

{

if (type == hCmdIterType)

{

GlobCmdIter *iter = (GlobCmdIter *)object;

delete iter;

}

else if (type == htConCmdIter)

{

ConCommandBaseIterator *iter = (ConCommandBaseIterator * )object;

delete iter;

}

}

virtual bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)

{

if (type == htConCmdIter)

{

*pSize = sizeof(ConCommandBaseIterator);

return true;

}

else if (type == hCmdIterType)

{

*pSize = sizeof(GlobCmdIter);

return true;

}

return false;

}

} s_ConsoleHelpers;

class CommandFlagsHelper : public IConCommandTracker

{

public:

void OnUnlinkConCommandBase(ConCommandBase *pBase, const char *name) override

{

m_CmdFlags.remove(name);

}

bool GetFlags(const char *name, int *flags)

{

ConCommandBase *pCmd;

if (m_CmdFlags.retrieve(name, &pCmd))

{

TrackConCommandBase(pCmd, this);

*flags = GetConCommandBaseFlags(pCmd);

return true;

}

else if ((pCmd=FindCommandBase(name)))

{

m_CmdFlags.insert(name, pCmd);

TrackConCommandBase(pCmd, this);

*flags = GetConCommandBaseFlags(pCmd);

return true;

}

else

{

return false;

}

}

bool SetFlags(const char *name, int flags)

{

ConCommandBase *pCmd;

if (m_CmdFlags.retrieve(name, &pCmd))

{

SetConCommandBaseFlags(pCmd, flags);

TrackConCommandBase(pCmd, this);

return true;

}

else if ((pCmd=FindCommandBase(name)))

{

m_CmdFlags.insert(name, pCmd);

SetConCommandBaseFlags(pCmd, flags);

TrackConCommandBase(pCmd, this);

return true;

}

else

{

return false;

}

}

private:

struct ConCommandPolicy

{

static inline bool matches(const char *name, ConCommandBase *base)

{

const char *conCommandChars = base->GetName();

std::string conCommandName = ke::Lowercase(conCommandChars);

std::string input = ke::Lowercase(name);

return conCommandName == input;

}

static inline uint32_t hash(const detail::CharsAndLength &key)

{

std::string lower = ke::Lowercase(key.c_str());

return detail::CharsAndLength(lower.c_str()).hash();

}

};

NameHashSet<ConCommandBase *, ConCommandPolicy> m_CmdFlags;

} s_CommandFlagsHelper;

#if SOURCE_ENGINE < SE_ORANGEBOX

static void ReplicateConVar(ConVar *pConVar)

{

int maxClients = g_Players.GetMaxClients();

char data[256];

bf_write buffer(data, sizeof(data));

buffer.WriteUBitLong(NET_SETCONVAR, NETMSG_BITS);

buffer.WriteByte(1);

buffer.WriteString(pConVar->GetName());

buffer.WriteString(pConVar->GetString());

for (int i = 1; i <= maxClients; i++)

{

CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);

if (pPlayer && pPlayer->IsInGame() && !pPlayer->IsFakeClient())

{

if (INetChannel *netchan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(i)))

netchan->SendData(buffer);

}

}

}

static void NotifyConVar(ConVar *pConVar)

{

IGameEvent *pEvent = gameevents->CreateEvent("server_cvar");

pEvent->SetString("cvarname", pConVar->GetName());

if (IsFlagSet(pConVar, FCVAR_PROTECTED))

{

pEvent->SetString("cvarvalue", "***PROTECTED***");

}

else

{

pEvent->SetString("cvarvalue", pConVar->GetString());

}

gameevents->FireEvent(pEvent);

}

#endif

static cell_t sm_CreateConVar(IPluginContext *pContext, const cell_t *params)

{

char *name, *defaultVal, *helpText;

pContext->LocalToString(params[1], &name);

// While the engine seems to accept a blank convar name, it causes a crash upon server quit

if (name == NULL || strcmp(name, "") == 0)

{

return pContext->ThrowNativeError("Convar with blank name is not permitted");

}

pContext->LocalToString(params[2], &defaultVal);

pContext->LocalToString(params[3], &helpText);

bool hasMin = params[5] ? true : false;

bool hasMax = params[7] ? true : false;

float min = sp_ctof(params[6]);

float max = sp_ctof(params[8]);

Handle_t hndl = g_ConVarManager.CreateConVar(pContext, name, defaultVal, helpText, params[4], hasMin, min, hasMax, max);

if (hndl == BAD_HANDLE)

{

return pContext->ThrowNativeError("Convar \"%s\" was not created. A console command with the same might already exist.", name);

}

return hndl;

}

static cell_t sm_FindConVar(IPluginContext *pContext, const cell_t *params)

{

char *name;

pContext->LocalToString(params[1], &name);

return g_ConVarManager.FindConVar(name);

}

static cell_t sm_HookConVarChange(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);

if (!pFunction)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);

}

g_ConVarManager.HookConVarChange(pConVar, pFunction);

return 1;

}

static cell_t sm_UnhookConVarChange(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);

if (!pFunction)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);

}

g_ConVarManager.UnhookConVarChange(pConVar, pFunction);

return 1;

}

static cell_t sm_GetConVarBool(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

return pConVar->GetBool();

}

static cell_t sm_GetConVarInt(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

return pConVar->GetInt();

}

/* This handles both SetConVarBool() and SetConVarInt() */

static cell_t sm_SetConVarNum(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

pConVar->SetValue(params[2]);

#if SOURCE_ENGINE < SE_ORANGEBOX

/* Should we replicate it? */

if (params[0] >= 3 && params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))

{

ReplicateConVar(pConVar);

}

/* Should we notify clients? */

if (params[0] >= 4 && params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))

{

NotifyConVar(pConVar);

}

#endif

return 1;

}

static cell_t sm_GetConVarFloat(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

float value = pConVar->GetFloat();

return sp_ftoc(value);

}

static cell_t sm_SetConVarFloat(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

float value = sp_ctof(params[2]);

pConVar->SetValue(value);

#if SOURCE_ENGINE < SE_ORANGEBOX

/* Should we replicate it? */

if (params[0] >= 3 && params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))

{

ReplicateConVar(pConVar);

}

/* Should we notify clients? */

if (params[0] >= 4 && params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))

{

NotifyConVar(pConVar);

}

#endif

return 1;

}

static cell_t sm_GetConVarString(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetString(), NULL);

return 1;

}

static cell_t sm_SetConVarString(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

char *value;

pContext->LocalToString(params[2], &value);

pConVar->SetValue(value);

#if SOURCE_ENGINE < SE_ORANGEBOX

/* Should we replicate it? */

if (params[0] >= 3 && params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))

{

ReplicateConVar(pConVar);

}

/* Should we notify clients? */

if (params[0] >= 4 && params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))

{

NotifyConVar(pConVar);

}

#endif

return 1;

}

static cell_t sm_ResetConVar(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

pConVar->Revert();

#if SOURCE_ENGINE < SE_ORANGEBOX

/* Should we replicate it? */

if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))

{

ReplicateConVar(pConVar);

}

/* Should we notify clients? */

if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))

{

NotifyConVar(pConVar);

}

#endif

return 1;

}

static cell_t GetConVarDefault(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

size_t bytes;

pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetDefault(), &bytes);

return bytes;

}

static cell_t sm_GetConVarFlags(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

return GetConCommandBaseFlags(pConVar);

}

static cell_t sm_GetConVarPlugin(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

IPlugin *pPlugin;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, nullptr, &pPlugin))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

return pPlugin ? pPlugin->GetMyHandle() : BAD_HANDLE;

}

static cell_t sm_SetConVarFlags(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

SetConCommandBaseFlags(pConVar, params[2]);

return 1;

}

static cell_t sm_GetConVarBounds(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

cell_t *addr;

bool hasBound;

float bound;

switch (params[2])

{

case ConVarBound_Upper:

hasBound = pConVar->GetMax(bound);

break;

case ConVarBound_Lower:

hasBound = pConVar->GetMin(bound);

break;

default:

return pContext->ThrowNativeError("Invalid ConVarBounds value %d");

}

pContext->LocalToPhysAddr(params[3], &addr);

*addr = sp_ftoc(bound);

return hasBound;

}

static cell_t sm_SetConVarBounds(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

switch (params[2])

{

case ConVarBound_Upper:

pConVar->m_fMaxVal = sp_ctof(params[4]);

pConVar->m_bHasMax = params[3] ? true : false;

break;

case ConVarBound_Lower:

pConVar->m_fMinVal = sp_ctof(params[4]);

pConVar->m_bHasMin = params[3] ? true : false;

break;

default:

return pContext->ThrowNativeError("Invalid ConVarBounds value %d");

}

return 1;

}

static cell_t sm_GetConVarName(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetName(), NULL);

return 1;

}

static cell_t sm_GetConVarDescription(IPluginContext *pContext, const cell_t *params)

{

Handle_t hndl = static_cast<Handle_t>(params[1]);

HandleError err;

ConVar *pConVar;

if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))

!= HandleError_None)

{

return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);

}

pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetHelpText(), NULL);

return 1;

}

static bool s_QueryAlreadyWarned = false;

static cell_t sm_QueryClientConVar(IPluginContext *pContext, const cell_t *params)

{

CPlayer *pPlayer;

char *name;

IPluginFunction *pCallback;

if (!g_ConVarManager.IsQueryingSupported())

{

if (!s_QueryAlreadyWarned)

{

s_QueryAlreadyWarned = true;

return pContext->ThrowNativeError("Game does not support client convar querying (one time warning)");

}

return 0;

}

pPlayer = g_Players.GetPlayerByIndex(params[1]);

if (!pPlayer)

{

return pContext->ThrowNativeError("Client index %d is invalid", params[1]);

}

if (!pPlayer->IsConnected())

{

return pContext->ThrowNativeError("Client %d is not connected", params[1]);

}

/* Trying a query on a bot results in callback not be fired, so don't bother */

if (pPlayer->IsFakeClient())

{

return 0;

}

pContext->LocalToString(params[2], &name);

pCallback = pContext->GetFunctionById(params[3]);

if (!pCallback)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[3]);

}

return g_ConVarManager.QueryClientConVar(pPlayer->GetEdict(), name, pCallback, params[4]);

}

static cell_t sm_RegServerCmd(IPluginContext *pContext, const cell_t *params)

{

char *name,*help;

IPluginFunction *pFunction;

pContext->LocalToString(params[1], &name);

if (strcasecmp(name, "sm") == 0)

{

return pContext->ThrowNativeError("Cannot register \"sm\" command");

}

pContext->LocalToString(params[3], &help);

pFunction = pContext->GetFunctionById(params[2]);

if (!pFunction)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);

}

IPlugin *pPlugin = scripts->FindPluginByContext(pContext);

if (!g_ConCmds.AddServerCommand(pFunction, name, help, params[4], pPlugin))

{

return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);

}

return 1;

}

static cell_t sm_RegConsoleCmd(IPluginContext *pContext, const cell_t *params)

{

char *name,*help;

IPluginFunction *pFunction;

pContext->LocalToString(params[1], &name);

if (strcasecmp(name, "sm") == 0)

{

return pContext->ThrowNativeError("Cannot register \"sm\" command");

}

pContext->LocalToString(params[3], &help);

pFunction = pContext->GetFunctionById(params[2]);

if (!pFunction)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);

}

IPlugin *pPlugin = scripts->FindPluginByContext(pContext);

const char *group = pPlugin->GetFilename();

if (!g_ConCmds.AddAdminCommand(pFunction, name, group, 0, help, params[4], pPlugin))

{

return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);

}

return 1;

}

static cell_t sm_RegAdminCmd(IPluginContext *pContext, const cell_t *params)

{

char *name,*help;

const char *group;

IPluginFunction *pFunction;

FlagBits flags = params[3];

int cmdflags = params[6];

pContext->LocalToString(params[1], &name);

if (strcasecmp(name, "sm") == 0)

{

return pContext->ThrowNativeError("Cannot register \"sm\" command");

}

pContext->LocalToString(params[4], &help);

pContext->LocalToString(params[5], (char **)&group);

pFunction = pContext->GetFunctionById(params[2]);

IPlugin *pPlugin = scripts->FindPluginByContext(pContext);

if (group[0] == '\0')

{

group = pPlugin->GetFilename();

}

if (!pFunction)

{

return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);

}

if (!g_ConCmds.AddAdminCommand(pFunction, name, group, flags, help, cmdflags, pPlugin))

{

return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);

}

return 1;

}

static cell_t sm_GetCmdArgs(IPluginContext *pContext, const cell_t *params)

{

const ICommandArgs *pCmd = g_HL2.PeekCommandStack();

if (!pCmd)

{

return pContext->ThrowNativeError("No command callback available");

}

return pCmd->ArgC() - 1;

}

static cell_t sm_GetCmdArg(IPluginContext *pContext, const cell_t *params)

{

const ICommandArgs *pCmd = g_HL2.PeekCommandStack();

if (!pCmd)

{

return pContext->ThrowNativeError("No command callback available");

}

size_t length;

const char *arg = pCmd->Arg(params[1]);

pContext->StringToLocalUTF8(params[2], params[3], arg ? arg : "", &length);

return (cell_t)length;

}

static cell_t sm_GetCmdArgString(IPluginContext *pContext, const cell_t *params)

{

const ICommandArgs *pCmd = g_HL2.PeekCommandStack();

if (!pCmd)

{

return pContext->ThrowNativeError("No command callback available");

}

const char *args = pCmd->ArgS();

size_t length;

if (!args)

{

args = "";

}

pContext->StringToLocalUTF8(params[1], params[2], args, &length);

return (cell_t)length;

}

char *g_ServerCommandBuffer = NULL;

cell_t g_ServerCommandBufferLength;

bool g_ShouldCatchSpew = false;

#if SOURCE_ENGINE < SE_NUCLEARDAWN

SpewOutputFunc_t g_OriginalSpewOutputFunc = NULL;

SpewRetval_t SourcemodSpewOutputFunc(SpewType_t spewType, tchar const *pMsg)

{

if (g_ServerCommandBuffer)

{

V_strcat(g_ServerCommandBuffer, pMsg, g_ServerCommandBufferLength);

}

if (g_OriginalSpewOutputFunc)

{

return g_OriginalSpewOutputFunc(spewType, pMsg);

} else {

return SPEW_CONTINUE;

}

}

#else

class CSourcemodLoggingListener: public ILoggingListener

{

public:

void Log(const LoggingContext_t *pContext, const tchar *pMessage)

{

if (g_ServerCommandBuffer)

{

V_strcat(g_ServerCommandBuffer, pMessage, g_ServerCommandBufferLength);

}

}

} g_SourcemodLoggingListener;

#endif

CON_COMMAND(sm_conhook_start, "")

{

if (!g_ShouldCatchSpew)

{

Warning("You shouldn't run this command!\n");

return;

}

#if SOURCE_ENGINE < SE_NUCLEARDAWN

g_OriginalSpewOutputFunc = GetSpewOutputFunc();

SpewOutputFunc(SourcemodSpewOutputFunc);

#else

#if SOURCE_ENGINE < SE_ALIENSWARM

LoggingSystem_PushLoggingState(false);

#else

LoggingSystem_PushLoggingState(false, false);

#endif

LoggingSystem_RegisterLoggingListener(&g_SourcemodLoggingListener);

#endif

}

CON_COMMAND(sm_conhook_stop, "")

{

if (!g_ShouldCatchSpew)

{

Warning("You shouldn't run this command!\n");

return;

}

#if SOURCE_ENGINE < SE_NUCLEARDAWN

SpewOutputFunc(g_OriginalSpewOutputFunc);

#else

LoggingSystem_PopLoggingState(false);

#endif

g_ShouldCatchSpew = false;

}

static cell_t sm_ServerCommandEx(IPluginContext *pContext, const cell_t *params)

{

g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);

char buffer[1024];

size_t len;

{

DetectExceptions eh(pContext);

len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 3);

if (eh.HasException())

return 0;

}

/* One byte for null terminator, one for newline */

buffer[len++] = '\n';

buffer[len] = '\0';

pContext->LocalToString(params[1], &g_ServerCommandBuffer);

g_ServerCommandBufferLength = params[2];