Home - sourcemod-central - file revision - core/smn_console.cpp@300cc2432356 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 Sep 24 15:06:10 2007 +0000 (2007-09-24)
changeset 1469 300cc2432356
parent 1429 e20c8ea353ed
child 1541 e46ad208b9b4
permissions -rw-r--r--
added chat trigger detection 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2007 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 "HalfLife2.h"
    34 #include "sourcemm_api.h"
    35 #include "HandleSys.h"
    36 #include "ConVarManager.h"
    37 #include "ConCmdManager.h"
    38 #include "PluginSys.h"
    39 #include "sm_stringutil.h"
    40 #include "PlayerManager.h"
    41 #include "ChatTriggers.h"
    42 #include "AdminCache.h"
    43 #include <inetchannel.h>
    44 #include <bitbuf.h>
    45 
    46 #define NET_SETCONVAR	5
    47 
    48 enum ConVarBounds
    49 {
    50 	ConVarBound_Upper = 0,
    51 	ConVarBound_Lower
    52 };
    53 
    54 HandleType_t hCmdIterType = 0;
    55 
    56 struct GlobCmdIter
    57 {
    58 	bool started;
    59 	List<ConCmdInfo *>::iterator iter;
    60 };
    61 
    62 class ConsoleHelpers : 
    63 	public SMGlobalClass,
    64 	public IHandleTypeDispatch
    65 {
    66 public:
    67 	virtual void OnSourceModAllInitialized()
    68 	{
    69 		HandleAccess access;
    70 		g_HandleSys.InitAccessDefaults(NULL, &access);
    71 		access.access[HandleAccess_Clone] = HANDLE_RESTRICT_OWNER | HANDLE_RESTRICT_IDENTITY;
    72 
    73 		hCmdIterType = g_HandleSys.CreateType(NULL, this, 0, NULL, &access, g_pCoreIdent, NULL);
    74 	}
    75 	virtual void OnHandleDestroy(HandleType_t type, void *object)
    76 	{
    77 		GlobCmdIter *iter = (GlobCmdIter *)object;
    78 		delete iter;
    79 	}
    80 } s_ConsoleHelpers;
    81 
    82 static void ReplicateConVar(ConVar *pConVar)
    83 {
    84 	int maxClients = g_Players.GetMaxClients();
    85 
    86 	char data[256];
    87 	bf_write buffer(data, sizeof(data));
    88 
    89 	buffer.WriteUBitLong(NET_SETCONVAR, 5);
    90 	buffer.WriteByte(1);
    91 	buffer.WriteString(pConVar->GetName());
    92 	buffer.WriteString(pConVar->GetString());
    93 
    94 	for (int i = 1; i <= maxClients; i++)
    95 	{
    96 		CPlayer *pPlayer = g_Players.GetPlayerByIndex(i);
    97 
    98 		if (pPlayer && pPlayer->IsInGame() && !pPlayer->IsFakeClient())
    99 		{
   100 			INetChannel *netchan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(i));
   101 			netchan->SendData(buffer);
   102 		}
   103 	}
   104 }
   105 
   106 static void NotifyConVar(ConVar *pConVar)
   107 {
   108 	IGameEvent *pEvent = gameevents->CreateEvent("server_cvar");
   109 	pEvent->SetString("cvarname", pConVar->GetName());
   110 	if (pConVar->IsBitSet(FCVAR_PROTECTED))
   111 	{
   112 		pEvent->SetString("cvarvalue", "***PROTECTED***");
   113 	} else {
   114 		pEvent->SetString("cvarvalue", pConVar->GetString());
   115 	}
   116 
   117 	gameevents->FireEvent(pEvent);
   118 }
   119 
   120 static cell_t sm_CreateConVar(IPluginContext *pContext, const cell_t *params)
   121 {
   122 	char *name, *defaultVal, *helpText;
   123 
   124 	pContext->LocalToString(params[1], &name);
   125 
   126 	// While the engine seems to accept a blank convar name, it causes a crash upon server quit
   127 	if (name == NULL || strcmp(name, "") == 0)
   128 	{
   129 		return pContext->ThrowNativeError("Convar with blank name is not permitted");
   130 	}
   131 
   132 	pContext->LocalToString(params[2], &defaultVal);
   133 	pContext->LocalToString(params[3], &helpText);
   134 
   135 	bool hasMin = params[5] ? true : false;
   136 	bool hasMax = params[7] ? true : false;
   137 	float min = sp_ctof(params[6]);
   138 	float max = sp_ctof(params[8]);
   139 
   140 	Handle_t hndl = g_ConVarManager.CreateConVar(pContext, name, defaultVal, helpText, params[4], hasMin, min, hasMax, max);
   141 
   142 	if (hndl == BAD_HANDLE)
   143 	{
   144 		return pContext->ThrowNativeError("Convar \"%s\" was not created. A console command with the same name already exists.", name);
   145 	}
   146 
   147 	return hndl;
   148 }
   149 
   150 static cell_t sm_FindConVar(IPluginContext *pContext, const cell_t *params)
   151 {
   152 	char *name;
   153 
   154 	pContext->LocalToString(params[1], &name);
   155 
   156 	return g_ConVarManager.FindConVar(name);
   157 }
   158 
   159 static cell_t sm_HookConVarChange(IPluginContext *pContext, const cell_t *params)
   160 {
   161 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   162 	HandleError err;
   163 	ConVar *pConVar;
   164 
   165 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   166 		!= HandleError_None)
   167 	{
   168 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   169 	}
   170 
   171 	IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
   172 
   173 	if (!pFunction)
   174 	{
   175 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   176 	}
   177 
   178 	g_ConVarManager.HookConVarChange(pConVar, pFunction);
   179 
   180 	return 1;
   181 }
   182 
   183 static cell_t sm_UnhookConVarChange(IPluginContext *pContext, const cell_t *params)
   184 {
   185 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   186 	HandleError err;
   187 	ConVar *pConVar;
   188 
   189 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   190 		!= HandleError_None)
   191 	{
   192 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   193 	}
   194 
   195 	IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
   196 
   197 	if (!pFunction)
   198 	{
   199 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   200 	}
   201 
   202 	g_ConVarManager.UnhookConVarChange(pConVar, pFunction);
   203 
   204 	return 1;
   205 }
   206 
   207 static cell_t sm_GetConVarBool(IPluginContext *pContext, const cell_t *params)
   208 {
   209 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   210 	HandleError err;
   211 	ConVar *pConVar;
   212 
   213 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   214 		!= HandleError_None)
   215 	{
   216 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   217 	}
   218 
   219 	return pConVar->GetBool();
   220 }
   221 
   222 static cell_t sm_GetConVarInt(IPluginContext *pContext, const cell_t *params)
   223 {
   224 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   225 	HandleError err;
   226 	ConVar *pConVar;
   227 
   228 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   229 		!= HandleError_None)
   230 	{
   231 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   232 	}
   233 
   234 	return pConVar->GetInt();
   235 }
   236 
   237 /* This handles both SetConVarBool() and SetConVarInt() */
   238 static cell_t sm_SetConVarNum(IPluginContext *pContext, const cell_t *params)
   239 {
   240 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   241 	HandleError err;
   242 	ConVar *pConVar;
   243 
   244 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   245 		!= HandleError_None)
   246 	{
   247 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   248 	}
   249 
   250 	pConVar->SetValue(params[2]);
   251 
   252 	/* Should we replicate it? */
   253 	if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED))
   254 	{
   255 		ReplicateConVar(pConVar);
   256 	}
   257 
   258 	/* Should we notify clients? */
   259 	if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY))
   260 	{
   261 		NotifyConVar(pConVar);
   262 	}
   263 
   264 	return 1;
   265 }
   266 
   267 static cell_t sm_GetConVarFloat(IPluginContext *pContext, const cell_t *params)
   268 {
   269 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   270 	HandleError err;
   271 	ConVar *pConVar;
   272 
   273 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   274 		!= HandleError_None)
   275 	{
   276 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   277 	}
   278 	
   279 	float value = pConVar->GetFloat();
   280 
   281 	return sp_ftoc(value);
   282 }
   283 
   284 static cell_t sm_SetConVarFloat(IPluginContext *pContext, const cell_t *params)
   285 {
   286 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   287 	HandleError err;
   288 	ConVar *pConVar;
   289 
   290 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   291 		!= HandleError_None)
   292 	{
   293 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   294 	}
   295 
   296 	float value = sp_ctof(params[2]);
   297 	pConVar->SetValue(value);
   298 
   299 	/* Should we replicate it? */
   300 	if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED))
   301 	{
   302 		ReplicateConVar(pConVar);
   303 	}
   304 
   305 	/* Should we notify clients? */
   306 	if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY))
   307 	{
   308 		NotifyConVar(pConVar);
   309 	}
   310 
   311 	return 1;
   312 }
   313 
   314 static cell_t sm_GetConVarString(IPluginContext *pContext, const cell_t *params)
   315 {
   316 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   317 	HandleError err;
   318 	ConVar *pConVar;
   319 
   320 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   321 		!= HandleError_None)
   322 	{
   323 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   324 	}
   325 
   326 	pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetString(), NULL);
   327 
   328 	return 1;
   329 }
   330 
   331 static cell_t sm_SetConVarString(IPluginContext *pContext, const cell_t *params)
   332 {
   333 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   334 	HandleError err;
   335 	ConVar *pConVar;
   336 
   337 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   338 		!= HandleError_None)
   339 	{
   340 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   341 	}
   342 
   343 	char *value;
   344 	pContext->LocalToString(params[2], &value);
   345 
   346 	pConVar->SetValue(value);
   347 
   348 	/* Should we replicate it? */
   349 	if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED))
   350 	{
   351 		ReplicateConVar(pConVar);
   352 	}
   353 
   354 	/* Should we notify clients? */
   355 	if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY))
   356 	{
   357 		NotifyConVar(pConVar);
   358 	}
   359 
   360 	return 1;
   361 }
   362 
   363 static cell_t sm_ResetConVar(IPluginContext *pContext, const cell_t *params)
   364 {
   365 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   366 	HandleError err;
   367 	ConVar *pConVar;
   368 
   369 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   370 		!= HandleError_None)
   371 	{
   372 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   373 	}
   374 
   375 	pConVar->Revert();
   376 	
   377 	/* Should we replicate it? */
   378 	if (params[2] && pConVar->IsBitSet(FCVAR_REPLICATED))
   379 	{
   380 		ReplicateConVar(pConVar);
   381 	}
   382 
   383 	/* Should we notify clients? */
   384 	if (params[3] && pConVar->IsBitSet(FCVAR_NOTIFY))
   385 	{
   386 		NotifyConVar(pConVar);
   387 	}
   388 
   389 	return 1;
   390 }
   391 
   392 static cell_t sm_GetConVarFlags(IPluginContext *pContext, const cell_t *params)
   393 {
   394 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   395 	HandleError err;
   396 	ConVar *pConVar;
   397 
   398 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   399 		!= HandleError_None)
   400 	{
   401 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   402 	}
   403 
   404 	return pConVar->GetFlags();
   405 }
   406 
   407 static cell_t sm_SetConVarFlags(IPluginContext *pContext, const cell_t *params)
   408 {
   409 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   410 	HandleError err;
   411 	ConVar *pConVar;
   412 
   413 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   414 		!= HandleError_None)
   415 	{
   416 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   417 	}
   418 
   419 	pConVar->SetFlags(params[2]);
   420 
   421 	return 1;
   422 }
   423 
   424 static cell_t sm_GetConVarBounds(IPluginContext *pContext, const cell_t *params)
   425 {
   426 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   427 	HandleError err;
   428 	ConVar *pConVar;
   429 
   430 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   431 		!= HandleError_None)
   432 	{
   433 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   434 	}
   435 
   436 	cell_t *addr;
   437 	bool hasBound;
   438 	float bound;
   439 
   440 	switch (params[2])
   441 	{
   442 	case ConVarBound_Upper:
   443 		hasBound = pConVar->GetMax(bound);
   444 		break;
   445 	case ConVarBound_Lower:
   446 		hasBound = pConVar->GetMin(bound);
   447 		break;
   448 	default:
   449 		return pContext->ThrowNativeError("Invalid ConVarBounds value %d");
   450 	}
   451 	
   452 	pContext->LocalToPhysAddr(params[3], &addr);
   453 	*addr = sp_ftoc(bound);
   454 
   455 	return hasBound;
   456 }
   457 
   458 static cell_t sm_SetConVarBounds(IPluginContext *pContext, const cell_t *params)
   459 {
   460 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   461 	HandleError err;
   462 	ConVar *pConVar;
   463 
   464 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   465 		!= HandleError_None)
   466 	{
   467 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   468 	}
   469 
   470 	switch (params[2])
   471 	{
   472 	case ConVarBound_Upper:
   473 		pConVar->SetMax(params[3] ? true : false, sp_ctof(params[4]));
   474 		break;
   475 	case ConVarBound_Lower:
   476 		pConVar->SetMin(params[3] ? true : false, sp_ctof(params[4]));
   477 		break;
   478 	default:
   479 		return pContext->ThrowNativeError("Invalid ConVarBounds value %d");
   480 	}
   481 
   482 	return 1;
   483 }
   484 
   485 static cell_t sm_GetConVarName(IPluginContext *pContext, const cell_t *params)
   486 {
   487 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   488 	HandleError err;
   489 	ConVar *pConVar;
   490 
   491 	if ((err=g_HandleSys.ReadHandle(hndl, g_ConVarManager.GetHandleType(), NULL, (void **)&pConVar))
   492 		!= HandleError_None)
   493 	{
   494 		return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
   495 	}
   496 
   497 	pContext->StringToLocalUTF8(params[2], params[3], pConVar->GetName(), NULL);
   498 
   499 	return 1;
   500 }
   501 
   502 static bool s_QueryAlreadyWarned = false;
   503 
   504 static cell_t sm_QueryClientConVar(IPluginContext *pContext, const cell_t *params)
   505 {
   506 	CPlayer *pPlayer;
   507 	char *name;
   508 	IPluginFunction *pCallback;
   509 
   510 	if (g_IsOriginalEngine)
   511 	{
   512 		if (!s_QueryAlreadyWarned)
   513 		{
   514 			s_QueryAlreadyWarned = true;
   515 			return pContext->ThrowNativeError("Game does not support client convar querying (one time warning)");
   516 		}
   517 
   518 		return 0;
   519 	}
   520 
   521 	pPlayer = g_Players.GetPlayerByIndex(params[1]);
   522 
   523 	if (!pPlayer)
   524 	{
   525 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   526 	}
   527 
   528 	if (!pPlayer->IsConnected())
   529 	{
   530 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   531 	}
   532 
   533 	/* Trying a query on a bot results in callback not be fired, so don't bother */
   534 	if (pPlayer->IsFakeClient())
   535 	{
   536 		return 0;
   537 	}
   538 
   539 	pContext->LocalToString(params[2], &name);
   540 	pCallback = pContext->GetFunctionById(params[3]);
   541 
   542 	if (!pCallback)
   543 	{
   544 		return pContext->ThrowNativeError("Invalid function id (%X)", params[3]);
   545 	}
   546 
   547 	return g_ConVarManager.QueryClientConVar(pPlayer->GetEdict(), name, pCallback, params[4]);
   548 }
   549 
   550 static cell_t sm_RegServerCmd(IPluginContext *pContext, const cell_t *params)
   551 {
   552 	char *name,*help;
   553 	IPluginFunction *pFunction;
   554 
   555 	pContext->LocalToString(params[1], &name);
   556 	pContext->LocalToString(params[3], &help);
   557 	pFunction = pContext->GetFunctionById(params[2]);
   558 
   559 	if (!pFunction)
   560 	{
   561 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   562 	}
   563 
   564 	if (!g_ConCmds.AddServerCommand(pFunction, name, help, params[4]))
   565 	{
   566 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   567 	}
   568 
   569 	return 1;
   570 }
   571 
   572 static cell_t sm_RegConsoleCmd(IPluginContext *pContext, const cell_t *params)
   573 {
   574 	char *name,*help;
   575 	IPluginFunction *pFunction;
   576 
   577 	pContext->LocalToString(params[1], &name);
   578 	pContext->LocalToString(params[3], &help);
   579 	pFunction = pContext->GetFunctionById(params[2]);
   580 
   581 	if (!pFunction)
   582 	{
   583 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   584 	}
   585 
   586 	if (!g_ConCmds.AddConsoleCommand(pFunction, name, help, params[4]))
   587 	{
   588 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   589 	}
   590 
   591 	return 1;
   592 }
   593 
   594 static cell_t sm_RegAdminCmd(IPluginContext *pContext, const cell_t *params)
   595 {
   596 	char *name,*help;
   597 	const char *group;
   598 	IPluginFunction *pFunction;
   599 	FlagBits flags = params[3];
   600 	int cmdflags = params[6];
   601 
   602 	pContext->LocalToString(params[1], &name);
   603 	pContext->LocalToString(params[4], &help);
   604 	pContext->LocalToString(params[5], (char **)&group);
   605 	pFunction = pContext->GetFunctionById(params[2]);
   606 
   607 	if (group[0] == '\0')
   608 	{
   609 		CPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pContext->GetContext());
   610 		group = pPlugin->GetFilename();
   611 	}
   612 
   613 	if (!pFunction)
   614 	{
   615 		return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
   616 	}
   617 
   618 	if (!g_ConCmds.AddAdminCommand(pFunction, name, group, flags, help, cmdflags))
   619 	{
   620 		return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
   621 	}
   622 
   623 	return 1;
   624 }
   625 
   626 static cell_t sm_GetCmdArgs(IPluginContext *pContext, const cell_t *params)
   627 {
   628 	return engine->Cmd_Argc() - 1;
   629 }
   630 
   631 static cell_t sm_GetCmdArg(IPluginContext *pContext, const cell_t *params)
   632 {
   633 	const char *arg = engine->Cmd_Argv(params[1]);
   634 	size_t length;
   635 	
   636 	pContext->StringToLocalUTF8(params[2], params[3], arg, &length);
   637 
   638 	return (cell_t)length;
   639 }
   640 
   641 static cell_t sm_GetCmdArgString(IPluginContext *pContext, const cell_t *params)
   642 {
   643 	const char *args = engine->Cmd_Args();
   644 	size_t length;
   645 
   646 	if (!args)
   647 	{
   648 		args = "";
   649 	}
   650 
   651 	pContext->StringToLocalUTF8(params[1], params[2], args, &length);
   652 
   653 	return (cell_t)length;
   654 }
   655 
   656 static cell_t sm_PrintToServer(IPluginContext *pCtx, const cell_t *params)
   657 {
   658 	char buffer[1024];
   659 	char *fmt;
   660 	int arg = 2;
   661 
   662 	pCtx->LocalToString(params[1], &fmt);
   663 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   664 
   665 	buffer[res++] = '\n';
   666 	buffer[res] = '\0';
   667 
   668 	META_CONPRINT(buffer);
   669 
   670 	return 1;
   671 }
   672 
   673 static cell_t sm_PrintToConsole(IPluginContext *pCtx, const cell_t *params)
   674 {
   675 	int index = params[1];
   676 	if ((index < 0) || (index > g_Players.GetMaxClients()))
   677 	{
   678 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   679 	}
   680 
   681 	CPlayer *pPlayer = NULL;
   682 	if (index != 0)
   683 	{
   684 		pPlayer = g_Players.GetPlayerByIndex(index);
   685 		if (!pPlayer->IsInGame())
   686 		{
   687 			return pCtx->ThrowNativeError("Client %d is not in game", index);
   688 		}
   689 		
   690 		/* Silent fail on bots, engine will crash */
   691 		if (pPlayer->IsFakeClient())
   692 		{
   693 			return 0;
   694 		}
   695 	}
   696 
   697 	char buffer[1024];
   698 	char *fmt;
   699 	int arg = 3;
   700 
   701 	pCtx->LocalToString(params[2], &fmt);
   702 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   703 
   704 	buffer[res++] = '\n';
   705 	buffer[res] = '\0';
   706 
   707 	if (index != 0)
   708 	{
   709 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
   710 	} else {
   711 		META_CONPRINT(buffer);
   712 	}
   713 
   714 	return 1;
   715 }
   716 
   717 static cell_t sm_ServerCommand(IPluginContext *pContext, const cell_t *params)
   718 {
   719 	g_SourceMod.SetGlobalTarget(LANG_SERVER);
   720 
   721 	char buffer[1024];
   722 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
   723 
   724 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   725 	{
   726 		return 0;
   727 	}
   728 
   729 	/* One byte for null terminator, one for newline */
   730 	buffer[len++] = '\n';
   731 	buffer[len] = '\0';
   732 
   733 	engine->ServerCommand(buffer);
   734 
   735 	return 1;
   736 }
   737 
   738 static cell_t sm_InsertServerCommand(IPluginContext *pContext, const cell_t *params)
   739 {
   740 	g_SourceMod.SetGlobalTarget(LANG_SERVER);
   741 
   742 	char buffer[1024];
   743 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
   744 
   745 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   746 	{
   747 		return 0;
   748 	}
   749 
   750 	/* One byte for null terminator, one for newline */
   751 	buffer[len++] = '\n';
   752 	buffer[len] = '\0';
   753 
   754 	engine->InsertServerCommand(buffer);
   755 
   756 	return 1;
   757 }
   758 
   759 static cell_t sm_ServerExecute(IPluginContext *pContext, const cell_t *params)
   760 {
   761 	engine->ServerExecute();
   762 
   763 	return 1;
   764 }
   765 
   766 static cell_t sm_ClientCommand(IPluginContext *pContext, const cell_t *params)
   767 {
   768 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   769 
   770 	if (!pPlayer)
   771 	{
   772 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   773 	}
   774 
   775 	if (!pPlayer->IsConnected())
   776 	{
   777 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   778 	}
   779 
   780 	g_SourceMod.SetGlobalTarget(params[1]);
   781 
   782 	char buffer[256];
   783 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   784 
   785 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   786 	{
   787 		return 0;
   788 	}
   789 
   790 	engine->ClientCommand(pPlayer->GetEdict(), "%s", buffer);
   791 
   792 	return 1;
   793 }
   794 
   795 static cell_t FakeClientCommand(IPluginContext *pContext, const cell_t *params)
   796 {
   797 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   798 
   799 	if (!pPlayer)
   800 	{
   801 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   802 	}
   803 
   804 	if (!pPlayer->IsConnected())
   805 	{
   806 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   807 	}
   808 
   809 	char buffer[256];
   810 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   811 
   812 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   813 	{
   814 		return 0;
   815 	}
   816 
   817 	serverpluginhelpers->ClientCommand(pPlayer->GetEdict(), buffer);
   818 
   819 	return 1;
   820 }
   821 
   822 static cell_t FakeClientCommandEx(IPluginContext *pContext, const cell_t *params)
   823 {
   824 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   825 
   826 	if (!pPlayer)
   827 	{
   828 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   829 	}
   830 
   831 	if (!pPlayer->IsConnected())
   832 	{
   833 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   834 	}
   835 
   836 	char buffer[256];
   837 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   838 
   839 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   840 	{
   841 		return 0;
   842 	}
   843 
   844 	g_HL2.AddToFakeCliCmdQueue(params[1], engine->GetPlayerUserId(pPlayer->GetEdict()), buffer);
   845 
   846 	return 1;
   847 }
   848 
   849 static cell_t ReplyToCommand(IPluginContext *pContext, const cell_t *params)
   850 {
   851 	g_SourceMod.SetGlobalTarget(params[1]);
   852 
   853 	/* Build the format string */
   854 	char buffer[1024];
   855 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 2);
   856 
   857 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   858 	{
   859 		return 0;
   860 	}
   861 
   862 	/* If we're printing to the server, shortcut out */
   863 	if (params[1] == 0)
   864 	{
   865 		/* Print */
   866 		buffer[len++] = '\n';
   867 		buffer[len] = '\0';
   868 		META_CONPRINT(buffer);
   869 		return 1;
   870 	}
   871 
   872 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   873 
   874 	if (!pPlayer)
   875 	{
   876 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   877 	}
   878 
   879 	if (!pPlayer->IsConnected())
   880 	{
   881 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   882 	}
   883 
   884 	g_SourceMod.SetGlobalTarget(params[1]);
   885 
   886 	unsigned int replyto = g_ChatTriggers.GetReplyTo();
   887 	if (replyto == SM_REPLY_CONSOLE)
   888 	{
   889 		buffer[len++] = '\n';
   890 		buffer[len] = '\0';
   891 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
   892 	} else if (replyto == SM_REPLY_CHAT) {
   893 		if (len >= 191)
   894 		{
   895 			len = 191;
   896 		}
   897 		buffer[len] = '\0';
   898 		g_HL2.TextMsg(params[1], HUD_PRINTTALK, buffer);
   899 	}
   900 
   901 	return 1;
   902 }
   903 
   904 static cell_t GetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
   905 {
   906 	return g_ChatTriggers.GetReplyTo();
   907 }
   908 
   909 static cell_t SetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
   910 {
   911 	return g_ChatTriggers.SetReplyTo(params[1]);
   912 }
   913 
   914 static cell_t GetCommandIterator(IPluginContext *pContext, const cell_t *params)
   915 {
   916 	GlobCmdIter *iter = new GlobCmdIter;
   917 	iter->started = false;
   918 
   919 	Handle_t hndl = g_HandleSys.CreateHandle(hCmdIterType, iter, pContext->GetIdentity(), g_pCoreIdent, NULL);
   920 	if (hndl == BAD_HANDLE)
   921 	{
   922 		delete iter;
   923 	}
   924 
   925 	return hndl;
   926 }
   927 
   928 static cell_t ReadCommandIterator(IPluginContext *pContext, const cell_t *params)
   929 {
   930 	GlobCmdIter *iter;
   931 	HandleError err;
   932 	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
   933 
   934 	if ((err = g_HandleSys.ReadHandle(params[1], hCmdIterType, &sec, (void **)&iter))
   935 		!= HandleError_None)
   936 	{
   937 		return pContext->ThrowNativeError("Invalid GlobCmdIter Handle %x", params[1]);
   938 	}
   939 
   940 	const List<ConCmdInfo *> &cmds = g_ConCmds.GetCommandList();
   941 
   942 	if (!iter->started)
   943 	{
   944 		iter->iter = cmds.begin();
   945 		iter->started = true;
   946 	}
   947 
   948 	while (iter->iter != cmds.end()
   949 			&& !(*(iter->iter))->sourceMod)
   950 	{
   951 		iter->iter++;
   952 	}
   953 
   954 	if (iter->iter == cmds.end())
   955 	{
   956 		return 0;
   957 	}
   958 
   959 	ConCmdInfo *pInfo = (*(iter->iter));
   960 
   961 	pContext->StringToLocalUTF8(params[2], params[3], pInfo->pCmd->GetName(), NULL);
   962 	pContext->StringToLocalUTF8(params[5], params[6], pInfo->pCmd->GetHelpText(), NULL);
   963 	
   964 	cell_t *addr;
   965 	pContext->LocalToPhysAddr(params[4], &addr);
   966 	*addr = pInfo->admin.eflags;
   967 
   968 	iter->iter++;
   969 
   970 	return 1;
   971 }
   972 
   973 static cell_t CheckCommandAccess(IPluginContext *pContext, const cell_t *params)
   974 {
   975 	if (params[1] == 0)
   976 	{
   977 		return 1;
   978 	}
   979 
   980 	char *cmd;
   981 	pContext->LocalToString(params[2], &cmd);
   982 
   983 	/* Auto-detect a command if we can */
   984 	FlagBits bits = params[3];
   985 	bool found_command = false;
   986 	if (params[0] < 4 || !params[4])
   987 	{
   988 		found_command = g_ConCmds.LookForCommandAdminFlags(cmd, &bits);
   989 	}
   990 	
   991 	if (!found_command)
   992 	{
   993 		g_Admins.GetCommandOverride(cmd, Override_Command, &bits);
   994 	}
   995 
   996 	return g_ConCmds.CheckCommandAccess(params[1], cmd, bits) ? 1 : 0;
   997 }
   998 
   999 static cell_t IsChatTrigger(IPluginContext *pContext, const cell_t *params)
  1000 {
  1001 	return g_ChatTriggers.IsChatTrigger() ? 1 : 0;
  1002 }
  1003 
  1004 REGISTER_NATIVES(consoleNatives)
  1005 {
  1006 	{"CreateConVar",		sm_CreateConVar},
  1007 	{"FindConVar",			sm_FindConVar},
  1008 	{"HookConVarChange",	sm_HookConVarChange},
  1009 	{"UnhookConVarChange",	sm_UnhookConVarChange},
  1010 	{"GetConVarBool",		sm_GetConVarBool},
  1011 	{"SetConVarBool",		sm_SetConVarNum},
  1012 	{"GetConVarInt",		sm_GetConVarInt},
  1013 	{"SetConVarInt",		sm_SetConVarNum},
  1014 	{"GetConVarFloat",		sm_GetConVarFloat},
  1015 	{"SetConVarFloat",		sm_SetConVarFloat},
  1016 	{"GetConVarString",		sm_GetConVarString},
  1017 	{"SetConVarString",		sm_SetConVarString},
  1018 	{"GetConVarFlags",		sm_GetConVarFlags},
  1019 	{"SetConVarFlags",		sm_SetConVarFlags},
  1020 	{"ResetConVar",			sm_ResetConVar},
  1021 	{"GetConVarName",		sm_GetConVarName},
  1022 	{"GetConVarBounds",		sm_GetConVarBounds},
  1023 	{"SetConVarBounds",		sm_SetConVarBounds},
  1024 	{"QueryClientConVar",	sm_QueryClientConVar},
  1025 	{"RegServerCmd",		sm_RegServerCmd},
  1026 	{"RegConsoleCmd",		sm_RegConsoleCmd},
  1027 	{"GetCmdArgString",		sm_GetCmdArgString},
  1028 	{"GetCmdArgs",			sm_GetCmdArgs},
  1029 	{"GetCmdArg",			sm_GetCmdArg},
  1030 	{"PrintToServer",		sm_PrintToServer},
  1031 	{"PrintToConsole",		sm_PrintToConsole},
  1032 	{"RegAdminCmd",			sm_RegAdminCmd},
  1033 	{"ServerCommand",		sm_ServerCommand},
  1034 	{"InsertServerCommand",	sm_InsertServerCommand},
  1035 	{"ServerExecute",		sm_ServerExecute},
  1036 	{"ClientCommand",		sm_ClientCommand},
  1037 	{"FakeClientCommand",	FakeClientCommand},
  1038 	{"ReplyToCommand",		ReplyToCommand},
  1039 	{"GetCmdReplySource",	GetCmdReplyTarget},
  1040 	{"SetCmdReplySource",	SetCmdReplyTarget},
  1041 	{"GetCommandIterator",	GetCommandIterator},
  1042 	{"ReadCommandIterator",	ReadCommandIterator},
  1043 	{"CheckCommandAccess",	CheckCommandAccess},
  1044 	{"FakeClientCommandEx",	FakeClientCommandEx},
  1045 	{"IsChatTrigger",		IsChatTrigger},
  1046 	{NULL,					NULL}
  1047 };
sourcemod-central
Feed