Home - sourcemod-central - file revision - core/PlayerManager.cpp@ff520b71249c Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/PlayerManager.cpp
author Scott Ehlert <ds@alliedmods.net>
Sat Apr 21 17:03:28 2007 +0000 (2007-04-21)
changeset 702 ff520b71249c
parent 682 a70055d6d3b3
child 717 6f9b8bab7ae8
permissions -rw-r--r--
Wow, how did I forget this - exported IMemoryUtils interface 
     1 /**
     2  * vim: set ts=4 :
     3  * ===============================================================
     4  * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.
     5  * ===============================================================
     6  *
     7  * This file is not open source and may not be copied without explicit
     8  * written permission of AlliedModders LLC.  This file may not be redistributed 
     9  * in whole or significant part.
    10  * For information, see LICENSE.txt or http://www.sourcemod.net/license.php
    11  *
    12  * Version: $Id$
    13  */
    14 
    15 #include "PlayerManager.h"
    16 #include "ForwardSys.h"
    17 #include "ShareSys.h"
    18 #include "AdminCache.h"
    19 #include "ConCmdManager.h"
    20 
    21 PlayerManager g_Players;
    22 
    23 SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);
    24 SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);
    25 SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);
    26 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);
    27 SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);
    28 SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);
    29 
    30 PlayerManager::PlayerManager()
    31 {
    32 	m_AuthQueue = NULL;
    33 	m_FirstPass = true;
    34 
    35 	m_UserIdLookUp = new int[USHRT_MAX];
    36 	memset(m_UserIdLookUp, 0, sizeof(int) * USHRT_MAX);
    37 }
    38 
    39 PlayerManager::~PlayerManager()
    40 {
    41 	delete [] m_AuthQueue;
    42 	delete [] m_UserIdLookUp;
    43 }
    44 
    45 void PlayerManager::OnSourceModAllInitialized()
    46 {
    47 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    48 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);
    49 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    50 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    51 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    52 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    53 	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    54 	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    55 
    56 	g_ShareSys.AddInterface(NULL, this);
    57 
    58 	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};
    59 	ParamType p2[] = {Param_Cell};
    60 
    61 	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_Event, 3, p1);
    62 	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);
    63 	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);
    64 	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);
    65 	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);
    66 	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);
    67 	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);
    68 	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);
    69 }
    70 
    71 void PlayerManager::OnSourceModShutdown()
    72 {
    73 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);
    74 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);
    75 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);
    76 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);
    77 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);
    78 	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);
    79 	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);
    80 
    81 	/* Release forwards */
    82 	g_Forwards.ReleaseForward(m_clconnect);
    83 	g_Forwards.ReleaseForward(m_clputinserver);
    84 	g_Forwards.ReleaseForward(m_cldisconnect);
    85 	g_Forwards.ReleaseForward(m_cldisconnect_post);
    86 	g_Forwards.ReleaseForward(m_clcommand);
    87 	g_Forwards.ReleaseForward(m_clinfochanged);
    88 	g_Forwards.ReleaseForward(m_clauth);
    89 	g_Forwards.ReleaseForward(m_onActivate);
    90 
    91 	delete [] m_Players;
    92 }
    93 
    94 void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)
    95 {
    96 	if (m_FirstPass)
    97 	{
    98 		/* Initialize all players */
    99 		m_maxClients = clientMax;
   100 		m_PlayerCount = 0;
   101 		m_Players = new CPlayer[m_maxClients + 1];
   102 		m_AuthQueue = new unsigned int[m_maxClients + 1];
   103 		m_FirstPass = false;
   104 
   105 		memset(m_AuthQueue, 0, sizeof(unsigned int) * (m_maxClients + 1));
   106 	}
   107 	m_onActivate->Execute(NULL);
   108 }
   109 
   110 void PlayerManager::RunAuthChecks()
   111 {
   112 	CPlayer *pPlayer;
   113 	const char *authstr;
   114 	unsigned int removed = 0;
   115 	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   116 	{
   117 		pPlayer = GetPlayerByIndex(m_AuthQueue[i]);
   118 		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);
   119 		if (authstr && authstr[0] != '\0'
   120 			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))
   121 		{
   122 			/* Set authorization */
   123 			pPlayer->m_AuthID.assign(authstr);
   124 			pPlayer->m_IsAuthorized = true;
   125 
   126 			/* Mark as removed from queue */
   127 			unsigned int client = m_AuthQueue[i];
   128 			m_AuthQueue[i] = 0;
   129 			removed++;
   130 
   131 			/* Send to extensions */
   132 			List<IClientListener *>::iterator iter;
   133 			IClientListener *pListener;
   134 			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   135 			{
   136 				pListener = (*iter);
   137 				pListener->OnClientAuthorized(client, authstr);
   138 				if (!pPlayer->IsConnected())
   139 				{
   140 					break;
   141 				}
   142 			}
   143 
   144 			/* Send to plugins if player is still connected */
   145 			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())
   146 			{
   147 				/* :TODO: handle the case of a player disconnecting in the middle */
   148 				m_clauth->PushCell(client);
   149 				m_clauth->PushString(authstr);
   150 				m_clauth->Execute(NULL);
   151 			}
   152 		}
   153 	}
   154 
   155 	/* Clean up the queue */
   156 	if (removed)
   157 	{
   158 		/* We don't have to compcat the list if it's empty */
   159 		if (removed != m_AuthQueue[0])
   160 		{
   161 			unsigned int diff = 0;
   162 			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   163 			{
   164 				/* If this member is removed... */
   165 				if (m_AuthQueue[i] == 0)
   166 				{
   167 					/* Increase the differential */
   168 					diff++;
   169 				} else {
   170 					/* diff cannot increase faster than i+1 */
   171 					assert(i > diff);
   172 					assert(i - diff >= 1);
   173 					/* move this index down */
   174 					m_AuthQueue[i - diff] = m_AuthQueue[i];
   175 				}
   176 			}
   177 			m_AuthQueue[0] -= removed;
   178 		} else {
   179 			m_AuthQueue[0] = 0;
   180 			g_SourceMod.SetAuthChecking(false);
   181 		}
   182 	}
   183 }
   184 
   185 bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   186 {
   187 	int client = engine->IndexOfEdict(pEntity);
   188 
   189 	List<IClientListener *>::iterator iter;
   190 	IClientListener *pListener = NULL;
   191 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   192 	{
   193 		pListener = (*iter);
   194 		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))
   195 		{
   196 			return false;
   197 		}
   198 	}
   199 
   200 	cell_t res = 1;
   201 
   202 	m_Players[client].Initialize(pszName, pszAddress, pEntity);
   203 	m_clconnect->PushCell(client);
   204 	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8, SM_PARAM_COPYBACK);
   205 	m_clconnect->PushCell(maxrejectlen);
   206 	m_clconnect->Execute(&res, NULL);
   207 
   208 	if (res)
   209 	{
   210 		if (!m_Players[client].IsAuthorized())
   211 		{
   212 			m_AuthQueue[++m_AuthQueue[0]] = client;
   213 			g_SourceMod.SetAuthChecking(true);
   214 		}
   215 	} else {
   216 		RETURN_META_VALUE(MRES_SUPERCEDE, false);
   217 	}
   218 
   219 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;
   220 
   221 	return true;
   222 }
   223 
   224 bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)
   225 {
   226 	int client = engine->IndexOfEdict(pEntity);
   227 	bool orig_value = META_RESULT_ORIG_RET(bool);
   228 	if (orig_value)
   229 	{
   230 		List<IClientListener *>::iterator iter;
   231 		IClientListener *pListener = NULL;
   232 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   233 		{
   234 			pListener = (*iter);
   235 			pListener->OnClientConnected(client);
   236 		}
   237 	}
   238 
   239 	return true;
   240 }
   241 
   242 void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername)
   243 {
   244 	cell_t res;
   245 	int client = engine->IndexOfEdict(pEntity);
   246 
   247 	CPlayer *pPlayer = GetPlayerByIndex(client);
   248 	/* If they're not connected, they're a bot */
   249 	if (!pPlayer->IsConnected())
   250 	{
   251 		/* Run manual connection routines */
   252 		char error[255];
   253 		const char *authid = engine->GetPlayerNetworkIDString(pEntity);
   254 		pPlayer->Authorize(authid);
   255 		if (!OnClientConnect(pEntity, playername, "127.0.0.1", error, sizeof(error)))
   256 		{
   257 			/* :TODO: kick the bot if it's rejected */
   258 			return;
   259 		}
   260 		List<IClientListener *>::iterator iter;
   261 		IClientListener *pListener = NULL;
   262 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   263 		{
   264 			pListener = (*iter);
   265 			pListener->OnClientConnected(client);
   266 			/* See if bot was kicked */
   267 			if (!pPlayer->IsConnected())
   268 			{
   269 				return;
   270 			}
   271 		}
   272 		/* Now do authorization */
   273 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   274 		{
   275 			pListener = (*iter);
   276 			pListener->OnClientAuthorized(client, authid);
   277 			/* See if bot was kicked */
   278 			if (!pPlayer->IsConnected())
   279 			{
   280 				return;
   281 			}
   282 		}
   283 		/* Finally, tell plugins */
   284 		if (m_clauth->GetFunctionCount())
   285 		{
   286 			m_clauth->PushCell(client);
   287 			m_clauth->PushString(authid);
   288 			m_clauth->Execute(NULL);
   289 		}
   290 	}
   291 
   292 	if (playerinfo)
   293 	{
   294 		pPlayer->m_Info = playerinfo->GetPlayerInfo(pEntity);
   295 	}
   296 
   297 	List<IClientListener *>::iterator iter;
   298 	IClientListener *pListener = NULL;
   299 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   300 	{
   301 		pListener = (*iter);
   302 		pListener->OnClientPutInServer(client);
   303 		/* See if player was kicked */
   304 		if (!pPlayer->IsConnected())
   305 		{
   306 			return;
   307 		}
   308 	}
   309 
   310 	m_Players[client].Connect();
   311 	m_PlayerCount++;
   312 	m_clputinserver->PushCell(client);
   313 	m_clputinserver->Execute(&res, NULL);
   314 }
   315 
   316 void PlayerManager::OnClientDisconnect(edict_t *pEntity)
   317 {
   318 	cell_t res;
   319 	int client = engine->IndexOfEdict(pEntity);
   320 
   321 	if (m_Players[client].IsConnected())
   322 	{
   323 		m_cldisconnect->PushCell(client);
   324 		m_cldisconnect->Execute(&res, NULL);
   325 	}
   326 
   327 	if (m_Players[client].IsInGame())
   328 	{
   329 		m_PlayerCount--;
   330 	}
   331 
   332 	List<IClientListener *>::iterator iter;
   333 	IClientListener *pListener = NULL;
   334 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   335 	{
   336 		pListener = (*iter);
   337 		pListener->OnClientDisconnecting(client);
   338 	}
   339 
   340 	/**
   341 	 * Remove client from auth queue if necessary
   342 	 */
   343 	if (!m_Players[client].IsAuthorized())
   344 	{
   345 		for (unsigned int i=1; i<=m_AuthQueue[0]; i++)
   346 		{
   347 			if (m_AuthQueue[i] == (unsigned)client)
   348 			{
   349 				/* Move everything ahead of us back by one */
   350 				for (unsigned int j=i+1; j<=m_AuthQueue[0]; j++)
   351 				{
   352 					m_AuthQueue[j-1] = m_AuthQueue[j];
   353 				}
   354 				/* Remove us and break */
   355 				m_AuthQueue[0]--;
   356 				break;
   357 			}
   358 		}
   359 	}
   360 
   361 	m_Players[client].Disconnect();
   362 	m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = 0;
   363 }
   364 
   365 void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)
   366 {
   367 	cell_t res;
   368 	int client = engine->IndexOfEdict(pEntity);
   369 
   370 	m_cldisconnect_post->PushCell(client);
   371 	m_cldisconnect_post->Execute(&res, NULL);
   372 
   373 	List<IClientListener *>::iterator iter;
   374 	IClientListener *pListener = NULL;
   375 	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
   376 	{
   377 		pListener = (*iter);
   378 		pListener->OnClientDisconnected(client);
   379 	}
   380 }
   381 
   382 void PlayerManager::OnClientCommand(edict_t *pEntity)
   383 {
   384 	cell_t res = Pl_Continue;
   385 	int client = engine->IndexOfEdict(pEntity);
   386 
   387 	int args = engine->Cmd_Argc() - 1;
   388 
   389 	m_clcommand->PushCell(client);
   390 	m_clcommand->PushCell(args);
   391 	m_clcommand->Execute(&res, NULL);
   392 
   393 	if (res >= Pl_Stop)
   394 	{
   395 		RETURN_META(MRES_SUPERCEDE);
   396 	}
   397 
   398 	res = g_ConCmds.DispatchClientCommand(client, (ResultType)res);
   399 
   400 	if (res >= Pl_Handled)
   401 	{
   402 		RETURN_META(MRES_SUPERCEDE);
   403 	}
   404 }
   405 
   406 void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)
   407 {
   408 	cell_t res;
   409 	int client = engine->IndexOfEdict(pEntity);
   410 
   411 	m_clinfochanged->PushCell(engine->IndexOfEdict(pEntity));
   412 	m_clinfochanged->Execute(&res, NULL);
   413 	m_Players[client].SetName(engine->GetClientConVarValue(client, "name"));
   414 }
   415 
   416 int PlayerManager::GetMaxClients()
   417 {
   418 	return m_maxClients;
   419 }
   420 
   421 CPlayer *PlayerManager::GetPlayerByIndex(int client) const
   422 {
   423 	if (client > m_maxClients || client < 1)
   424 	{
   425 		return NULL;
   426 	}
   427 	return &m_Players[client];
   428 }
   429 
   430 int PlayerManager::GetNumPlayers()
   431 {
   432 	return m_PlayerCount;
   433 }
   434 
   435 int PlayerManager::GetClientOfUserId(int userid)
   436 {
   437 	return (userid < 0 || userid > USHRT_MAX) ? 0 : m_UserIdLookUp[userid];
   438 }
   439 
   440 void PlayerManager::AddClientListener(IClientListener *listener)
   441 {
   442 	m_hooks.push_back(listener);
   443 }
   444 
   445 void PlayerManager::RemoveClientListener(IClientListener *listener)
   446 {
   447 	m_hooks.remove(listener);
   448 }
   449 
   450 IGamePlayer *PlayerManager::GetGamePlayer(edict_t *pEdict)
   451 {
   452 	int index = engine->IndexOfEdict(pEdict);
   453 	return GetGamePlayer(index);
   454 }
   455 
   456 IGamePlayer *PlayerManager::GetGamePlayer(int client)
   457 {
   458 	return GetPlayerByIndex(client);
   459 }
   460 
   461 void PlayerManager::ClearAdminId(AdminId id)
   462 {
   463 	for (int i=1; i<=m_maxClients; i++)
   464 	{
   465 		if (m_Players[i].m_Admin == id)
   466 		{
   467 			m_Players[i].DumpAdmin(true);
   468 		}
   469 	}
   470 }
   471 
   472 void PlayerManager::ClearAllAdmins()
   473 {
   474 	for (int i=1; i<=m_maxClients; i++)
   475 	{
   476 		m_Players[i].DumpAdmin(true);
   477 	}
   478 }
   479 
   480 
   481 /*******************
   482  *** PLAYER CODE ***
   483  *******************/
   484 
   485 CPlayer::CPlayer()
   486 {
   487 	m_IsConnected = false;
   488 	m_IsInGame = false;
   489 	m_IsAuthorized = false;
   490 	m_pEdict = NULL;
   491 	m_Admin = INVALID_ADMIN_ID;
   492 	m_TempAdmin = false;
   493 	m_Info = NULL;
   494 }
   495 
   496 void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)
   497 {
   498 	m_IsConnected = true;
   499 	m_Name.assign(name);
   500 	m_Ip.assign(ip);
   501 	m_pEdict = pEntity;
   502 }
   503 
   504 void CPlayer::Connect()
   505 {
   506 	m_IsInGame = true;
   507 }
   508 
   509 void CPlayer::Authorize(const char *steamid)
   510 {
   511 	m_IsAuthorized = true;
   512 	m_AuthID.assign(steamid);
   513 }
   514 
   515 void CPlayer::Disconnect()
   516 {
   517 	DumpAdmin(false);
   518 	m_IsConnected = false;
   519 	m_IsInGame = false;
   520 	m_IsAuthorized = false;
   521 	m_Name.clear();
   522 	m_Ip.clear();
   523 	m_AuthID.clear();
   524 	m_pEdict = NULL;
   525 	m_Info = NULL;
   526 }
   527 
   528 void CPlayer::SetName(const char *name)
   529 {
   530 	m_Name.assign(name);
   531 }
   532 
   533 const char *CPlayer::GetName()
   534 {
   535 	return (m_Info) ? m_Info->GetName(): m_Name.c_str();
   536 }
   537 
   538 const char *CPlayer::GetIPAddress()
   539 {
   540 	return m_Ip.c_str();
   541 }
   542 
   543 const char *CPlayer::GetAuthString()
   544 {
   545 	return m_AuthID.c_str();
   546 }
   547 
   548 edict_t *CPlayer::GetEdict()
   549 {
   550 	return m_pEdict;
   551 }
   552 
   553 bool CPlayer::IsInGame()
   554 {
   555 	return m_IsInGame;
   556 }
   557 
   558 bool CPlayer::IsConnected()
   559 {
   560 	return m_IsConnected;
   561 }
   562 
   563 bool CPlayer::IsAuthorized()
   564 {
   565 	return m_IsAuthorized;
   566 }
   567 
   568 IPlayerInfo *CPlayer::GetPlayerInfo()
   569 {
   570 	return m_Info;
   571 }
   572 
   573 bool CPlayer::IsFakeClient()
   574 {
   575 	return (strcmp(m_AuthID.c_str(), "BOT") == 0);
   576 }
   577 
   578 void CPlayer::SetAdminId(AdminId id, bool temporary)
   579 {
   580 	if (!m_IsConnected)
   581 	{
   582 		return;
   583 	}
   584 
   585 	DumpAdmin(false);
   586 
   587 	m_Admin = id;
   588 	m_TempAdmin = temporary;
   589 }
   590 
   591 AdminId CPlayer::GetAdminId()
   592 {
   593 	return m_Admin;
   594 }
   595 
   596 void CPlayer::DumpAdmin(bool deleting)
   597 {
   598 	if (m_Admin != INVALID_ADMIN_ID)
   599 	{
   600 		if (m_TempAdmin && !deleting)
   601 		{
   602 			g_Admins.InvalidateAdmin(m_Admin);
   603 		}
   604 		m_Admin = INVALID_ADMIN_ID;
   605 		m_TempAdmin = false;
   606 	}
   607 }
sourcemod-central
Feed