sourcemod-central: core/PlayerManager.cpp@feff70182207

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    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 <inetchannel.h>

    42 #include <iclient.h>

    43 #include "TimerSys.h"

    44 #include "Translator.h"

    45 #include "Logger.h"

    46 #include "ChatTriggers.h"

    47 #include "HalfLife2.h"

    49 PlayerManager g_Players;

    50 bool g_OnMapStarted = false;

    51 IForward *PreAdminCheck = NULL;

    52 IForward *PostAdminCheck = NULL;

    53 const unsigned int *g_NumPlayersToAuth = NULL;

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

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

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

    58 #if defined ORANGEBOX_BUILD

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

    60 #else

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

    62 #endif

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

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

    66 class KickPlayerTimer : public ITimedEvent

    67 {

    68 public:

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

    70 	{

    71 		int userid = (int)pData;

    72 		int client = g_Players.GetClientOfUserId(userid);

    73 		if (client)

    74 		{

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

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

    77 		}

    78 		return Pl_Stop;

    79 	}

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

    81 	{

    82 	}

    83 } s_KickPlayerTimer;

    85 PlayerManager::PlayerManager()

    86 {

    87 	m_AuthQueue = NULL;

    88 	m_FirstPass = false;

    90 	m_UserIdLookUp = new int[USHRT_MAX+1];

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

    92 }

    94 PlayerManager::~PlayerManager()

    95 {

    96 	g_NumPlayersToAuth = NULL;

    98 	delete [] m_AuthQueue;

    99 	delete [] m_UserIdLookUp;

   100 }

   102 void PlayerManager::OnSourceModAllInitialized()

   103 {

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

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

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

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

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

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

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

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

   113 	g_ShareSys.AddInterface(NULL, this);

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

   116 	ParamType p2[] = {Param_Cell};

   118 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_Event, 3, p1);

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

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

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

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

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

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

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

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

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

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

   130 }

   132 void PlayerManager::OnSourceModShutdown()

   133 {

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

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

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

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

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

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

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

   142 	/* Release forwards */

   143 	g_Forwards.ReleaseForward(m_clconnect);

   144 	g_Forwards.ReleaseForward(m_clputinserver);

   145 	g_Forwards.ReleaseForward(m_cldisconnect);

   146 	g_Forwards.ReleaseForward(m_cldisconnect_post);

   147 	g_Forwards.ReleaseForward(m_clcommand);

   148 	g_Forwards.ReleaseForward(m_clinfochanged);

   149 	g_Forwards.ReleaseForward(m_clauth);

   150 	g_Forwards.ReleaseForward(m_onActivate);

   151 	g_Forwards.ReleaseForward(m_onActivate2);

   153 	g_Forwards.ReleaseForward(PreAdminCheck);

   154 	g_Forwards.ReleaseForward(PostAdminCheck);

   156 	delete [] m_Players;

   157 }

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

   160 												 const char *value,

   161 												 ConfigSource source,

   162 												 char *error,

   163 												 size_t maxlength)

   164 {

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

   166 	{

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

   168 		{

   169 			m_PassInfoVar.assign(value);

   170 		}

   171 		return ConfigResult_Accept;

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

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

   174 		{

   175 			m_QueryLang = true;

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

   177 			m_QueryLang = false;

   178 		} else {

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

   180 			return ConfigResult_Reject;

   181 		}

   182 		return ConfigResult_Accept;

   183 	}

   184 	return ConfigResult_Ignore;

   185 }

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

   188 {

   189 	if (!m_FirstPass)

   190 	{

   191 		/* Initialize all players */

   192 		m_maxClients = clientMax;

   193 		m_PlayerCount = 0;

   194 		m_Players = new CPlayer[m_maxClients + 1];

   195 		m_AuthQueue = new unsigned int[m_maxClients + 1];

   196 		m_FirstPass = true;

   198 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (m_maxClients + 1));

   200 		g_NumPlayersToAuth = &m_AuthQueue[0];

   201 	}

   202 	m_onActivate->Execute(NULL);

   203 	m_onActivate2->Execute(NULL);

   205 	List<IClientListener *>::iterator iter;

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

   207 	{

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

   209 		{

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

   211 		}

   212 	}

   214 	g_OnMapStarted = true;

   216 	SM_ExecuteAllConfigs();

   217 }

   219 bool PlayerManager::IsServerActivated()

   220 {

   221 	return m_FirstPass;

   222 }

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

   225 {

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

   227 	if (password != NULL)

   228 	{

   229 		if (m_PassInfoVar.size() < 1)

   230 		{

   231 			return false;

   232 		}

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

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

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

   237 		{

   238 			return false;

   239 		}

   240 	}

   242 	pPlayer->SetAdminId(id, false);

   244 	return true;

   245 }

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

   248 {

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

   250 	if (password == NULL)

   251 	{

   252 		return false;

   253 	}

   255 	if (m_PassInfoVar.size() < 1)

   256 	{

   257 		return false;

   258 	}

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

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

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

   263 	{

   264 		return false;

   265 	}

   267 	pPlayer->SetAdminId(id, false);

   269 	return true;

   270 }

   272 void PlayerManager::RunAuthChecks()

   273 {

   274 	CPlayer *pPlayer;

   275 	const char *authstr;

   276 	unsigned int removed = 0;

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

   278 	{

   279 		pPlayer = GetPlayerByIndex(m_AuthQueue[i]);

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

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

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

   283 		{

   284 			/* Set authorization */

   285 			pPlayer->Authorize(authstr);

   287 			/* Mark as removed from queue */

   288 			unsigned int client = m_AuthQueue[i];

   289 			m_AuthQueue[i] = 0;

   290 			removed++;

   292 			/* Send to extensions */

   293 			List<IClientListener *>::iterator iter;

   294 			IClientListener *pListener;

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

   296 			{

   297 				pListener = (*iter);

   298 				pListener->OnClientAuthorized(client, authstr);

   299 				if (!pPlayer->IsConnected())

   300 				{

   301 					break;

   302 				}

   303 			}

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

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

   307 			{

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

   309 				m_clauth->PushCell(client);

   310 				m_clauth->PushString(authstr);

   311 				m_clauth->Execute(NULL);

   312 			}

   314 			if (pPlayer->IsConnected())

   315 			{

   316 				pPlayer->Authorize_Post();

   317 			}

   318 		}

   319 	}

   321 	/* Clean up the queue */

   322 	if (removed)

   323 	{

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

   325 		if (removed != m_AuthQueue[0])

   326 		{

   327 			unsigned int diff = 0;

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

   329 			{

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

   331 				if (m_AuthQueue[i] == 0)

   332 				{

   333 					/* Increase the differential */

   334 					diff++;

   335 				} else {

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

   337 					assert(i > diff);

   338 					assert(i - diff >= 1);

   339 					/* move this index down */

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

   341 				}

   342 			}

   343 			m_AuthQueue[0] -= removed;

   344 		} else {

   345 			m_AuthQueue[0] = 0;

   346 		}

   347 	}

   348 }

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

   351 {

   352 	int client = engine->IndexOfEdict(pEntity);

   354 	List<IClientListener *>::iterator iter;

   355 	IClientListener *pListener = NULL;

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

   357 	{

   358 		pListener = (*iter);

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

   360 		{

   361 			return false;

   362 		}

   363 	}

   365 	cell_t res = 1;

   367 	m_Players[client].Initialize(pszName, pszAddress, pEntity);

   368 	m_clconnect->PushCell(client);

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

   370 	m_clconnect->PushCell(maxrejectlen);

   371 	m_clconnect->Execute(&res, NULL);

   373 	if (res)

   374 	{

   375 		if (!m_Players[client].IsAuthorized())

   376 		{

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

   378 		}

   379 	} else {

   380 		RETURN_META_VALUE(MRES_SUPERCEDE, false);

   381 	}

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

   385 	return true;

   386 }

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

   389 {

   390 	int client = engine->IndexOfEdict(pEntity);

   391 	bool orig_value = META_RESULT_ORIG_RET(bool);

   392 	CPlayer *pPlayer = GetPlayerByIndex(client);

   394 	if (orig_value)

   395 	{

   396 		List<IClientListener *>::iterator iter;

   397 		IClientListener *pListener = NULL;

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

   399 		{

   400 			pListener = (*iter);

   401 			pListener->OnClientConnected(client);

   402 			if (!pPlayer->IsConnected())

   403 			{

   404 				break;

   405 			}

   406 		}

   407 	}

   409 	return true;

   410 }

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

   413 {

   414 	cell_t res;

   415 	int client = engine->IndexOfEdict(pEntity);

   417 	CPlayer *pPlayer = GetPlayerByIndex(client);

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

   419 	if (!pPlayer->IsConnected())

   420 	{

   421 		/* Run manual connection routines */

   422 		char error[255];

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

   424 		pPlayer->Authorize(authid);

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

   426 		{

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

   428 			return;

   429 		}

   430 		List<IClientListener *>::iterator iter;

   431 		IClientListener *pListener = NULL;

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

   433 		{

   434 			pListener = (*iter);

   435 			pListener->OnClientConnected(client);

   436 			/* See if bot was kicked */

   437 			if (!pPlayer->IsConnected())

   438 			{

   439 				return;

   440 			}

   441 		}

   442 		/* Now do authorization */

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

   444 		{

   445 			pListener = (*iter);

   446 			pListener->OnClientAuthorized(client, authid);

   447 		}

   448 		/* Finally, tell plugins */

   449 		if (m_clauth->GetFunctionCount())

   450 		{

   451 			m_clauth->PushCell(client);

   452 			m_clauth->PushString(authid);

   453 			m_clauth->Execute(NULL);

   454 		}

   455 		pPlayer->Authorize_Post();

   456 	}

   458 	if (playerinfo)

   459 	{

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

   461 	}

   463 	/* Get the client's language */

   464 	if (m_QueryLang)

   465 	{

   466 		const char *name;

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

   468 		{

   469 			unsigned int langid;

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

   471 		} else {

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

   473 		}

   474 	}

   476 	m_Players[client].Connect();

   477 	m_PlayerCount++;

   479 	List<IClientListener *>::iterator iter;

   480 	IClientListener *pListener = NULL;

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

   482 	{

   483 		pListener = (*iter);

   484 		pListener->OnClientPutInServer(client);

   485 	}

   487 	m_clputinserver->PushCell(client);

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

   489 }

   491 void PlayerManager::OnSourceModLevelEnd()

   492 {

   493 	/* Disconnect all bots still in game */

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

   495 	{

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

   497 		{

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

   499 		}

   500 	}

   501 	m_PlayerCount = 0;

   502 }

   504 void PlayerManager::OnClientDisconnect(edict_t *pEntity)

   505 {

   506 	cell_t res;

   507 	int client = engine->IndexOfEdict(pEntity);

   509 	if (m_Players[client].IsConnected())

   510 	{

   511 		m_cldisconnect->PushCell(client);

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

   513 	} else {

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

   515 		return;

   516 	}

   518 	if (m_Players[client].WasCountedAsInGame())

   519 	{

   520 		m_PlayerCount--;

   521 	}

   523 	List<IClientListener *>::iterator iter;

   524 	IClientListener *pListener = NULL;

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

   526 	{

   527 		pListener = (*iter);

   528 		pListener->OnClientDisconnecting(client);

   529 	}

   531 	/**

   532 	 * Remove client from auth queue if necessary

   533 	 */

   534 	if (!m_Players[client].IsAuthorized())

   535 	{

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

   537 		{

   538 			if (m_AuthQueue[i] == (unsigned)client)

   539 			{

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

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

   542 				{

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

   544 				}

   545 				/* Remove us and break */

   546 				m_AuthQueue[0]--;

   547 				break;

   548 			}

   549 		}

   550 	}

   552 	m_Players[client].Disconnect();

   553 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = 0;

   554 }

   556 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)

   557 {

   558 	cell_t res;

   559 	int client = engine->IndexOfEdict(pEntity);

   561 	m_cldisconnect_post->PushCell(client);

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

   564 	List<IClientListener *>::iterator iter;

   565 	IClientListener *pListener = NULL;

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

   567 	{

   568 		pListener = (*iter);

   569 		pListener->OnClientDisconnected(client);

   570 	}

   571 }

   573 #if defined ORANGEBOX_BUILD

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

   575 {

   576 #else

   577 void PlayerManager::OnClientCommand(edict_t *pEntity)

   578 {

   579 	CCommand args;

   580 #endif

   581 	int client = engine->IndexOfEdict(pEntity);

   582 	cell_t res = Pl_Continue;

   584 	CPlayer *pPlayer = GetPlayerByIndex(client);

   585 	if (!pPlayer || !pPlayer->IsConnected())

   586 	{

   587 		return;

   588 	}

   590 	g_HL2.PushCommandStack(&args);

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

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

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

   596 	if (result)

   597 	{

   598 		res = Pl_Handled;

   599 	} else {

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

   601 		if (result)

   602 		{

   603 			res = Pl_Handled;

   604 		}

   605 	}

   607 	cell_t res2 = Pl_Continue;

   608 	m_clcommand->PushCell(client);

   609 	m_clcommand->PushCell(argcount);

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

   612 	if (res2 > res)

   613 	{

   614 		res = res2;

   615 	}

   617 	if (res >= Pl_Stop)

   618 	{

   619 		g_HL2.PopCommandStack();

   620 		RETURN_META(MRES_SUPERCEDE);

   621 	}

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

   625 	g_HL2.PopCommandStack();

   627 	if (res >= Pl_Handled)

   628 	{

   629 		RETURN_META(MRES_SUPERCEDE);

   630 	}

   631 }

   633 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)

   634 {

   635 	cell_t res;

   636 	int client = engine->IndexOfEdict(pEntity);

   638 	if (!m_Players[client].IsConnected())

   639 	{

   640 		return;

   641 	}

   643 	m_clinfochanged->PushCell(engine->IndexOfEdict(pEntity));

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

   646 	IPlayerInfo *info = m_Players[client].GetPlayerInfo();

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

   648 	const char *old_name = m_Players[client].m_Name.c_str();

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

   651 	{

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

   653 		if (id != INVALID_ADMIN_ID && m_Players[client].GetAdminId() != id)

   654 		{

   655 			if (!CheckSetAdminName(client, &m_Players[client], id))

   656 			{

   657 				m_Players[client].Kick("Your name is reserved by SourceMod; set your password to use it.");

   658 				RETURN_META(MRES_IGNORED);

   659 			}

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

   661 			if (id == m_Players[client].GetAdminId())

   662 			{

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

   664 				m_Players[client].SetAdminId(INVALID_ADMIN_ID, false);

   665 			}

   666 		}

   667 		m_Players[client].SetName(new_name);

   668 	}

   670 	if (m_PassInfoVar.size() > 0)

   671 	{

   672 		/* Try for a password change */

   673 		const char *old_pass = m_Players[client].m_LastPassword.c_str();

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

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

   676 		{

   677 			m_Players[client].m_LastPassword.assign(new_pass);

   678 			if (m_Players[client].IsInGame() && m_Players[client].IsAuthorized())

   679 			{

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

   681 				m_Players[client].DoBasicAdminChecks();

   682 			}

   683 		}

   684 	}

   685 }

   687 int PlayerManager::GetMaxClients()

   688 {

   689 	return m_maxClients;

   690 }

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

   693 {

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

   695 	{

   696 		return NULL;

   697 	}

   698 	return &m_Players[client];

   699 }

   701 int PlayerManager::GetNumPlayers()

   702 {

   703 	return m_PlayerCount;

   704 }

   706 int PlayerManager::GetClientOfUserId(int userid)

   707 {

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

   709 	{

   710 		return 0;

   711 	}

   713 	int client = m_UserIdLookUp[userid];

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

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

   717 	 * check before invoking this backwards compat code.

   718 	 */

   719 	if (client)

   720 	{

   721 		CPlayer *player = GetPlayerByIndex(client);

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

   723 		{

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

   725 			if (realUserId == userid)

   726 			{

   727 				return client;

   728 			}

   729 		}

   730 	}

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

   733 	CPlayer *player;

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

   735 	{

   736 		player = GetPlayerByIndex(i);

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

   738 		{

   739 			continue;

   740 		}

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

   742 		{

   743 			m_UserIdLookUp[userid] = i;

   744 			return i;

   745 		}

   746 	}

   748 	return 0;

   749 }

   751 void PlayerManager::AddClientListener(IClientListener *listener)

   752 {

   753 	m_hooks.push_back(listener);

   754 }

   756 void PlayerManager::RemoveClientListener(IClientListener *listener)

   757 {

   758 	m_hooks.remove(listener);

   759 }

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

   762 {

   763 	int index = engine->IndexOfEdict(pEdict);

   764 	return GetGamePlayer(index);

   765 }

   767 IGamePlayer *PlayerManager::GetGamePlayer(int client)

   768 {

   769 	return GetPlayerByIndex(client);

   770 }

   772 void PlayerManager::ClearAdminId(AdminId id)

   773 {

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

   775 	{

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

   777 		{

   778 			m_Players[i].DumpAdmin(true);

   779 		}

   780 	}

   781 }

   783 void PlayerManager::ClearAllAdmins()

   784 {

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

   786 	{

   787 		m_Players[i].DumpAdmin(true);

   788 	}

   789 }

   791 const char *PlayerManager::GetPassInfoVar()

   792 {

   793 	return m_PassInfoVar.c_str();

   794 }

   796 void PlayerManager::RecheckAnyAdmins()

   797 {

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

   799 	{

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

   801 		{

   802 			m_Players[i].DoBasicAdminChecks();

   803 		}

   804 	}

   805 }

   807 unsigned int PlayerManager::GetReplyTo()

   808 {

   809 	return g_ChatTriggers.GetReplyTo();

   810 }

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

   813 {

   814 	return g_ChatTriggers.SetReplyTo(reply);

   815 }

   817 /*******************

   818  *** PLAYER CODE ***

   819  *******************/

   821 CPlayer::CPlayer()

   822 {

   823 	m_IsConnected = false;

   824 	m_IsInGame = false;

   825 	m_IsAuthorized = false;

   826 	m_pEdict = NULL;

   827 	m_Admin = INVALID_ADMIN_ID;

   828 	m_TempAdmin = false;

   829 	m_Info = NULL;

   830 	m_bAdminCheckSignalled = false;

   831 	m_bIsInKickQueue = false;

   832 	m_LastPassword.clear();

   833 	m_LangId = LANGUAGE_ENGLISH;

   834 }

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

   837 {

   838 	m_IsConnected = true;

   839 	m_Name.assign(name);

   840 	m_Ip.assign(ip);

   841 	m_pEdict = pEntity;

   842 	m_iIndex = engine->IndexOfEdict(pEntity);

   843 	m_LangId = g_Translator.GetServerLanguage();

   845 	char ip2[24], *ptr;

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

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

   848 	{

   849 		*ptr = '\0';

   850 	}

   851 	m_IpNoPort.assign(ip2);

   852 }

   854 void CPlayer::Connect()

   855 {

   856 	if (m_IsInGame)

   857 	{

   858 		return;

   859 	}

   861 	m_IsInGame = true;

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

   864 	int client = engine->IndexOfEdict(m_pEdict);

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

   866 	{

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

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

   869 	} else {

   870 		m_LastPassword.assign("");

   871 	}

   873 	if (m_IsAuthorized)

   874 	{

   875 		DoPostConnectAuthorization();

   876 	}

   877 }

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

   880 {

   881 	if (m_IsAuthorized)

   882 	{

   883 		return;

   884 	}

   886 	m_IsAuthorized = true;

   887 	m_AuthID.assign(steamid);

   888 }

   890 void CPlayer::Disconnect()

   891 {

   892 	DumpAdmin(false);

   893 	m_IsConnected = false;

   894 	m_IsInGame = false;

   895 	m_IsAuthorized = false;

   896 	m_Name.clear();

   897 	m_Ip.clear();

   898 	m_AuthID.clear();

   899 	m_pEdict = NULL;

   900 	m_Info = NULL;

   901 	m_bAdminCheckSignalled = false;

   902 	m_UserId = -1;

   903 	m_bIsInKickQueue = false;

   904 }

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

   907 {

   908 	m_Name.assign(name);

   909 }

   911 const char *CPlayer::GetName()

   912 {

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

   914 	{

   915 		return m_Info->GetName();

   916 	}

   918 	return m_Name.c_str();

   919 }

   921 const char *CPlayer::GetIPAddress()

   922 {

   923 	return m_Ip.c_str();

   924 }

   926 const char *CPlayer::GetAuthString()

   927 {

   928 	return m_AuthID.c_str();

   929 }

   931 edict_t *CPlayer::GetEdict()

   932 {

   933 	return m_pEdict;

   934 }

   936 bool CPlayer::IsInGame()

   937 {

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

   939 }

   941 bool CPlayer::WasCountedAsInGame()

   942 {

   943 	return m_IsInGame;

   944 }

   946 bool CPlayer::IsConnected()

   947 {

   948 	return m_IsConnected;

   949 }

   951 bool CPlayer::IsAuthorized()

   952 {

   953 	return m_IsAuthorized;

   954 }

   956 IPlayerInfo *CPlayer::GetPlayerInfo()

   957 {

   958 	if (m_pEdict->GetUnknown())

   959 	{

   960 		return m_Info;

   961 	}

   963 	return NULL;

   964 }

   966 bool CPlayer::IsFakeClient()

   967 {

   968 	return (strcmp(m_AuthID.c_str(), "BOT") == 0);

   969 }

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

   972 {

   973 	if (!m_IsConnected)

   974 	{

   975 		return;

   976 	}

   978 	DumpAdmin(false);

   980 	m_Admin = id;

   981 	m_TempAdmin = temporary;

   982 }

   984 AdminId CPlayer::GetAdminId()

   985 {

   986 	return m_Admin;

   987 }

   989 void CPlayer::DumpAdmin(bool deleting)

   990 {

   991 	if (m_Admin != INVALID_ADMIN_ID)

   992 	{

   993 		if (m_TempAdmin && !deleting)

   994 		{

   995 			g_Admins.InvalidateAdmin(m_Admin);

   996 		}

   997 		m_Admin = INVALID_ADMIN_ID;

   998 		m_TempAdmin = false;

   999 	}

  1000 }

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

  1003 {

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

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

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

  1007 }

  1009 void CPlayer::Authorize_Post()

  1010 {

  1011 	if (m_IsInGame)

  1012 	{

  1013 		DoPostConnectAuthorization();

  1014 	}

  1015 }

  1017 void CPlayer::DoPostConnectAuthorization()

  1018 {

  1019 	cell_t result = 0;

  1020 	PreAdminCheck->PushCell(m_iIndex);

  1021 	PreAdminCheck->Execute(&result);

  1023 	/* Defer, for better or worse */

  1024 	if ((ResultType)result >= Pl_Handled)

  1025 	{

  1026 		return;

  1027 	}

  1029 	/* Sanity check */

  1030 	if (!IsConnected())

  1031 	{

  1032 		return;

  1033 	}

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

  1036 	DoBasicAdminChecks();

  1038 	/* Send the notification out */

  1039 	NotifyPostAdminChecks();

  1040 }

  1042 void CPlayer::NotifyPostAdminChecks()

  1043 {

  1044 	if (m_bAdminCheckSignalled)

  1045 	{

  1046 		return;

  1047 	}

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

  1050 	m_bAdminCheckSignalled = true;

  1052 	PostAdminCheck->PushCell(m_iIndex);

  1053 	PostAdminCheck->Execute(NULL);

  1054 }

  1056 void CPlayer::DoBasicAdminChecks()

  1057 {

  1058 	if (GetAdminId() != INVALID_ADMIN_ID)

  1059 	{

  1060 		return;

  1061 	}

  1063 	/* First check the name */

  1064 	AdminId id;

  1065 	int client = engine->IndexOfEdict(m_pEdict);

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

  1068 	{

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

  1070 		{

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

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

  1073 		}

  1074 		return;

  1075 	}

  1077 	/* Check IP */

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

  1079 	{

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

  1081 		{

  1082 			return;

  1083 		}

  1084 	}

  1086 	/* Check IP address */

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

  1088 	{

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

  1090 		{

  1091 			return;

  1092 		}

  1093 	}

  1094 }

  1096 unsigned int CPlayer::GetLanguageId()

  1097 {

  1098 	return m_LangId;

  1099 }

  1101 int CPlayer::GetUserId()

  1102 {

  1103 	if (m_UserId == -1)

  1104 	{

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

  1106 	}

  1108 	return m_UserId;

  1109 }

  1111 bool CPlayer::IsInKickQueue()

  1112 {

  1113 	return m_bIsInKickQueue;

  1114 }

  1116 void CPlayer::MarkAsBeingKicked()

  1117 {

  1118 	m_bIsInKickQueue = true;

  1119 }

author	David Anderson <dvander@alliedmods.net>
	Sun Oct 14 02:30:16 2007 +0000 (2007-10-14)
changeset 1544	feff70182207
parent 1541	e46ad208b9b4
child 1576	f36378b2d71f
permissions	-rw-r--r--