sourcemod-central: core/AdminCache.cpp@63aafc6ff212

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

    33 #include <assert.h>

    34 #include <ITextParsers.h>

    35 #include "AdminCache.h"

    36 #include "ShareSys.h"

    37 #include "ForwardSys.h"

    38 #include "PlayerManager.h"

    39 #include "ConCmdManager.h"

    40 #include "Logger.h"

    41 #include "sourcemod.h"

    42 #include "sm_stringutil.h"

    43 #include "sourcemm_api.h"

    44 #include "sm_srvcmds.h"

    46 #define LEVEL_STATE_NONE		0

    47 #define LEVEL_STATE_LEVELS		1

    48 #define LEVEL_STATE_FLAGS		2

    50 AdminCache g_Admins;

    51 char g_ReverseFlags[26];

    52 AdminFlag g_FlagLetters[26];

    53 bool g_FlagSet[26];

    55 ConVar sm_immunity_mode("sm_immunity_mode", "1", FCVAR_SPONLY, "Mode for deciding immunity protection");

    57 /* Default flags */

    58 AdminFlag g_DefaultFlags[26] =

    59 {

    60 	Admin_Reservation, Admin_Generic, Admin_Kick, Admin_Ban, Admin_Unban,

    61 	Admin_Slay, Admin_Changemap, Admin_Convars, Admin_Config, Admin_Chat,

    62 	Admin_Vote, Admin_Password, Admin_RCON, Admin_Cheats, Admin_Custom1,

    63 	Admin_Custom2, Admin_Custom3, Admin_Custom4, Admin_Custom5, Admin_Custom6,

    64 	Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic,

    65 	Admin_Root

    66 };

    69 class FlagReader : public ITextListener_SMC

    70 {

    71 public:

    72 	void LoadLevels()

    73 	{

    74 		if (!Parse())

    75 		{

    76 			memcpy(g_FlagLetters, g_DefaultFlags, sizeof(AdminFlag) * 26);

    77 			for (unsigned int i=0; i<20; i++)

    78 			{

    79 				g_FlagSet[i] = true;

    80 			}

    81 			g_FlagSet[25] = true;

    82 		}

    83 	}

    84 private:

    85 	bool Parse()

    86 	{

    87 		SMCStates states;

    88 		SMCError error;

    90 		m_bFileNameLogged = false;

    91 		g_SourceMod.BuildPath(Path_SM, m_File, sizeof(m_File), "configs/admin_levels.cfg");

    93 		if ((error = textparsers->ParseFile_SMC(m_File, this, &states))

    94 			!= SMCError_Okay)

    95 		{

    96 			const char *err_string = textparsers->GetSMCErrorString(error);

    97 			if (!err_string)

    98 			{

    99 				err_string = "Unknown error";

   100 			}

   101 			ParseError(NULL, "Error %d (%s)", error, err_string);

   102 			return false;

   103 		}

   105 		return true;

   106 	}

   107 	void ReadSMC_ParseStart()

   108 	{

   109 		m_LevelState = LEVEL_STATE_NONE;

   110 		m_IgnoreLevel = 0;

   111 		memset(g_FlagSet, 0, sizeof(g_FlagSet));

   112 	}

   113 	SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name)

   114 	{

   115 		if (m_IgnoreLevel)

   116 		{

   117 			m_IgnoreLevel++;

   118 			return SMCResult_Continue;

   119 		}

   121 		if (m_LevelState == LEVEL_STATE_NONE)

   122 		{

   123 			if (strcmp(name, "Levels") == 0)

   124 			{

   125 				m_LevelState = LEVEL_STATE_LEVELS;

   126 			}

   127 			else

   128 			{

   129 				m_IgnoreLevel++;

   130 			}

   131 		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

   132 			if (strcmp(name, "Flags") == 0)

   133 			{

   134 				m_LevelState = LEVEL_STATE_FLAGS;

   135 			}

   136 			else

   137 			{

   138 				m_IgnoreLevel++;

   139 			}

   140 		}

   141 		else

   142 		{

   143 			m_IgnoreLevel++;

   144 		}

   146 		return SMCResult_Continue;

   147 	}

   148 	SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)

   149 	{

   150 		if (m_LevelState != LEVEL_STATE_FLAGS || m_IgnoreLevel)

   151 		{

   152 			return SMCResult_Continue;

   153 		}

   155 		unsigned char c = (unsigned)value[0];

   157 		if (c < (unsigned)'a' || c > (unsigned)'z')

   158 		{

   159 			ParseError(states, "Flag \"%c\" is not a lower-case ASCII letter", c);

   160 			return SMCResult_Continue;

   161 		}

   163 		c -= (unsigned)'a';

   165 		assert(c >= 0 && c < 26);

   167 		if (!g_Admins.FindFlag(key, &g_FlagLetters[c]))

   168 		{

   169 			ParseError(states, "Unrecognized admin level \"%s\"", key);

   170 			return SMCResult_Continue;

   171 		}

   173 		g_FlagSet[c] = true;

   175 		return SMCResult_Continue;

   176 	}

   177 	SMCResult ReadSMC_LeavingSection(const SMCStates *states)

   178 	{

   179 		if (m_IgnoreLevel)

   180 		{

   181 			m_IgnoreLevel--;

   182 			return SMCResult_Continue;

   183 		}

   185 		if (m_LevelState == LEVEL_STATE_FLAGS)

   186 		{

   187 			m_LevelState = LEVEL_STATE_LEVELS;

   188 			return SMCResult_Halt;

   189 		}

   190 		else if (m_LevelState == LEVEL_STATE_LEVELS)

   191 		{

   192 			m_LevelState = LEVEL_STATE_NONE;

   193 		}

   195 		return SMCResult_Continue;

   196 	}

   197 	void ParseError(const SMCStates *states, const char *message, ...)

   198 	{

   199 		va_list ap;

   200 		char buffer[256];

   202 		va_start(ap, message);

   203 		UTIL_FormatArgs(buffer, sizeof(buffer), message, ap);

   204 		va_end(ap);

   206 		if (!m_bFileNameLogged)

   207 		{

   208 			g_Logger.LogError("[SM] Parse error(s) detected in file \"%s\":", m_File);

   209 			m_bFileNameLogged = true;

   210 		}

   212 		g_Logger.LogError("[SM] (Line %d): %s", states ? states->line : 0, buffer);

   213 	}

   214 private:

   215 	bool m_bFileNameLogged;

   216 	char m_File[PLATFORM_MAX_PATH];

   217 	int m_LevelState;

   218 	int m_IgnoreLevel;

   219 } s_FlagReader;

   221 AdminCache::AdminCache()

   222 {

   223 	m_pCmdOverrides = sm_trie_create();

   224 	m_pCmdGrpOverrides = sm_trie_create();

   225 	m_pStrings = new BaseStringTable(1024);

   226 	m_pMemory = m_pStrings->GetMemTable();

   227 	m_FreeGroupList = m_FirstGroup = m_LastGroup = INVALID_GROUP_ID;

   228 	m_FreeUserList = m_FirstUser = m_LastUser = INVALID_ADMIN_ID;

   229 	m_pGroups = sm_trie_create();

   230 	m_pCacheFwd = NULL;

   231 	m_FirstGroup = -1;

   232 	m_pAuthTables = sm_trie_create();

   233 	m_InvalidatingAdmins = false;

   234 	m_destroying = false;

   235 	m_pLevelNames = sm_trie_create();

   236 }

   238 AdminCache::~AdminCache()

   239 {

   240 	m_destroying = true;

   241 	DumpAdminCache(AdminCache_Overrides, false);

   242 	DumpAdminCache(AdminCache_Groups, false);

   244 	sm_trie_destroy(m_pCmdGrpOverrides);

   245 	sm_trie_destroy(m_pCmdOverrides);

   247 	if (m_pGroups)

   248 	{

   249 		sm_trie_destroy(m_pGroups);

   250 	}

   252 	List<AuthMethod>::iterator iter;

   253 	for (iter=m_AuthMethods.begin();

   254 		 iter!=m_AuthMethods.end();

   255 		 iter++)

   256 	{

   257 		sm_trie_destroy((*iter).table);

   258 	}

   260 	sm_trie_destroy(m_pAuthTables);

   262 	delete m_pStrings;

   264 	sm_trie_destroy(m_pLevelNames);

   265 }

   267 void AdminCache::OnSourceModStartup(bool late)

   268 {

   269 	RegisterAuthIdentType("steam");

   270 	RegisterAuthIdentType("name");

   271 	RegisterAuthIdentType("ip");

   273 	NameFlag("reservation", Admin_Reservation);

   274 	NameFlag("kick", Admin_Kick);

   275 	NameFlag("generic", Admin_Generic);

   276 	NameFlag("ban", Admin_Ban);

   277 	NameFlag("unban", Admin_Unban);

   278 	NameFlag("slay", Admin_Slay);

   279 	NameFlag("changemap", Admin_Changemap);

   280 	NameFlag("cvars", Admin_Convars);

   281 	NameFlag("config", Admin_Config);

   282 	NameFlag("chat", Admin_Chat);

   283 	NameFlag("vote", Admin_Vote);

   284 	NameFlag("password", Admin_Password);

   285 	NameFlag("rcon", Admin_RCON);

   286 	NameFlag("cheats", Admin_Cheats);

   287 	NameFlag("root", Admin_Root);

   288 	NameFlag("custom1", Admin_Custom1);

   289 	NameFlag("custom2", Admin_Custom2);

   290 	NameFlag("custom3", Admin_Custom3);

   291 	NameFlag("custom4", Admin_Custom4);

   292 	NameFlag("custom5", Admin_Custom5);

   293 	NameFlag("custom6", Admin_Custom6);

   294 }

   296 void AdminCache::OnSourceModAllInitialized()

   297 {

   298 	m_pCacheFwd = g_Forwards.CreateForward("OnRebuildAdminCache", ET_Ignore, 1, NULL, Param_Cell);

   299 	g_ShareSys.AddInterface(NULL, this);

   300 }

   302 void AdminCache::OnSourceModLevelChange(const char *mapName)

   303 {

   304 	int i;

   305 	AdminFlag flag;

   307 	/* For now, we only read these once per level. */

   308 	s_FlagReader.LoadLevels();

   310 	for (i = 0; i < 26; i++)

   311 	{

   312 		if (FindFlag('a' + i, &flag))

   313 		{

   314 			g_ReverseFlags[flag] = 'a' + i;

   315 		}

   316 		else

   317 		{

   318 			g_ReverseFlags[flag] = '?';

   319 		}

   320 	}

   321 }

   323 void AdminCache::OnSourceModShutdown()

   324 {

   325 	g_Forwards.ReleaseForward(m_pCacheFwd);

   326 	m_pCacheFwd = NULL;

   327 }

   329 void AdminCache::OnSourceModPluginsLoaded()

   330 {

   331 	DumpAdminCache(AdminCache_Overrides, true);

   332 	DumpAdminCache(AdminCache_Groups, true);

   333 }

   335 void AdminCache::NameFlag(const char *str, AdminFlag flag)

   336 {

   337 	sm_trie_insert(m_pLevelNames, str, (void *)flag);

   338 }

   340 bool AdminCache::FindFlag(const char *str, AdminFlag *pFlag)

   341 {

   342 	void *obj;

   343 	if (!sm_trie_retrieve(m_pLevelNames, str, &obj))

   344 	{

   345 		return false;

   346 	}

   348 	if (pFlag)

   349 	{

   350 		*pFlag = (AdminFlag)(int)obj;

   351 	}

   353 	return true;

   354 }

   356 void AdminCache::AddCommandOverride(const char *cmd, OverrideType type, FlagBits flags)

   357 {

   358 	Trie *pTrie = NULL;

   359 	if (type == Override_Command)

   360 	{

   361 		pTrie = m_pCmdOverrides;

   362 	} else if (type == Override_CommandGroup) {

   363 		pTrie = m_pCmdGrpOverrides;

   364 	} else {

   365 		return;

   366 	}

   368 	sm_trie_insert(pTrie, cmd, (void *)(unsigned int)flags);

   370 	g_ConCmds.UpdateAdminCmdFlags(cmd, type, flags, false);

   371 }

   373 bool AdminCache::GetCommandOverride(const char *cmd, OverrideType type, FlagBits *pFlags)

   374 {

   375 	Trie *pTrie = NULL;

   377 	if (type == Override_Command)

   378 	{

   379 		pTrie = m_pCmdOverrides;

   380 	} else if (type == Override_CommandGroup) {

   381 		pTrie = m_pCmdGrpOverrides;

   382 	} else {

   383 		return false;

   384 	}

   386 	void *object;

   387 	if (sm_trie_retrieve(pTrie, cmd, &object))

   388 	{

   389 		if (pFlags)

   390 		{

   391 			*pFlags = (FlagBits)object;

   392 		}

   393 		return true;

   394 	}

   396 	return false;

   397 }

   399 void AdminCache::UnsetCommandOverride(const char *cmd, OverrideType type)

   400 {

   401 	if (type == Override_Command)

   402 	{

   403 		return _UnsetCommandOverride(cmd);

   404 	} else if (type == Override_CommandGroup) {

   405 		return _UnsetCommandGroupOverride(cmd);

   406 	}

   407 }

   409 void AdminCache::_UnsetCommandGroupOverride(const char *group)

   410 {

   411 	if (!m_pCmdGrpOverrides)

   412 	{

   413 		return;

   414 	}

   416 	sm_trie_delete(m_pCmdGrpOverrides, group);

   418 	g_ConCmds.UpdateAdminCmdFlags(group, Override_CommandGroup, 0, true);

   419 }

   421 void AdminCache::_UnsetCommandOverride(const char *cmd)

   422 {

   423 	if (!m_pCmdOverrides)

   424 	{

   425 		return;

   426 	}

   428 	sm_trie_delete(m_pCmdOverrides, cmd);

   430 	g_ConCmds.UpdateAdminCmdFlags(cmd, Override_Command, 0, true);

   431 }

   433 void AdminCache::DumpCommandOverrideCache(OverrideType type)

   434 {

   435 	if (type == Override_Command && m_pCmdOverrides)

   436 	{

   437 		sm_trie_clear(m_pCmdOverrides);

   438 	} else if (type == Override_CommandGroup && m_pCmdGrpOverrides) {

   439 		sm_trie_clear(m_pCmdGrpOverrides);

   440 	}

   441 }

   443 AdminId AdminCache::CreateAdmin(const char *name)

   444 {

   445 	AdminId id;

   446 	AdminUser *pUser;

   448 	if (m_FreeUserList != INVALID_ADMIN_ID)

   449 	{

   450 		pUser = (AdminUser *)m_pMemory->GetAddress(m_FreeUserList);

   451 		assert(pUser->magic == USR_MAGIC_UNSET);

   452 		id = m_FreeUserList;

   453 		m_FreeUserList = pUser->next_user;

   454 	}

   455 	else

   456 	{

   457 		id = m_pMemory->CreateMem(sizeof(AdminUser), (void **)&pUser);

   458 		pUser->grp_size = 0;

   459 		pUser->grp_table = -1;

   460 	}

   462 	pUser->flags = 0;

   463 	pUser->eflags = 0;

   464 	pUser->grp_count = 0;

   465 	pUser->password = -1;

   466 	pUser->magic = USR_MAGIC_SET;

   467 	pUser->auth.identidx = -1;

   468 	pUser->auth.index = 0;

   469 	pUser->immunity_level = 0;

   470 	pUser->serialchange = 1;

   472 	if (m_FirstUser == INVALID_ADMIN_ID)

   473 	{

   474 		m_FirstUser = id;

   475 		m_LastUser = id;

   476 	}

   477 	else

   478 	{

   479 		AdminUser *pPrev = (AdminUser *)m_pMemory->GetAddress(m_LastUser);

   480 		pPrev->next_user = id;

   481 		pUser->prev_user = m_LastUser;

   482 		m_LastUser = id;

   483 	}

   485 	/* Since we always append to the tail, we should invalidate their next */

   486 	pUser->next_user = -1;

   488 	if (name && name[0] != '\0')

   489 	{

   490 		int nameidx = m_pStrings->AddString(name);

   491 		pUser = (AdminUser *)m_pMemory->GetAddress(id);

   492 		pUser->nameidx = nameidx;

   493 	}

   494 	else

   495 	{

   496 		pUser->nameidx = -1;

   497 	}

   499 	return id;

   500 }

   502 GroupId AdminCache::AddGroup(const char *group_name)

   503 {

   504 	if (sm_trie_retrieve(m_pGroups, group_name, NULL))

   505 	{

   506 		return INVALID_GROUP_ID;

   507 	}

   509 	GroupId id;

   510 	AdminGroup *pGroup;

   511 	if (m_FreeGroupList != INVALID_GROUP_ID)

   512 	{

   513 		pGroup = (AdminGroup *)m_pMemory->GetAddress(m_FreeGroupList);

   514 		assert(pGroup->magic == GRP_MAGIC_UNSET);

   515 		id = m_FreeGroupList;

   516 		m_FreeGroupList = pGroup->next_grp;

   517 	} else {

   518 		id = m_pMemory->CreateMem(sizeof(AdminGroup), (void **)&pGroup);

   519 	}

   521 	pGroup->immunity_level = 0;

   522 	pGroup->immune_table = -1;

   523 	pGroup->magic = GRP_MAGIC_SET;

   524 	pGroup->next_grp = INVALID_GROUP_ID;

   525 	pGroup->pCmdGrpTable = NULL;

   526 	pGroup->pCmdTable = NULL;

   527 	pGroup->addflags = 0;

   529 	if (m_FirstGroup == INVALID_GROUP_ID)

   530 	{

   531 		m_FirstGroup = id;

   532 		m_LastGroup = id;

   533 		pGroup->prev_grp = INVALID_GROUP_ID;

   534 	} else {

   535 		AdminGroup *pPrev = (AdminGroup *)m_pMemory->GetAddress(m_LastGroup);

   536 		assert(pPrev->magic == GRP_MAGIC_SET);

   537 		pPrev->next_grp = id;

   538 		pGroup->prev_grp = m_LastGroup;

   539 		m_LastGroup = id;

   540 	}

   542 	int nameidx = m_pStrings->AddString(group_name);

   543 	pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   544 	pGroup->nameidx = nameidx;

   546 	sm_trie_insert(m_pGroups, group_name, (void *)id);

   548 	return id;

   549 }

   551 GroupId AdminCache::FindGroupByName(const char *group_name)

   552 {

   553 	void *object;

   555 	if (!sm_trie_retrieve(m_pGroups, group_name, &object))

   556 	{

   557 		return INVALID_GROUP_ID;

   558 	}

   560 	GroupId id = (GroupId)object;

   561 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   563 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   564 	{

   565 		return INVALID_GROUP_ID;

   566 	}

   568 	return id;

   569 }

   571 void AdminCache::SetGroupAddFlag(GroupId id, AdminFlag flag, bool enabled)

   572 {

   573 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   574 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   575 	{

   576 		return;

   577 	}

   579 	if (flag < Admin_Reservation || flag >= AdminFlags_TOTAL)

   580 	{

   581 		return;

   582 	}

   584 	FlagBits bits = (1<<(FlagBits)flag);

   586 	if (enabled)

   587 	{

   588 		pGroup->addflags |= bits;

   589 	} else {

   590 		pGroup->addflags &= ~bits;

   591 	}

   592 }

   594 bool AdminCache::GetGroupAddFlag(GroupId id, AdminFlag flag)

   595 {

   596 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   597 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   598 	{

   599 		return false;

   600 	}

   602 	if (flag < Admin_Reservation || flag >= AdminFlags_TOTAL)

   603 	{

   604 		return false;

   605 	}

   607 	FlagBits bit = 1<<(FlagBits)flag;

   608 	return ((pGroup->addflags & bit) == bit);

   609 }

   611 FlagBits AdminCache::GetGroupAddFlags(GroupId id)

   612 {

   613 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   614 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   615 	{

   616 		return 0;

   617 	}

   619 	return pGroup->addflags;

   620 }

   622 const char *AdminCache::GetGroupName(GroupId gid)

   623 {

   624 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

   625 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   626 	{

   627 		return NULL;

   628 	}

   630 	return m_pStrings->GetString(pGroup->nameidx);

   631 }

   633 void AdminCache::SetGroupGenericImmunity(GroupId id, ImmunityType type, bool enabled)

   634 {

   635 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   636 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   637 	{

   638 		return;

   639 	}

   641 	unsigned int level = 0;

   643 	if (enabled)

   644 	{

   645 		if (type == Immunity_Default)

   646 		{

   647 			level = 1;

   648 		} else if (type == Immunity_Global) {

   649 			level = 2;

   650 		}

   651 		if (level > pGroup->immunity_level)

   652 		{

   653 			pGroup->immunity_level = level;

   654 		}

   655 	} else {

   656 		pGroup->immunity_level = 0;

   657 	}

   658 }

   660 bool AdminCache::GetGroupGenericImmunity(GroupId id, ImmunityType type)

   661 {

   662 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   663 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   664 	{

   665 		return false;

   666 	}

   668 	if (type == Immunity_Default && pGroup->immunity_level >= 1)

   669 	{

   670 		return true;

   671 	} else if (type == Immunity_Global && pGroup->immunity_level >= 2) {

   672 		return true;

   673 	}

   675 	return false;

   676 }

   678 void AdminCache::AddGroupImmunity(GroupId id, GroupId other_id)

   679 {

   680 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(other_id);

   681 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   682 	{

   683 		return;

   684 	}

   686 	pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   687 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   688 	{

   689 		return;

   690 	}

   692 	/* We always need to resize the immunity table */

   693 	int *table, tblidx;

   694 	if (pGroup->immune_table == -1)

   695 	{

   696 		tblidx = m_pMemory->CreateMem(sizeof(int) * 2, (void **)&table);

   697 		pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   698 		table[0] = 0;

   699 	} else {

   700 		int *old_table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

   701 		/* Break out if this group is already in the list */

   702 		for (int i=0; i<old_table[0]; i++)

   703 		{

   704 			if (old_table[1+i] == other_id)

   705 			{

   706 				return;

   707 			}

   708 		}

   709 		tblidx = m_pMemory->CreateMem(sizeof(int) * (old_table[0] + 2), (void **)&table);

   710 		/* Get the old address again in case of resize */

   711 		pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   712 		old_table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

   713 		table[0] = old_table[0];

   714 		for (unsigned int i=1; i<=(unsigned int)old_table[0]; i++)

   715 		{

   716 			table[i] = old_table[i];

   717 		}

   718 	}

   720 	/* Assign */

   721 	pGroup->immune_table = tblidx;

   723 	/* Add to the array */

   724 	table[0]++;

   725 	table[table[0]] = other_id;

   726 }

   728 unsigned int AdminCache::GetGroupImmunityCount(GroupId id)

   729 {

   730 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   731 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   732 	{

   733 		return 0;

   734 	}

   736 	if (pGroup->immune_table == -1)

   737 	{

   738 		return 0;

   739 	}

   741 	int *table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

   743 	return table[0];

   744 }

   746 GroupId AdminCache::GetGroupImmunity(GroupId id, unsigned int number)

   747 {

   748 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   749 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   750 	{

   751 		return INVALID_GROUP_ID;

   752 	}

   754 	if (pGroup->immune_table == -1)

   755 	{

   756 		return INVALID_GROUP_ID;

   757 	}

   759 	int *table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

   760 	if (number >= (unsigned int)table[0])

   761 	{

   762 		return INVALID_GROUP_ID;

   763 	}

   765 	return table[1 + number];

   766 }

   768 void AdminCache::AddGroupCommandOverride(GroupId id, const char *name, OverrideType type, OverrideRule rule)

   769 {

   770 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   771 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   772 	{

   773 		return;

   774 	}

   776 	Trie *pTrie = NULL;

   777 	if (type == Override_Command)

   778 	{

   779 		if (pGroup->pCmdTable == NULL)

   780 		{

   781 			pGroup->pCmdTable = sm_trie_create();

   782 		}

   783 		pTrie = pGroup->pCmdTable;

   784 	} else if (type == Override_CommandGroup) {

   785 		if (pGroup->pCmdGrpTable == NULL)

   786 		{

   787 			pGroup->pCmdGrpTable = sm_trie_create();

   788 		}

   789 		pTrie = pGroup->pCmdGrpTable;

   790 	} else {

   791 		return;

   792 	}

   794 	sm_trie_insert(pTrie, name, (void *)(int)rule);

   795 }

   797 bool AdminCache::GetGroupCommandOverride(GroupId id, const char *name, OverrideType type, OverrideRule *pRule)

   798 {

   799 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   800 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   801 	{

   802 		return false;

   803 	}

   805 	Trie *pTrie = NULL;

   806 	if (type == Override_Command)

   807 	{

   808 		if (pGroup->pCmdTable == NULL)

   809 		{

   810 			return false;

   811 		}

   812 		pTrie = pGroup->pCmdTable;

   813 	} else if (type == Override_CommandGroup) {

   814 		if (pGroup->pCmdGrpTable == NULL)

   815 		{

   816 			return false;

   817 		}

   818 		pTrie = pGroup->pCmdGrpTable;

   819 	} else {

   820 		return false;

   821 	}

   823 	void *object;

   824 	if (!sm_trie_retrieve(pTrie, name, &object))

   825 	{

   826 		return false;

   827 	}

   829 	if (pRule)

   830 	{

   831 		*pRule = (OverrideRule)(int)object;

   832 	}

   834 	return true;

   835 }

   837 Trie *AdminCache::GetMethodByIndex(unsigned int index)

   838 {

   839 	List<AuthMethod>::iterator iter;

   840 	for (iter=m_AuthMethods.begin();

   841 		 iter!=m_AuthMethods.end();

   842 		 iter++)

   843 	{

   844 		if (index-- == 0)

   845 		{

   846 			return (*iter).table;

   847 		}

   848 	}

   850 	return NULL;

   851 }

   853 bool AdminCache::InvalidateAdmin(AdminId id)

   854 {

   855 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

   856 	AdminUser *pOther;

   857 	if (!pUser || pUser->magic != USR_MAGIC_SET)

   858 	{

   859 		return false;

   860 	}

   862 	if (!m_InvalidatingAdmins && !m_destroying)

   863 	{

   864 		g_Players.ClearAdminId(id);

   865 	}

   867 	/* Unlink from the dbl link list */

   868 	if (id == m_FirstUser && id == m_LastUser)

   869 	{

   870 		m_FirstUser = INVALID_ADMIN_ID;

   871 		m_LastUser = INVALID_ADMIN_ID;

   872 	} else if (id == m_FirstUser) {

   873 		m_FirstUser = pUser->next_user;

   874 		pOther = (AdminUser *)m_pMemory->GetAddress(m_FirstUser);

   875 		pOther->prev_user = INVALID_ADMIN_ID;

   876 	} else if (id == m_LastUser) {

   877 		m_LastUser = pUser->prev_user;

   878 		pOther = (AdminUser *)m_pMemory->GetAddress(m_LastUser);

   879 		pOther->next_user = INVALID_ADMIN_ID;

   880 	} else {

   881 		pOther = (AdminUser *)m_pMemory->GetAddress(pUser->prev_user);

   882 		pOther->next_user = pUser->next_user;

   883 		pOther = (AdminUser *)m_pMemory->GetAddress(pUser->next_user);

   884 		pOther->prev_user = pUser->prev_user;

   885 	}

   887 	/* Unlink from auth tables */

   888 	if (pUser->auth.identidx != -1)

   889 	{

   890 		Trie *pTrie = GetMethodByIndex(pUser->auth.index);

   891 		if (pTrie)

   892 		{

   893 			sm_trie_delete(pTrie, m_pStrings->GetString(pUser->auth.identidx));

   894 		}

   895 	}

   897 	/* Clear table counts */

   898 	pUser->grp_count = 0;

   900 	/* Link into free list */

   901 	pUser->magic = USR_MAGIC_UNSET;

   902 	pUser->next_user = m_FreeUserList;

   903 	m_FreeUserList = id;

   905 	/* Unset serial change */

   906 	pUser->serialchange = 0;

   908 	return true;

   909 }

   912 void AdminCache::InvalidateGroup(GroupId id)

   913 {

   914 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

   915 	AdminGroup *pOther;

   917 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

   918 	{

   919 		return;

   920 	}

   922 	const char *str = m_pStrings->GetString(pGroup->nameidx);

   923 	sm_trie_delete(m_pGroups, str);

   925 	/* Unlink from the live dbllink list */

   926 	if (id == m_FirstGroup && id == m_LastGroup)

   927 	{

   928 		m_LastGroup = INVALID_GROUP_ID;

   929 		m_FirstGroup = INVALID_GROUP_ID;

   930 	} else if (id == m_FirstGroup) {

   931 		m_FirstGroup = pGroup->next_grp;

   932 		pOther = (AdminGroup *)m_pMemory->GetAddress(m_FirstGroup);

   933 		pOther->prev_grp = INVALID_GROUP_ID;

   934 	} else if (id == m_LastGroup) {

   935 		m_LastGroup = pGroup->prev_grp;

   936 		pOther = (AdminGroup *)m_pMemory->GetAddress(m_LastGroup);

   937 		pOther->next_grp = INVALID_GROUP_ID;

   938 	} else {

   939 		pOther = (AdminGroup *)m_pMemory->GetAddress(pGroup->prev_grp);

   940 		pOther->next_grp = pGroup->next_grp;

   941 		pOther = (AdminGroup *)m_pMemory->GetAddress(pGroup->next_grp);

   942 		pOther->prev_grp = pGroup->prev_grp;

   943 	}

   945 	/* Free any used memory to be safe */

   946 	if (pGroup->pCmdGrpTable)

   947 	{

   948 		sm_trie_destroy(pGroup->pCmdGrpTable);

   949 		pGroup->pCmdGrpTable = NULL;

   950 	}

   951 	if (pGroup->pCmdTable)

   952 	{

   953 		sm_trie_destroy(pGroup->pCmdTable);

   954 		pGroup->pCmdTable = NULL;

   955 	}

   957 	/* Link into the free list */

   958 	pGroup->magic = GRP_MAGIC_UNSET;

   959 	pGroup->next_grp = m_FreeGroupList;

   960 	m_FreeGroupList = id;

   962 	int idx = m_FirstUser;

   963 	AdminUser *pUser;

   964 	int *table;

   965 	while (idx != INVALID_ADMIN_ID)

   966 	{

   967 		pUser = (AdminUser *)m_pMemory->GetAddress(idx);

   968 		if (pUser->grp_count > 0)

   969 		{

   970 			table = (int *)m_pMemory->GetAddress(pUser->grp_table);

   971 			for (unsigned int i=0; i<pUser->grp_count; i++)

   972 			{

   973 				if (table[i] == id)

   974 				{

   975 					/* We have to remove this entry */

   976 					for (unsigned int j=i+1; j<pUser->grp_count; j++)

   977 					{

   978 						/* Move everything down by one */

   979 						table[j-1] = table[j];

   980 					}

   981 					/* Decrease count */

   982 					pUser->grp_count--;

   983 					/* Recalculate effective flags */

   984 					pUser->eflags = pUser->flags;

   985 					for (unsigned int j=0; j<pUser->grp_count; j++)

   986 					{

   987 						pOther = (AdminGroup *)m_pMemory->GetAddress(table[j]);

   988 						pUser->eflags |= pOther->addflags;

   989 					}

   990 					/* Mark as changed */

   991 					pUser->serialchange++;

   992 					/* Break now, duplicates aren't allowed */

   993 					break;

   994 				}

   995 			}

   996 		}

   997 		idx = pUser->next_user;

   998 	}

   999 }

  1001 void AdminCache::InvalidateGroupCache()

  1002 {

  1003 	/* Nuke the free list */

  1004 	m_FreeGroupList = -1;

  1006 	/* Nuke reverse lookups */

  1007 	sm_trie_clear(m_pGroups);

  1009 	/* Free memory on groups */

  1010 	GroupId cur = m_FirstGroup;

  1011 	AdminGroup *pGroup;

  1012 	while (cur != INVALID_GROUP_ID)

  1013 	{

  1014 		pGroup = (AdminGroup *)m_pMemory->GetAddress(cur);

  1015 		assert(pGroup->magic == GRP_MAGIC_SET);

  1016 		if (pGroup->pCmdGrpTable)

  1017 		{

  1018 			sm_trie_destroy(pGroup->pCmdGrpTable);

  1019 		}

  1020 		if (pGroup->pCmdTable)

  1021 		{

  1022 			sm_trie_destroy(pGroup->pCmdTable);

  1023 		}

  1024 		cur = pGroup->next_grp;

  1025 	}

  1027 	m_FirstGroup = INVALID_GROUP_ID;

  1028 	m_LastGroup = INVALID_GROUP_ID;

  1030 	InvalidateAdminCache(false);

  1032 	/* Reset the memory table */

  1033 	m_pMemory->Reset();

  1034 }

  1036 void AdminCache::AddAdminListener(IAdminListener *pListener)

  1037 {

  1038 	m_hooks.push_back(pListener);

  1039 }

  1041 void AdminCache::RemoveAdminListener(IAdminListener *pListener)

  1042 {

  1043 	m_hooks.remove(pListener);

  1044 }

  1046 void AdminCache::RegisterAuthIdentType(const char *name)

  1047 {

  1048 	if (sm_trie_retrieve(m_pAuthTables, name, NULL))

  1049 	{

  1050 		return;

  1051 	}

  1053 	Trie *pAuth = sm_trie_create();

  1055 	AuthMethod method;

  1056 	method.name.assign(name);

  1057 	method.table = pAuth;

  1059 	m_AuthMethods.push_back(method);

  1061 	sm_trie_insert(m_pAuthTables, name, pAuth);

  1062 }

  1064 void AdminCache::InvalidateAdminCache(bool unlink_admins)

  1065 {

  1066 	m_InvalidatingAdmins = true;

  1067 	if (!m_destroying)

  1068 	{

  1069 		g_Players.ClearAllAdmins();

  1070 	}

  1071 	/* Wipe the identity cache first */

  1072 	List<AuthMethod>::iterator iter;

  1073 	for (iter=m_AuthMethods.begin();

  1074 		 iter!=m_AuthMethods.end();

  1075 		 iter++)

  1076 	{

  1077 		sm_trie_clear((*iter).table);

  1078 	}

  1080 	if (unlink_admins)

  1081 	{

  1082 		while (m_FirstUser != INVALID_ADMIN_ID)

  1083 		{

  1084 			InvalidateAdmin(m_FirstUser);

  1085 		}

  1086 	} else {

  1087 		m_FirstUser = -1;

  1088 		m_LastUser = -1;

  1089 		m_FreeUserList = -1;

  1090 	}

  1091 	m_InvalidatingAdmins = false;

  1092 }

  1094 void AdminCache::DumpAdminCache(AdminCachePart part, bool rebuild)

  1095 {

  1096 	List<IAdminListener *>::iterator iter;

  1097 	IAdminListener *pListener;

  1098 	cell_t result;

  1100 	if (part == AdminCache_Overrides)

  1101 	{

  1102 		DumpCommandOverrideCache(Override_Command);

  1103 		DumpCommandOverrideCache(Override_CommandGroup);

  1104 		if (rebuild && !m_destroying)

  1105 		{

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

  1107 			{

  1108 				pListener = (*iter);

  1109 				pListener->OnRebuildOverrideCache();

  1110 			}

  1111 			m_pCacheFwd->PushCell(part);

  1112 			m_pCacheFwd->Execute(&result);

  1113 		}

  1114 	} else if (part == AdminCache_Groups || part == AdminCache_Admins) {

  1115 		if (part == AdminCache_Groups)

  1116 		{

  1117 			InvalidateGroupCache();

  1118 			if (rebuild && !m_destroying)

  1119 			{

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

  1121 				{

  1122 					pListener = (*iter);

  1123 					pListener->OnRebuildGroupCache();

  1124 				}

  1125 				m_pCacheFwd->PushCell(part);

  1126 				m_pCacheFwd->Execute(&result);

  1127 			}

  1128 		}

  1129 		InvalidateAdminCache(true);

  1130 		if (rebuild && !m_destroying)

  1131 		{

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

  1133 			{

  1134 				pListener = (*iter);

  1135 				pListener->OnRebuildAdminCache((part == AdminCache_Groups));

  1136 			}

  1137 			m_pCacheFwd->PushCell(AdminCache_Admins);

  1138 			m_pCacheFwd->Execute(&result);

  1139 			g_Players.RecheckAnyAdmins();

  1140 		}

  1141 	}

  1142 }

  1144 const char *AdminCache::GetAdminName(AdminId id)

  1145 {

  1146 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1147 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1148 	{

  1149 		return NULL;

  1150 	}

  1152 	return m_pStrings->GetString(pUser->nameidx);

  1153 }

  1155 bool AdminCache::GetMethodIndex(const char *name, unsigned int *_index)

  1156 {

  1157 	List<AuthMethod>::iterator iter;

  1158 	unsigned int index = 0;

  1159 	for (iter=m_AuthMethods.begin();

  1160 		 iter!=m_AuthMethods.end();

  1161 		 iter++,index++)

  1162 	{

  1163 		if ((*iter).name.compare(name) == 0)

  1164 		{

  1165 			*_index = index;

  1166 			return true;

  1167 		}

  1168 	}

  1170 	return false;

  1171 }

  1173 bool AdminCache::BindAdminIdentity(AdminId id, const char *auth, const char *ident)

  1174 {

  1175 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1176 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1177 	{

  1178 		return false;

  1179 	}

  1181 	Trie *pTable;

  1182 	if (!sm_trie_retrieve(m_pAuthTables, auth, (void **)&pTable))

  1183 	{

  1184 		return false;

  1185 	}

  1187 	if (sm_trie_retrieve(pTable, ident, NULL))

  1188 	{

  1189 		return false;

  1190 	}

  1192 	int i_ident = m_pStrings->AddString(ident);

  1194 	pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1195 	pUser->auth.identidx = i_ident;

  1196 	GetMethodIndex(auth, &pUser->auth.index);

  1198 	return sm_trie_insert(pTable, ident, (void **)id);

  1199 }

  1201 AdminId AdminCache::FindAdminByIdentity(const char *auth, const char *identity)

  1202 {

  1203 	Trie *pTable;

  1204 	if (!sm_trie_retrieve(m_pAuthTables, auth, (void **)&pTable))

  1205 	{

  1206 		return INVALID_ADMIN_ID;

  1207 	}

  1209 	void *object;

  1210 	if (!sm_trie_retrieve(pTable, identity, &object))

  1211 	{

  1212 		return INVALID_ADMIN_ID;

  1213 	}

  1215 	return (AdminId)object;

  1216 }

  1218 void AdminCache::SetAdminFlag(AdminId id, AdminFlag flag, bool enabled)

  1219 {

  1220 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1221 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1222 	{

  1223 		return;

  1224 	}

  1226 	if (flag < Admin_Reservation

  1227 		|| flag >= AdminFlags_TOTAL)

  1228 	{

  1229 		return;

  1230 	}

  1232 	FlagBits bits = (1<<(FlagBits)flag);

  1234 	if (enabled)

  1235 	{

  1236 		pUser->flags |= bits;

  1237 		pUser->eflags |= bits;

  1238 	} else {

  1239 		pUser->flags &= ~bits;

  1240 		pUser->eflags &= ~bits;

  1241 	}

  1243 	pUser->serialchange++;

  1244 }

  1246 bool AdminCache::GetAdminFlag(AdminId id, AdminFlag flag, AccessMode mode)

  1247 {

  1248 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1249 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1250 	{

  1251 		return false;

  1252 	}

  1254 	if (flag < Admin_Reservation

  1255 		|| flag >= AdminFlags_TOTAL)

  1256 	{

  1257 		return false;

  1258 	}

  1260 	FlagBits bit = (1<<(FlagBits)flag);

  1262 	if (mode == Access_Real)

  1263 	{

  1264 		return ((pUser->flags & bit) == bit);

  1265 	} else if (mode == Access_Effective) {

  1266 		bool has_bit = ((pUser->eflags & bit) == bit);

  1267 		if (!has_bit && flag != Admin_Root && ((pUser->eflags & ADMFLAG_ROOT) == ADMFLAG_ROOT))

  1268 		{

  1269 			has_bit = true;

  1270 		}

  1271 		return has_bit;

  1272 	}

  1274 	return false;

  1275 }

  1277 FlagBits AdminCache::GetAdminFlags(AdminId id, AccessMode mode)

  1278 {

  1279 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1280 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1281 	{

  1282 		return 0;

  1283 	}

  1285 	if (mode == Access_Real)

  1286 	{

  1287 		return pUser->flags;

  1288 	} else if (mode == Access_Effective) {

  1289 		return pUser->eflags;

  1290 	}

  1292 	return 0;

  1293 }

  1295 void AdminCache::SetAdminFlags(AdminId id, AccessMode mode, FlagBits bits)

  1296 {

  1297 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1298 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1299 	{

  1300 		return;

  1301 	}

  1303 	if (mode == Access_Real)

  1304 	{

  1305 		pUser->flags = bits;

  1306 		pUser->eflags = bits;

  1307 	} else if (mode == Access_Effective) {

  1308 		pUser->eflags = bits;

  1309 	}

  1311 	pUser->serialchange++;

  1312 }

  1314 bool AdminCache::AdminInheritGroup(AdminId id, GroupId gid)

  1315 {

  1316 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1317 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1318 	{

  1319 		return false;

  1320 	}

  1322 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

  1323 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

  1324 	{

  1325 		return false;

  1326 	}

  1328 	/* First check for duplicates */

  1329 	if (pUser->grp_count != 0)

  1330 	{

  1331 		int *temp_table = (int *)m_pMemory->GetAddress(pUser->grp_table);

  1332 		for (unsigned int i=0; i<pUser->grp_count; i++)

  1333 		{

  1334 			if (temp_table[i] == gid)

  1335 			{

  1336 				return false;

  1337 			}

  1338 		}

  1339 	}

  1341 	int *table;

  1342 	if (pUser->grp_count + 1 > pUser->grp_size)

  1343 	{

  1344 		int new_size = 0;

  1345 		int tblidx;

  1347 		if (pUser->grp_size == 0)

  1348 		{

  1349 			new_size = 2;

  1350 		} else {

  1351 			new_size = pUser->grp_size * 2;

  1352 		}

  1354 		/* Create and refresh pointers */

  1355 		tblidx = m_pMemory->CreateMem(new_size * sizeof(int), (void **)&table);

  1356 		pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1357 		pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

  1359 		/* Copy old data if necessary */

  1360 		if (pUser->grp_table != -1)

  1361 		{

  1362 			int *old_table = (int *)m_pMemory->GetAddress(pUser->grp_table);

  1363 			memcpy(table, old_table, sizeof(int) * pUser->grp_count);

  1364 		}

  1365 		pUser->grp_table = tblidx;

  1366 		pUser->grp_size = new_size;

  1367 	} else {

  1368 		table = (int *)m_pMemory->GetAddress(pUser->grp_table);

  1369 	}

  1371 	table[pUser->grp_count] = gid;

  1372 	pUser->grp_count++;

  1374 	/* Compute new effective permissions */

  1375 	pUser->eflags |= pGroup->addflags;

  1377 	if (pGroup->immunity_level > pUser->immunity_level)

  1378 	{

  1379 		pUser->immunity_level = pGroup->immunity_level;

  1380 	}

  1382 	pUser->serialchange++;

  1384 	return true;

  1385 }

  1387 bool AdminCache::IsValidAdmin(AdminId id)

  1388 {

  1389 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1390 	return (pUser != NULL && pUser->magic == USR_MAGIC_SET);

  1391 }

  1393 unsigned int AdminCache::GetAdminGroupCount(AdminId id)

  1394 {

  1395 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1396 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1397 	{

  1398 		return 0;

  1399 	}

  1401 	return pUser->grp_count;

  1402 }

  1404 GroupId AdminCache::GetAdminGroup(AdminId id, unsigned int index, const char **name)

  1405 {

  1406 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1407 	if (!pUser || pUser->magic != USR_MAGIC_SET || index >= pUser->grp_count)

  1408 	{

  1409 		return INVALID_GROUP_ID;

  1410 	}

  1412 	int *table = (int *)m_pMemory->GetAddress(pUser->grp_table);

  1414 	GroupId gid = table[index];

  1416 	if (name)

  1417 	{

  1418 		*name = GetGroupName(gid);

  1419 	}

  1421 	return gid;

  1422 }

  1424 const char *AdminCache::GetAdminPassword(AdminId id)

  1425 {

  1426 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1427 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1428 	{

  1429 		return NULL;

  1430 	}

  1432 	return m_pStrings->GetString(pUser->password);

  1433 }

  1435 void AdminCache::SetAdminPassword(AdminId id, const char *password)

  1436 {

  1437 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1438 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1439 	{

  1440 		return;

  1441 	}

  1443 	int i_password = m_pStrings->AddString(password);

  1444 	pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1445 	pUser->password = i_password;

  1446 }

  1448 unsigned int AdminCache::FlagBitsToBitArray(FlagBits bits, bool array[], unsigned int maxSize)

  1449 {

  1450 	unsigned int i;

  1451 	for (i=0; i<maxSize && i<AdminFlags_TOTAL; i++)

  1452 	{

  1453 		array[i] = ((bits & (1<<i)) == (unsigned)(1<<i));

  1454 	}

  1456 	return i;

  1457 }

  1459 FlagBits AdminCache::FlagBitArrayToBits(const bool array[], unsigned int maxSize)

  1460 {

  1461 	FlagBits bits = 0;

  1462 	for (unsigned int i=0; i<maxSize && i<AdminFlags_TOTAL; i++)

  1463 	{

  1464 		if (array[i])

  1465 		{

  1466 			bits |= (1<<i);

  1467 		}

  1468 	}

  1470 	return bits;

  1471 }

  1473 FlagBits AdminCache::FlagArrayToBits(const AdminFlag array[], unsigned int numFlags)

  1474 {

  1475 	FlagBits bits = 0;

  1476 	for (unsigned int i=0; i<numFlags && i<AdminFlags_TOTAL; i++)

  1477 	{

  1478 		bits |= (1 << (FlagBits)array[i]);

  1479 	}

  1481 	return bits;

  1482 }

  1484 unsigned int AdminCache::FlagBitsToArray(FlagBits bits, AdminFlag array[], unsigned int maxSize)

  1485 {

  1486 	unsigned int i, num=0;

  1487 	for (i=0; num<maxSize && i<AdminFlags_TOTAL; i++)

  1488 	{

  1489 		if ((bits & (1<<i)) == (unsigned)(1<<i))

  1490 		{

  1491 			array[num++] = (AdminFlag)i;

  1492 		}

  1493 	}

  1495 	return num;

  1496 }

  1498 bool AdminCache::CheckAdminFlags(AdminId id, FlagBits bits)

  1499 {

  1500 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1501 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1502 	{

  1503 		return false;

  1504 	}

  1506 	return ((pUser->eflags & bits) == bits);

  1507 }

  1509 bool AdminCache::CanAdminTarget(AdminId id, AdminId target)

  1510 {

  1511 	/**

  1512 	 * Zeroth, if the targeting AdminId is INVALID_ADMIN_ID, targeting fails.

  1513 	 * First, if the targeted AdminId is INVALID_ADMIN_ID, targeting succeeds.

  1514 	 */

  1516 	if (id == INVALID_ADMIN_ID)

  1517 	{

  1518 		return false;

  1519 	}

  1521 	if (target == INVALID_ADMIN_ID)

  1522 	{

  1523 		return true;

  1524 	}

  1526 	if (id == target)

  1527 	{

  1528 		return true;

  1529 	}

  1531 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1532 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1533 	{

  1534 		return false;

  1535 	}

  1537 	AdminUser *pTarget = (AdminUser *)m_pMemory->GetAddress(target);

  1538 	if (!pTarget || pTarget->magic != USR_MAGIC_SET)

  1539 	{

  1540 		return false;

  1541 	}

  1543 	/**

  1544 	 * Second, if the targeting admin is root, targeting succeeds.

  1545 	 */

  1546 	if (pUser->eflags & ADMFLAG_ROOT)

  1547 	{

  1548 		return true;

  1549 	}

  1551 	/** Fourth, if the targeted admin is immune from targeting admin. */

  1552 	int mode = sm_immunity_mode.GetInt();

  1553 	switch (mode)

  1554 	{

  1555 		case 1:

  1556 		{

  1557 			if (pTarget->immunity_level > pUser->immunity_level)

  1558 			{

  1559 				return false;

  1560 			}

  1561 			break;

  1562 		}

  1563 		case 3:

  1564 		{

  1565 			/* If neither has any immunity, let this pass. */

  1566 			if (!pUser->immunity_level && !pTarget->immunity_level)

  1567 			{

  1568 				return true;

  1569 			}

  1570 			/* Don't break, go to the next case. */

  1571 		}

  1572 		case 2:

  1573 		{

  1574 			if (pTarget->immunity_level >= pUser->immunity_level)

  1575 			{

  1576 				return false;

  1577 			}

  1578 			break;

  1579 		}

  1580 	}

  1582 	/**

  1583 	 * Fifth, if the targeted admin has specific immunity from the

  1584 	 *  targeting admin via group immunities, targeting fails.

  1585 	 */

  1586 	//:TODO: speed this up... maybe with trie hacks.

  1587 	//idea is to insert %d.%d in the trie after computing this and use it as a cache lookup.

  1588 	//problem is the trie cannot delete prefixes, so we'd have a problem with invalidations.

  1589 	if (pTarget->grp_count > 0 && pUser->grp_count > 0)

  1590 	{

  1591 		int *grp_table = (int *)m_pMemory->GetAddress(pTarget->grp_table);

  1592 		int *src_table = (int *)m_pMemory->GetAddress(pUser->grp_table);

  1593 		GroupId id, other;

  1594 		unsigned int num;

  1595 		for (unsigned int i=0; i<pTarget->grp_count; i++)

  1596 		{

  1597 			id = grp_table[i];

  1598 			num = GetGroupImmunityCount(id);

  1599 			for (unsigned int j=0; j<num; i++)

  1600 			{

  1601 				other = GetGroupImmunity(id, j);

  1602 				for (unsigned int k=0; k<pUser->grp_count; k++)

  1603 				{

  1604 					if (other == src_table[k])

  1605 					{

  1606 						return false;

  1607 					}

  1608 				}

  1609 			}

  1610 		}

  1611 	}

  1613 	return true;

  1614 }

  1616 bool AdminCache::FindFlag(char c, AdminFlag *pAdmFlag)

  1617 {

  1618 	if (c < 'a'

  1619 		|| c > 'z'

  1620 		|| !g_FlagSet[(unsigned)c - (unsigned)'a'])

  1621 	{

  1622 		return false;

  1623 	}

  1625 	if (pAdmFlag)

  1626 	{

  1627 		*pAdmFlag = g_FlagLetters[(unsigned)c - (unsigned)'a'];

  1628 	}

  1630 	return true;

  1631 }

  1633 bool AdminCache::FindFlagChar(AdminFlag flag, char *c)

  1634 {

  1635 	if (!g_FlagSet[flag])

  1636 	{

  1637 		return false;

  1638 	}

  1640 	if (c)

  1641 	{

  1642 		*c = g_ReverseFlags[flag];

  1643 	}

  1645 	return true;

  1646 }

  1648 FlagBits AdminCache::ReadFlagString(const char *flags, const char **end)

  1649 {

  1650 	FlagBits bits = 0;

  1652 	while (flags && (*flags != '\0'))

  1653 	{

  1654 		AdminFlag flag;

  1655 		if (!FindFlag(*flags, &flag))

  1656 		{

  1657 			break;

  1658 		}

  1659 		bits |= FlagArrayToBits(&flag, 1);

  1660 		flags++;

  1661 	}

  1663 	if (end)

  1664 	{

  1665 		*end = flags;

  1666 	}

  1668 	return bits;

  1669 }

  1671 unsigned int AdminCache::GetAdminSerialChange(AdminId id)

  1672 {

  1673 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1674 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1675 	{

  1676 		return 0;

  1677 	}

  1679 	return pUser->serialchange;

  1680 }

  1682 bool AdminCache::CanAdminUseCommand(int client, const char *cmd)

  1683 {

  1684 	FlagBits bits;

  1685 	OverrideType otype = Override_Command;

  1687 	if (cmd[0] == '@')

  1688 	{

  1689 		otype = Override_CommandGroup;

  1690 		cmd++;

  1691 	}

  1693 	if (!g_ConCmds.LookForCommandAdminFlags(cmd, &bits))

  1694 	{

  1695 		if (!GetCommandOverride(cmd, otype, &bits))

  1696 		{

  1697 			bits = 0;

  1698 		}

  1699 	}

  1701 	return g_ConCmds.CheckCommandAccess(client, cmd, bits);

  1702 }

  1704 unsigned int AdminCache::SetGroupImmunityLevel(GroupId gid, unsigned int level)

  1705 {

  1706 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

  1707 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

  1708 	{

  1709 		return 0;

  1710 	}

  1712 	unsigned int old_level = pGroup->immunity_level;

  1714 	pGroup->immunity_level = level;

  1716 	return old_level;

  1717 }

  1719 unsigned int AdminCache::GetGroupImmunityLevel(GroupId gid)

  1720 {

  1721 	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

  1722 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

  1723 	{

  1724 		return 0;

  1725 	}

  1727 	return pGroup->immunity_level;

  1728 }

  1730 unsigned int AdminCache::SetAdminImmunityLevel(AdminId id, unsigned int level)

  1731 {

  1732 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1733 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1734 	{

  1735 		return 0;

  1736 	}

  1738 	unsigned int old_level = pUser->immunity_level;

  1740 	pUser->immunity_level = level;

  1742 	return old_level;

  1743 }

  1745 unsigned int AdminCache::GetAdminImmunityLevel(AdminId id)

  1746 {

  1747 	AdminUser *pUser = (AdminUser *)m_pMemory->GetAddress(id);

  1748 	if (!pUser || pUser->magic != USR_MAGIC_SET)

  1749 	{

  1750 		return 0;

  1751 	}

  1753 	return pUser->immunity_level;

  1754 }

  1756 bool AdminCache::CheckAccess(int client, const char *cmd, FlagBits flags, bool override_only)

  1757 {

  1758 	if (client == 0)

  1759 	{

  1760 		return true;

  1761 	}

  1763 	/* Auto-detect a command if we can */

  1764 	FlagBits bits = flags;

  1765 	bool found_command = false;

  1766 	if (!override_only)

  1767 	{

  1768 		found_command = g_ConCmds.LookForCommandAdminFlags(cmd, &bits);

  1769 	}

  1771 	if (!found_command)

  1772 	{

  1773 		GetCommandOverride(cmd, Override_Command, &bits);

  1774 	}

  1776 	return g_ConCmds.CheckCommandAccess(client, cmd, bits) ? 1 : 0;

  1777 }

  1779 void iterator_glob_basic_override(Trie *pTrie, const char *key, void **value, void *data)

  1780 {

  1781 	FILE *fp;

  1782 	int flags;

  1783 	char flagstr[64];

  1785 	fp = (FILE *)data;

  1786 	flags = (int)*value;

  1787 	g_Admins.FillFlagString(flags, flagstr, sizeof(flagstr));

  1789 	fprintf(fp, "\t\"%s\"\t\t\"%s\"\n", key, flagstr);

  1790 }

  1792 void iterator_glob_grp_override(Trie *pTrie, const char *key, void **value, void *data)

  1793 {

  1794 	FILE *fp;

  1795 	int flags;

  1796 	char flagstr[64];

  1798 	fp = (FILE *)data;

  1799 	flags = (int)*value;

  1800 	g_Admins.FillFlagString(flags, flagstr, sizeof(flagstr));

  1802 	fprintf(fp, "\t\"@%s\"\t\t\"%s\"\n", key, flagstr);

  1803 }

  1805 void iterator_group_basic_override(Trie *pTrie, const char *key, void **value, void *data)

  1806 {

  1807 	FILE *fp;

  1808 	int flags;

  1809 	char flagstr[64];

  1811 	fp = (FILE *)data;

  1812 	flags = (int)*value;

  1813 	g_Admins.FillFlagString(flags, flagstr, sizeof(flagstr));

  1815 	fprintf(fp, "\t\t\t\"%s\"\t\t\"%s\"\n", key, flagstr);

  1816 }

  1818 void iterator_group_grp_override(Trie *pTrie, const char *key, void **value, void *data)

  1819 {

  1820 	FILE *fp;

  1821 	int flags;

  1822 	char flagstr[64];

  1824 	fp = (FILE *)data;

  1825 	flags = (int)*value;

  1826 	g_Admins.FillFlagString(flags, flagstr, sizeof(flagstr));

  1828 	fprintf(fp, "\t\t\t\"@%s\"\t\t\"%s\"\n", key, flagstr);

  1829 }

  1831 void AdminCache::DumpCache(FILE *fp)

  1832 {

  1833 	int *itable;

  1834 	AdminId aid;

  1835 	GroupId gid;

  1836 	char flagstr[64];

  1837 	unsigned int num;

  1838 	AdminUser *pAdmin;

  1839 	AdminGroup *pGroup;

  1840 	char name_buffer[512];

  1842 	fprintf(fp, "\"Groups\"\n{\n");

  1844 	num = 0;

  1845 	gid = m_FirstGroup;

  1846 	while (gid != INVALID_GROUP_ID

  1847 			&& (pGroup = GetGroup(gid)) != NULL)

  1848 	{

  1849 		num++;

  1850 		FillFlagString(pGroup->addflags, flagstr, sizeof(flagstr));

  1852 		fprintf(fp, "\t/* num = %d, gid = 0x%X */\n", num, gid);

  1853 		fprintf(fp, "\t\"%s\"\n\t{\n", GetString(pGroup->nameidx));

  1854 		fprintf(fp, "\t\t\"flags\"\t\t\t\"%s\"\n", flagstr);

  1855 		fprintf(fp, "\t\t\"immunity\"\t\t\"%d\"\n", pGroup->immunity_level);

  1857 		if (pGroup->immune_table != -1

  1858 			&& (itable = (int *)m_pMemory->GetAddress(pGroup->immune_table)) != NULL)

  1859 		{

  1860 			AdminGroup *pAltGroup;

  1861 			const char *gname, *mod;

  1863 			for (int i = 1; i <= itable[0]; i++)

  1864 			{

  1865 				if ((pAltGroup = GetGroup(itable[i])) == NULL)

  1866 				{

  1867 					/* Assume the rest of the table is corrupt */

  1868 					break;

  1869 				}

  1870 				gname = GetString(pAltGroup->nameidx);

  1871 				if (atoi(gname) != 0)

  1872 				{

  1873 					mod = "@";

  1874 				}

  1875 				else

  1876 				{

  1877 					mod = "";

  1878 				}

  1879 				fprintf(fp, "\t\t\"immunity\"\t\t\"%s%s\"\n", mod, gname);

  1880 			}

  1881 		}

  1883 		fprintf(fp, "\n\t\t\"Overrides\"\n\t\t{\n");

  1884 		if (pGroup->pCmdGrpTable != NULL)

  1885 		{

  1886 			sm_trie_bad_iterator(pGroup->pCmdGrpTable,

  1887 				name_buffer,

  1888 				sizeof(name_buffer),

  1889 				iterator_group_grp_override,

  1890 				fp);

  1891 		}

  1892 		if (pGroup->pCmdTable != NULL)

  1893 		{

  1894 			sm_trie_bad_iterator(pGroup->pCmdTable,

  1895 				name_buffer,

  1896 				sizeof(name_buffer),

  1897 				iterator_group_basic_override,

  1898 				fp);

  1899 		}

  1900 		fprintf(fp, "\t\t}\n");

  1902 		fprintf(fp, "\t}\n");

  1904 		if ((gid = pGroup->next_grp) != INVALID_GROUP_ID)

  1905 		{

  1906 			fprintf(fp, "\n");

  1907 		}

  1908 	}

  1910 	fprintf(fp, "}\n\n");

  1911 	fprintf(fp, "\"Admins\"\n{\n");

  1913 	num = 0;

  1914 	aid = m_FirstUser;

  1915 	while (aid != INVALID_ADMIN_ID

  1916 			&& (pAdmin = GetUser(aid)) != NULL)

  1917 	{

  1918 		num++;

  1919 		FillFlagString(pAdmin->flags, flagstr, sizeof(flagstr));

  1921 		fprintf(fp, "\t/* num = %d, aid = 0x%X, serialno = 0x%X*/\n", num, aid, pAdmin->serialchange);

  1923 		if (pAdmin->nameidx != -1)

  1924 		{

  1925 			fprintf(fp, "\t\"%s\"\n\t{\n", GetString(pAdmin->nameidx));

  1926 		}

  1927 		else

  1928 		{

  1929 			fprintf(fp, "\t\"\"\n\t{\n");

  1930 		}

  1932 		if (pAdmin->auth.identidx != -1)

  1933 		{

  1934 			fprintf(fp, "\t\t\"auth\"\t\t\t\"%s\"\n", GetMethodName(pAdmin->auth.index));

  1935 			fprintf(fp, "\t\t\"identity\"\t\t\"%s\"\n", GetString(pAdmin->auth.identidx));

  1936 		}

  1937 		if (pAdmin->password != -1)

  1938 		{

  1939 			fprintf(fp, "\t\t\"password\"\t\t\"%s\"\n", GetString(pAdmin->password));

  1940 		}

  1941 		fprintf(fp, "\t\t\"flags\"\t\t\t\"%s\"\n", flagstr);

  1942 		fprintf(fp, "\t\t\"immunity\"\t\t\"%d\"\n", pAdmin->immunity_level);

  1944 		if (pAdmin->grp_count != 0

  1945 			&& pAdmin->grp_table != -1

  1946 			&& (itable = (int *)m_pMemory->GetAddress(pAdmin->grp_table)) != NULL)

  1947 		{

  1948 			unsigned int i;

  1950 			for (i = 0; i < pAdmin->grp_count; i++)

  1951 			{

  1952 				if ((pGroup = GetGroup(itable[i])) == NULL)

  1953 				{

  1954 					/* Assume the rest of the table is corrupt */

  1955 					break;

  1956 				}

  1957 				fprintf(fp, "\t\t\"group\"\t\t\t\"%s\"\n", GetString(pGroup->nameidx));

  1958 			}

  1959 		}

  1961 		fprintf(fp, "\t}\n");

  1963 		if ((aid = pAdmin->next_user) != INVALID_ADMIN_ID)

  1964 		{

  1965 			fprintf(fp, "\n");

  1966 		}

  1967 	}

  1969 	fprintf(fp, "}\n\n");

  1971 	fprintf(fp, "\"Overrides\"\n{\n");

  1972 	if (m_pCmdGrpOverrides != NULL)

  1973 	{

  1974 		sm_trie_bad_iterator(m_pCmdGrpOverrides,

  1975 			name_buffer,

  1976 			sizeof(name_buffer),

  1977 			iterator_glob_grp_override,

  1978 			fp);

  1979 	}

  1980 	if (m_pCmdOverrides != NULL)

  1981 	{

  1982 		sm_trie_bad_iterator(m_pCmdOverrides,

  1983 			name_buffer,

  1984 			sizeof(name_buffer),

  1985 			iterator_glob_basic_override,

  1986 			fp);

  1987 	}

  1988 	fprintf(fp, "}\n");

  1989 }

  1991 AdminGroup *AdminCache::GetGroup(GroupId gid)

  1992 {

  1993 	AdminGroup *pGroup;

  1995 	pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

  1996 	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

  1997 	{

  1998 		return NULL;

  1999 	}

  2001 	return pGroup;

  2002 }

  2004 AdminUser *AdminCache::GetUser(AdminId aid)

  2005 {

  2006 	AdminUser *pAdmin;

  2008 	pAdmin = (AdminUser *)m_pMemory->GetAddress(aid);

  2009 	if (!pAdmin || pAdmin->magic != USR_MAGIC_SET)

  2010 	{

  2011 		return NULL;

  2012 	}

  2014 	return pAdmin;

  2015 }

  2017 const char *AdminCache::GetMethodName(unsigned int index)

  2018 {

  2019 	List<AuthMethod>::iterator iter;

  2020 	for (iter=m_AuthMethods.begin();

  2021 		iter!=m_AuthMethods.end();

  2022 		iter++)

  2023 	{

  2024 		if (index-- == 0)

  2025 		{

  2026 			return (*iter).name.c_str();

  2027 		}

  2028 	}

  2030 	return NULL;

  2031 }

  2033 const char *AdminCache::GetString(int idx)

  2034 {

  2035 	return m_pStrings->GetString(idx);

  2036 }

  2038 size_t AdminCache::FillFlagString(FlagBits bits, char *buffer, size_t maxlen)

  2039 {

  2040 	size_t pos;

  2041 	unsigned int i, num_flags;

  2042 	AdminFlag flags[AdminFlags_TOTAL];

  2044 	num_flags = FlagBitsToArray(bits, flags, AdminFlags_TOTAL);

  2046 	pos = 0;

  2047 	for (i = 0; pos < maxlen && i < num_flags; i++)

  2048 	{

  2049 		if (FindFlagChar(flags[i], &buffer[pos]))

  2050 		{

  2051 			pos++;

  2052 		}

  2053 	}

  2054 	buffer[pos] = '\0';

  2056 	return pos;

  2057 }

  2059 CON_COMMAND(sm_dump_admcache, "Dumps the admin cache for debugging")

  2060 {

  2061 	FILE *fp;

  2062 	char buffer[PLATFORM_MAX_PATH];

  2064 	g_SourceMod.BuildPath(Path_SM, buffer, sizeof(buffer), "data/admin_cache_dump.txt");

  2066 	if ((fp = fopen(buffer, "wt")) == NULL)

  2067 	{

  2068 		g_RootMenu.ConsolePrint("Could not open file for writing: %s", buffer);

  2069 		return;

  2070 	}

  2072 	g_Admins.DumpCache(fp);

  2074 	g_RootMenu.ConsolePrint("Admin cache dumped to: %s", buffer);

  2076 	fclose(fp);

  2077 }

author	David Anderson <dvander@alliedmods.net>
	Sun Apr 13 06:06:27 2008 +0000 (2008-04-13)
changeset 1999	63aafc6ff212
parent 1965	63d5a5f6935f
child 2000	38c6fa875d9b
permissions	-rw-r--r--