sourcemod-central: core/PlayerManager.cpp@409a6de13f09

     1 /**

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

     3  * =============================================================================

     4  * SourceMod

     5  * Copyright (C) 2004-2009 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  */

    32 #include "PlayerManager.h"

    33 #include "ForwardSys.h"

    34 #include "ShareSys.h"

    35 #include "AdminCache.h"

    36 #include "ConCmdManager.h"

    37 #include "MenuStyle_Valve.h"

    38 #include "MenuStyle_Radio.h"

    39 #include "sm_stringutil.h"

    40 #include "CoreConfig.h"

    41 #include "TimerSys.h"

    42 #include "Translator.h"

    43 #include "Logger.h"

    44 #include "ChatTriggers.h"

    45 #include "HalfLife2.h"

    46 #include <inetchannel.h>

    47 #include <iclient.h>

    48 #include "GameConfigs.h"

    49 #include "ExtensionSys.h"

    50 #include <sourcemod_version.h>

    51 #include "ConsoleDetours.h"

    52 #include "logic_bridge.h"

    54 PlayerManager g_Players;

    55 bool g_OnMapStarted = false;

    56 IForward *PreAdminCheck = NULL;

    57 IForward *PostAdminCheck = NULL;

    58 IForward *PostAdminFilter = NULL;

    59 IForward *OnClientConnected = NULL;

    60 const unsigned int *g_NumPlayersToAuth = NULL;

    61 int lifestate_offset = -1;

    62 List<ICommandTargetProcessor *> target_processors;

    64 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);

    65 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);

    66 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);

    67 #if SOURCE_ENGINE >= SE_ORANGEBOX

    68 SH_DECL_HOOK2_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *, const CCommand &);

    69 #else

    70 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);

    71 #endif

    72 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);

    73 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);

    75 #if SOURCE_ENGINE >= SE_ORANGEBOX

    76 SH_DECL_EXTERN1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &);

    77 #elif SOURCE_ENGINE == SE_DARKMESSIAH

    78 SH_DECL_EXTERN0_void(ConCommand, Dispatch, SH_NOATTRIB, false);

    79 #else

    80 # if SH_IMPL_VERSION >= 4

    81  extern int __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    82 # else

    83  extern bool __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    84 # endif

    85 extern bool __SourceHook_FHRemoveConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

    86 #endif

    88 ConCommand *maxplayersCmd = NULL;

    90 unsigned int g_PlayerSerialCount = 0;

    92 class KickPlayerTimer : public ITimedEvent

    93 {

    94 public:

    95 	ResultType OnTimer(ITimer *pTimer, void *pData)

    96 	{

    97 		int userid = (int)pData;

    98 		int client = g_Players.GetClientOfUserId(userid);

    99 		if (client)

   100 		{

   101 			CPlayer *player = g_Players.GetPlayerByIndex(client);

   102 			player->Kick("Your name is reserved by SourceMod; set your password to use it.");

   103 		}

   104 		return Pl_Stop;

   105 	}

   106 	void OnTimerEnd(ITimer *pTimer, void *pData)

   107 	{

   108 	}

   109 } s_KickPlayerTimer;

   111 PlayerManager::PlayerManager()

   112 {

   113 	m_AuthQueue = NULL;

   114 	m_FirstPass = false;

   115 	m_maxClients = 0;

   117 	m_UserIdLookUp = new int[USHRT_MAX+1];

   118 	memset(m_UserIdLookUp, 0, sizeof(int) * (USHRT_MAX+1));

   119 }

   121 PlayerManager::~PlayerManager()

   122 {

   123 	g_NumPlayersToAuth = NULL;

   125 	delete [] m_AuthQueue;

   126 	delete [] m_UserIdLookUp;

   127 }

   129 void PlayerManager::OnSourceModAllInitialized()

   130 {

   131 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

   132 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

   133 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

   134 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

   135 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

   136 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

   137 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

   138 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

   140 	g_ShareSys.AddInterface(NULL, this);

   142 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};

   143 	ParamType p2[] = {Param_Cell};

   145 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_LowEvent, 3, p1);

   146 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);

   147 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);

   148 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);

   149 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);

   150 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);

   151 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);

   152 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);

   153 	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);

   154 	OnClientConnected = g_Forwards.CreateForward("OnClientConnected", ET_Ignore, 1, p2);

   156 	PreAdminCheck = g_Forwards.CreateForward("OnClientPreAdminCheck", ET_Event, 1, p1);

   157 	PostAdminCheck = g_Forwards.CreateForward("OnClientPostAdminCheck", ET_Ignore, 1, p1);

   158 	PostAdminFilter = g_Forwards.CreateForward("OnClientPostAdminFilter", ET_Ignore, 1, p1);

   160 	m_bIsListenServer = !engine->IsDedicatedServer();

   161 	m_ListenClient = 0;

   163 	g_ConVarManager.AddConVarChangeListener("tv_enable", this);

   165 	ConCommand *pCmd = FindCommand("maxplayers");

   166 	if (pCmd != NULL)

   167 	{

   168 		SH_ADD_HOOK_STATICFUNC(ConCommand, Dispatch, pCmd, CmdMaxplayersCallback, true);

   169 		maxplayersCmd = pCmd;

   170 	}

   171 }

   173 void PlayerManager::OnSourceModShutdown()

   174 {

   175 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

   176 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

   177 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

   178 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

   179 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

   180 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

   181 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

   183 	/* Release forwards */

   184 	g_Forwards.ReleaseForward(m_clconnect);

   185 	g_Forwards.ReleaseForward(m_clputinserver);

   186 	g_Forwards.ReleaseForward(m_cldisconnect);

   187 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   188 	g_Forwards.ReleaseForward(m_clcommand);

   189 	g_Forwards.ReleaseForward(m_clinfochanged);

   190 	g_Forwards.ReleaseForward(m_clauth);

   191 	g_Forwards.ReleaseForward(m_onActivate);

   192 	g_Forwards.ReleaseForward(m_onActivate2);

   193 	g_Forwards.ReleaseForward(OnClientConnected);

   195 	g_Forwards.ReleaseForward(PreAdminCheck);

   196 	g_Forwards.ReleaseForward(PostAdminCheck);

   197 	g_Forwards.ReleaseForward(PostAdminFilter);

   199 	delete [] m_Players;

   201 	g_ConVarManager.RemoveConVarChangeListener("tv_enable", this);

   203 	if (maxplayersCmd != NULL)

   204 	{

   205 		SH_REMOVE_HOOK_STATICFUNC(ConCommand, Dispatch, maxplayersCmd, CmdMaxplayersCallback, true);

   206 	}

   207 }

   209 ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key,

   210 												 const char *value,

   211 												 ConfigSource source,

   212 												 char *error,

   213 												 size_t maxlength)

   214 {

   215 	if (strcmp(key, "PassInfoVar") == 0)

   216 	{

   217 		if (strcmp(value, "_password") != 0)

   218 		{

   219 			m_PassInfoVar.assign(value);

   220 		}

   221 		return ConfigResult_Accept;

   222 	} else if (strcmp(key, "AllowClLanguageVar") == 0) {

   223 		if (strcasecmp(value, "on") == 0)

   224 		{

   225 			m_QueryLang = true;

   226 		} else if (strcasecmp(value, "off") == 0) {

   227 			m_QueryLang = false;

   228 		} else {

   229 			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");

   230 			return ConfigResult_Reject;

   231 		}

   232 		return ConfigResult_Accept;

   233 	}

   234 	return ConfigResult_Ignore;

   235 }

   237 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)

   238 {

   239 	if (!m_FirstPass)

   240 	{

   241 		/* Initialize all players */

   242 		m_maxClients = clientMax;

   243 		m_PlayerCount = 0;

   244 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

   245 		m_AuthQueue = new unsigned int[ABSOLUTE_PLAYER_LIMIT + 1];

   246 		m_FirstPass = true;

   248 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (ABSOLUTE_PLAYER_LIMIT + 1));

   250 		g_NumPlayersToAuth = &m_AuthQueue[0];

   252 		g_PluginSys.SyncMaxClients(clientMax);

   253 	}

   254 	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, clientMax);

   255 	m_onActivate->Execute(NULL);

   256 	m_onActivate2->Execute(NULL);

   258 	List<IClientListener *>::iterator iter;

   259 	for (iter = m_hooks.begin(); iter != m_hooks.end(); iter++)

   260 	{

   261 		if ((*iter)->GetClientListenerVersion() >= 5)

   262 		{

   263 			(*iter)->OnServerActivated(clientMax);

   264 		}

   265 	}

   267 	g_OnMapStarted = true;

   269 	SMGlobalClass *cls = SMGlobalClass::head;

   270 	while (cls)

   271 	{

   272 		cls->OnSourceModLevelActivated();

   273 		cls = cls->m_pGlobalClassNext;

   274 	}

   276 	SM_ExecuteAllConfigs();

   277 }

   279 bool PlayerManager::IsServerActivated()

   280 {

   281 	return m_FirstPass;

   282 }

   284 bool PlayerManager::CheckSetAdmin(int index, CPlayer *pPlayer, AdminId id)

   285 {

   286 	const char *password = g_Admins.GetAdminPassword(id);

   287 	if (password != NULL)

   288 	{

   289 		if (m_PassInfoVar.size() < 1)

   290 		{

   291 			return false;

   292 		}

   294 		/* Whoa... the user needs a password! */

   295 		const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

   296 		if (!given || strcmp(given, password) != 0)

   297 		{

   298 			return false;

   299 		}

   300 	}

   302 	pPlayer->SetAdminId(id, false);

   304 	return true;

   305 }

   307 bool PlayerManager::CheckSetAdminName(int index, CPlayer *pPlayer, AdminId id)

   308 {

   309 	const char *password = g_Admins.GetAdminPassword(id);

   310 	if (password == NULL)

   311 	{

   312 		return false;

   313 	}

   315 	if (m_PassInfoVar.size() < 1)

   316 	{

   317 		return false;

   318 	}

   320 	/* Whoa... the user needs a password! */

   321 	const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

   322 	if (!given || strcmp(given, password) != 0)

   323 	{

   324 		return false;

   325 	}

   327 	pPlayer->SetAdminId(id, false);

   329 	return true;

   330 }

   332 void PlayerManager::RunAuthChecks()

   333 {

   334 	CPlayer *pPlayer;

   335 	const char *authstr;

   336 	unsigned int removed = 0;

   337 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

   338 	{

   339 		pPlayer = &m_Players[m_AuthQueue[i]];

   340 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);

   341 		if (authstr && authstr[0] != '\0'

   342 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))

   343 		{

   344 			/* Set authorization */

   345 			pPlayer->Authorize(authstr);

   347 			/* Mark as removed from queue */

   348 			unsigned int client = m_AuthQueue[i];

   349 			m_AuthQueue[i] = 0;

   350 			removed++;

   352 			/* Send to extensions */

   353 			List<IClientListener *>::iterator iter;

   354 			IClientListener *pListener;

   355 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   356 			{

   357 				pListener = (*iter);

   358 				pListener->OnClientAuthorized(client, authstr);

   359 				if (!pPlayer->IsConnected())

   360 				{

   361 					break;

   362 				}

   363 			}

   365 			/* Send to plugins if player is still connected */

   366 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())

   367 			{

   368 				/* :TODO: handle the case of a player disconnecting in the middle */

   369 				m_clauth->PushCell(client);

   370 				m_clauth->PushString(authstr);

   371 				m_clauth->Execute(NULL);

   372 			}

   374 			if (pPlayer->IsConnected())

   375 			{

   376 				pPlayer->Authorize_Post();

   377 			}

   378 		}

   379 	}

   381 	/* Clean up the queue */

   382 	if (removed)

   383 	{

   384 		/* We don't have to compact the list if it's empty */

   385 		if (removed != m_AuthQueue[0])

   386 		{

   387 			unsigned int diff = 0;

   388 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

   389 			{

   390 				/* If this member is removed... */

   391 				if (m_AuthQueue[i] == 0)

   392 				{

   393 					/* Increase the differential */

   394 					diff++;

   395 				} else {

   396 					/* diff cannot increase faster than i+1 */

   397 					assert(i > diff);

   398 					assert(i - diff >= 1);

   399 					/* move this index down */

   400 					m_AuthQueue[i - diff] = m_AuthQueue[i];

   401 				}

   402 			}

   403 			m_AuthQueue[0] -= removed;

   404 		} else {

   405 			m_AuthQueue[0] = 0;

   406 		}

   407 	}

   408 }

   410 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

   411 {

   412 	int client = IndexOfEdict(pEntity);

   413 	CPlayer *pPlayer = &m_Players[client];

   415 	List<IClientListener *>::iterator iter;

   416 	IClientListener *pListener = NULL;

   417 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   418 	{

   419 		pListener = (*iter);

   420 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))

   421 		{

   422 			return false;

   423 		}

   424 	}

   426 	cell_t res = 1;

   428 	pPlayer->Initialize(pszName, pszAddress, pEntity);

   429 	m_clconnect->PushCell(client);

   430 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);

   431 	m_clconnect->PushCell(maxrejectlen);

   432 	m_clconnect->Execute(&res);

   434 	if (res)

   435 	{

   436 		if (!pPlayer->IsAuthorized())

   437 		{

   438 			m_AuthQueue[++m_AuthQueue[0]] = client;

   439 		}

   441 		m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;

   442 	}

   443 	else

   444 	{

   445 		if (!pPlayer->IsFakeClient())

   446 		{

   447 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   448 		}

   449 	}

   451 	return true;

   452 }

   454 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

   455 {

   456 	int client = IndexOfEdict(pEntity);

   457 	bool orig_value = META_RESULT_ORIG_RET(bool);

   458 	CPlayer *pPlayer = &m_Players[client];

   460 	if (orig_value)

   461 	{

   462 		List<IClientListener *>::iterator iter;

   463 		IClientListener *pListener = NULL;

   464 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   465 		{

   466 			pListener = (*iter);

   467 			pListener->OnClientConnected(client);

   468 			if (!pPlayer->IsConnected())

   469 			{

   470 				break;

   471 			}

   472 		}

   474 		if (!pPlayer->IsFakeClient()

   475 			&& m_bIsListenServer

   476 			&& strncmp(pszAddress, "127.0.0.1", 9) == 0)

   477 		{

   478 			m_ListenClient = client;

   479 		}

   481 		cell_t res;

   482 		OnClientConnected->PushCell(client);

   483 		OnClientConnected->Execute(&res, NULL);

   484 	}

   485 	else

   486 	{

   487 		InvalidatePlayer(pPlayer);

   488 	}

   490 	return true;

   491 }

   493 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)

   494 {

   495 	cell_t res;

   496 	int client = IndexOfEdict(pEntity);

   497 	CPlayer *pPlayer = &m_Players[client];

   499 	/* If they're not connected, they're a bot */

   500 	if (!pPlayer->IsConnected())

   501 	{

   502 		/* Run manual connection routines */

   503 		char error[255];

   504 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);

   505 		pPlayer->Authorize(authid);

   506 		pPlayer->m_bFakeClient = true;

   507 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))

   508 		{

   509 			/* :TODO: kick the bot if it's rejected */

   510 			return;

   511 		}

   512 		List<IClientListener *>::iterator iter;

   513 		IClientListener *pListener = NULL;

   514 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   515 		{

   516 			pListener = (*iter);

   517 			pListener->OnClientConnected(client);

   518 			/* See if bot was kicked */

   519 			if (!pPlayer->IsConnected())

   520 			{

   521 				return;

   522 			}

   523 		}

   524 		/* Now do authorization */

   525 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   526 		{

   527 			pListener = (*iter);

   528 			pListener->OnClientAuthorized(client, authid);

   529 		}

   530 		/* Finally, tell plugins */

   531 		if (m_clauth->GetFunctionCount())

   532 		{

   533 			m_clauth->PushCell(client);

   534 			m_clauth->PushString(authid);

   535 			m_clauth->Execute(NULL);

   536 		}

   537 		pPlayer->Authorize_Post();

   538 	}

   540 	if (playerinfo)

   541 	{

   542 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);

   543 	}

   545 	/* Get the client's language */

   546 	if (m_QueryLang)

   547 	{

   548 		const char *name;

   549 		if (!pPlayer->IsFakeClient() && (name=engine->GetClientConVarValue(client, "cl_language")))

   550 		{

   551 			unsigned int langid;

   552 			pPlayer->m_LangId = (g_Translator.GetLanguageByName(name, &langid)) ? langid : g_Translator.GetServerLanguage();

   553 		} else {

   554 			pPlayer->m_LangId = g_Translator.GetServerLanguage();

   555 		}

   556 	}

   558 	pPlayer->Connect();

   559 	m_PlayerCount++;

   561 	List<IClientListener *>::iterator iter;

   562 	IClientListener *pListener = NULL;

   563 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   564 	{

   565 		pListener = (*iter);

   566 		pListener->OnClientPutInServer(client);

   567 	}

   569 	m_clputinserver->PushCell(client);

   570 	m_clputinserver->Execute(&res, NULL);

   572 	if (pPlayer->IsAuthorized())

   573 	{

   574 		pPlayer->DoPostConnectAuthorization();

   575 	}

   576 }

   578 void PlayerManager::OnSourceModLevelEnd()

   579 {

   580 	/* Disconnect all bots still in game */

   581 	for (int i=1; i<=m_maxClients; i++)

   582 	{

   583 		if (m_Players[i].IsConnected())

   584 		{

   585 			OnClientDisconnect(m_Players[i].GetEdict());

   586 		}

   587 	}

   588 	m_PlayerCount = 0;

   589 }

   591 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   592 {

   593 	cell_t res;

   594 	int client = IndexOfEdict(pEntity);

   595 	CPlayer *pPlayer = &m_Players[client];

   597 	if (pPlayer->IsConnected())

   598 	{

   599 		m_cldisconnect->PushCell(client);

   600 		m_cldisconnect->Execute(&res, NULL);

   601 	}

   602 	else

   603 	{

   604 		/* We don't care, prevent a double call */

   605 		return;

   606 	}

   608 	if (pPlayer->WasCountedAsInGame())

   609 	{

   610 		m_PlayerCount--;

   611 	}

   613 	List<IClientListener *>::iterator iter;

   614 	IClientListener *pListener = NULL;

   615 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   616 	{

   617 		pListener = (*iter);

   618 		pListener->OnClientDisconnecting(client);

   619 	}

   621 	InvalidatePlayer(pPlayer);

   623 	if (m_ListenClient == client)

   624 	{

   625 		m_ListenClient = 0;

   626 	}

   627 }

   629 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   630 {

   631 	cell_t res;

   632 	int client = IndexOfEdict(pEntity);

   634 	m_cldisconnect_post->PushCell(client);

   635 	m_cldisconnect_post->Execute(&res, NULL);

   637 	List<IClientListener *>::iterator iter;

   638 	IClientListener *pListener = NULL;

   639 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

   640 	{

   641 		pListener = (*iter);

   642 		pListener->OnClientDisconnected(client);

   643 	}

   644 }

   646 void ClientConsolePrint(edict_t *e, const char *fmt, ...)

   647 {

   648 	char buffer[512];

   650 	va_list ap;

   651 	va_start(ap, fmt);

   652 	size_t len = vsnprintf(buffer, sizeof(buffer), fmt, ap);

   653 	va_end(ap);

   655 	if (len >= sizeof(buffer) - 1)

   656 	{

   657 		buffer[sizeof(buffer) - 2] = '\n';

   658 		buffer[sizeof(buffer) - 1] = '\0';

   659 	} else {

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

   661 		buffer[len] = '\0';

   662 	}

   664 	engine->ClientPrintf(e, buffer);

   665 }

   667 #if SOURCE_ENGINE >= SE_ORANGEBOX

   668 void PlayerManager::OnClientCommand(edict_t *pEntity, const CCommand &args)

   669 {

   670 #else

   671 void PlayerManager::OnClientCommand(edict_t *pEntity)

   672 {

   673 	CCommand args;

   674 #endif

   675 	int client = IndexOfEdict(pEntity);

   676 	cell_t res = Pl_Continue;

   677 	CPlayer *pPlayer = &m_Players[client];

   679 	if (!pPlayer->IsConnected())

   680 	{

   681 		return;

   682 	}

   684 	if (strcmp(args.Arg(0), "sm") == 0)

   685 	{

   686 		if (args.ArgC() > 1 && strcmp(args.Arg(1), "plugins") == 0)

   687 		{

   688 			g_PluginSys.ListPluginsToClient(pPlayer, args);

   689 			RETURN_META(MRES_SUPERCEDE);

   690 		}

   691 		else if (args.ArgC() > 1 && strcmp(args.Arg(1), "credits") == 0)

   692 		{

   693 			ClientConsolePrint(pEntity,

   694 				"SourceMod would not be possible without:");

   695 			ClientConsolePrint(pEntity,

   696 				" David \"BAILOPAN\" Anderson, Borja \"faluco\" Ferrer");

   697 			ClientConsolePrint(pEntity,

   698 				" Scott \"DS\" Ehlert, Matt \"pRED\" Woodrow");

   699 			ClientConsolePrint(pEntity,

   700 				" Michael \"ferret\" McKoy, Pavol \"PM OnoTo\" Marko");

   701 			ClientConsolePrint(pEntity,

   702 				"SourceMod is open source under the GNU General Public License.");

   703 			RETURN_META(MRES_SUPERCEDE);

   704 		}

   706 		ClientConsolePrint(pEntity,

   707 			"SourceMod %s, by AlliedModders LLC", SM_FULL_VERSION);

   708 		ClientConsolePrint(pEntity,

   709 			"To see running plugins, type \"sm plugins\"");

   710 		ClientConsolePrint(pEntity,

   711 			"To see credits, type \"sm credits\"");

   712 		ClientConsolePrint(pEntity,

   713 			"Visit http://www.sourcemod.net/");

   714 		RETURN_META(MRES_SUPERCEDE);

   715 	}

   717 	g_HL2.PushCommandStack(&args);

   719 	int argcount = args.ArgC() - 1;

   720 	const char *cmd = g_HL2.CurrentCommandName();

   722 	bool result = g_ValveMenuStyle.OnClientCommand(client, cmd, args);

   723 	if (result)

   724 	{

   725 		res = Pl_Handled;

   726 	} else {

   727 		result = g_RadioMenuStyle.OnClientCommand(client, cmd, args);

   728 		if (result)

   729 		{

   730 			res = Pl_Handled;

   731 		}

   732 	}

   734 	if (g_ConsoleDetours.IsEnabled())

   735 	{

   736 		cell_t res2 = g_ConsoleDetours.InternalDispatch(client, args);

   737 		if (res2 >= Pl_Stop)

   738 		{

   739 			g_HL2.PopCommandStack();

   740 			RETURN_META(MRES_SUPERCEDE);

   741 		}

   742 		else if (res2 > res)

   743 		{

   744 			res = res2;

   745 		}

   746 	}

   748 	cell_t res2 = Pl_Continue;

   749 	if (pPlayer->IsInGame())

   750 	{

   751 		m_clcommand->PushCell(client);

   752 		m_clcommand->PushCell(argcount);

   753 		m_clcommand->Execute(&res2, NULL);

   754 	}

   756 	if (res2 > res)

   757 	{

   758 		res = res2;

   759 	}

   761 	if (res >= Pl_Stop)

   762 	{

   763 		g_HL2.PopCommandStack();

   764 		RETURN_META(MRES_SUPERCEDE);

   765 	}

   767 	res = g_ConCmds.DispatchClientCommand(client, cmd, argcount, (ResultType)res);

   769 	g_HL2.PopCommandStack();

   771 	if (res >= Pl_Handled)

   772 	{

   773 		RETURN_META(MRES_SUPERCEDE);

   774 	}

   775 }

   777 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   778 {

   779 	cell_t res;

   780 	int client = IndexOfEdict(pEntity);

   781 	CPlayer *pPlayer = &m_Players[client];

   783 	if (!pPlayer->IsConnected())

   784 	{

   785 		return;

   786 	}

   788 	m_clinfochanged->PushCell(client);

   789 	m_clinfochanged->Execute(&res, NULL);

   791 	if (pPlayer->IsFakeClient())

   792 	{

   793 		return;

   794 	}

   796 	IPlayerInfo *info = pPlayer->GetPlayerInfo();

   797 	const char *new_name = info ? info->GetName() : engine->GetClientConVarValue(client, "name");

   798 	const char *old_name = pPlayer->m_Name.c_str();

   800 	if (strcmp(old_name, new_name) != 0)

   801 	{

   802 		AdminId id = g_Admins.FindAdminByIdentity("name", new_name);

   803 		if (id != INVALID_ADMIN_ID && pPlayer->GetAdminId() != id)

   804 		{

   805 			if (!CheckSetAdminName(client, pPlayer, id))

   806 			{

   807 				pPlayer->Kick("Your name is reserved by SourceMod; set your password to use it.");

   808 				RETURN_META(MRES_IGNORED);

   809 			}

   810 		} else if ((id = g_Admins.FindAdminByIdentity("name", old_name)) != INVALID_ADMIN_ID) {

   811 			if (id == pPlayer->GetAdminId())

   812 			{

   813 				/* This player is changing their name; force them to drop admin privileges! */

   814 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   815 			}

   816 		}

   817 		pPlayer->SetName(new_name);

   818 	}

   820 	if (m_PassInfoVar.size() > 0)

   821 	{

   822 		/* Try for a password change */

   823 		const char *old_pass = pPlayer->m_LastPassword.c_str();

   824 		const char *new_pass = engine->GetClientConVarValue(client, m_PassInfoVar.c_str());

   825 		if (strcmp(old_pass, new_pass) != 0)

   826 		{

   827 			pPlayer->m_LastPassword.assign(new_pass);

   828 			if (pPlayer->IsInGame() && pPlayer->IsAuthorized())

   829 			{

   830 				/* If there is already an admin id assigned, this will just bail out. */

   831 				pPlayer->DoBasicAdminChecks();

   832 			}

   833 		}

   834 	}

   835 }

   837 int PlayerManager::GetMaxClients()

   838 {

   839 	return m_maxClients;

   840 }

   842 CPlayer *PlayerManager::GetPlayerByIndex(int client) const

   843 {

   844 	if (client > m_maxClients || client < 1)

   845 	{

   846 		return NULL;

   847 	}

   848 	return &m_Players[client];

   849 }

   851 int PlayerManager::GetNumPlayers()

   852 {

   853 	return m_PlayerCount;

   854 }

   856 int PlayerManager::GetClientOfUserId(int userid)

   857 {

   858 	if (userid < 0 || userid > USHRT_MAX)

   859 	{

   860 		return 0;

   861 	}

   863 	int client = m_UserIdLookUp[userid];

   865 	/* Verify the userid.  The cache can get messed up with older

   866 	 * Valve engines.  :TODO: If this gets fixed, do an old engine

   867 	 * check before invoking this backwards compat code.

   868 	 */

   869 	if (client)

   870 	{

   871 		CPlayer *player = GetPlayerByIndex(client);

   872 		if (player && player->IsConnected())

   873 		{

   874 			int realUserId = engine->GetPlayerUserId(player->GetEdict());

   875 			if (realUserId == userid)

   876 			{

   877 				return client;

   878 			}

   879 		}

   880 	}

   882 	/* If we can't verify the userid, we have to do a manual loop */

   883 	CPlayer *player;

   884 	for (int i = 1; i <= m_maxClients; i++)

   885 	{

   886 		player = GetPlayerByIndex(i);

   887 		if (!player || !player->IsConnected())

   888 		{

   889 			continue;

   890 		}

   891 		if (engine->GetPlayerUserId(player->GetEdict()) == userid)

   892 		{

   893 			m_UserIdLookUp[userid] = i;

   894 			return i;

   895 		}

   896 	}

   898 	return 0;

   899 }

   901 void PlayerManager::AddClientListener(IClientListener *listener)

   902 {

   903 	m_hooks.push_back(listener);

   904 }

   906 void PlayerManager::RemoveClientListener(IClientListener *listener)

   907 {

   908 	m_hooks.remove(listener);

   909 }

   911 IGamePlayer *PlayerManager::GetGamePlayer(edict_t *pEdict)

   912 {

   913 	int index = IndexOfEdict(pEdict);

   914 	return GetGamePlayer(index);

   915 }

   917 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   918 {

   919 	return GetPlayerByIndex(client);

   920 }

   922 void PlayerManager::ClearAdminId(AdminId id)

   923 {

   924 	for (int i=1; i<=m_maxClients; i++)

   925 	{

   926 		if (m_Players[i].m_Admin == id)

   927 		{

   928 			m_Players[i].DumpAdmin(true);

   929 		}

   930 	}

   931 }

   933 void PlayerManager::ClearAllAdmins()

   934 {

   935 	for (int i=1; i<=m_maxClients; i++)

   936 	{

   937 		m_Players[i].DumpAdmin(true);

   938 	}

   939 }

   941 const char *PlayerManager::GetPassInfoVar()

   942 {

   943 	return m_PassInfoVar.c_str();

   944 }

   946 void PlayerManager::RecheckAnyAdmins()

   947 {

   948 	for (int i=1; i<=m_maxClients; i++)

   949 	{

   950 		if (m_Players[i].IsInGame() && m_Players[i].IsAuthorized())

   951 		{

   952 			m_Players[i].DoBasicAdminChecks();

   953 		}

   954 	}

   955 }

   957 unsigned int PlayerManager::GetReplyTo()

   958 {

   959 	return g_ChatTriggers.GetReplyTo();

   960 }

   962 unsigned int PlayerManager::SetReplyTo(unsigned int reply)

   963 {

   964 	return g_ChatTriggers.SetReplyTo(reply);

   965 }

   967 int PlayerManager::FilterCommandTarget(IGamePlayer *pAdmin, IGamePlayer *pTarget, int flags)

   968 {

   969 	return InternalFilterCommandTarget((CPlayer *)pAdmin, (CPlayer *)pTarget, flags);

   970 }

   972 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   973 {

   974 	target_processors.push_back(pHandler);

   975 }

   977 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   978 {

   979 	target_processors.remove(pHandler);

   980 }

   982 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   983 {

   984 	/**

   985 	* Remove client from auth queue if necessary

   986 	*/

   987 	if (!pPlayer->IsAuthorized())

   988 	{

   989 		for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

   990 		{

   991 			if (m_AuthQueue[i] == (unsigned)pPlayer->m_iIndex)

   992 			{

   993 				/* Move everything ahead of us back by one */

   994 				for (unsigned int j=i+1; j<=m_AuthQueue[0]; j++)

   995 				{

   996 					m_AuthQueue[j-1] = m_AuthQueue[j];

   997 				}

   998 				/* Remove us and break */

   999 				m_AuthQueue[0]--;

  1000 				break;

  1001 			}

  1002 		}

  1003 	}

  1005 	m_UserIdLookUp[engine->GetPlayerUserId(pPlayer->m_pEdict)] = 0;

  1006 	pPlayer->Disconnect();

  1007 }

  1009 int PlayerManager::InternalFilterCommandTarget(CPlayer *pAdmin, CPlayer *pTarget, int flags)

  1010 {

  1011 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

  1012 		&& !pTarget->IsConnected())

  1013 	{

  1014 		return COMMAND_TARGET_NONE;

  1015 	}

  1016 	else if ((flags & COMMAND_FILTER_CONNECTED) != COMMAND_FILTER_CONNECTED &&

  1017 		!pTarget->IsInGame())

  1018 	{

  1019 		return COMMAND_TARGET_NOT_IN_GAME;

  1020 	}

  1022 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

  1023 		&& pTarget->IsFakeClient())

  1024 	{

  1025 		return COMMAND_TARGET_NOT_HUMAN;

  1026 	}

  1028 	if (pAdmin != NULL)

  1029 	{

  1030 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

  1031 			&& !g_Admins.CanAdminTarget(pAdmin->GetAdminId(), pTarget->GetAdminId()))

  1032 		{

  1033 			return COMMAND_TARGET_IMMUNE;

  1034 		}

  1035 	}

  1037 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

  1038 		&& pTarget->GetLifeState() != PLAYER_LIFE_ALIVE)

  1039 	{

  1040 		return COMMAND_TARGET_NOT_ALIVE;

  1041 	}

  1043 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

  1044 		&& pTarget->GetLifeState() != PLAYER_LIFE_DEAD)

  1045 	{

  1046 		return COMMAND_TARGET_NOT_DEAD;

  1047 	}

  1049 	return COMMAND_TARGET_VALID;

  1050 }

  1052 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

  1053 {

  1054 	CPlayer *pTarget, *pAdmin;

  1055 	int max_clients, total = 0;

  1057 	max_clients = GetMaxClients();

  1059 	if (info->max_targets < 1)

  1060 	{

  1061 		info->reason = COMMAND_TARGET_NONE;

  1062 		info->num_targets = 0;

  1063 	}

  1065 	if (info->admin == 0)

  1066 	{

  1067 		pAdmin = NULL;

  1068 	}

  1069 	else

  1070 	{

  1071 		pAdmin = GetPlayerByIndex(info->admin);

  1072 	}

  1074 	if (info->pattern[0] == '#')

  1075 	{

  1076 		int userid = atoi(&info->pattern[1]);

  1077 		int client = GetClientOfUserId(userid);

  1079 		/* See if a valid userid matched */

  1080 		if (client > 0)

  1081 		{

  1082 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1083 			if (pTarget != NULL)

  1084 			{

  1085 				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags)) == COMMAND_TARGET_VALID)

  1086 				{

  1087 					info->targets[0] = client;

  1088 					info->num_targets = 1;

  1089 					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1090 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1091 				}

  1092 				else

  1093 				{

  1094 					info->num_targets = 0;

  1095 				}

  1096 				return;

  1097 			}

  1098 		}

  1100 		/* Do we need to look for a steam id? */

  1101 		if (strncmp(&info->pattern[1], "STEAM_", 6) == 0)

  1102 		{

  1103 			size_t p, len;

  1104 			char new_pattern[256];

  1106 			strcpy(new_pattern, "STEAM_");

  1107 			len = strlen(&info->pattern[7]);

  1108 			for (p = 0; p < len; p++)

  1109 			{

  1110 				new_pattern[6 + p] = info->pattern[7 + p];

  1111 				if (new_pattern[6 + p] == '_')

  1112 				{

  1113 					new_pattern[6 + p] = ':';

  1114 				}

  1115 			}

  1116 			new_pattern[6 + p] = '\0';

  1118 			for (int i = 1; i <= max_clients; i++)

  1119 			{

  1120 				if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1121 				{

  1122 					continue;

  1123 				}

  1124 				if (!pTarget->IsConnected() || !pTarget->IsAuthorized())

  1125 				{

  1126 					continue;

  1127 				}

  1128 				if (strcmp(pTarget->GetAuthString(), new_pattern) == 0)

  1129 				{

  1130 					if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))

  1131 						== COMMAND_TARGET_VALID)

  1132 					{

  1133 						info->targets[0] = i;

  1134 						info->num_targets = 1;

  1135 						strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1136 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1137 					}

  1138 					else

  1139 					{

  1140 						info->num_targets = 0;

  1141 					}

  1142 					return;

  1143 				}

  1144 			}

  1145 		}

  1147 		/* See if an exact name matches */

  1148 		for (int i = 1; i <= max_clients; i++)

  1149 		{

  1150 			if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1151 			{

  1152 				continue;

  1153 			}

  1154 			if  (!pTarget->IsConnected())

  1155 			{

  1156 				continue;

  1157 			}

  1158 			if (strcmp(pTarget->GetName(), &info->pattern[1]) == 0)

  1159 			{

  1160 				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))

  1161 					== COMMAND_TARGET_VALID)

  1162 				{

  1163 					info->targets[0] = i;

  1164 					info->num_targets = 1;

  1165 					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);

  1166 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1167 				}

  1168 				else

  1169 				{

  1170 					info->num_targets = 0;

  1171 				}

  1172 				return;

  1173 			}

  1174 		}

  1175 	}

  1177 	if (strcmp(info->pattern, "@me") == 0 && info->admin != 0)

  1178 	{

  1179 		info->reason = FilterCommandTarget(pAdmin, pAdmin, info->flags);

  1180 		if (info->reason == COMMAND_TARGET_VALID)

  1181 		{

  1182 			info->targets[0] = info->admin;

  1183 			info->num_targets = 1;

  1184 			strncopy(info->target_name, pAdmin->GetName(), info->target_name_maxlength);

  1185 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1186 		}

  1187 		else

  1188 		{

  1189 			info->num_targets = 0;

  1190 		}

  1191 		return;

  1192 	}

  1194 	if ((info->flags & COMMAND_FILTER_NO_MULTI) != COMMAND_FILTER_NO_MULTI)

  1195 	{

  1196 		bool is_multi = false;

  1197 		bool bots_only = false;

  1198 		int skip_client = -1;

  1200 		if (strcmp(info->pattern, "@all") == 0)

  1201 		{

  1202 			is_multi = true;

  1203 			strncopy(info->target_name, "all players", info->target_name_maxlength);

  1204 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1205 		}

  1206 		else if (strcmp(info->pattern, "@dead") == 0)

  1207 		{

  1208 			is_multi = true;

  1209 			if ((info->flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE)

  1210 			{

  1211 				info->num_targets = 0;

  1212 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1213 				return;

  1214 			}

  1215 			info->flags |= COMMAND_FILTER_DEAD;

  1216 			strncopy(info->target_name, "all dead players", info->target_name_maxlength);

  1217 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1218 		}

  1219 		else if (strcmp(info->pattern, "@alive") == 0)

  1220 		{

  1221 			is_multi = true;

  1222 			if ((info->flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD)

  1223 			{

  1224 				info->num_targets = 0;

  1225 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1226 				return;

  1227 			}

  1228 			strncopy(info->target_name, "all alive players", info->target_name_maxlength);

  1229 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1230 			info->flags |= COMMAND_FILTER_ALIVE;

  1231 		}

  1232 		else if (strcmp(info->pattern, "@bots") == 0)

  1233 		{

  1234 			is_multi = true;

  1235 			if ((info->flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS)

  1236 			{

  1237 				info->num_targets = 0;

  1238 				info->reason = COMMAND_FILTER_NO_BOTS;

  1239 				return;

  1240 			}

  1241 			strncopy(info->target_name, "all bots", info->target_name_maxlength);

  1242 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1243 			bots_only = true;

  1244 		}

  1245 		else if (strcmp(info->pattern, "@humans") == 0)

  1246 		{

  1247 			is_multi = true;

  1248 			strncopy(info->target_name, "all humans", info->target_name_maxlength);

  1249 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1250 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1251 		}

  1252 		else if (strcmp(info->pattern, "@!me") == 0)

  1253 		{

  1254 			is_multi = true;

  1255 			strncopy(info->target_name, "all players", info->target_name_maxlength);

  1256 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1257 			skip_client = info->admin;

  1258 		}

  1260 		if (is_multi)

  1261 		{

  1262 			for (int i = 1; i <= max_clients && total < info->max_targets; i++)

  1263 			{

  1264 				if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1265 				{

  1266 					continue;

  1267 				}

  1268 				if (FilterCommandTarget(pAdmin, pTarget, info->flags) > 0)

  1269 				{

  1270 					if ((!bots_only || pTarget->IsFakeClient())

  1271 						&& skip_client != i)

  1272 					{

  1273 						info->targets[total++] = i;

  1274 					}

  1275 				}

  1276 			}

  1278 			info->num_targets = total;

  1279 			info->reason = (info->num_targets) ? COMMAND_TARGET_VALID : COMMAND_TARGET_EMPTY_FILTER;

  1280 			return;

  1281 		}

  1282 	}

  1284 	List<ICommandTargetProcessor *>::iterator iter;

  1285 	for (iter = target_processors.begin(); iter != target_processors.end(); iter++)

  1286 	{

  1287 		ICommandTargetProcessor *pProcessor = (*iter);

  1288 		if (pProcessor->ProcessCommandTarget(info))

  1289 		{

  1290 			return;

  1291 		}

  1292 	}

  1294 	/* Check partial names */

  1295 	int found_client = 0;

  1296 	CPlayer *pFoundClient = NULL;

  1297 	for (int i = 1; i <= max_clients; i++)

  1298 	{

  1299 		if ((pTarget = GetPlayerByIndex(i)) == NULL)

  1300 		{

  1301 			continue;

  1302 		}

  1304 		if (logicore.stristr(pTarget->GetName(), info->pattern) != NULL)

  1305 		{

  1306 			if (found_client)

  1307 			{

  1308 				info->num_targets = 0;

  1309 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1310 				return;

  1311 			}

  1312 			else

  1313 			{

  1314 				found_client = i;

  1315 				pFoundClient = pTarget;

  1316 			}

  1317 		}

  1318 	}

  1320 	if (found_client)

  1321 	{

  1322 		if ((info->reason = FilterCommandTarget(pAdmin, pFoundClient, info->flags))

  1323 			== COMMAND_TARGET_VALID)

  1324 		{

  1325 			info->targets[0] = found_client;

  1326 			info->num_targets = 1;

  1327 			strncopy(info->target_name, pFoundClient->GetName(), info->target_name_maxlength);

  1328 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1329 		}

  1330 		else

  1331 		{

  1332 			info->num_targets = 0;

  1333 		}

  1334 	}

  1335 	else

  1336 	{

  1337 		info->num_targets = 0;

  1338 		info->reason = COMMAND_TARGET_NONE;

  1339 	}

  1340 }

  1342 void PlayerManager::OnConVarChanged( ConVar *pConVar, const char *oldValue, float flOldValue )

  1343 {

  1344 	if (pConVar->GetBool() && !atoi(oldValue))

  1345 	{

  1346 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1347 	}

  1348 	else

  1349 	{

  1350 		MaxPlayersChanged();

  1351 	}

  1352 }

  1354 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1355 {

  1356 	m_maxClients = newvalue;

  1357 }

  1359 void PlayerManager::MaxPlayersChanged( int newvalue /*= -1*/ )

  1360 {

  1361 	if (!m_FirstPass)

  1362 	{

  1363 		return;

  1364 	}

  1366 	if (newvalue == -1)

  1367 	{

  1368 		newvalue = gpGlobals->maxClients;

  1369 	}

  1371 	if (newvalue == MaxClients())

  1372 	{

  1373 		return;

  1374 	}

  1376 	/* Notify the rest of core */

  1377 	SMGlobalClass *pBase = SMGlobalClass::head;

  1378 	while (pBase)

  1379 	{

  1380 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1381 		pBase = pBase->m_pGlobalClassNext;

  1382 	}

  1384 	/* Notify Extensions */

  1385 	List<IClientListener *>::iterator iter;

  1386 	IClientListener *pListener = NULL;

  1387 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

  1388 	{

  1389 		pListener = (*iter);

  1390 		if (pListener->GetClientListenerVersion() >= 8)

  1391 		{

  1392 			pListener->OnMaxPlayersChanged(newvalue);

  1393 		}

  1394 	}

  1395 }

  1397 int PlayerManager::GetClientFromSerial(unsigned int serial)

  1398 {

  1399 	serial_t s;

  1400 	s.value = serial;

  1402 	int client = s.bits.index;

  1404 	IGamePlayer *pPlayer = GetGamePlayer(client);

  1406 	if (!pPlayer)

  1407 	{

  1408 		return 0;

  1409 	}

  1411 	if (serial == pPlayer->GetSerial())

  1412 	{

  1413 		return client;

  1414 	}

  1416 	return 0;

  1417 }

  1419 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1420 void CmdMaxplayersCallback(const CCommand &command)

  1421 {

  1422 #else

  1423 void CmdMaxplayersCallback()

  1424 {

  1425 #endif

  1427 	g_Players.MaxPlayersChanged();

  1428 }

  1431 /*******************

  1432  *** PLAYER CODE ***

  1433  *******************/

  1435 CPlayer::CPlayer()

  1436 {

  1437 	m_IsConnected = false;

  1438 	m_IsInGame = false;

  1439 	m_IsAuthorized = false;

  1440 	m_pEdict = NULL;

  1441 	m_Admin = INVALID_ADMIN_ID;

  1442 	m_TempAdmin = false;

  1443 	m_Info = NULL;

  1444 	m_bAdminCheckSignalled = false;

  1445 	m_UserId = -1;

  1446 	m_bIsInKickQueue = false;

  1447 	m_LastPassword.clear();

  1448 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1449 	m_bFakeClient = false;

  1450 }

  1452 void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)

  1453 {

  1454 	m_IsConnected = true;

  1455 	m_Name.assign(name);

  1456 	m_Ip.assign(ip);

  1457 	m_pEdict = pEntity;

  1458 	m_iIndex = IndexOfEdict(pEntity);

  1459 	m_LangId = g_Translator.GetServerLanguage();

  1461 	m_Serial.bits.index = m_iIndex;

  1462 	m_Serial.bits.serial = g_PlayerSerialCount++;

  1464 	char ip2[24], *ptr;

  1465 	strncopy(ip2, ip, sizeof(ip2));

  1466 	if ((ptr = strchr(ip2, ':')) != NULL)

  1467 	{

  1468 		*ptr = '\0';

  1469 	}

  1470 	m_IpNoPort.assign(ip2);

  1471 }

  1473 void CPlayer::Connect()

  1474 {

  1475 	if (m_IsInGame)

  1476 	{

  1477 		return;

  1478 	}

  1480 	m_IsInGame = true;

  1482 	const char *var = g_Players.GetPassInfoVar();

  1483 	int client = IndexOfEdict(m_pEdict);

  1484 	if (var[0] != '\0')

  1485 	{

  1486 		const char *pass = engine->GetClientConVarValue(client, var);

  1487 		m_LastPassword.assign(pass ? pass : "");

  1488 	}

  1489 	else

  1490 	{

  1491 		m_LastPassword.assign("");

  1492 	}

  1493 }

  1495 void CPlayer::Authorize(const char *steamid)

  1496 {

  1497 	if (m_IsAuthorized)

  1498 	{

  1499 		return;

  1500 	}

  1502 	m_IsAuthorized = true;

  1503 	m_AuthID.assign(steamid);

  1504 }

  1506 void CPlayer::Disconnect()

  1507 {

  1508 	DumpAdmin(false);

  1509 	m_IsConnected = false;

  1510 	m_IsInGame = false;

  1511 	m_IsAuthorized = false;

  1512 	m_Name.clear();

  1513 	m_Ip.clear();

  1514 	m_AuthID.clear();

  1515 	m_pEdict = NULL;

  1516 	m_Info = NULL;

  1517 	m_bAdminCheckSignalled = false;

  1518 	m_UserId = -1;

  1519 	m_bIsInKickQueue = false;

  1520 	m_bFakeClient = false;

  1521 }

  1523 void CPlayer::SetName(const char *name)

  1524 {

  1525 	m_Name.assign(name);

  1526 }

  1528 const char *CPlayer::GetName()

  1529 {

  1530 	if (m_Info && m_pEdict->GetUnknown())

  1531 	{

  1532 		return m_Info->GetName();

  1533 	}

  1535 	return m_Name.c_str();

  1536 }

  1538 const char *CPlayer::GetIPAddress()

  1539 {

  1540 	return m_Ip.c_str();

  1541 }

  1543 const char *CPlayer::GetAuthString()

  1544 {

  1545 	return m_AuthID.c_str();

  1546 }

  1548 edict_t *CPlayer::GetEdict()

  1549 {

  1550 	return m_pEdict;

  1551 }

  1553 bool CPlayer::IsInGame()

  1554 {

  1555 	return m_IsInGame && (m_pEdict->GetUnknown() != NULL);

  1556 }

  1558 bool CPlayer::WasCountedAsInGame()

  1559 {

  1560 	return m_IsInGame;

  1561 }

  1563 bool CPlayer::IsConnected()

  1564 {

  1565 	return m_IsConnected;

  1566 }

  1568 bool CPlayer::IsAuthorized()

  1569 {

  1570 	return m_IsAuthorized;

  1571 }

  1573 IPlayerInfo *CPlayer::GetPlayerInfo()

  1574 {

  1575 	if (m_pEdict->GetUnknown())

  1576 	{

  1577 		return m_Info;

  1578 	}

  1580 	return NULL;

  1581 }

  1583 bool CPlayer::IsFakeClient()

  1584 {

  1585 	return m_bFakeClient;

  1586 }

  1588 void CPlayer::SetAdminId(AdminId id, bool temporary)

  1589 {

  1590 	if (!m_IsConnected)

  1591 	{

  1592 		return;

  1593 	}

  1595 	DumpAdmin(false);

  1597 	m_Admin = id;

  1598 	m_TempAdmin = temporary;

  1599 }

  1601 AdminId CPlayer::GetAdminId()

  1602 {

  1603 	return m_Admin;

  1604 }

  1606 void CPlayer::DumpAdmin(bool deleting)

  1607 {

  1608 	if (m_Admin != INVALID_ADMIN_ID)

  1609 	{

  1610 		if (m_TempAdmin && !deleting)

  1611 		{

  1612 			g_Admins.InvalidateAdmin(m_Admin);

  1613 		}

  1614 		m_Admin = INVALID_ADMIN_ID;

  1615 		m_TempAdmin = false;

  1616 	}

  1617 }

  1619 void CPlayer::Kick(const char *str)

  1620 {

  1621 	MarkAsBeingKicked();

  1622 	INetChannel *pNetChan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(m_iIndex));

  1623 	if (pNetChan == NULL)

  1624 	{

  1625 		/* What does this even mean? Hell if I know. */

  1626 		int userid = GetUserId();

  1627 		if (userid > 0)

  1628 		{

  1629 			char buffer[255];

  1630 			UTIL_Format(buffer, sizeof(buffer), "kickid %d %s\n", userid, str);

  1631 			engine->ServerCommand(buffer);

  1632 		}

  1633 	}

  1634 	else

  1635 	{

  1636 		IClient *pClient = static_cast<IClient *>(pNetChan->GetMsgHandler());

  1637 		pClient->Disconnect("%s", str);

  1638 	}

  1639 }

  1641 void CPlayer::Authorize_Post()

  1642 {

  1643 	if (m_IsInGame)

  1644 	{

  1645 		DoPostConnectAuthorization();

  1646 	}

  1647 }

  1649 void CPlayer::DoPostConnectAuthorization()

  1650 {

  1651 	bool delay = false;

  1653 	List<IClientListener *>::iterator iter;

  1654 	for (iter = g_Players.m_hooks.begin();

  1655 		 iter != g_Players.m_hooks.end();

  1656 		 iter++)

  1657 	{

  1658 		IClientListener *pListener = (*iter);

  1659 #if defined MIN_API_FOR_ADMINCALLS

  1660 		if (pListener->GetClientListenerVersion() < MIN_API_FOR_ADMINCALLS)

  1661 		{

  1662 			continue;

  1663 		}

  1664 #endif

  1665 		if (!pListener->OnClientPreAdminCheck(m_iIndex))

  1666 		{

  1667 			delay = true;

  1668 		}

  1669 	}

  1671 	cell_t result = 0;

  1672 	PreAdminCheck->PushCell(m_iIndex);

  1673 	PreAdminCheck->Execute(&result);

  1675 	/* Defer, for better or worse */

  1676 	if (delay || (ResultType)result >= Pl_Handled)

  1677 	{

  1678 		return;

  1679 	}

  1681 	/* Sanity check */

  1682 	if (!IsConnected())

  1683 	{

  1684 		return;

  1685 	}

  1687 	/* Otherwise, go ahead and do admin checks */

  1688 	DoBasicAdminChecks();

  1690 	/* Send the notification out */

  1691 	NotifyPostAdminChecks();

  1692 }

  1694 bool CPlayer::RunAdminCacheChecks()

  1695 {

  1696 	AdminId old_id = GetAdminId();

  1698 	DoBasicAdminChecks();

  1700 	return (GetAdminId() != old_id);

  1701 }

  1703 void CPlayer::NotifyPostAdminChecks()

  1704 {

  1705 	if (m_bAdminCheckSignalled)

  1706 	{

  1707 		return;

  1708 	}

  1710 	/* Block beforehand so they can't double-call */

  1711 	m_bAdminCheckSignalled = true;

  1713 	List<IClientListener *>::iterator iter;

  1714 	for (iter = g_Players.m_hooks.begin();

  1715 		iter != g_Players.m_hooks.end();

  1716 		iter++)

  1717 	{

  1718 		IClientListener *pListener = (*iter);

  1719 #if defined MIN_API_FOR_ADMINCALLS

  1720 		if (pListener->GetClientListenerVersion() < MIN_API_FOR_ADMINCALLS)

  1721 		{

  1722 			continue;

  1723 		}

  1724 #endif

  1725 		pListener->OnClientPostAdminCheck(m_iIndex);

  1726 	}

  1728 	PostAdminFilter->PushCell(m_iIndex);

  1729 	PostAdminFilter->Execute(NULL);

  1731 	PostAdminCheck->PushCell(m_iIndex);

  1732 	PostAdminCheck->Execute(NULL);

  1733 }

  1735 void CPlayer::DoBasicAdminChecks()

  1736 {

  1737 	if (GetAdminId() != INVALID_ADMIN_ID)

  1738 	{

  1739 		return;

  1740 	}

  1742 	/* First check the name */

  1743 	AdminId id;

  1744 	int client = IndexOfEdict(m_pEdict);

  1746 	if ((id = g_Admins.FindAdminByIdentity("name", GetName())) != INVALID_ADMIN_ID)

  1747 	{

  1748 		if (!g_Players.CheckSetAdminName(client, this, id))

  1749 		{

  1750 			int userid = engine->GetPlayerUserId(m_pEdict);

  1751 			g_Timers.CreateTimer(&s_KickPlayerTimer, 0.1f, (void *)userid, 0);

  1752 		}

  1753 		return;

  1754 	}

  1756 	/* Check IP */

  1757 	if ((id = g_Admins.FindAdminByIdentity("ip", m_IpNoPort.c_str())) != INVALID_ADMIN_ID)

  1758 	{

  1759 		if (g_Players.CheckSetAdmin(client, this, id))

  1760 		{

  1761 			return;

  1762 		}

  1763 	}

  1765 	/* Check steam id */

  1766 	if ((id = g_Admins.FindAdminByIdentity("steam", m_AuthID.c_str())) != INVALID_ADMIN_ID)

  1767 	{

  1768 		if (g_Players.CheckSetAdmin(client, this, id))

  1769 		{

  1770 			return;

  1771 		}

  1772 	}

  1773 }

  1775 unsigned int CPlayer::GetLanguageId()

  1776 {

  1777 	return m_LangId;

  1778 }

  1780 int CPlayer::GetUserId()

  1781 {

  1782 	if (m_UserId == -1)

  1783 	{

  1784 		m_UserId = engine->GetPlayerUserId(GetEdict());

  1785 	}

  1787 	return m_UserId;

  1788 }

  1790 bool CPlayer::IsInKickQueue()

  1791 {

  1792 	return m_bIsInKickQueue;

  1793 }

  1795 void CPlayer::MarkAsBeingKicked()

  1796 {

  1797 	m_bIsInKickQueue = true;

  1798 }

  1800 int CPlayer::GetLifeState()

  1801 {

  1802 	if (lifestate_offset == -1)

  1803 	{

  1804 		if (!g_pGameConf->GetOffset("m_lifeState", &lifestate_offset))

  1805 		{

  1806 			lifestate_offset = -2;

  1807 		}

  1808 	}

  1810 	if (lifestate_offset < 0)

  1811 	{

  1812 		IPlayerInfo *info = GetPlayerInfo();

  1813 		if (info == NULL)

  1814 		{

  1815 			return PLAYER_LIFE_UNKNOWN;

  1816 		}

  1817 		return info->IsDead() ? PLAYER_LIFE_DEAD : PLAYER_LIFE_ALIVE;

  1818 	}

  1820 	if (m_pEdict == NULL)

  1821 	{

  1822 		return PLAYER_LIFE_UNKNOWN;

  1823 	}

  1825 	CBaseEntity *pEntity;

  1826 	IServerUnknown *pUnknown = m_pEdict->GetUnknown();

  1827 	if (pUnknown == NULL || (pEntity = pUnknown->GetBaseEntity()) == NULL)

  1828 	{

  1829 		return PLAYER_LIFE_UNKNOWN;

  1830 	}

  1832 	if (*((uint8_t *)pEntity + lifestate_offset) == LIFE_ALIVE)

  1833 	{

  1834 		return PLAYER_LIFE_ALIVE;

  1835 	}

  1836 	else

  1837 	{

  1838 		return PLAYER_LIFE_DEAD;

  1839 	}

  1840 }

  1842 unsigned int CPlayer::GetSerial()

  1843 {

  1844 	return m_Serial.value;

  1845 }

author	David Anderson <dvander@alliedmods.net>
	Fri May 14 19:28:10 2010 -0700 (2010-05-14)
changeset 3002	409a6de13f09
parent 2961	c3bb13e8760b
child 3004	e3ac0dc6d9a4
permissions	-rw-r--r--