Home - sourcemod-central - file revision - core/smn_console.cpp@ecbaee393b0b 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 15 00:38:25 2007 +0000 (2007-10-15)
changeset 1568 ecbaee393b0b
parent 1547 78abc407c8a3
child 1581 2562512b4a44
permissions -rw-r--r--
extensions can now be built for multiple engines, and will autoload from auto.X.Y folders 
     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 (IsFlagSet(pConVar, 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] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   254 	{
   255 		ReplicateConVar(pConVar);
   256 	}
   257 
   258 	/* Should we notify clients? */
   259 	if (params[4] && IsFlagSet(pConVar, 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] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   301 	{
   302 		ReplicateConVar(pConVar);
   303 	}
   304 
   305 	/* Should we notify clients? */
   306 	if (params[4] && IsFlagSet(pConVar, 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] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   350 	{
   351 		ReplicateConVar(pConVar);
   352 	}
   353 
   354 	/* Should we notify clients? */
   355 	if (params[4] && IsFlagSet(pConVar, 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] && IsFlagSet(pConVar, FCVAR_REPLICATED))
   379 	{
   380 		ReplicateConVar(pConVar);
   381 	}
   382 
   383 	/* Should we notify clients? */
   384 	if (params[3] && IsFlagSet(pConVar, 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 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   629 
   630 	if (!pCmd)
   631 	{
   632 		return pContext->ThrowNativeError("No command callback available");
   633 	}
   634 
   635 	return pCmd->ArgC() - 1;
   636 }
   637 
   638 static cell_t sm_GetCmdArg(IPluginContext *pContext, const cell_t *params)
   639 {
   640 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   641 
   642 	if (!pCmd)
   643 	{
   644 		return pContext->ThrowNativeError("No command callback available");
   645 	}
   646 
   647 	size_t length;
   648 
   649 	const char *arg = pCmd->Arg(params[1]);
   650 	
   651 	pContext->StringToLocalUTF8(params[2], params[3], arg ? arg : "", &length);
   652 
   653 	return (cell_t)length;
   654 }
   655 
   656 static cell_t sm_GetCmdArgString(IPluginContext *pContext, const cell_t *params)
   657 {
   658 	const CCommand *pCmd = g_HL2.PeekCommandStack();
   659 
   660 	if (!pCmd)
   661 	{
   662 		return pContext->ThrowNativeError("No command callback available");
   663 	}
   664 
   665 	const char *args = pCmd->ArgS();
   666 	size_t length;
   667 
   668 	if (!args)
   669 	{
   670 		args = "";
   671 	}
   672 
   673 	pContext->StringToLocalUTF8(params[1], params[2], args, &length);
   674 
   675 	return (cell_t)length;
   676 }
   677 
   678 static cell_t sm_PrintToServer(IPluginContext *pCtx, const cell_t *params)
   679 {
   680 	char buffer[1024];
   681 	char *fmt;
   682 	int arg = 2;
   683 
   684 	pCtx->LocalToString(params[1], &fmt);
   685 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   686 
   687 	buffer[res++] = '\n';
   688 	buffer[res] = '\0';
   689 
   690 	META_CONPRINT(buffer);
   691 
   692 	return 1;
   693 }
   694 
   695 static cell_t sm_PrintToConsole(IPluginContext *pCtx, const cell_t *params)
   696 {
   697 	int index = params[1];
   698 	if ((index < 0) || (index > g_Players.GetMaxClients()))
   699 	{
   700 		return pCtx->ThrowNativeError("Client index %d is invalid", index);
   701 	}
   702 
   703 	CPlayer *pPlayer = NULL;
   704 	if (index != 0)
   705 	{
   706 		pPlayer = g_Players.GetPlayerByIndex(index);
   707 		if (!pPlayer->IsInGame())
   708 		{
   709 			return pCtx->ThrowNativeError("Client %d is not in game", index);
   710 		}
   711 		
   712 		/* Silent fail on bots, engine will crash */
   713 		if (pPlayer->IsFakeClient())
   714 		{
   715 			return 0;
   716 		}
   717 	}
   718 
   719 	char buffer[1024];
   720 	char *fmt;
   721 	int arg = 3;
   722 
   723 	pCtx->LocalToString(params[2], &fmt);
   724 	size_t res = atcprintf(buffer, sizeof(buffer)-2, fmt, pCtx, params, &arg);
   725 
   726 	buffer[res++] = '\n';
   727 	buffer[res] = '\0';
   728 
   729 	if (index != 0)
   730 	{
   731 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
   732 	} else {
   733 		META_CONPRINT(buffer);
   734 	}
   735 
   736 	return 1;
   737 }
   738 
   739 static cell_t sm_ServerCommand(IPluginContext *pContext, const cell_t *params)
   740 {
   741 	g_SourceMod.SetGlobalTarget(LANG_SERVER);
   742 
   743 	char buffer[1024];
   744 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
   745 
   746 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   747 	{
   748 		return 0;
   749 	}
   750 
   751 	/* One byte for null terminator, one for newline */
   752 	buffer[len++] = '\n';
   753 	buffer[len] = '\0';
   754 
   755 	engine->ServerCommand(buffer);
   756 
   757 	return 1;
   758 }
   759 
   760 static cell_t sm_InsertServerCommand(IPluginContext *pContext, const cell_t *params)
   761 {
   762 	g_SourceMod.SetGlobalTarget(LANG_SERVER);
   763 
   764 	char buffer[1024];
   765 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 1);
   766 
   767 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   768 	{
   769 		return 0;
   770 	}
   771 
   772 	/* One byte for null terminator, one for newline */
   773 	buffer[len++] = '\n';
   774 	buffer[len] = '\0';
   775 
   776 	InsertServerCommand(buffer);
   777 
   778 	return 1;
   779 }
   780 
   781 static cell_t sm_ServerExecute(IPluginContext *pContext, const cell_t *params)
   782 {
   783 	engine->ServerExecute();
   784 
   785 	return 1;
   786 }
   787 
   788 static cell_t sm_ClientCommand(IPluginContext *pContext, const cell_t *params)
   789 {
   790 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   791 
   792 	if (!pPlayer)
   793 	{
   794 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   795 	}
   796 
   797 	if (!pPlayer->IsConnected())
   798 	{
   799 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   800 	}
   801 
   802 	g_SourceMod.SetGlobalTarget(params[1]);
   803 
   804 	char buffer[256];
   805 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   806 
   807 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   808 	{
   809 		return 0;
   810 	}
   811 
   812 	engine->ClientCommand(pPlayer->GetEdict(), "%s", buffer);
   813 
   814 	return 1;
   815 }
   816 
   817 static cell_t FakeClientCommand(IPluginContext *pContext, const cell_t *params)
   818 {
   819 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   820 
   821 	if (!pPlayer)
   822 	{
   823 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   824 	}
   825 
   826 	if (!pPlayer->IsConnected())
   827 	{
   828 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   829 	}
   830 
   831 	char buffer[256];
   832 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   833 
   834 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   835 	{
   836 		return 0;
   837 	}
   838 
   839 	serverpluginhelpers->ClientCommand(pPlayer->GetEdict(), buffer);
   840 
   841 	return 1;
   842 }
   843 
   844 static cell_t FakeClientCommandEx(IPluginContext *pContext, const cell_t *params)
   845 {
   846 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   847 
   848 	if (!pPlayer)
   849 	{
   850 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   851 	}
   852 
   853 	if (!pPlayer->IsConnected())
   854 	{
   855 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   856 	}
   857 
   858 	char buffer[256];
   859 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   860 
   861 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   862 	{
   863 		return 0;
   864 	}
   865 
   866 	g_HL2.AddToFakeCliCmdQueue(params[1], engine->GetPlayerUserId(pPlayer->GetEdict()), buffer);
   867 
   868 	return 1;
   869 }
   870 
   871 static cell_t ReplyToCommand(IPluginContext *pContext, const cell_t *params)
   872 {
   873 	g_SourceMod.SetGlobalTarget(params[1]);
   874 
   875 	/* Build the format string */
   876 	char buffer[1024];
   877 	size_t len = g_SourceMod.FormatString(buffer, sizeof(buffer)-2, pContext, params, 2);
   878 
   879 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   880 	{
   881 		return 0;
   882 	}
   883 
   884 	/* If we're printing to the server, shortcut out */
   885 	if (params[1] == 0)
   886 	{
   887 		/* Print */
   888 		buffer[len++] = '\n';
   889 		buffer[len] = '\0';
   890 		META_CONPRINT(buffer);
   891 		return 1;
   892 	}
   893 
   894 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(params[1]);
   895 
   896 	if (!pPlayer)
   897 	{
   898 		return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
   899 	}
   900 
   901 	if (!pPlayer->IsConnected())
   902 	{
   903 		return pContext->ThrowNativeError("Client %d is not connected", params[1]);
   904 	}
   905 
   906 	g_SourceMod.SetGlobalTarget(params[1]);
   907 
   908 	unsigned int replyto = g_ChatTriggers.GetReplyTo();
   909 	if (replyto == SM_REPLY_CONSOLE)
   910 	{
   911 		buffer[len++] = '\n';
   912 		buffer[len] = '\0';
   913 		engine->ClientPrintf(pPlayer->GetEdict(), buffer);
   914 	} else if (replyto == SM_REPLY_CHAT) {
   915 		if (len >= 191)
   916 		{
   917 			len = 191;
   918 		}
   919 		buffer[len] = '\0';
   920 		g_HL2.TextMsg(params[1], HUD_PRINTTALK, buffer);
   921 	}
   922 
   923 	return 1;
   924 }
   925 
   926 static cell_t GetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
   927 {
   928 	return g_ChatTriggers.GetReplyTo();
   929 }
   930 
   931 static cell_t SetCmdReplyTarget(IPluginContext *pContext, const cell_t *params)
   932 {
   933 	return g_ChatTriggers.SetReplyTo(params[1]);
   934 }
   935 
   936 static cell_t GetCommandIterator(IPluginContext *pContext, const cell_t *params)
   937 {
   938 	GlobCmdIter *iter = new GlobCmdIter;
   939 	iter->started = false;
   940 
   941 	Handle_t hndl = g_HandleSys.CreateHandle(hCmdIterType, iter, pContext->GetIdentity(), g_pCoreIdent, NULL);
   942 	if (hndl == BAD_HANDLE)
   943 	{
   944 		delete iter;
   945 	}
   946 
   947 	return hndl;
   948 }
   949 
   950 static cell_t ReadCommandIterator(IPluginContext *pContext, const cell_t *params)
   951 {
   952 	GlobCmdIter *iter;
   953 	HandleError err;
   954 	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
   955 
   956 	if ((err = g_HandleSys.ReadHandle(params[1], hCmdIterType, &sec, (void **)&iter))
   957 		!= HandleError_None)
   958 	{
   959 		return pContext->ThrowNativeError("Invalid GlobCmdIter Handle %x", params[1]);
   960 	}
   961 
   962 	const List<ConCmdInfo *> &cmds = g_ConCmds.GetCommandList();
   963 
   964 	if (!iter->started)
   965 	{
   966 		iter->iter = cmds.begin();
   967 		iter->started = true;
   968 	}
   969 
   970 	while (iter->iter != cmds.end()
   971 			&& !(*(iter->iter))->sourceMod)
   972 	{
   973 		iter->iter++;
   974 	}
   975 
   976 	if (iter->iter == cmds.end())
   977 	{
   978 		return 0;
   979 	}
   980 
   981 	ConCmdInfo *pInfo = (*(iter->iter));
   982 
   983 	pContext->StringToLocalUTF8(params[2], params[3], pInfo->pCmd->GetName(), NULL);
   984 	pContext->StringToLocalUTF8(params[5], params[6], pInfo->pCmd->GetHelpText(), NULL);
   985 	
   986 	cell_t *addr;
   987 	pContext->LocalToPhysAddr(params[4], &addr);
   988 	*addr = pInfo->admin.eflags;
   989 
   990 	iter->iter++;
   991 
   992 	return 1;
   993 }
   994 
   995 static cell_t CheckCommandAccess(IPluginContext *pContext, const cell_t *params)
   996 {
   997 	if (params[1] == 0)
   998 	{
   999 		return 1;
  1000 	}
  1001 
  1002 	char *cmd;
  1003 	pContext->LocalToString(params[2], &cmd);
  1004 
  1005 	/* Auto-detect a command if we can */
  1006 	FlagBits bits = params[3];
  1007 	bool found_command = false;
  1008 	if (params[0] < 4 || !params[4])
  1009 	{
  1010 		found_command = g_ConCmds.LookForCommandAdminFlags(cmd, &bits);
  1011 	}
  1012 	
  1013 	if (!found_command)
  1014 	{
  1015 		g_Admins.GetCommandOverride(cmd, Override_Command, &bits);
  1016 	}
  1017 
  1018 	return g_ConCmds.CheckCommandAccess(params[1], cmd, bits) ? 1 : 0;
  1019 }
  1020 
  1021 static cell_t IsChatTrigger(IPluginContext *pContext, const cell_t *params)
  1022 {
  1023 	return g_ChatTriggers.IsChatTrigger() ? 1 : 0;
  1024 }
  1025 
  1026 REGISTER_NATIVES(consoleNatives)
  1027 {
  1028 	{"CreateConVar",		sm_CreateConVar},
  1029 	{"FindConVar",			sm_FindConVar},
  1030 	{"HookConVarChange",	sm_HookConVarChange},
  1031 	{"UnhookConVarChange",	sm_UnhookConVarChange},
  1032 	{"GetConVarBool",		sm_GetConVarBool},
  1033 	{"SetConVarBool",		sm_SetConVarNum},
  1034 	{"GetConVarInt",		sm_GetConVarInt},
  1035 	{"SetConVarInt",		sm_SetConVarNum},
  1036 	{"GetConVarFloat",		sm_GetConVarFloat},
  1037 	{"SetConVarFloat",		sm_SetConVarFloat},
  1038 	{"GetConVarString",		sm_GetConVarString},
  1039 	{"SetConVarString",		sm_SetConVarString},
  1040 	{"GetConVarFlags",		sm_GetConVarFlags},
  1041 	{"SetConVarFlags",		sm_SetConVarFlags},
  1042 	{"ResetConVar",			sm_ResetConVar},
  1043 	{"GetConVarName",		sm_GetConVarName},
  1044 	{"GetConVarBounds",		sm_GetConVarBounds},
  1045 	{"SetConVarBounds",		sm_SetConVarBounds},
  1046 	{"QueryClientConVar",	sm_QueryClientConVar},
  1047 	{"RegServerCmd",		sm_RegServerCmd},
  1048 	{"RegConsoleCmd",		sm_RegConsoleCmd},
  1049 	{"GetCmdArgString",		sm_GetCmdArgString},
  1050 	{"GetCmdArgs",			sm_GetCmdArgs},
  1051 	{"GetCmdArg",			sm_GetCmdArg},
  1052 	{"PrintToServer",		sm_PrintToServer},
  1053 	{"PrintToConsole",		sm_PrintToConsole},
  1054 	{"RegAdminCmd",			sm_RegAdminCmd},
  1055 	{"ServerCommand",		sm_ServerCommand},
  1056 	{"InsertServerCommand",	sm_InsertServerCommand},
  1057 	{"ServerExecute",		sm_ServerExecute},
  1058 	{"ClientCommand",		sm_ClientCommand},
  1059 	{"FakeClientCommand",	FakeClientCommand},
  1060 	{"ReplyToCommand",		ReplyToCommand},
  1061 	{"GetCmdReplySource",	GetCmdReplyTarget},
  1062 	{"SetCmdReplySource",	SetCmdReplyTarget},
  1063 	{"GetCommandIterator",	GetCommandIterator},
  1064 	{"ReadCommandIterator",	ReadCommandIterator},
  1065 	{"CheckCommandAccess",	CheckCommandAccess},
  1066 	{"FakeClientCommandEx",	FakeClientCommandEx},
  1067 	{"IsChatTrigger",		IsChatTrigger},
  1068 	{NULL,					NULL}
  1069 };
sourcemod-central
Feed