sourcemod-central: core/PlayerManager.cpp@5c995a647735

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2008 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 "sm_version.h"

    52 PlayerManager g_Players;

    53 bool g_OnMapStarted = false;

    54 IForward *PreAdminCheck = NULL;

    55 IForward *PostAdminCheck = NULL;

    56 IForward *PostAdminFilter = NULL;

    57 IForward *OnClientConnected = NULL;

    58 const unsigned int *g_NumPlayersToAuth = NULL;

    59 int lifestate_offset = -1;

    60 List<ICommandTargetProcessor *> target_processors;

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

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

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

    65 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

    67 #else

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

    69 #endif

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

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

    73 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

    75 #else

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

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

    78 #endif

    80 ConCommand *maxplayersCmd = NULL;

    82 class KickPlayerTimer : public ITimedEvent

    83 {

    84 public:

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

    86 	{

    87 		int userid = (int)pData;

    88 		int client = g_Players.GetClientOfUserId(userid);

    89 		if (client)

    90 		{

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

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

    93 		}

    94 		return Pl_Stop;

    95 	}

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

    97 	{

    98 	}

    99 } s_KickPlayerTimer;

   101 PlayerManager::PlayerManager()

   102 {

   103 	m_AuthQueue = NULL;

   104 	m_FirstPass = false;

   105 	m_maxClients = 0;

   107 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

   109 }

   111 PlayerManager::~PlayerManager()

   112 {

   113 	g_NumPlayersToAuth = NULL;

   115 	delete [] m_AuthQueue;

   116 	delete [] m_UserIdLookUp;

   117 }

   119 void PlayerManager::OnSourceModAllInitialized()

   120 {

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

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

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

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

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

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

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

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

   130 	g_ShareSys.AddInterface(NULL, this);

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

   133 	ParamType p2[] = {Param_Cell};

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

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

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

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

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

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

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

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

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

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

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

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

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

   150 	m_bIsListenServer = !engine->IsDedicatedServer();

   151 	m_ListenClient = 0;

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

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

   156 	if (pCmd != NULL)

   157 	{

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

   159 		maxplayersCmd = pCmd;

   160 	}

   161 }

   163 void PlayerManager::OnSourceModShutdown()

   164 {

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

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

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

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

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

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

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

   173 	/* Release forwards */

   174 	g_Forwards.ReleaseForward(m_clconnect);

   175 	g_Forwards.ReleaseForward(m_clputinserver);

   176 	g_Forwards.ReleaseForward(m_cldisconnect);

   177 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   178 	g_Forwards.ReleaseForward(m_clcommand);

   179 	g_Forwards.ReleaseForward(m_clinfochanged);

   180 	g_Forwards.ReleaseForward(m_clauth);

   181 	g_Forwards.ReleaseForward(m_onActivate);

   182 	g_Forwards.ReleaseForward(m_onActivate2);

   183 	g_Forwards.ReleaseForward(OnClientConnected);

   185 	g_Forwards.ReleaseForward(PreAdminCheck);

   186 	g_Forwards.ReleaseForward(PostAdminCheck);

   187 	g_Forwards.ReleaseForward(PostAdminFilter);

   189 	delete [] m_Players;

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

   193 	if (maxplayersCmd != NULL)

   194 	{

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

   196 	}

   197 }

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

   200 												 const char *value,

   201 												 ConfigSource source,

   202 												 char *error,

   203 												 size_t maxlength)

   204 {

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

   206 	{

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

   208 		{

   209 			m_PassInfoVar.assign(value);

   210 		}

   211 		return ConfigResult_Accept;

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

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

   214 		{

   215 			m_QueryLang = true;

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

   217 			m_QueryLang = false;

   218 		} else {

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

   220 			return ConfigResult_Reject;

   221 		}

   222 		return ConfigResult_Accept;

   223 	}

   224 	return ConfigResult_Ignore;

   225 }

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

   228 {

   229 	if (!m_FirstPass)

   230 	{

   231 		/* Initialize all players */

   232 		m_maxClients = clientMax;

   233 		m_PlayerCount = 0;

   234 		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

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

   236 		m_FirstPass = true;

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

   240 		g_NumPlayersToAuth = &m_AuthQueue[0];

   242 		g_PluginSys.SyncMaxClients(clientMax);

   243 	}

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

   245 	m_onActivate->Execute(NULL);

   246 	m_onActivate2->Execute(NULL);

   248 	List<IClientListener *>::iterator iter;

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

   250 	{

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

   252 		{

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

   254 		}

   255 	}

   257 	g_OnMapStarted = true;

   259 	SMGlobalClass *cls = SMGlobalClass::head;

   260 	while (cls)

   261 	{

   262 		cls->OnSourceModLevelActivated();

   263 		cls = cls->m_pGlobalClassNext;

   264 	}

   266 	SM_ExecuteAllConfigs();

   267 }

   269 bool PlayerManager::IsServerActivated()

   270 {

   271 	return m_FirstPass;

   272 }

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

   275 {

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

   277 	if (password != NULL)

   278 	{

   279 		if (m_PassInfoVar.size() < 1)

   280 		{

   281 			return false;

   282 		}

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

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

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

   287 		{

   288 			return false;

   289 		}

   290 	}

   292 	pPlayer->SetAdminId(id, false);

   294 	return true;

   295 }

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

   298 {

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

   300 	if (password == NULL)

   301 	{

   302 		return false;

   303 	}

   305 	if (m_PassInfoVar.size() < 1)

   306 	{

   307 		return false;

   308 	}

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

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

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

   313 	{

   314 		return false;

   315 	}

   317 	pPlayer->SetAdminId(id, false);

   319 	return true;

   320 }

   322 void PlayerManager::RunAuthChecks()

   323 {

   324 	CPlayer *pPlayer;

   325 	const char *authstr;

   326 	unsigned int removed = 0;

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

   328 	{

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

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

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

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

   333 		{

   334 			/* Set authorization */

   335 			pPlayer->Authorize(authstr);

   337 			/* Mark as removed from queue */

   338 			unsigned int client = m_AuthQueue[i];

   339 			m_AuthQueue[i] = 0;

   340 			removed++;

   342 			/* Send to extensions */

   343 			List<IClientListener *>::iterator iter;

   344 			IClientListener *pListener;

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

   346 			{

   347 				pListener = (*iter);

   348 				pListener->OnClientAuthorized(client, authstr);

   349 				if (!pPlayer->IsConnected())

   350 				{

   351 					break;

   352 				}

   353 			}

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

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

   357 			{

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

   359 				m_clauth->PushCell(client);

   360 				m_clauth->PushString(authstr);

   361 				m_clauth->Execute(NULL);

   362 			}

   364 			if (pPlayer->IsConnected())

   365 			{

   366 				pPlayer->Authorize_Post();

   367 			}

   368 		}

   369 	}

   371 	/* Clean up the queue */

   372 	if (removed)

   373 	{

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

   375 		if (removed != m_AuthQueue[0])

   376 		{

   377 			unsigned int diff = 0;

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

   379 			{

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

   381 				if (m_AuthQueue[i] == 0)

   382 				{

   383 					/* Increase the differential */

   384 					diff++;

   385 				} else {

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

   387 					assert(i > diff);

   388 					assert(i - diff >= 1);

   389 					/* move this index down */

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

   391 				}

   392 			}

   393 			m_AuthQueue[0] -= removed;

   394 		} else {

   395 			m_AuthQueue[0] = 0;

   396 		}

   397 	}

   398 }

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

   401 {

   402 	int client = IndexOfEdict(pEntity);

   403 	CPlayer *pPlayer = &m_Players[client];

   405 	List<IClientListener *>::iterator iter;

   406 	IClientListener *pListener = NULL;

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

   408 	{

   409 		pListener = (*iter);

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

   411 		{

   412 			return false;

   413 		}

   414 	}

   416 	cell_t res = 1;

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

   419 	m_clconnect->PushCell(client);

   420 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);

   421 	m_clconnect->PushCell(maxrejectlen);

   422 	m_clconnect->Execute(&res);

   424 	if (res)

   425 	{

   426 		if (!pPlayer->IsAuthorized())

   427 		{

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

   429 		}

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

   432 	}

   433 	else

   434 	{

   435 		if (!pPlayer->IsFakeClient())

   436 		{

   437 			RETURN_META_VALUE(MRES_SUPERCEDE, false);

   438 		}

   439 	}

   441 	return true;

   442 }

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

   445 {

   446 	int client = IndexOfEdict(pEntity);

   447 	bool orig_value = META_RESULT_ORIG_RET(bool);

   448 	CPlayer *pPlayer = &m_Players[client];

   450 	if (orig_value)

   451 	{

   452 		List<IClientListener *>::iterator iter;

   453 		IClientListener *pListener = NULL;

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

   455 		{

   456 			pListener = (*iter);

   457 			pListener->OnClientConnected(client);

   458 			if (!pPlayer->IsConnected())

   459 			{

   460 				break;

   461 			}

   462 		}

   464 		if (!pPlayer->IsFakeClient()

   465 			&& m_bIsListenServer

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

   467 		{

   468 			m_ListenClient = client;

   469 		}

   471 		cell_t res;

   472 		OnClientConnected->PushCell(client);

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

   474 	}

   475 	else

   476 	{

   477 		InvalidatePlayer(pPlayer);

   478 	}

   480 	return true;

   481 }

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

   484 {

   485 	cell_t res;

   486 	int client = IndexOfEdict(pEntity);

   487 	CPlayer *pPlayer = &m_Players[client];

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

   490 	if (!pPlayer->IsConnected())

   491 	{

   492 		/* Run manual connection routines */

   493 		char error[255];

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

   495 		pPlayer->Authorize(authid);

   496 		pPlayer->m_bFakeClient = true;

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

   498 		{

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

   500 			return;

   501 		}

   502 		List<IClientListener *>::iterator iter;

   503 		IClientListener *pListener = NULL;

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

   505 		{

   506 			pListener = (*iter);

   507 			pListener->OnClientConnected(client);

   508 			/* See if bot was kicked */

   509 			if (!pPlayer->IsConnected())

   510 			{

   511 				return;

   512 			}

   513 		}

   514 		/* Now do authorization */

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

   516 		{

   517 			pListener = (*iter);

   518 			pListener->OnClientAuthorized(client, authid);

   519 		}

   520 		/* Finally, tell plugins */

   521 		if (m_clauth->GetFunctionCount())

   522 		{

   523 			m_clauth->PushCell(client);

   524 			m_clauth->PushString(authid);

   525 			m_clauth->Execute(NULL);

   526 		}

   527 		pPlayer->Authorize_Post();

   528 	}

   530 	if (playerinfo)

   531 	{

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

   533 	}

   535 	/* Get the client's language */

   536 	if (m_QueryLang)

   537 	{

   538 		const char *name;

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

   540 		{

   541 			unsigned int langid;

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

   543 		} else {

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

   545 		}

   546 	}

   548 	pPlayer->Connect();

   549 	m_PlayerCount++;

   551 	List<IClientListener *>::iterator iter;

   552 	IClientListener *pListener = NULL;

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

   554 	{

   555 		pListener = (*iter);

   556 		pListener->OnClientPutInServer(client);

   557 	}

   559 	m_clputinserver->PushCell(client);

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

   562 	if (pPlayer->IsAuthorized())

   563 	{

   564 		pPlayer->DoPostConnectAuthorization();

   565 	}

   566 }

   568 void PlayerManager::OnSourceModLevelEnd()

   569 {

   570 	/* Disconnect all bots still in game */

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

   572 	{

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

   574 		{

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

   576 		}

   577 	}

   578 	m_PlayerCount = 0;

   579 }

   581 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   582 {

   583 	cell_t res;

   584 	int client = IndexOfEdict(pEntity);

   585 	CPlayer *pPlayer = &m_Players[client];

   587 	if (pPlayer->IsConnected())

   588 	{

   589 		m_cldisconnect->PushCell(client);

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

   591 	}

   592 	else

   593 	{

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

   595 		return;

   596 	}

   598 	if (pPlayer->WasCountedAsInGame())

   599 	{

   600 		m_PlayerCount--;

   601 	}

   603 	List<IClientListener *>::iterator iter;

   604 	IClientListener *pListener = NULL;

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

   606 	{

   607 		pListener = (*iter);

   608 		pListener->OnClientDisconnecting(client);

   609 	}

   611 	InvalidatePlayer(pPlayer);

   613 	if (m_ListenClient == client)

   614 	{

   615 		m_ListenClient = 0;

   616 	}

   617 }

   619 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   620 {

   621 	cell_t res;

   622 	int client = IndexOfEdict(pEntity);

   624 	m_cldisconnect_post->PushCell(client);

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

   627 	List<IClientListener *>::iterator iter;

   628 	IClientListener *pListener = NULL;

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

   630 	{

   631 		pListener = (*iter);

   632 		pListener->OnClientDisconnected(client);

   633 	}

   634 }

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

   637 {

   638 	char buffer[512];

   640 	va_list ap;

   641 	va_start(ap, fmt);

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

   643 	va_end(ap);

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

   646 	{

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

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

   649 	} else {

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

   651 		buffer[len] = '\0';

   652 	}

   654 	engine->ClientPrintf(e, buffer);

   655 }

   657 #if SOURCE_ENGINE >= SE_ORANGEBOX

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

   659 {

   660 #else

   661 void PlayerManager::OnClientCommand(edict_t *pEntity)

   662 {

   663 	CCommand args;

   664 #endif

   665 	int client = IndexOfEdict(pEntity);

   666 	cell_t res = Pl_Continue;

   667 	CPlayer *pPlayer = &m_Players[client];

   669 	if (!pPlayer->IsConnected())

   670 	{

   671 		return;

   672 	}

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

   675 	{

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

   677 		{

   678 			g_PluginSys.ListPluginsToClient(pPlayer, args);

   679 			RETURN_META(MRES_SUPERCEDE);

   680 		}

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

   682 		{

   683 			ClientConsolePrint(pEntity,

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

   685 			ClientConsolePrint(pEntity,

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

   687 			ClientConsolePrint(pEntity,

   688 				" Scott \"Damaged Soul\" Ehlert, Matt \"pRED\" Woodrow");

   689 			ClientConsolePrint(pEntity,

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

   691 			ClientConsolePrint(pEntity,

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

   693 			RETURN_META(MRES_SUPERCEDE);

   694 		}

   696 		ClientConsolePrint(pEntity,

   697 			"SourceMod %s, by AlliedModders LLC", SVN_FULL_VERSION);

   698 		ClientConsolePrint(pEntity,

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

   700 		ClientConsolePrint(pEntity,

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

   702 		ClientConsolePrint(pEntity,

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

   704 		RETURN_META(MRES_SUPERCEDE);

   705 	}

   707 	g_HL2.PushCommandStack(&args);

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

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

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

   713 	if (result)

   714 	{

   715 		res = Pl_Handled;

   716 	} else {

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

   718 		if (result)

   719 		{

   720 			res = Pl_Handled;

   721 		}

   722 	}

   724 	cell_t res2 = Pl_Continue;

   725 	m_clcommand->PushCell(client);

   726 	m_clcommand->PushCell(argcount);

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

   729 	if (res2 > res)

   730 	{

   731 		res = res2;

   732 	}

   734 	if (res >= Pl_Stop)

   735 	{

   736 		g_HL2.PopCommandStack();

   737 		RETURN_META(MRES_SUPERCEDE);

   738 	}

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

   742 	g_HL2.PopCommandStack();

   744 	if (res >= Pl_Handled)

   745 	{

   746 		RETURN_META(MRES_SUPERCEDE);

   747 	}

   748 }

   750 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   751 {

   752 	cell_t res;

   753 	int client = IndexOfEdict(pEntity);

   754 	CPlayer *pPlayer = &m_Players[client];

   756 	if (!pPlayer->IsConnected())

   757 	{

   758 		return;

   759 	}

   761 	m_clinfochanged->PushCell(client);

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

   764 	if (pPlayer->IsFakeClient())

   765 	{

   766 		return;

   767 	}

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

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

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

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

   774 	{

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

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

   777 		{

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

   779 			{

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

   781 				RETURN_META(MRES_IGNORED);

   782 			}

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

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

   785 			{

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

   787 				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);

   788 			}

   789 		}

   790 		pPlayer->SetName(new_name);

   791 	}

   793 	if (m_PassInfoVar.size() > 0)

   794 	{

   795 		/* Try for a password change */

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

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

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

   799 		{

   800 			pPlayer->m_LastPassword.assign(new_pass);

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

   802 			{

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

   804 				pPlayer->DoBasicAdminChecks();

   805 			}

   806 		}

   807 	}

   808 }

   810 int PlayerManager::GetMaxClients()

   811 {

   812 	return m_maxClients;

   813 }

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

   816 {

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

   818 	{

   819 		return NULL;

   820 	}

   821 	return &m_Players[client];

   822 }

   824 int PlayerManager::GetNumPlayers()

   825 {

   826 	return m_PlayerCount;

   827 }

   829 int PlayerManager::GetClientOfUserId(int userid)

   830 {

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

   832 	{

   833 		return 0;

   834 	}

   836 	int client = m_UserIdLookUp[userid];

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

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

   840 	 * check before invoking this backwards compat code.

   841 	 */

   842 	if (client)

   843 	{

   844 		CPlayer *player = GetPlayerByIndex(client);

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

   846 		{

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

   848 			if (realUserId == userid)

   849 			{

   850 				return client;

   851 			}

   852 		}

   853 	}

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

   856 	CPlayer *player;

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

   858 	{

   859 		player = GetPlayerByIndex(i);

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

   861 		{

   862 			continue;

   863 		}

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

   865 		{

   866 			m_UserIdLookUp[userid] = i;

   867 			return i;

   868 		}

   869 	}

   871 	return 0;

   872 }

   874 void PlayerManager::AddClientListener(IClientListener *listener)

   875 {

   876 	m_hooks.push_back(listener);

   877 }

   879 void PlayerManager::RemoveClientListener(IClientListener *listener)

   880 {

   881 	m_hooks.remove(listener);

   882 }

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

   885 {

   886 	int index = IndexOfEdict(pEdict);

   887 	return GetGamePlayer(index);

   888 }

   890 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   891 {

   892 	return GetPlayerByIndex(client);

   893 }

   895 void PlayerManager::ClearAdminId(AdminId id)

   896 {

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

   898 	{

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

   900 		{

   901 			m_Players[i].DumpAdmin(true);

   902 		}

   903 	}

   904 }

   906 void PlayerManager::ClearAllAdmins()

   907 {

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

   909 	{

   910 		m_Players[i].DumpAdmin(true);

   911 	}

   912 }

   914 const char *PlayerManager::GetPassInfoVar()

   915 {

   916 	return m_PassInfoVar.c_str();

   917 }

   919 void PlayerManager::RecheckAnyAdmins()

   920 {

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

   922 	{

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

   924 		{

   925 			m_Players[i].DoBasicAdminChecks();

   926 		}

   927 	}

   928 }

   930 unsigned int PlayerManager::GetReplyTo()

   931 {

   932 	return g_ChatTriggers.GetReplyTo();

   933 }

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

   936 {

   937 	return g_ChatTriggers.SetReplyTo(reply);

   938 }

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

   941 {

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

   943 }

   945 void PlayerManager::RegisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   946 {

   947 	target_processors.push_back(pHandler);

   948 }

   950 void PlayerManager::UnregisterCommandTargetProcessor(ICommandTargetProcessor *pHandler)

   951 {

   952 	target_processors.remove(pHandler);

   953 }

   955 void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)

   956 {

   957 	/**

   958 	* Remove client from auth queue if necessary

   959 	*/

   960 	if (!pPlayer->IsAuthorized())

   961 	{

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

   963 		{

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

   965 			{

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

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

   968 				{

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

   970 				}

   971 				/* Remove us and break */

   972 				m_AuthQueue[0]--;

   973 				break;

   974 			}

   975 		}

   976 	}

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

   979 	pPlayer->Disconnect();

   980 }

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

   983 {

   984 	if ((flags & COMMAND_FILTER_CONNECTED) == COMMAND_FILTER_CONNECTED

   985 		&& !pTarget->IsConnected())

   986 	{

   987 		return COMMAND_TARGET_NONE;

   988 	}

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

   990 		!pTarget->IsInGame())

   991 	{

   992 		return COMMAND_TARGET_NOT_IN_GAME;

   993 	}

   995 	if ((flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS

   996 		&& pTarget->IsFakeClient())

   997 	{

   998 		return COMMAND_TARGET_NOT_HUMAN;

   999 	}

  1001 	if (pAdmin != NULL)

  1002 	{

  1003 		if ((flags & COMMAND_FILTER_NO_IMMUNITY) != COMMAND_FILTER_NO_IMMUNITY

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

  1005 		{

  1006 			return COMMAND_TARGET_IMMUNE;

  1007 		}

  1008 	}

  1010 	if ((flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE

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

  1012 	{

  1013 		return COMMAND_TARGET_NOT_ALIVE;

  1014 	}

  1016 	if ((flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD

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

  1018 	{

  1019 		return COMMAND_TARGET_NOT_DEAD;

  1020 	}

  1022 	return COMMAND_TARGET_VALID;

  1023 }

  1025 void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)

  1026 {

  1027 	CPlayer *pTarget, *pAdmin;

  1028 	int max_clients, total = 0;

  1030 	max_clients = GetMaxClients();

  1032 	if (info->max_targets < 1)

  1033 	{

  1034 		info->reason = COMMAND_TARGET_NONE;

  1035 		info->num_targets = 0;

  1036 	}

  1038 	if (info->admin == 0)

  1039 	{

  1040 		pAdmin = NULL;

  1041 	}

  1042 	else

  1043 	{

  1044 		pAdmin = GetPlayerByIndex(info->admin);

  1045 	}

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

  1048 	{

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

  1050 		int client = GetClientOfUserId(userid);

  1052 		/* See if a valid userid matched */

  1053 		if (client > 0)

  1054 		{

  1055 			IGamePlayer *pTarget = GetPlayerByIndex(client);

  1056 			if (pTarget != NULL)

  1057 			{

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

  1059 				{

  1060 					info->targets[0] = client;

  1061 					info->num_targets = 1;

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

  1063 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1064 				}

  1065 				else

  1066 				{

  1067 					info->num_targets = 0;

  1068 				}

  1069 				return;

  1070 			}

  1071 		}

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

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

  1075 		{

  1076 			size_t p, len;

  1077 			char new_pattern[256];

  1079 			strcpy(new_pattern, "STEAM_");

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

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

  1082 			{

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

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

  1085 				{

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

  1087 				}

  1088 			}

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

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

  1092 			{

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

  1094 				{

  1095 					continue;

  1096 				}

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

  1098 				{

  1099 					continue;

  1100 				}

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

  1102 				{

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

  1104 						== COMMAND_TARGET_VALID)

  1105 					{

  1106 						info->targets[0] = i;

  1107 						info->num_targets = 1;

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

  1109 						info->target_name_style = COMMAND_TARGETNAME_RAW;

  1110 					}

  1111 					else

  1112 					{

  1113 						info->num_targets = 0;

  1114 					}

  1115 					return;

  1116 				}

  1117 			}

  1118 		}

  1120 		/* See if an exact name matches */

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

  1122 		{

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

  1124 			{

  1125 				continue;

  1126 			}

  1127 			if  (!pTarget->IsConnected())

  1128 			{

  1129 				continue;

  1130 			}

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

  1132 			{

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

  1134 					== COMMAND_TARGET_VALID)

  1135 				{

  1136 					info->targets[0] = i;

  1137 					info->num_targets = 1;

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

  1139 					info->target_name_style = COMMAND_TARGETNAME_RAW;

  1140 				}

  1141 				else

  1142 				{

  1143 					info->num_targets = 0;

  1144 				}

  1145 				return;

  1146 			}

  1147 		}

  1148 	}

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

  1151 	{

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

  1153 		info->num_targets = 1;

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

  1155 		info->target_name_style = COMMAND_TARGETNAME_RAW;

  1156 		return;

  1157 	}

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

  1160 	{

  1161 		bool is_multi = false;

  1162 		bool bots_only = false;

  1163 		int skip_client = -1;

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

  1166 		{

  1167 			is_multi = true;

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

  1169 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1170 		}

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

  1172 		{

  1173 			is_multi = true;

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

  1175 			{

  1176 				info->num_targets = 0;

  1177 				info->reason = COMMAND_TARGET_NOT_ALIVE;

  1178 				return;

  1179 			}

  1180 			info->flags |= COMMAND_FILTER_DEAD;

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

  1182 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1183 		}

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

  1185 		{

  1186 			is_multi = true;

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

  1188 			{

  1189 				info->num_targets = 0;

  1190 				info->reason = COMMAND_TARGET_NOT_DEAD;

  1191 				return;

  1192 			}

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

  1194 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1195 			info->flags |= COMMAND_FILTER_ALIVE;

  1196 		}

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

  1198 		{

  1199 			is_multi = true;

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

  1201 			{

  1202 				info->num_targets = 0;

  1203 				info->reason = COMMAND_FILTER_NO_BOTS;

  1204 				return;

  1205 			}

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

  1207 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1208 			bots_only = true;

  1209 		}

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

  1211 		{

  1212 			is_multi = true;

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

  1214 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1215 			info->flags |= COMMAND_FILTER_NO_BOTS;

  1216 		}

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

  1218 		{

  1219 			is_multi = true;

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

  1221 			info->target_name_style = COMMAND_TARGETNAME_ML;

  1222 			skip_client = info->admin;

  1223 		}

  1225 		if (is_multi)

  1226 		{

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

  1228 			{

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

  1230 				{

  1231 					continue;

  1232 				}

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

  1234 				{

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

  1236 						&& skip_client != i)

  1237 					{

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

  1239 					}

  1240 				}

  1241 			}

  1243 			info->num_targets = total;

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

  1245 			return;

  1246 		}

  1247 	}

  1249 	List<ICommandTargetProcessor *>::iterator iter;

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

  1251 	{

  1252 		ICommandTargetProcessor *pProcessor = (*iter);

  1253 		if (pProcessor->ProcessCommandTarget(info))

  1254 		{

  1255 			return;

  1256 		}

  1257 	}

  1259 	/* Check partial names */

  1260 	int found_client = 0;

  1261 	CPlayer *pFoundClient = NULL;

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

  1263 	{

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

  1265 		{

  1266 			continue;

  1267 		}

  1269 		if (stristr(pTarget->GetName(), info->pattern) != NULL)

  1270 		{

  1271 			if (found_client)

  1272 			{

  1273 				info->num_targets = 0;

  1274 				info->reason = COMMAND_TARGET_AMBIGUOUS;

  1275 				return;

  1276 			}

  1277 			else

  1278 			{

  1279 				found_client = i;

  1280 				pFoundClient = pTarget;

  1281 			}

  1282 		}

  1283 	}

  1285 	if (found_client)

  1286 	{

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

  1288 			== COMMAND_TARGET_VALID)

  1289 		{

  1290 			info->targets[0] = found_client;

  1291 			info->num_targets = 1;

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

  1293 			info->target_name_style = COMMAND_TARGETNAME_RAW;

  1294 		}

  1295 		else

  1296 		{

  1297 			info->num_targets = 0;

  1298 		}

  1299 	}

  1300 	else

  1301 	{

  1302 		info->num_targets = 0;

  1303 		info->reason = COMMAND_TARGET_NONE;

  1304 	}

  1305 }

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

  1308 {

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

  1310 	{

  1311 		MaxPlayersChanged(gpGlobals->maxClients + 1);

  1312 	}

  1313 	else

  1314 	{

  1315 		MaxPlayersChanged();

  1316 	}

  1317 }

  1319 void PlayerManager::OnSourceModMaxPlayersChanged( int newvalue )

  1320 {

  1321 	m_maxClients = newvalue;

  1322 }

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

  1325 {

  1326 	if (newvalue == -1)

  1327 	{

  1328 		newvalue = gpGlobals->maxClients;

  1329 	}

  1331 	if (newvalue == MaxClients())

  1332 	{

  1333 		return;

  1334 	}

  1336 	/* Notify the rest of core */

  1337 	SMGlobalClass *pBase = SMGlobalClass::head;

  1338 	while (pBase)

  1339 	{

  1340 		pBase->OnSourceModMaxPlayersChanged(newvalue);

  1341 		pBase = pBase->m_pGlobalClassNext;

  1342 	}

  1344 	/* Notify Extensions */

  1345 	List<IClientListener *>::iterator iter;

  1346 	IClientListener *pListener = NULL;

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

  1348 	{

  1349 		pListener = (*iter);

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

  1351 		{

  1352 			pListener->OnMaxPlayersChanged(newvalue);

  1353 		}

  1354 	}

  1355 }

  1357 #if SOURCE_ENGINE >= SE_ORANGEBOX

  1358 void CmdMaxplayersCallback(const CCommand &command)

  1359 {

  1360 #else

  1361 void CmdMaxplayersCallback()

  1362 {

  1363 #endif

  1365 	g_Players.MaxPlayersChanged();

  1366 }

  1369 /*******************

  1370  *** PLAYER CODE ***

  1371  *******************/

  1373 CPlayer::CPlayer()

  1374 {

  1375 	m_IsConnected = false;

  1376 	m_IsInGame = false;

  1377 	m_IsAuthorized = false;

  1378 	m_pEdict = NULL;

  1379 	m_Admin = INVALID_ADMIN_ID;

  1380 	m_TempAdmin = false;

  1381 	m_Info = NULL;

  1382 	m_bAdminCheckSignalled = false;

  1383 	m_bIsInKickQueue = false;

  1384 	m_LastPassword.clear();

  1385 	m_LangId = SOURCEMOD_LANGUAGE_ENGLISH;

  1386 	m_bFakeClient = false;

  1387 }

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

  1390 {

  1391 	m_IsConnected = true;

  1392 	m_Name.assign(name);

  1393 	m_Ip.assign(ip);

  1394 	m_pEdict = pEntity;

  1395 	m_iIndex = IndexOfEdict(pEntity);

  1396 	m_LangId = g_Translator.GetServerLanguage();

  1398 	char ip2[24], *ptr;

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

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

  1401 	{

  1402 		*ptr = '\0';

  1403 	}

  1404 	m_IpNoPort.assign(ip2);

  1405 }

  1407 void CPlayer::Connect()

  1408 {

  1409 	if (m_IsInGame)

  1410 	{

  1411 		return;

  1412 	}

  1414 	m_IsInGame = true;

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

  1417 	int client = IndexOfEdict(m_pEdict);

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

  1419 	{

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

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

  1422 	}

  1423 	else

  1424 	{

  1425 		m_LastPassword.assign("");

  1426 	}

  1427 }

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

  1430 {

  1431 	if (m_IsAuthorized)

  1432 	{

  1433 		return;

  1434 	}

  1436 	m_IsAuthorized = true;

  1437 	m_AuthID.assign(steamid);

  1438 }

  1440 void CPlayer::Disconnect()

  1441 {

  1442 	DumpAdmin(false);

  1443 	m_IsConnected = false;

  1444 	m_IsInGame = false;

  1445 	m_IsAuthorized = false;

  1446 	m_Name.clear();

  1447 	m_Ip.clear();

  1448 	m_AuthID.clear();

  1449 	m_pEdict = NULL;

  1450 	m_Info = NULL;

  1451 	m_bAdminCheckSignalled = false;

  1452 	m_UserId = -1;

  1453 	m_bIsInKickQueue = false;

  1454 	m_bFakeClient = false;

  1455 }

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

  1458 {

  1459 	m_Name.assign(name);

  1460 }

  1462 const char *CPlayer::GetName()

  1463 {

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

  1465 	{

  1466 		return m_Info->GetName();

  1467 	}

  1469 	return m_Name.c_str();

  1470 }

  1472 const char *CPlayer::GetIPAddress()

  1473 {

  1474 	return m_Ip.c_str();

  1475 }

  1477 const char *CPlayer::GetAuthString()

  1478 {

  1479 	return m_AuthID.c_str();

  1480 }

  1482 edict_t *CPlayer::GetEdict()

  1483 {

  1484 	return m_pEdict;

  1485 }

  1487 bool CPlayer::IsInGame()

  1488 {

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

  1490 }

  1492 bool CPlayer::WasCountedAsInGame()

  1493 {

  1494 	return m_IsInGame;

  1495 }

  1497 bool CPlayer::IsConnected()

  1498 {

  1499 	return m_IsConnected;

  1500 }

  1502 bool CPlayer::IsAuthorized()

  1503 {

  1504 	return m_IsAuthorized;

  1505 }

  1507 IPlayerInfo *CPlayer::GetPlayerInfo()

  1508 {

  1509 	if (m_pEdict->GetUnknown())

  1510 	{

  1511 		return m_Info;

  1512 	}

  1514 	return NULL;

  1515 }

  1517 bool CPlayer::IsFakeClient()

  1518 {

  1519 	return m_bFakeClient;

  1520 }

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

  1523 {

  1524 	if (!m_IsConnected)

  1525 	{

  1526 		return;

  1527 	}

  1529 	DumpAdmin(false);

  1531 	m_Admin = id;

  1532 	m_TempAdmin = temporary;

  1533 }

  1535 AdminId CPlayer::GetAdminId()

  1536 {

  1537 	return m_Admin;

  1538 }

  1540 void CPlayer::DumpAdmin(bool deleting)

  1541 {

  1542 	if (m_Admin != INVALID_ADMIN_ID)

  1543 	{

  1544 		if (m_TempAdmin && !deleting)

  1545 		{

  1546 			g_Admins.InvalidateAdmin(m_Admin);

  1547 		}

  1548 		m_Admin = INVALID_ADMIN_ID;

  1549 		m_TempAdmin = false;

  1550 	}

  1551 }

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

  1554 {

  1555 	MarkAsBeingKicked();

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

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

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

  1559 }

  1561 void CPlayer::Authorize_Post()

  1562 {

  1563 	if (m_IsInGame)

  1564 	{

  1565 		DoPostConnectAuthorization();

  1566 	}

  1567 }

  1569 void CPlayer::DoPostConnectAuthorization()

  1570 {

  1571 	bool delay = false;

  1573 	List<IClientListener *>::iterator iter;

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

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

  1576 		 iter++)

  1577 	{

  1578 		IClientListener *pListener = (*iter);

  1579 #if defined MIN_API_FOR_ADMINCALLS

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

  1581 		{

  1582 			continue;

  1583 		}

  1584 #endif

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

  1586 		{

  1587 			delay = true;

  1588 		}

  1589 	}

  1591 	cell_t result = 0;

  1592 	PreAdminCheck->PushCell(m_iIndex);

  1593 	PreAdminCheck->Execute(&result);

  1595 	/* Defer, for better or worse */

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

  1597 	{

  1598 		return;

  1599 	}

  1601 	/* Sanity check */

  1602 	if (!IsConnected())

  1603 	{

  1604 		return;

  1605 	}

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

  1608 	DoBasicAdminChecks();

  1610 	/* Send the notification out */

  1611 	NotifyPostAdminChecks();

  1612 }

  1614 bool CPlayer::RunAdminCacheChecks()

  1615 {

  1616 	AdminId old_id = GetAdminId();

  1618 	DoBasicAdminChecks();

  1620 	return (GetAdminId() != old_id);

  1621 }

  1623 void CPlayer::NotifyPostAdminChecks()

  1624 {

  1625 	if (m_bAdminCheckSignalled)

  1626 	{

  1627 		return;

  1628 	}

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

  1631 	m_bAdminCheckSignalled = true;

  1633 	List<IClientListener *>::iterator iter;

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

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

  1636 		iter++)

  1637 	{

  1638 		IClientListener *pListener = (*iter);

  1639 #if defined MIN_API_FOR_ADMINCALLS

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

  1641 		{

  1642 			continue;

  1643 		}

  1644 #endif

  1645 		pListener->OnClientPostAdminCheck(m_iIndex);

  1646 	}

  1648 	PostAdminFilter->PushCell(m_iIndex);

  1649 	PostAdminFilter->Execute(NULL);

  1651 	PostAdminCheck->PushCell(m_iIndex);

  1652 	PostAdminCheck->Execute(NULL);

  1653 }

  1655 void CPlayer::DoBasicAdminChecks()

  1656 {

  1657 	if (GetAdminId() != INVALID_ADMIN_ID)

  1658 	{

  1659 		return;

  1660 	}

  1662 	/* First check the name */

  1663 	AdminId id;

  1664 	int client = IndexOfEdict(m_pEdict);

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

  1667 	{

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

  1669 		{

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

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

  1672 		}

  1673 		return;

  1674 	}

  1676 	/* Check IP */

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

  1678 	{

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

  1680 		{

  1681 			return;

  1682 		}

  1683 	}

  1685 	/* Check steam id */

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

  1687 	{

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

  1689 		{

  1690 			return;

  1691 		}

  1692 	}

  1693 }

  1695 unsigned int CPlayer::GetLanguageId()

  1696 {

  1697 	return m_LangId;

  1698 }

  1700 int CPlayer::GetUserId()

  1701 {

  1702 	if (m_UserId == -1)

  1703 	{

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

  1705 	}

  1707 	return m_UserId;

  1708 }

  1710 bool CPlayer::IsInKickQueue()

  1711 {

  1712 	return m_bIsInKickQueue;

  1713 }

  1715 void CPlayer::MarkAsBeingKicked()

  1716 {

  1717 	m_bIsInKickQueue = true;

  1718 }

  1720 int CPlayer::GetLifeState()

  1721 {

  1722 	if (lifestate_offset == -1)

  1723 	{

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

  1725 		{

  1726 			lifestate_offset = -2;

  1727 		}

  1728 	}

  1730 	if (lifestate_offset < 0)

  1731 	{

  1732 		IPlayerInfo *info = GetPlayerInfo();

  1733 		if (info == NULL)

  1734 		{

  1735 			return PLAYER_LIFE_UNKNOWN;

  1736 		}

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

  1738 	}

  1740 	if (m_pEdict == NULL)

  1741 	{

  1742 		return PLAYER_LIFE_UNKNOWN;

  1743 	}

  1745 	CBaseEntity *pEntity;

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

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

  1748 	{

  1749 		return PLAYER_LIFE_UNKNOWN;

  1750 	}

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

  1753 	{

  1754 		return PLAYER_LIFE_ALIVE;

  1755 	}

  1756 	else

  1757 	{

  1758 		return PLAYER_LIFE_DEAD;

  1759 	}

  1760 }

author	David Anderson <dvander@alliedmods.net>
	Sun Feb 08 15:40:48 2009 -0500 (2009-02-08)
changeset 2571	5c995a647735
parent 2548	15e59f457851
child 2583	d3b2571c378b
permissions	-rw-r--r--