Home - sourcemod-central - file revision - core/smn_console.cpp@ee4b042d33db Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_console.cpp
author David Anderson <dvander@alliedmods.net>
Mon Oct 14 11:56:43 2013 -0700 (2013-10-14)
changeset 4147 ee4b042d33db
parent 4139 de7d1cd00703
child 4217 4c87212c5817
permissions -rw-r--r--
Update linux dep script (no bug, r=NPOTB). 
     1 /**
     2  * vim: set ts=4 sw=4 tw=99 noet :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2010 AlliedModders LLC.  All rights reserved.
     6  * =============================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or modify it under
     9  * the terms of the GNU General Public License, version 3.0, as published by the
    10  * Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful, but WITHOUT
    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    15  * details.
    16  *
    17  * You should have received a copy of the GNU General Public License along with
    18  * this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to link the
    21  * code of this program (as well as its derivative works) to "Half-Life 2," the
    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
    23  * by the Valve Corporation.  You must obey the GNU General Public License in
    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants
    25  * this exception to all derivative works.  AlliedModders LLC defines further
    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
    27  * or <http://www.sourcemod.net/license.php>.
    28  *
    29  * Version: $Id$
    30  */
    31 
    32 #include "sm_globals.h"
    33 #include "sourcemod.h"
    34 #include "HalfLife2.h"
    35 #include "sourcemm_api.h"
    36 #include "ConVarManager.h"
    37 #include "ConCmdManager.h"
    38 #include "sm_stringutil.h"
    39 #include "PlayerManager.h"
    40 #include "ChatTriggers.h"
    41 #include "AdminCache.h"
    42 #include <inetchannel.h>
    43 #include <bitbuf.h>
    44 #include <tier0/dbg.h>
    45 #include "Logger.h"
    46 #include "ConsoleDetours.h"
    47 #include "ConCommandBaseIterator.h"
    48 #include "logic_bridge.h"
    49 #include <sm_namehashset.h>
    50 
    51 #if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_DOTA
    52 #include <netmessages.pb.h>
    53 #endif
    54 
    55 #if SOURCE_ENGINE >= SE_EYE
    56 #define NETMSG_BITS 6
    57 #else
    58 #define NETMSG_BITS 5
    59 #endif
    60 
    61 #if SOURCE_ENGINE >= SE_LEFT4DEAD
    62 #define NET_SETCONVAR	6
    63 #else
    64 #define NET_SETCONVAR	5
    65 #endif
    66 
    67 enum ConVarBounds
    68 {
    69 	ConVarBound_Upper = 0,
    70 	ConVarBound_Lower
    71 };
    72 
    73 HandleType_t hCmdIterType = 0;
    74 HandleType_t htConCmdIter = 0;
    75 
    76 struct GlobCmdIter
    77 {
    78 	bool started;
    79 	List<ConCmdInfo *>::iterator iter;
    80 };
    81 
    82 class ConsoleHelpers : 
    83 	public SMGlobalClass,
    84 	public IHandleTypeDispatch
    85 {
    86 public:
    87 	virtual void OnSourceModAllInitialized()
    88 	{
    89 		HandleAccess access;
    90 
    91 		handlesys->InitAccessDefaults(NULL, &access);
    92 
    93 		htConCmdIter = handlesys->CreateType("ConCmdIter", this, 0, NULL, &access, g_pCoreIdent, NULL);
    94 
    95 		access.access[HandleAccess_Clone] = HANDLE_RESTRICT_OWNER | HANDLE_RESTRICT_IDENTITY;
    96 
    97 		hCmdIterType = handlesys->CreateType("CmdIter", this, 0, NULL, &access, g_pCoreIdent, NULL);
    98 	}
    99 	virtual void OnHandleDestroy(HandleType_t type, void *object)
   100 	{
   101 		if (type == hCmdIterType)
   102 		{
   103 			GlobCmdIter *iter = (GlobCmdIter *)object;
   104 			delete iter;
   105 		}
   106 		else if (type == htConCmdIter)
   107 		{
   108 			ConCommandBaseIterator *iter = (ConCommandBaseIterator * )object;
   109 			delete iter;
   110 		}
   111 	}
   112 	virtual bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
   113 	{
   114 		if (type == htConCmdIter)
   115 		{
   116 			*pSize = sizeof(ConCommandBaseIterator);
   117 			return true;
   118 		}
   119 		else if (type == hCmdIterType)
   120 		{
   121 			*pSize = sizeof(GlobCmdIter);
   122 			return true;
   123 		}
   124 		return false;
   125 	}
   126 } s_ConsoleHelpers;
   127 
   128 class CommandFlagsHelper : public IConCommandTracker
   129 {
   130 public:
   131 	void OnUnlinkConCommandBase(ConCommandBase *pBase, const char *name, bool is_read_safe)
   132 	{
   133 		m_CmdFlags.remove(name);
   134 	}
   135 	bool GetFlags(const char *name, int *flags)
   136 	{
   137 		ConCommandBase *pCmd;
   138 		if (m_CmdFlags.retrieve(name, &pCmd))
   139 		{
   140 			TrackConCommandBase(pCmd, this);
   141 			*flags = pCmd->GetFlags();
   142 			return true;
   143 		}
   144 		else if ((pCmd=FindCommandBase(name)))
   145 		{
   146 			m_CmdFlags.insert(name, pCmd);
   147 			TrackConCommandBase(pCmd, this);
   148 			*flags = pCmd->GetFlags();
   149 			return true;
   150 		}
   151 		else
   152 		{
   153 			return false;
   154 		}
   155 	}
   156 	bool SetFlags(const char *name, int flags)
   157 	{
   158 		ConCommandBase *pCmd;
   159 		if (m_CmdFlags.retrieve(name, &pCmd))
   160 		{
   161 			pCmd->SetFlags(flags);
   162 			TrackConCommandBase(pCmd, this);
   163 			return true;
   164 		}
   165 		else if ((pCmd=FindCommandBase(name)))
   166 		{
   167 			m_CmdFlags.insert(name, pCmd);
   168 			pCmd->SetFlags(flags);
   169 			TrackConCommandBase(pCmd, this);
   170 			return true;
   171 		}
   172 		else
   173 		{
   174 			return false;
   175 		}
   176 	}
   177 private:
   178 	struct ConCommandPolicy
   179 	{
   180 		static inline bool matches(const char *name, ConCommandBase *base)
   181 		{
   182 			return strcmp(name, base->GetName()) == 0;
   183 		}
   184 	};
   185 	NameHashSet<ConCommandBase *, ConCommandPolicy> m_CmdFlags;
   186 } s_CommandFlagsHelper;
   187 
   188 #if SOURCE_ENGINE < SE_ORANGEBOX
   189 static void ReplicateConVar(ConVar *pConVar)
   190 {
   191 	int maxClients = g_Players.GetMaxClients();
   192 
   193 	char data[256];
   194 	bf_write buffer(data, sizeof(data));
   195 
   196 	buffer.WriteUBitLong(NET_SETCONVAR, NETMSG_BITS);
   197 	buffer.WriteByte(1);
   198 	buffer.WriteString(pConVar->GetName());
   199 	buffer.WriteString(pConVar->GetString());
   200 
   201 	for (int i = 1; i <= maxClients; i++)
   202 	{
   203 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);
   204 
   205 		if (pPlayer && pPlayer->IsInGame() && !pPlayer->IsFakeClient())
   206 		{
   207 			if (INetChannel *netchan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(i)))
   208 				netchan->SendData(buffer);
   209 		}
   210 	}
   211 }
   212 
   213 static void NotifyConVar(ConVar *pConVar)
   214 {
   215 	IGameEvent *pEvent = gameevents->CreateEvent("server_cvar");
   216 	pEvent->SetString("cvarname", pConVar->GetName());
   217 	if (IsFlagSet(pConVar, FCVAR_PROTECTED))
   218 	{
   219 		pEvent->SetString("cvarvalue", "***PROTECTED***");
   220 	}
   221 	else
   222 	{
   223 		pEvent->SetString("cvarvalue", pConVar->GetString());
   224 	}
   225 
   226 	gameevents->FireEvent(pEvent);
   227 }
   228 #endif
   229 
   230 static cell_t sm_CreateConVar(IPluginContext *pContext, const cell_t *params)
   231 {
   232 	char *name, *defaultVal, *helpText;
   233 
   234 	pContext->LocalToString(params[1], &name);
   235 
   236 	// While the engine seems to accept a blank convar name, it causes a crash upon server quit
   237 	if (name == NULL || strcmp(name, "") == 0)
   238 	{
   239 		return pContext->ThrowNativeError("Convar with blank name is not permitted");
   240 	}
   241 
   242 	pContext->LocalToString(params[2], &defaultVal);
   243 	pContext->LocalToString(params[3], &helpText);
   244 
   245 	bool hasMin = params[5] ? true : false;
   246 	bool hasMax = params[7] ? true : false;
   247 	float min = sp_ctof(params[6]);
   248 	float max = sp_ctof(params[8]);
   249 
   250 	Handle_t hndl = g_ConVarManager.CreateConVar(pContext, name, defaultVal, helpText, params[4], hasMin, min, hasMax, max);
   251 
   252 	if (hndl == BAD_HANDLE)
   253 	{
   254 		return pContext->ThrowNativeError("Convar \"%s\" was not created. A console command with the same might already exist.", name);
   255 	}
   256 
   257 	return hndl;
   258 }
   259 
   260 static cell_t sm_FindConVar(IPluginContext *pContext, const cell_t *params)
   261 {
   262 	char *name;
   263 
   264 	pContext->LocalToString(params[1], &name);
   265 
   266 	return g_ConVarManager.FindConVar(name);
   267 }
   268 
   269 static cell_t sm_HookConVarChange(IPluginContext *pContext, const cell_t *params)
   270 {
   271 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   272 	HandleError err;
   273 	ConVar *pConVar;
   274 
   275 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   276 		!= HandleError_None)
   277 	{
   278 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   279 	}
   280 
   281 	IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
   282 
   283 	if (!pFunction)
   284 	{
   285 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   286 	}
   287 
   288 	g_ConVarManager.HookConVarChange(pConVar, pFunction);
   289 
   290 	return 1;
   291 }
   292 
   293 static cell_t sm_UnhookConVarChange(IPluginContext *pContext, const cell_t *params)
   294 {
   295 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   296 	HandleError err;
   297 	ConVar *pConVar;
   298 
   299 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   300 		!= HandleError_None)
   301 	{
   302 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   303 	}
   304 
   305 	IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
   306 
   307 	if (!pFunction)
   308 	{
   309 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   310 	}
   311 
   312 	g_ConVarManager.UnhookConVarChange(pConVar, pFunction);
   313 
   314 	return 1;
   315 }
   316 
   317 static cell_t sm_GetConVarBool(IPluginContext *pContext, const cell_t *params)
   318 {
   319 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   320 	HandleError err;
   321 	ConVar *pConVar;
   322 
   323 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   324 		!= HandleError_None)
   325 	{
   326 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   327 	}
   328 
   329 	return pConVar->GetBool();
   330 }
   331 
   332 static cell_t sm_GetConVarInt(IPluginContext *pContext, const cell_t *params)
   333 {
   334 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   335 	HandleError err;
   336 	ConVar *pConVar;
   337 
   338 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   339 		!= HandleError_None)
   340 	{
   341 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   342 	}
   343 
   344 	return pConVar->GetInt();
   345 }
   346 
   347 /* This handles both SetConVarBool() and SetConVarInt() */
   348 static cell_t sm_SetConVarNum(IPluginContext *pContext, const cell_t *params)
   349 {
   350 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   351 	HandleError err;
   352 	ConVar *pConVar;
   353 
   354 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   355 		!= HandleError_None)
   356 	{
   357 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   358 	}
   359 
   360 	pConVar->SetValue(params[2]);
   361 
   362 #if SOURCE_ENGINE < SE_ORANGEBOX
   363 	/* Should we replicate it? */
   364 	if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   365 	{
   366 		ReplicateConVar(pConVar);
   367 	}
   368 
   369 	/* Should we notify clients? */
   370 	if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))
   371 	{
   372 		NotifyConVar(pConVar);
   373 	}
   374 #endif
   375 
   376 	return 1;
   377 }
   378 
   379 static cell_t sm_GetConVarFloat(IPluginContext *pContext, const cell_t *params)
   380 {
   381 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   382 	HandleError err;
   383 	ConVar *pConVar;
   384 
   385 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   386 		!= HandleError_None)
   387 	{
   388 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   389 	}
   390 	
   391 	float value = pConVar->GetFloat();
   392 
   393 	return sp_ftoc(value);
   394 }
   395 
   396 static cell_t sm_SetConVarFloat(IPluginContext *pContext, const cell_t *params)
   397 {
   398 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   399 	HandleError err;
   400 	ConVar *pConVar;
   401 
   402 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   403 		!= HandleError_None)
   404 	{
   405 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   406 	}
   407 
   408 	float value = sp_ctof(params[2]);
   409 	pConVar->SetValue(value);
   410 
   411 #if SOURCE_ENGINE < SE_ORANGEBOX
   412 	/* Should we replicate it? */
   413 	if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   414 	{
   415 		ReplicateConVar(pConVar);
   416 	}
   417 
   418 	/* Should we notify clients? */
   419 	if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))
   420 	{
   421 		NotifyConVar(pConVar);
   422 	}
   423 #endif
   424 
   425 	return 1;
   426 }
   427 
   428 static cell_t sm_GetConVarString(IPluginContext *pContext, const cell_t *params)
   429 {
   430 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   431 	HandleError err;
   432 	ConVar *pConVar;
   433 
   434 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   435 		!= HandleError_None)
   436 	{
   437 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   438 	}
   439 
   440 	pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetString(), NULL);
   441 
   442 	return 1;
   443 }
   444 
   445 static cell_t sm_SetConVarString(IPluginContext *pContext, const cell_t *params)
   446 {
   447 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   448 	HandleError err;
   449 	ConVar *pConVar;
   450 
   451 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   452 		!= HandleError_None)
   453 	{
   454 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   455 	}
   456 
   457 	char *value;
   458 	pContext->LocalToString(params[2], &value);
   459 
   460 	pConVar->SetValue(value);
   461 
   462 #if SOURCE_ENGINE < SE_ORANGEBOX
   463 	/* Should we replicate it? */
   464 	if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   465 	{
   466 		ReplicateConVar(pConVar);
   467 	}
   468 
   469 	/* Should we notify clients? */
   470 	if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))
   471 	{
   472 		NotifyConVar(pConVar);
   473 	}
   474 #endif
   475 
   476 	return 1;
   477 }
   478 
   479 static cell_t sm_ResetConVar(IPluginContext *pContext, const cell_t *params)
   480 {
   481 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   482 	HandleError err;
   483 	ConVar *pConVar;
   484 
   485 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   486 		!= HandleError_None)
   487 	{
   488 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   489 	}
   490 
   491 	pConVar->Revert();
   492 	
   493 #if SOURCE_ENGINE < SE_ORANGEBOX
   494 	/* Should we replicate it? */
   495 	if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   496 	{
   497 		ReplicateConVar(pConVar);
   498 	}
   499 
   500 	/* Should we notify clients? */
   501 	if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY))
   502 	{
   503 		NotifyConVar(pConVar);
   504 	}
   505 #endif
   506 
   507 	return 1;
   508 }
   509 
   510 static cell_t GetConVarDefault(IPluginContext *pContext, const cell_t *params)
   511 {
   512 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   513 	HandleError err;
   514 	ConVar *pConVar;
   515 
   516 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   517 		!= HandleError_None)
   518 	{
   519 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   520 	}
   521 
   522 	size_t bytes;
   523 	pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetDefault(), &bytes);
   524 
   525 	return bytes;
   526 }
   527 
   528 static cell_t sm_GetConVarFlags(IPluginContext *pContext, const cell_t *params)
   529 {
   530 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   531 	HandleError err;
   532 	ConVar *pConVar;
   533 
   534 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   535 		!= HandleError_None)
   536 	{
   537 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   538 	}
   539 
   540 	return pConVar->GetFlags();
   541 }
   542 
   543 static cell_t sm_SetConVarFlags(IPluginContext *pContext, const cell_t *params)
   544 {
   545 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   546 	HandleError err;
   547 	ConVar *pConVar;
   548 
   549 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   550 		!= HandleError_None)
   551 	{
   552 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   553 	}
   554 
   555 	pConVar->SetFlags(params[2]);
   556 
   557 	return 1;
   558 }
   559 
   560 static cell_t sm_GetConVarBounds(IPluginContext *pContext, const cell_t *params)
   561 {
   562 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   563 	HandleError err;
   564 	ConVar *pConVar;
   565 
   566 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   567 		!= HandleError_None)
   568 	{
   569 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   570 	}
   571 
   572 	cell_t *addr;
   573 	bool hasBound;
   574 	float bound;
   575 
   576 	switch (params[2])
   577 	{
   578 	case ConVarBound_Upper:
   579 		hasBound = pConVar->GetMax(bound);
   580 		break;
   581 	case ConVarBound_Lower:
   582 		hasBound = pConVar->GetMin(bound);
   583 		break;
   584 	default:
   585 		return pContext->ThrowNativeError("Invalid ConVarBounds value %d");
   586 	}
   587 	
   588 	pContext->LocalToPhysAddr(params[3], &addr);
   589 	*addr = sp_ftoc(bound);
   590 
   591 	return hasBound;
   592 }
   593 
   594 static cell_t sm_SetConVarBounds(IPluginContext *pContext, const cell_t *params)
   595 {
   596 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   597 	HandleError err;
   598 	ConVar *pConVar;
   599 
   600 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   601 		!= HandleError_None)
   602 	{
   603 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   604 	}
   605 
   606 	switch (params[2])
   607 	{
   608 	case ConVarBound_Upper:
   609 		pConVar->SetMax(params[3] ? true : false, sp_ctof(params[4]));
   610 		break;
   611 	case ConVarBound_Lower:
   612 		pConVar->SetMin(params[3] ? true : false, sp_ctof(params[4]));
   613 		break;
   614 	default:
   615 		return pContext->ThrowNativeError("Invalid ConVarBounds value %d");
   616 	}
   617 
   618 	return 1;
   619 }
   620 
   621 static cell_t sm_GetConVarName(IPluginContext *pContext, const cell_t *params)
   622 {
   623 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   624 	HandleError err;
   625 	ConVar *pConVar;
   626 
   627 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
   628 		!= HandleError_None)
   629 	{
   630 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   631 	}
   632 
   633 	pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetName(), NULL);
   634 
   635 	return 1;
   636 }
   637 
   638 static bool s_QueryAlreadyWarned = false;
   639 
   640 static cell_t sm_QueryClientConVar(IPluginContext *pContext, const cell_t *params)
   641 {
   642 	CPlayer *pPlayer;
   643 	char *name;
   644 	IPluginFunction *pCallback;
   645 
   646 	if (!g_ConVarManager.IsQueryingSupported())
   647 	{
   648 		if (!s_QueryAlreadyWarned)
   649 		{
   650 			s_QueryAlreadyWarned = true;
   651 			return pContext->ThrowNativeError("Game does not support client convar querying (one time warning)");
   652 		}
   653 
   654 		return 0;
   655 	}
   656 
   657 	pPlayer = g_Players.GetPlayerByIndex(params[1]);
   658 
   659 	if (!pPlayer)
   660 	{
   661 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   662 	}
   663 
   664 	if (!pPlayer->IsConnected())
   665 	{
   666 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   667 	}
   668 
   669 	/* Trying a query on a bot results in callback not be fired, so don't bother */
   670 	if (pPlayer->IsFakeClient())
   671 	{
   672 		return 0;
   673 	}
   674 
   675 	pContext->LocalToString(params[2], &name);
   676 	pCallback = pContext->GetFunctionById(params[3]);
   677 
   678 	if (!pCallback)
   679 	{
   680 		return pContext->ThrowNativeError("Invalid function id (%X)", params[3]);
   681 	}
   682 
   683 	return g_ConVarManager.QueryClientConVar(pPlayer->GetEdict(), name, pCallback, params[4]);
   684 }
   685 
   686 static cell_t sm_RegServerCmd(IPluginContext *pContext, const cell_t *params)
   687 {
   688 	char *name,*help;
   689 	IPluginFunction *pFunction;
   690 
   691 	pContext->LocalToString(params[1], &name);
   692 
   693 	if (strcasecmp(name, "sm") == 0)
   694 	{
   695 		return pContext->ThrowNativeError("Cannot register \"sm\" command");
   696 	}
   697 
   698 	pContext->LocalToString(params[3], &help);
   699 	pFunction = pContext->GetFunctionById(params[2]);
   700 
   701 	if (!pFunction)
   702 	{
   703 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   704 	}
   705 
   706 	if (!g_ConCmds.AddServerCommand(pFunction, name, help, params[4]))
   707 	{
   708 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   709 	}
   710 
   711 	return 1;
   712 }
   713 
   714 static cell_t sm_RegConsoleCmd(IPluginContext *pContext, const cell_t *params)
   715 {
   716 	char *name,*help;
   717 	IPluginFunction *pFunction;
   718 
   719 	pContext->LocalToString(params[1], &name);
   720 
   721 	if (strcasecmp(name, "sm") == 0)
   722 	{
   723 		return pContext->ThrowNativeError("Cannot register \"sm\" command");
   724 	}
   725 
   726 	pContext->LocalToString(params[3], &help);
   727 	pFunction = pContext->GetFunctionById(params[2]);
   728 
   729 	if (!pFunction)
   730 	{
   731 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   732 	}
   733 
   734 	IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   735 	const char *group = pPlugin->GetFilename();
   736 	if (!g_ConCmds.AddAdminCommand(pFunction, name, group, 0, help, params[4]))
   737 	{
   738 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   739 	}
   740 
   741 	return 1;
   742 }
   743 
   744 static cell_t sm_RegAdminCmd(IPluginContext *pContext, const cell_t *params)
   745 {
   746 	char *name,*help;
   747 	const char *group;
   748 	IPluginFunction *pFunction;
   749 	FlagBits flags = params[3];
   750 	int cmdflags = params[6];
   751 
   752 	pContext->LocalToString(params[1], &name);
   753 
   754 	if (strcasecmp(name, "sm") == 0)
   755 	{
   756 		return pContext->ThrowNativeError("Cannot register \"sm\" command");
   757 	}
   758 
   759 	pContext->LocalToString(params[4], &help);
   760 	pContext->LocalToString(params[5], (char **)&group);
   761 	pFunction = pContext->GetFunctionById(params[2]);
   762 
   763 	if (group[0] == '\0')
   764 	{
   765 		IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   766 		group = pPlugin->GetFilename();
   767 	}
   768 
   769 	if (!pFunction)
   770 	{
   771 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   772 	}
   773 
   774 	if (!g_ConCmds.AddAdminCommand(pFunction, name, group, flags, help, cmdflags))
   775 	{
   776 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   777 	}
   778 
   779 	return 1;
   780 }
   781 
   782 static cell_t sm_GetCmdArgs(IPluginContext *pContext, const cell_t *params)
   783 {
   784 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   785 
   786 	if (!pCmd)
   787 	{
   788 		return pContext->ThrowNativeError("No command callback available");
   789 	}
   790 
   791 	return pCmd->ArgC() - 1;
   792 }
   793 
   794 static cell_t sm_GetCmdArg(IPluginContext *pContext, const cell_t *params)
   795 {
   796 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   797 
   798 	if (!pCmd)
   799 	{
   800 		return pContext->ThrowNativeError("No command callback available");
   801 	}
   802 
   803 	size_t length;
   804 
   805 	const char *arg = pCmd->Arg(params[1]);
   806 	
   807 	pContext->StringToLocalUTF8(params[2], params[3], arg ? arg : "", &length);
   808 
   809 	return (cell_t)length;
   810 }
   811 
   812 static cell_t sm_GetCmdArgString(IPluginContext *pContext, const cell_t *params)
   813 {
   814 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   815 
   816 	if (!pCmd)
   817 	{
   818 		return pContext->ThrowNativeError("No command callback available");
   819 	}
   820 
   821 	const char *args = pCmd->ArgS();
   822 	size_t length;
   823 
   824 	if (!args)
   825 	{
   826 		args = "";
   827 	}
   828 
   829 	pContext->StringToLocalUTF8(params[1], params[2], args, &length);
   830 
   831 	return (cell_t)length;
   832 }
   833 
   834 static cell_t sm_PrintToServer(IPluginContext *pCtx, const cell_t *params)
   835 {
   836 	char buffer[1024];
   837 	char *fmt;
   838 	int arg = 2;
   839 
   840 	pCtx->LocalToString(params[1], &fmt);
   841 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   842 
   843 	buffer[res++] = '\n';
   844 	buffer[res] = '\0';
   845 
   846 	META_CONPRINT(buffer);
   847 
   848 	return 1;
   849 }
   850 
   851 static cell_t sm_PrintToConsole(IPluginContext *pCtx, const cell_t *params)
   852 {
   853 	int index = params[1];
   854 	if ((index < 0) || (index > g_Players.GetMaxClients()))
   855 	{
   856 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   857 	}
   858 
   859 	CPlayer *pPlayer = NULL;
   860 	if (index != 0)
   861 	{
   862 		pPlayer = g_Players.GetPlayerByIndex(index);
   863 		if (!pPlayer->IsInGame())
   864 		{
   865 			return pCtx->ThrowNativeError("Client %d is not in game", index);
   866 		}
   867 		
   868 		/* Silent fail on bots, engine will crash */
   869 		if (pPlayer->IsFakeClient())
   870 		{
   871 			return 0;
   872 		}
   873 	}
   874 
   875 	char buffer[1024];
   876 	char *fmt;
   877 	int arg = 3;
   878 
   879 	pCtx->LocalToString(params[2], &fmt);
   880 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   881 
   882 	buffer[res++] = '\n';
   883 	buffer[res] = '\0';
   884 
   885 	if (index != 0)
   886 	{
   887 #if SOURCE_ENGINE == SE_DOTA
   888 		engine->ClientPrintf(pPlayer->GetIndex(), buffer);
   889 #else
   890 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
   891 #endif
   892 	} else {
   893 		META_CONPRINT(buffer);
   894 	}
   895 
   896 	return 1;
   897 }
   898 
   899 static cell_t sm_ServerCommand(IPluginContext *pContext, const cell_t *params)
   900 {
   901 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   902 
   903 	char buffer[1024];
   904 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
   905 
   906 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
   907 	{
   908 		return 0;
   909 	}
   910 
   911 	/* One byte for null terminator, one for newline */
   912 	buffer[len++] = '\n';
   913 	buffer[len] = '\0';
   914 
   915 	engine->ServerCommand(buffer);
   916 
   917 	return 1;
   918 }
   919 
   920 char *g_ServerCommandBuffer = NULL;
   921 cell_t g_ServerCommandBufferLength;
   922 
   923 bool g_ShouldCatchSpew = false;
   924 
   925 #if SOURCE_ENGINE < SE_NUCLEARDAWN
   926 SpewOutputFunc_t g_OriginalSpewOutputFunc = NULL;
   927 
   928 SpewRetval_t SourcemodSpewOutputFunc(SpewType_t spewType, tchar const *pMsg)
   929 {
   930 	if (g_ServerCommandBuffer)
   931 	{
   932 		V_strcat(g_ServerCommandBuffer, pMsg, g_ServerCommandBufferLength);
   933 	}
   934 
   935 	if (g_OriginalSpewOutputFunc)
   936 	{
   937 		return g_OriginalSpewOutputFunc(spewType, pMsg);
   938 	} else {
   939 		return SPEW_CONTINUE;
   940 	}
   941 }
   942 #else
   943 class CSourcemodLoggingListener: public ILoggingListener
   944 {
   945 public:
   946 	void Log(const LoggingContext_t *pContext, const tchar *pMessage)
   947 	{
   948 		if (g_ServerCommandBuffer)
   949 		{
   950 			V_strcat(g_ServerCommandBuffer, pMessage, g_ServerCommandBufferLength);
   951 		}
   952 	}
   953 } g_SourcemodLoggingListener;
   954 #endif
   955 
   956 CON_COMMAND(sm_conhook_start, "")
   957 {
   958 	if (!g_ShouldCatchSpew)
   959 	{
   960 		Warning("You shouldn't run this command!\n");
   961 		return;
   962 	}
   963 
   964 #if SOURCE_ENGINE < SE_NUCLEARDAWN
   965 	g_OriginalSpewOutputFunc = GetSpewOutputFunc();
   966 	SpewOutputFunc(SourcemodSpewOutputFunc);
   967 #else
   968 #if SOURCE_ENGINE < SE_ALIENSWARM
   969 	LoggingSystem_PushLoggingState(false);
   970 #else
   971 	LoggingSystem_PushLoggingState(false, false);
   972 #endif
   973 	LoggingSystem_RegisterLoggingListener(&g_SourcemodLoggingListener);
   974 #endif
   975 }
   976 
   977 CON_COMMAND(sm_conhook_stop, "")
   978 {
   979 	if (!g_ShouldCatchSpew)
   980 	{
   981 		Warning("You shouldn't run this command!\n");
   982 		return;
   983 	}
   984 
   985 #if SOURCE_ENGINE < SE_NUCLEARDAWN
   986 	SpewOutputFunc(g_OriginalSpewOutputFunc);
   987 #else
   988 	LoggingSystem_PopLoggingState(false);
   989 #endif
   990 
   991 	g_ShouldCatchSpew = false;
   992 }
   993 
   994 static cell_t sm_ServerCommandEx(IPluginContext *pContext, const cell_t *params)
   995 {
   996 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   997 
   998 	char buffer[1024];
   999 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 3);
  1000 
  1001 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1002 	{
  1003 		return 0;
  1004 	}
  1005 
  1006 	/* One byte for null terminator, one for newline */
  1007 	buffer[len++] = '\n';
  1008 	buffer[len] = '\0';
  1009 
  1010 	pContext->LocalToString(params[1], &g_ServerCommandBuffer);
  1011 	g_ServerCommandBufferLength = params[2];
  1012 	
  1013 	if (g_ServerCommandBufferLength > 0)
  1014 	{
  1015 		g_ServerCommandBuffer[0] = '\0';
  1016 	}
  1017 
  1018 	engine->ServerExecute();
  1019 
  1020 	g_ShouldCatchSpew = true;
  1021 	engine->ServerCommand("sm_conhook_start\n");
  1022 	engine->ServerCommand(buffer);
  1023 	engine->ServerCommand("sm_conhook_stop\n");
  1024 
  1025 	engine->ServerExecute();
  1026 
  1027 	if (g_ServerCommandBufferLength > 0)
  1028 	{
  1029 		g_ServerCommandBuffer[g_ServerCommandBufferLength-1] = '\0';
  1030 	}
  1031 
  1032 	g_ServerCommandBuffer = NULL;
  1033 	g_ServerCommandBufferLength = 0;
  1034 
  1035 	return 1;
  1036 }
  1037 
  1038 static cell_t sm_InsertServerCommand(IPluginContext *pContext, const cell_t *params)
  1039 {
  1040 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
  1041 
  1042 	char buffer[1024];
  1043 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
  1044 
  1045 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1046 	{
  1047 		return 0;
  1048 	}
  1049 
  1050 	/* One byte for null terminator, one for newline */
  1051 	buffer[len++] = '\n';
  1052 	buffer[len] = '\0';
  1053 
  1054 	InsertServerCommand(buffer);
  1055 
  1056 	return 1;
  1057 }
  1058 
  1059 static cell_t sm_ServerExecute(IPluginContext *pContext, const cell_t *params)
  1060 {
  1061 	engine->ServerExecute();
  1062 
  1063 	return 1;
  1064 }
  1065 
  1066 static cell_t sm_ClientCommand(IPluginContext *pContext, const cell_t *params)
  1067 {
  1068 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
  1069 
  1070 	if (!pPlayer)
  1071 	{
  1072 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
  1073 	}
  1074 
  1075 	if (!pPlayer->IsConnected())
  1076 	{
  1077 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
  1078 	}
  1079 
  1080 	g_SourceMod.SetGlobalTarget(params[1]);
  1081 
  1082 	char buffer[256];
  1083 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
  1084 
  1085 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1086 	{
  1087 		return 0;
  1088 	}
  1089 
  1090 	engine->ClientCommand(
  1091 #if SOURCE_ENGINE == SE_DOTA
  1092 		pPlayer->GetIndex(),
  1093 #else
  1094 		pPlayer->GetEdict(),
  1095 #endif
  1096 		"%s", buffer);
  1097 
  1098 	return 1;
  1099 }
  1100 
  1101 static cell_t FakeClientCommand(IPluginContext *pContext, const cell_t *params)
  1102 {
  1103 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
  1104 
  1105 	if (!pPlayer)
  1106 	{
  1107 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
  1108 	}
  1109 
  1110 	if (!pPlayer->IsConnected())
  1111 	{
  1112 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
  1113 	}
  1114 
  1115 	g_SourceMod.SetGlobalTarget(params[1]);
  1116 
  1117 	char buffer[256];
  1118 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
  1119 
  1120 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1121 	{
  1122 		return 0;
  1123 	}
  1124 
  1125 #if SOURCE_ENGINE == SE_DOTA
  1126 	engine->ClientCommand(pPlayer->GetIndex(), "%s", buffer);
  1127 #else
  1128 	serverpluginhelpers->ClientCommand(pPlayer->GetEdict(), buffer);
  1129 #endif
  1130 
  1131 	return 1;
  1132 }
  1133 
  1134 static cell_t FakeClientCommandEx(IPluginContext *pContext, const cell_t *params)
  1135 {
  1136 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
  1137 
  1138 	if (!pPlayer)
  1139 	{
  1140 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
  1141 	}
  1142 
  1143 	if (!pPlayer->IsConnected())
  1144 	{
  1145 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
  1146 	}
  1147 
  1148 	g_SourceMod.SetGlobalTarget(params[1]);
  1149 
  1150 	char buffer[256];
  1151 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
  1152 
  1153 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1154 	{
  1155 		return 0;
  1156 	}
  1157 
  1158 	g_HL2.AddToFakeCliCmdQueue(params[1], GetPlayerUserId(pPlayer->GetEdict()), buffer);
  1159 
  1160 	return 1;
  1161 }
  1162 
  1163 static cell_t ReplyToCommand(IPluginContext *pContext, const cell_t *params)
  1164 {
  1165 	g_SourceMod.SetGlobalTarget(params[1]);
  1166 
  1167 	/* Build the format string */
  1168 	char buffer[1024];
  1169 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 2);
  1170 
  1171 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
  1172 	{
  1173 		return 0;
  1174 	}
  1175 
  1176 	/* If we're printing to the server, shortcut out */
  1177 	if (params[1] == 0)
  1178 	{
  1179 		/* Print */
  1180 		buffer[len++] = '\n';
  1181 		buffer[len] = '\0';
  1182 		META_CONPRINT(buffer);
  1183 		return 1;
  1184 	}
  1185 
  1186 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
  1187 
  1188 	if (!pPlayer)
  1189 	{
  1190 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
  1191 	}
  1192 
  1193 	if (!pPlayer->IsConnected())
  1194 	{
  1195 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
  1196 	}
  1197 
  1198 	unsigned int replyto = g_ChatTriggers.GetReplyTo();
  1199 	if (replyto == SM_REPLY_CONSOLE)
  1200 	{
  1201 		buffer[len++] = '\n';
  1202 		buffer[len] = '\0';
  1203 #if SOURCE_ENGINE == SE_DOTA
  1204 		engine->ClientPrintf(pPlayer->GetIndex(), buffer);
  1205 #else
  1206 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
  1207 #endif
  1208 	} else if (replyto == SM_REPLY_CHAT) {
  1209 		if (len >= 191)
  1210 		{
  1211 			len = 191;
  1212 		}
  1213 		buffer[len] = '\0';
  1214 		g_HL2.TextMsg(params[1], HUD_PRINTTALK, buffer);
  1215 	}
  1216 
  1217 	return 1;
  1218 }
  1219 
  1220 static cell_t GetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
  1221 {
  1222 	return g_ChatTriggers.GetReplyTo();
  1223 }
  1224 
  1225 static cell_t SetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
  1226 {
  1227 	return g_ChatTriggers.SetReplyTo(params[1]);
  1228 }
  1229 
  1230 static cell_t GetCommandIterator(IPluginContext *pContext, const cell_t *params)
  1231 {
  1232 	GlobCmdIter *iter = new GlobCmdIter;
  1233 	iter->started = false;
  1234 
  1235 	Handle_t hndl = handlesys->CreateHandle(hCmdIterType, iter, pContext->GetIdentity(), g_pCoreIdent, NULL);
  1236 	if (hndl == BAD_HANDLE)
  1237 	{
  1238 		delete iter;
  1239 	}
  1240 
  1241 	return hndl;
  1242 }
  1243 
  1244 static cell_t ReadCommandIterator(IPluginContext *pContext, const cell_t *params)
  1245 {
  1246 	GlobCmdIter *iter;
  1247 	HandleError err;
  1248 	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
  1249 
  1250 	if ((err = handlesys->ReadHandle(params[1], hCmdIterType, &sec, (void **)&iter))
  1251 		!= HandleError_None)
  1252 	{
  1253 		return pContext->ThrowNativeError("Invalid GlobCmdIter Handle %x", params[1]);
  1254 	}
  1255 
  1256 	const List<ConCmdInfo *> &cmds = g_ConCmds.GetCommandList();
  1257 
  1258 	if (!iter->started)
  1259 	{
  1260 		iter->iter = cmds.begin();
  1261 		iter->started = true;
  1262 	}
  1263 
  1264 	while (iter->iter != cmds.end()
  1265 			&& !(*(iter->iter))->sourceMod)
  1266 	{
  1267 		iter->iter++;
  1268 	}
  1269 
  1270 	if (iter->iter == cmds.end())
  1271 	{
  1272 		return 0;
  1273 	}
  1274 
  1275 	ConCmdInfo *pInfo = (*(iter->iter));
  1276 
  1277 	pContext->StringToLocalUTF8(params[2], params[3], pInfo->pCmd->GetName(), NULL);
  1278 	pContext->StringToLocalUTF8(params[5], params[6], pInfo->pCmd->GetHelpText(), NULL);
  1279 	
  1280 	cell_t *addr;
  1281 	pContext->LocalToPhysAddr(params[4], &addr);
  1282 	*addr = pInfo->eflags;
  1283 
  1284 	iter->iter++;
  1285 
  1286 	return 1;
  1287 }
  1288 
  1289 static cell_t CheckCommandAccess(IPluginContext *pContext, const cell_t *params)
  1290 {
  1291 	if (params[1] == 0)
  1292 	{
  1293 		return 1;
  1294 	}
  1295 
  1296 	char *cmd;
  1297 	pContext->LocalToString(params[2], &cmd);
  1298 
  1299 	/* Match up with an admin command if possible */
  1300 	FlagBits bits = params[3];
  1301 	bool found_command = false;
  1302 	if (params[0] < 4 || !params[4])
  1303 	{
  1304 		found_command = g_ConCmds.LookForCommandAdminFlags(cmd, &bits);
  1305 	}
  1306 	
  1307 	if (!found_command)
  1308 	{
  1309 		g_Admins.GetCommandOverride(cmd, Override_Command, &bits);
  1310 	}
  1311 
  1312 	return g_ConCmds.CheckClientCommandAccess(params[1], cmd, bits) ? 1 : 0;
  1313 }
  1314 
  1315 static cell_t CheckAccess(IPluginContext *pContext, const cell_t *params)
  1316 {
  1317 	char *cmd;
  1318 	pContext->LocalToString(params[2], &cmd);
  1319 
  1320 	/* Match up with an admin command if possible */
  1321 	FlagBits bits = params[3];
  1322 	bool found_command = false;
  1323 	if (params[0] < 4 || !params[4])
  1324 	{
  1325 		found_command = g_ConCmds.LookForCommandAdminFlags(cmd, &bits);
  1326 	}
  1327 	
  1328 	if (!found_command)
  1329 	{
  1330 		g_Admins.GetCommandOverride(cmd, Override_Command, &bits);
  1331 	}
  1332 
  1333 	return g_ConCmds.CheckAdminCommandAccess(params[1], cmd, bits) ? 1 : 0;
  1334 }
  1335 
  1336 static cell_t IsChatTrigger(IPluginContext *pContext, const cell_t *params)
  1337 {
  1338 	return g_ChatTriggers.IsChatTrigger() ? 1 : 0;
  1339 }
  1340 
  1341 static cell_t SetCommandFlags(IPluginContext *pContext, const cell_t *params)
  1342 {
  1343 	char *name;
  1344 	pContext->LocalToString(params[1], &name);
  1345 
  1346 	return (s_CommandFlagsHelper.SetFlags(name, params[2])) ? 1 : 0;
  1347 }
  1348 
  1349 static cell_t GetCommandFlags(IPluginContext *pContext, const cell_t *params)
  1350 {
  1351 	char *name;
  1352 	int flags;
  1353 	pContext->LocalToString(params[1], &name);
  1354 
  1355 	return (s_CommandFlagsHelper.GetFlags(name, &flags)) ? flags : -1;
  1356 }
  1357 
  1358 static cell_t FindFirstConCommand(IPluginContext *pContext, const cell_t *params)
  1359 {
  1360 	Handle_t hndl;
  1361 	ConCommandBaseIterator *pIter;
  1362 	cell_t *pIsCmd, *pFlags;
  1363 	const ConCommandBase *pConCmd;
  1364 	const char *desc;
  1365 
  1366 	pContext->LocalToPhysAddr(params[3], &pIsCmd);
  1367 	pContext->LocalToPhysAddr(params[4], &pFlags);
  1368 
  1369 	pIter = new ConCommandBaseIterator();
  1370 
  1371 	if (!pIter->IsValid())
  1372 	{
  1373 		delete pIter;
  1374 		return BAD_HANDLE;
  1375 	}
  1376 
  1377 	pConCmd = pIter->Get();
  1378 
  1379 	pContext->StringToLocalUTF8(params[1], params[2], pConCmd->GetName(), NULL);
  1380 	*pIsCmd = pConCmd->IsCommand() ? 1 : 0;
  1381 	*pFlags = pConCmd->GetFlags();
  1382 
  1383 	if (params[6])
  1384 	{
  1385 		desc = pConCmd->GetHelpText();
  1386 		pContext->StringToLocalUTF8(params[5], params[6], (desc && desc[0]) ? desc : "", NULL);
  1387 	}
  1388 
  1389 	if ((hndl = handlesys->CreateHandle(htConCmdIter, pIter, pContext->GetIdentity(), g_pCoreIdent, NULL))
  1390 		== BAD_HANDLE)
  1391 	{
  1392 		delete pIter;
  1393 		return BAD_HANDLE;
  1394 	}
  1395 
  1396 	return hndl;
  1397 }
  1398 
  1399 static cell_t FindNextConCommand(IPluginContext *pContext, const cell_t *params)
  1400 {
  1401 	HandleError err;
  1402 	ConCommandBaseIterator *pIter;
  1403 	cell_t *pIsCmd, *pFlags;
  1404 	const char *desc;
  1405 	const ConCommandBase *pConCmd;
  1406 	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
  1407 
  1408 	if ((err = handlesys->ReadHandle(params[1], htConCmdIter, &sec, (void **)&pIter)) != HandleError_None)
  1409 	{
  1410 		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
  1411 	}
  1412 
  1413 	if (!pIter->IsValid())
  1414 	{
  1415 		return 0;
  1416 	}
  1417 
  1418 	pIter->Next();
  1419 	if (!pIter->IsValid())
  1420 	{
  1421 		return 0;
  1422 	}
  1423 	pConCmd = pIter->Get();
  1424 
  1425 	pContext->LocalToPhysAddr(params[4], &pIsCmd);
  1426 	pContext->LocalToPhysAddr(params[5], &pFlags);
  1427 
  1428 	pContext->StringToLocalUTF8(params[2], params[3], pConCmd->GetName(), NULL);
  1429 	*pIsCmd = pConCmd->IsCommand() ? 1 : 0;
  1430 	*pFlags = pConCmd->GetFlags();
  1431 
  1432 	if (params[7])
  1433 	{
  1434 		desc = pConCmd->GetHelpText();
  1435 		pContext->StringToLocalUTF8(params[6], params[7], (desc && desc[0]) ? desc : "", NULL);
  1436 	}
  1437 
  1438 	return 1;
  1439 }
  1440 
  1441 static cell_t SendConVarValue(IPluginContext *pContext, const cell_t *params)
  1442 {
  1443 	Handle_t hndl = static_cast<Handle_t>(params[2]);
  1444 	HandleError err;
  1445 	ConVar *pConVar;
  1446 
  1447 	char *value;
  1448 	pContext->LocalToString(params[3], &value);
  1449 
  1450 	if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
  1451 		!= HandleError_None)
  1452 	{
  1453 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
  1454 	}
  1455 
  1456 	char data[256];
  1457 	bf_write buffer(data, sizeof(data));
  1458 
  1459 #if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_DOTA
  1460 	CNETMsg_SetConVar msg;
  1461 	CMsg_CVars_CVar *cvar = msg.mutable_convars()->add_cvars();
  1462 
  1463 	cvar->set_name(pConVar->GetName());
  1464 	cvar->set_value(value);
  1465 
  1466 	int msgsize = msg.ByteSize();
  1467    
  1468 	buffer.WriteVarInt32(net_SetConVar);
  1469 	buffer.WriteVarInt32(msgsize);
  1470 	msg.SerializeWithCachedSizesToArray( (uint8 *)( buffer.GetBasePointer() + buffer.GetNumBytesWritten() ) );
  1471 	buffer.SeekToBit( ( buffer.GetNumBytesWritten() + msgsize ) * 8 );
  1472 #else
  1473 	buffer.WriteUBitLong(NET_SETCONVAR, NETMSG_BITS);
  1474 	buffer.WriteByte(1);
  1475 	buffer.WriteString(pConVar->GetName());
  1476 	buffer.WriteString(value);
  1477 #endif
  1478 
  1479 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
  1480 
  1481 	if (!pPlayer)
  1482 	{
  1483 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
  1484 	}
  1485 
  1486 	if (!pPlayer->IsConnected())
  1487 	{
  1488 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
  1489 	}
  1490 
  1491 	if (pPlayer->IsFakeClient())
  1492 	{
  1493 		return pContext->ThrowNativeError("Client %d is fake and cannot be targeted", params[1]);
  1494 	}
  1495 
  1496 	INetChannel *netchan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(params[1]));
  1497 	if (netchan == NULL)
  1498 	{
  1499 		return 0;
  1500 	}
  1501 
  1502 	netchan->SendData(buffer);
  1503 
  1504 	return 1;
  1505 }
  1506 
  1507 static cell_t AddServerTag(IPluginContext *pContext, const cell_t *params)
  1508 {
  1509 	return 0;
  1510 }
  1511 
  1512 static cell_t RemoveServerTag(IPluginContext *pContext, const cell_t *params)
  1513 {
  1514 	return 0;
  1515 }
  1516 
  1517 static cell_t AddCommandListener(IPluginContext *pContext, const cell_t *params)
  1518 {
  1519 	char *name;
  1520 	IPluginFunction *pFunction;
  1521 
  1522 	pContext->LocalToString(params[2], &name);
  1523 
  1524 	if (strcasecmp(name, "sm") == 0)
  1525 	{
  1526 		g_Logger.LogError("Request to register \"sm\" command denied.");
  1527 		return 0;
  1528 	}
  1529 
  1530 	pFunction = pContext->GetFunctionById(params[1]);
  1531 
  1532 	if (!pFunction)
  1533 		return pContext->ThrowNativeError("Invalid function id (%X)", params[1]);
  1534 
  1535 	if (!g_ConsoleDetours.AddListener(pFunction, name[0] == '\0' ? NULL : name))
  1536 		return pContext->ThrowNativeError("This game does not support command listeners");
  1537 
  1538 	return 1;
  1539 }
  1540 
  1541 static cell_t RemoveCommandListener(IPluginContext *pContext, const cell_t *params)
  1542 {
  1543 	char *name;
  1544 	IPluginFunction *pFunction;
  1545 
  1546 	pContext->LocalToString(params[2], &name);
  1547 	pFunction = pContext->GetFunctionById(params[1]);
  1548 	if (!pFunction)
  1549 		return pContext->ThrowNativeError("Invalid function id (%X)", params[1]);
  1550 
  1551 	if (!g_ConsoleDetours.RemoveListener(pFunction, name[0] == '\0' ? NULL : name))
  1552 		return pContext->ThrowNativeError("No matching callback was registered");
  1553 	
  1554 	return 1;
  1555 }
  1556 
  1557 REGISTER_NATIVES(consoleNatives)
  1558 {
  1559 	{"CreateConVar",		sm_CreateConVar},
  1560 	{"FindConVar",			sm_FindConVar},
  1561 	{"HookConVarChange",	sm_HookConVarChange},
  1562 	{"UnhookConVarChange",	sm_UnhookConVarChange},
  1563 	{"GetConVarBool",		sm_GetConVarBool},
  1564 	{"SetConVarBool",		sm_SetConVarNum},
  1565 	{"GetConVarInt",		sm_GetConVarInt},
  1566 	{"SetConVarInt",		sm_SetConVarNum},
  1567 	{"GetConVarFloat",		sm_GetConVarFloat},
  1568 	{"SetConVarFloat",		sm_SetConVarFloat},
  1569 	{"GetConVarString",		sm_GetConVarString},
  1570 	{"SetConVarString",		sm_SetConVarString},
  1571 	{"GetConVarFlags",		sm_GetConVarFlags},
  1572 	{"SetConVarFlags",		sm_SetConVarFlags},
  1573 	{"ResetConVar",			sm_ResetConVar},
  1574 	{"GetConVarName",		sm_GetConVarName},
  1575 	{"GetConVarBounds",		sm_GetConVarBounds},
  1576 	{"SetConVarBounds",		sm_SetConVarBounds},
  1577 	{"QueryClientConVar",	sm_QueryClientConVar},
  1578 	{"GetConVarDefault",	GetConVarDefault},
  1579 	{"RegServerCmd",		sm_RegServerCmd},
  1580 	{"RegConsoleCmd",		sm_RegConsoleCmd},
  1581 	{"GetCmdArgString",		sm_GetCmdArgString},
  1582 	{"GetCmdArgs",			sm_GetCmdArgs},
  1583 	{"GetCmdArg",			sm_GetCmdArg},
  1584 	{"PrintToServer",		sm_PrintToServer},
  1585 	{"PrintToConsole",		sm_PrintToConsole},
  1586 	{"RegAdminCmd",			sm_RegAdminCmd},
  1587 	{"ServerCommand",		sm_ServerCommand},
  1588 	{"ServerCommandEx",		sm_ServerCommandEx},
  1589 	{"InsertServerCommand",	sm_InsertServerCommand},
  1590 	{"ServerExecute",		sm_ServerExecute},
  1591 	{"ClientCommand",		sm_ClientCommand},
  1592 	{"FakeClientCommand",	FakeClientCommand},
  1593 	{"ReplyToCommand",		ReplyToCommand},
  1594 	{"GetCmdReplySource",	GetCmdReplyTarget},
  1595 	{"SetCmdReplySource",	SetCmdReplyTarget},
  1596 	{"GetCommandIterator",	GetCommandIterator},
  1597 	{"ReadCommandIterator",	ReadCommandIterator},
  1598 	{"CheckCommandAccess",	CheckCommandAccess},
  1599 	{"CheckAccess",			CheckAccess},
  1600 	{"FakeClientCommandEx",	FakeClientCommandEx},
  1601 	{"IsChatTrigger",		IsChatTrigger},
  1602 	{"SetCommandFlags",		SetCommandFlags},
  1603 	{"GetCommandFlags",		GetCommandFlags},
  1604 	{"FindFirstConCommand",	FindFirstConCommand},
  1605 	{"FindNextConCommand",	FindNextConCommand},
  1606 	{"SendConVarValue",		SendConVarValue},
  1607 	{"AddServerTag",		AddServerTag},
  1608 	{"RemoveServerTag",		RemoveServerTag},
  1609 	{"AddCommandListener",	AddCommandListener},
  1610 	{"RemoveCommandListener", RemoveCommandListener},
  1611 	{NULL,					NULL}
  1612 };
sourcemod-central
Feed