sourcemod-central: core/AdminCache.cpp@10f58032bc78

     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

     9  * modify it under the terms of the GNU General Public License,

    10  * version 3.0, as published by the Free Software Foundation.

    11  *

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

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15  * GNU General Public License for more details.

    16  *

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

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

    19  *

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

    21  * link the code of this program (as well as its derivative works) to

    22  * "Half-Life 2," the "Source Engine," the "SourcePawn JIT," and any

    23  * Game MODs that run on software by the Valve Corporation.  You must

    24  * obey the GNU General Public License in all respects for all other

    25  * code used. Additionally, AlliedModders LLC grants this exception

    26  * to all derivative works. AlliedModders LLC defines further

    27  * exceptions, found in LICENSE.txt (as of this writing, version

    28  * JULY-31-2007), or <http://www.sourcemod.net/license.php>.

    29  *

    30  * Version: $Id$

    31  */

    33 #include <string.h>

    34 #include <assert.h>

    35 #include "AdminCache.h"

    36 #include "ShareSys.h"

    37 #include "ForwardSys.h"

    38 #include "PlayerManager.h"

    39 #include "ConCmdManager.h"

    40 #include "TextParsers.h"

    41 #include "Logger.h"

    42 #include "sourcemod.h"

    43 #include "sm_stringutil.h"

    45 #define LEVEL_STATE_NONE		0

    46 #define LEVEL_STATE_LEVELS		1

    47 #define LEVEL_STATE_FLAGS		2

    49 AdminCache g_Admins;

    50 AdminFlag g_FlagLetters[26];

    51 bool g_FlagSet[26];

    53 /* Default flags */

    54 AdminFlag g_DefaultFlags[26] =

    55 {

    56 	Admin_Reservation, Admin_Generic, Admin_Kick, Admin_Ban, Admin_Unban,

    57 	Admin_Slay, Admin_Changemap, Admin_Convars, Admin_Config, Admin_Chat,

    58 	Admin_Vote, Admin_Password, Admin_RCON, Admin_Cheats, Admin_Custom1,

    59 	Admin_Custom2, Admin_Custom3, Admin_Custom4, Admin_Custom5, Admin_Custom6,

    60 	Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic,

    61 	Admin_Root

    62 };

    65 class FlagReader : public ITextListener_SMC

    66 {

    67 public:

    68 	void LoadLevels()

    69 	{

    70 		if (!Parse())

    71 		{

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

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

    74 			{

    75 				g_FlagSet[i] = true;

    76 			}

    77 			g_FlagSet[25] = true;

    78 		}

    79 	}

    80 private:

    81 	bool Parse()

    82 	{

    83 		unsigned int line = 0;

    84 		SMCParseError error;

    86 		m_Line = 0;

    87 		m_bFileNameLogged = false;

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

    90 		if ((error = g_TextParser.ParseFile_SMC(m_File, this, &line, NULL))

    91 			!= SMCParse_Okay)

    92 		{

    93 			const char *err_string = g_TextParser.GetSMCErrorString(error);

    94 			if (!err_string)

    95 			{

    96 				err_string = "Unknown error";

    97 			}

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

    99 			return false;

   100 		}

   102 		return true;

   103 	}

   104 	void ReadSMC_ParseStart()

   105 	{

   106 		m_LevelState = LEVEL_STATE_NONE;

   107 		m_IgnoreLevel = 0;

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

   109 	}

   110 	SMCParseResult ReadSMC_NewSection(const char *name, bool opt_quotes)

   111 	{

   112 		if (m_IgnoreLevel)

   113 		{

   114 			m_IgnoreLevel++;

   115 			return SMCParse_Continue;

   116 		}

   118 		if (m_LevelState == LEVEL_STATE_NONE)

   119 		{

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

   121 			{

   122 				m_LevelState = LEVEL_STATE_LEVELS;

   123 			} else {

   124 				m_IgnoreLevel++;

   125 			}

   126 		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

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

   128 			{

   129 				m_LevelState = LEVEL_STATE_FLAGS;

   130 			} else {

   131 				m_IgnoreLevel++;

   132 			}

   133 		} else {

   134 			m_IgnoreLevel++;

   135 		}

   137 		return SMCParse_Continue;

   138 	}

   139 	SMCParseResult ReadSMC_KeyValue(const char *key, const char *value, bool key_quotes, bool value_quotes)

   140 	{

   141 		if (m_LevelState != LEVEL_STATE_FLAGS || m_IgnoreLevel)

   142 		{

   143 			return SMCParse_Continue;

   144 		}

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

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

   149 		{

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

   151 			return SMCParse_Continue;

   152 		}

   154 		c -= (unsigned)'a';

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

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

   159 		{

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

   161 			return SMCParse_Continue;

   162 		}

   164 		g_FlagSet[c] = true;

   166 		return SMCParse_Continue;

   167 	}

   168 	SMCParseResult ReadSMC_LeavingSection()

   169 	{

   170 		if (m_IgnoreLevel)

   171 		{

   172 			m_IgnoreLevel--;

   173 			return SMCParse_Continue;

   174 		}

   176 		if (m_LevelState == LEVEL_STATE_FLAGS)

   177 		{

   178 			m_LevelState = LEVEL_STATE_LEVELS;

   179 			return SMCParse_Halt;

   180 		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

   181 			m_LevelState = LEVEL_STATE_NONE;

   182 		}

   184 		return SMCParse_Continue;

   185 	}

   186 	SMCParseResult ReadSMC_RawLine(const char *line, unsigned int curline)

   187 	{

   188 		m_Line = curline;

   189 		return SMCParse_Continue;

   190 	}

   191 	void ParseError(const char *message, ...)

   192 	{

   193 		va_list ap;

   194 		char buffer[256];

   196 		va_start(ap, message);

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

   198 		va_end(ap);

   200 		if (!m_bFileNameLogged)

   201 		{

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

   203 			m_bFileNameLogged = true;

   204 		}

   206 		g_Logger.LogError("[SM] (Line %d): %s", m_Line, buffer);

   207 	}

   208 private:

   209 	bool m_bFileNameLogged;

   210 	char m_File[PLATFORM_MAX_PATH];

   211 	int m_LevelState;

   212 	int m_IgnoreLevel;

   213 	unsigned int m_Line;

   214 } s_FlagReader;

   216 AdminCache::AdminCache()

   217 {

   218 	m_pCmdOverrides = sm_trie_create();

   219 	m_pCmdGrpOverrides = sm_trie_create();

   220 	m_pStrings = new BaseStringTable(1024);

   221 	m_pMemory = m_pStrings->GetMemTable();

   222 	m_FreeGroupList = m_FirstGroup = m_LastGroup = INVALID_GROUP_ID;

   223 	m_FreeUserList = m_FirstUser = m_LastUser = INVALID_ADMIN_ID;

   224 	m_pGroups = sm_trie_create();

   225 	m_pCacheFwd = NULL;

   226 	m_FirstGroup = -1;

   227 	m_pAuthTables = sm_trie_create();

   228 	m_InvalidatingAdmins = false;

   229 	m_destroying = false;

   230 	m_pLevelNames = sm_trie_create();

   231 }

   233 AdminCache::~AdminCache()

   234 {

   235 	m_destroying = true;

   236 	DumpAdminCache(AdminCache_Overrides, false);

   237 	DumpAdminCache(AdminCache_Groups, false);

   239 	sm_trie_destroy(m_pCmdGrpOverrides);

   240 	sm_trie_destroy(m_pCmdOverrides);

   242 	if (m_pGroups)

   243 	{

   244 		sm_trie_destroy(m_pGroups);

   245 	}

   247 	List<AuthMethod>::iterator iter;

   248 	for (iter=m_AuthMethods.begin();

   249 		 iter!=m_AuthMethods.end();

   250 		 iter++)

   251 	{

   252 		sm_trie_destroy((*iter).table);

   253 	}

   255 	sm_trie_destroy(m_pAuthTables);

   257 	delete m_pStrings;

   259 	sm_trie_destroy(m_pLevelNames);

   260 }

   262 void AdminCache::OnSourceModStartup(bool late)

   263 {

   264 	RegisterAuthIdentType("steam");

   265 	RegisterAuthIdentType("name");

   266 	RegisterAuthIdentType("ip");

   268 	NameFlag("reservation", Admin_Reservation);

   269 	NameFlag("kick", Admin_Kick);

   270 	NameFlag("generic", Admin_Generic);

   271 	NameFlag("ban", Admin_Ban);

   272 	NameFlag("unban", Admin_Unban);

   273 	NameFlag("slay", Admin_Slay);

   274 	NameFlag("changemap", Admin_Changemap);

   275 	NameFlag("cvars", Admin_Convars);

   276 	NameFlag("config", Admin_Config);

   277 	NameFlag("chat", Admin_Chat);

   278 	NameFlag("vote", Admin_Vote);

   279 	NameFlag("password", Admin_Password);

   280 	NameFlag("rcon", Admin_RCON);

   281 	NameFlag("cheats", Admin_Cheats);

   282 	NameFlag("root", Admin_Root);

   283 	NameFlag("custom1", Admin_Custom1);

   284 	NameFlag("custom2", Admin_Custom2);

   285 	NameFlag("custom3", Admin_Custom3);

   286 	NameFlag("custom4", Admin_Custom4);

   287 	NameFlag("custom5", Admin_Custom5);

   288 	NameFlag("custom6", Admin_Custom6);

   289 }

   291 void AdminCache::OnSourceModAllInitialized()

   292 {

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

   294 	g_ShareSys.AddInterface(NULL, this);

   295 }

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

   298 {

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

   300 	s_FlagReader.LoadLevels();

   301 }

   303 void AdminCache::OnSourceModShutdown()

   304 {

   305 	g_Forwards.ReleaseForward(m_pCacheFwd);

   306 	m_pCacheFwd = NULL;

   307 }

   309 void AdminCache::OnSourceModPluginsLoaded()

   310 {

   311 	DumpAdminCache(AdminCache_Overrides, true);

   312 	DumpAdminCache(AdminCache_Groups, true);

   313 }

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

   316 {

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

   318 }

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

   321 {

   322 	void *obj;

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

   324 	{

   325 		return false;

   326 	}

   328 	if (pFlag)

   329 	{

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

   331 	}

   333 	return true;

   334 }

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

   337 {

   338 	Trie *pTrie = NULL;

   339 	if (type == Override_Command)

   340 	{

   341 		pTrie = m_pCmdOverrides;

   342 	} else if (type == Override_CommandGroup) {

   343 		pTrie = m_pCmdGrpOverrides;

   344 	} else {

   345 		return;

   346 	}

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

   350 	g_ConCmds.UpdateAdminCmdFlags(cmd, type, flags);

   351 }

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

   354 {

   355 	Trie *pTrie = NULL;

   357 	if (type == Override_Command)

   358 	{

   359 		pTrie = m_pCmdOverrides;

   360 	} else if (type == Override_CommandGroup) {

   361 		pTrie = m_pCmdGrpOverrides;

   362 	} else {

   363 		return false;

   364 	}

   366 	void *object;

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

   368 	{

   369 		if (pFlags)

   370 		{

   371 			*pFlags = (FlagBits)object;

   372 		}

   373 		return true;

   374 	}

   376 	return false;

   377 }

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

   380 {

   381 	if (type == Override_Command)

   382 	{

   383 		return _UnsetCommandOverride(cmd);

   384 	} else if (type == Override_CommandGroup) {

   385 		return _UnsetCommandGroupOverride(cmd);

   386 	}

   387 }

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

   390 {

   391 	if (!m_pCmdGrpOverrides)

   392 	{

   393 		return;

   394 	}

   396 	sm_trie_delete(m_pCmdGrpOverrides, group);

   398 	g_ConCmds.UpdateAdminCmdFlags(group, Override_CommandGroup, 0);

   399 }

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

   402 {

   403 	if (!m_pCmdOverrides)

   404 	{

   405 		return;

   406 	}

   408 	sm_trie_delete(m_pCmdOverrides, cmd);

   410 	g_ConCmds.UpdateAdminCmdFlags(cmd, Override_Command, 0);

   411 }

   413 void AdminCache::DumpCommandOverrideCache(OverrideType type)

   414 {

   415 	if (type == Override_Command && m_pCmdOverrides)

   416 	{

   417 		sm_trie_clear(m_pCmdOverrides);

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

   419 		sm_trie_clear(m_pCmdGrpOverrides);

   420 	}

   421 }

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

   424 {

   425 	AdminId id;

   426 	AdminUser *pUser;

   428 	if (m_FreeUserList != INVALID_ADMIN_ID)

   429 	{

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

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

   432 		id = m_FreeUserList;

   433 		m_FreeUserList = pUser->next_user;

   434 	} else {

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

   436 		pUser->grp_size = 0;

   437 		pUser->grp_table = -1;

   438 	}

   440 	pUser->flags = 0;

   441 	pUser->eflags = 0;

   442 	pUser->grp_count = 0;

   443 	pUser->password = -1;

   444 	pUser->magic = USR_MAGIC_SET;

   445 	pUser->auth.identidx = -1;

   446 	pUser->auth.index = 0;

   447 	pUser->immune_default = false;

   448 	pUser->immune_global = false;

   450 	if (m_FirstUser == INVALID_ADMIN_ID)

   451 	{

   452 		m_FirstUser = id;

   453 		m_LastUser = id;

   454 	} else {

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

   456 		pPrev->next_user = id;

   457 		pUser->prev_user = m_LastUser;

   458 		m_LastUser = id;

   459 	}

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

   462 	{

   463 		pUser->nameidx = m_pStrings->AddString(name);

   464 	}

   466 	return id;

   467 }

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

   470 {

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

   472 	{

   473 		return INVALID_GROUP_ID;

   474 	}

   476 	GroupId id;

   477 	AdminGroup *pGroup;

   478 	if (m_FreeGroupList != INVALID_GROUP_ID)

   479 	{

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

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

   482 		id = m_FreeGroupList;

   483 		m_FreeGroupList = pGroup->next_grp;

   484 	} else {

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

   486 	}

   488 	pGroup->immune_default = false;

   489 	pGroup->immune_global = false;

   490 	pGroup->immune_table = -1;

   491 	pGroup->magic = GRP_MAGIC_SET;

   492 	pGroup->next_grp = INVALID_GROUP_ID;

   493 	pGroup->pCmdGrpTable = NULL;

   494 	pGroup->pCmdTable = NULL;

   495 	pGroup->addflags = 0;

   497 	if (m_FirstGroup == INVALID_GROUP_ID)

   498 	{

   499 		m_FirstGroup = id;

   500 		m_LastGroup = id;

   501 		pGroup->prev_grp = INVALID_GROUP_ID;

   502 	} else {

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

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

   505 		pPrev->next_grp = id;

   506 		pGroup->prev_grp = m_LastGroup;

   507 		m_LastGroup = id;

   508 	}

   510 	pGroup->nameidx = m_pStrings->AddString(group_name);

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

   514 	return id;

   515 }

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

   518 {

   519 	void *object;

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

   522 	{

   523 		return INVALID_GROUP_ID;

   524 	}

   526 	GroupId id = (GroupId)object;

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

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

   530 	{

   531 		return INVALID_GROUP_ID;

   532 	}

   534 	return id;

   535 }

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

   538 {

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

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

   541 	{

   542 		return;

   543 	}

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

   546 	{

   547 		return;

   548 	}

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

   552 	if (enabled)

   553 	{

   554 		pGroup->addflags |= bits;

   555 	} else {

   556 		pGroup->addflags &= ~bits;

   557 	}

   558 }

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

   561 {

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

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

   564 	{

   565 		return false;

   566 	}

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

   569 	{

   570 		return false;

   571 	}

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

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

   575 }

   577 FlagBits AdminCache::GetGroupAddFlags(GroupId id)

   578 {

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

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

   581 	{

   582 		return 0;

   583 	}

   585 	return pGroup->addflags;

   586 }

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

   589 {

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

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

   592 	{

   593 		return;

   594 	}

   596 	if (type == Immunity_Default)

   597 	{

   598 		pGroup->immune_default = enabled;

   599 	} else if (type == Immunity_Global) {

   600 		pGroup->immune_global = enabled;

   601 	}

   602 }

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

   605 {

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

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

   608 	{

   609 		return false;

   610 	}

   612 	if (type == Immunity_Default)

   613 	{

   614 		return pGroup->immune_default;

   615 	} else if (type == Immunity_Global) {

   616 		return pGroup->immune_global;

   617 	}

   619 	return false;

   620 }

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

   623 {

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

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

   626 	{

   627 		return;

   628 	}

   630 	AdminGroup *pOther = (AdminGroup *)m_pMemory->GetAddress(id);

   631 	if (!pOther || pOther->magic != GRP_MAGIC_SET)

   632 	{

   633 		return;

   634 	}

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

   637 	int *table, tblidx;

   638 	if (pOther->immune_table == -1)

   639 	{

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

   641 		table[0] = 0;

   642 	} else {

   643 		int *old_table = (int *)m_pMemory->GetAddress(pOther->immune_table);

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

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

   646 		{

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

   648 			{

   649 				return;

   650 			}

   651 		}

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

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

   654 		old_table = (int *)m_pMemory->GetAddress(pOther->immune_table);

   655 		table[0] = old_table[0];

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

   657 		{

   658 			table[i] = old_table[i];

   659 		}

   660 	}

   662 	/* Assign */

   663 	pOther->immune_table = tblidx;

   665 	/* Add to the array */

   666 	table[0]++;

   667 	table[table[0]] = other_id;

   668 }

   670 unsigned int AdminCache::GetGroupImmunityCount(GroupId id)

   671 {

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

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

   674 	{

   675 		return 0;

   676 	}

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

   679 	{

   680 		return 0;

   681 	}

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

   685 	return table[0];

   686 }

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

   689 {

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

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

   692 	{

   693 		return INVALID_GROUP_ID;

   694 	}

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

   697 	{

   698 		return INVALID_GROUP_ID;

   699 	}

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

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

   703 	{

   704 		return INVALID_GROUP_ID;

   705 	}

   707 	return table[1 + number];

   708 }

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

   711 {

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

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

   714 	{

   715 		return;

   716 	}

   718 	Trie *pTrie = NULL;

   719 	if (type == Override_Command)

   720 	{

   721 		if (pGroup->pCmdTable == NULL)

   722 		{

   723 			pGroup->pCmdTable = sm_trie_create();

   724 		}

   725 		pTrie = pGroup->pCmdTable;

   726 	} else if (type == Override_CommandGroup) {

   727 		if (pGroup->pCmdGrpTable == NULL)

   728 		{

   729 			pGroup->pCmdGrpTable = sm_trie_create();

   730 		}

   731 		pTrie = pGroup->pCmdGrpTable;

   732 	} else {

   733 		return;

   734 	}

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

   737 }

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

   740 {

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

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

   743 	{

   744 		return false;

   745 	}

   747 	Trie *pTrie = NULL;

   748 	if (type == Override_Command)

   749 	{

   750 		if (pGroup->pCmdTable == NULL)

   751 		{

   752 			return false;

   753 		}

   754 		pTrie = pGroup->pCmdTable;

   755 	} else if (type == Override_CommandGroup) {

   756 		if (pGroup->pCmdGrpTable == NULL)

   757 		{

   758 			return false;

   759 		}

   760 		pTrie = pGroup->pCmdGrpTable;

   761 	} else {

   762 		return false;

   763 	}

   765 	void *object;

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

   767 	{

   768 		return false;

   769 	}

   771 	if (pRule)

   772 	{

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

   774 	}

   776 	return true;

   777 }

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

   780 {

   781 	List<AuthMethod>::iterator iter;

   782 	for (iter=m_AuthMethods.begin();

   783 		 iter!=m_AuthMethods.end();

   784 		 iter++)

   785 	{

   786 		if (index-- == 0)

   787 		{

   788 			return (*iter).table;

   789 		}

   790 	}

   792 	return NULL;

   793 }

   795 bool AdminCache::InvalidateAdmin(AdminId id)

   796 {

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

   798 	AdminUser *pOther;

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

   800 	{

   801 		return false;

   802 	}

   804 	if (!m_InvalidatingAdmins && !m_destroying)

   805 	{

   806 		g_Players.ClearAdminId(id);

   807 	}

   809 	/* Unlink from the dbl link list */

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

   811 	{

   812 		m_FirstUser = INVALID_ADMIN_ID;

   813 		m_LastUser = INVALID_ADMIN_ID;

   814 	} else if (id == m_FirstUser) {

   815 		m_FirstUser = pUser->next_user;

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

   817 		pOther->prev_user = INVALID_ADMIN_ID;

   818 	} else if (id == m_LastUser) {

   819 		m_LastUser = pUser->prev_user;

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

   821 		pOther->next_user = INVALID_ADMIN_ID;

   822 	} else {

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

   824 		pOther->next_user = pUser->next_user;

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

   826 		pOther->prev_user = pUser->prev_user;

   827 	}

   829 	/* Unlink from auth tables */

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

   831 	{

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

   833 		if (pTrie)

   834 		{

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

   836 		}

   837 	}

   839 	/* Clear table counts */

   840 	pUser->grp_count = 0;

   842 	/* Link into free list */

   843 	pUser->magic = USR_MAGIC_UNSET;

   844 	pUser->next_user = m_FreeUserList;

   845 	m_FreeUserList = id;

   847 	return true;

   848 }

   851 void AdminCache::InvalidateGroup(GroupId id)

   852 {

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

   854 	AdminGroup *pOther;

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

   857 	{

   858 		return;

   859 	}

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

   862 	sm_trie_delete(m_pGroups, str);

   864 	/* Unlink from the live dbllink list */

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

   866 	{

   867 		m_LastGroup = INVALID_GROUP_ID;

   868 		m_FirstGroup = INVALID_GROUP_ID;

   869 	} else if (id == m_FirstGroup) {

   870 		m_FirstGroup = pGroup->next_grp;

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

   872 		pOther->prev_grp = INVALID_GROUP_ID;

   873 	} else if (id == m_LastGroup) {

   874 		m_LastGroup = pGroup->prev_grp;

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

   876 		pOther->next_grp = INVALID_GROUP_ID;

   877 	} else {

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

   879 		pOther->next_grp = pGroup->next_grp;

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

   881 		pOther->prev_grp = pGroup->prev_grp;

   882 	}

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

   885 	if (pGroup->pCmdGrpTable)

   886 	{

   887 		sm_trie_destroy(pGroup->pCmdGrpTable);

   888 		pGroup->pCmdGrpTable = NULL;

   889 	}

   890 	if (pGroup->pCmdTable)

   891 	{

   892 		sm_trie_destroy(pGroup->pCmdTable);

   893 		pGroup->pCmdTable = NULL;

   894 	}

   896 	/* Link into the free list */

   897 	pGroup->magic = GRP_MAGIC_UNSET;

   898 	pGroup->next_grp = m_FreeGroupList;

   899 	m_FreeGroupList = id;

   901 	int idx = m_FirstUser;

   902 	AdminUser *pUser;

   903 	int *table;

   904 	while (idx != INVALID_ADMIN_ID)

   905 	{

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

   907 		if (pUser->grp_count > 0)

   908 		{

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

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

   911 			{

   912 				if (table[i] == id)

   913 				{

   914 					/* We have to remove this entry */

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

   916 					{

   917 						/* Move everything down by one */

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

   919 					}

   920 					/* Decrease count */

   921 					pUser->grp_count--;

   922 					/* Recalculate effective flags */

   923 					pUser->eflags = pUser->flags;

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

   925 					{

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

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

   928 					}

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

   930 					break;

   931 				}

   932 			}

   933 		}

   934 		idx = pUser->next_user;

   935 	}

   936 }

   938 void AdminCache::InvalidateGroupCache()

   939 {

   940 	/* Nuke the free list */

   941 	m_FreeGroupList = -1;

   943 	/* Nuke reverse lookups */

   944 	sm_trie_clear(m_pGroups);

   946 	/* Free memory on groups */

   947 	GroupId cur = m_FirstGroup;

   948 	AdminGroup *pGroup;

   949 	while (cur != INVALID_GROUP_ID)

   950 	{

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

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

   953 		if (pGroup->pCmdGrpTable)

   954 		{

   955 			sm_trie_destroy(pGroup->pCmdGrpTable);

   956 		}

   957 		if (pGroup->pCmdTable)

   958 		{

   959 			sm_trie_destroy(pGroup->pCmdTable);

   960 		}

   961 		cur = pGroup->next_grp;

   962 	}

   964 	m_FirstGroup = INVALID_GROUP_ID;

   965 	m_LastGroup = INVALID_GROUP_ID;

   967 	InvalidateAdminCache(false);

   969 	/* Reset the memory table */

   970 	m_pMemory->Reset();

   971 }

   973 void AdminCache::AddAdminListener(IAdminListener *pListener)

   974 {

   975 	m_hooks.push_back(pListener);

   976 }

   978 void AdminCache::RemoveAdminListener(IAdminListener *pListener)

   979 {

   980 	m_hooks.remove(pListener);

   981 }

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

   984 {

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

   986 	{

   987 		return;

   988 	}

   990 	Trie *pAuth = sm_trie_create();

   992 	AuthMethod method;

   993 	method.name.assign(name);

   994 	method.table = pAuth;

   996 	m_AuthMethods.push_back(method);

   998 	sm_trie_insert(m_pAuthTables, name, pAuth);

   999 }

  1001 void AdminCache::InvalidateAdminCache(bool unlink_admins)

  1002 {

  1003 	m_InvalidatingAdmins = true;

  1004 	if (!m_destroying)

  1005 	{

  1006 		g_Players.ClearAllAdmins();

  1007 	}

  1008 	/* Wipe the identity cache first */

  1009 	List<AuthMethod>::iterator iter;

  1010 	for (iter=m_AuthMethods.begin();

  1011 		 iter!=m_AuthMethods.end();

  1012 		 iter++)

  1013 	{

  1014 		sm_trie_clear((*iter).table);

  1015 	}

  1017 	if (unlink_admins)

  1018 	{

  1019 		while (m_FirstUser != INVALID_ADMIN_ID)

  1020 		{

  1021 			InvalidateAdmin(m_FirstUser);

  1022 		}

  1023 	} else {

  1024 		m_FirstUser = -1;

  1025 		m_LastUser = -1;

  1026 		m_FreeUserList = -1;

  1027 	}

  1028 	m_InvalidatingAdmins = false;

  1029 }

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

  1032 {

  1033 	List<IAdminListener *>::iterator iter;

  1034 	IAdminListener *pListener;

  1035 	cell_t result;

  1037 	if (part == AdminCache_Overrides)

  1038 	{

  1039 		DumpCommandOverrideCache(Override_Command);

  1040 		DumpCommandOverrideCache(Override_CommandGroup);

  1041 		if (rebuild && !m_destroying)

  1042 		{

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

  1044 			{

  1045 				pListener = (*iter);

  1046 				pListener->OnRebuildOverrideCache();

  1047 			}

  1048 			m_pCacheFwd->PushCell(part);

  1049 			m_pCacheFwd->Execute(&result);

  1050 		}

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

  1052 		if (part == AdminCache_Groups)

  1053 		{

  1054 			InvalidateGroupCache();

  1055 			if (rebuild && !m_destroying)

  1056 			{

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

  1058 				{

  1059 					pListener = (*iter);

  1060 					pListener->OnRebuildGroupCache();

  1061 				}

  1062 				m_pCacheFwd->PushCell(part);

  1063 				m_pCacheFwd->Execute(&result);

  1064 			}

  1065 		}

  1066 		InvalidateAdminCache(true);

  1067 		if (rebuild && !m_destroying)

  1068 		{

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

  1070 			{

  1071 				pListener = (*iter);

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

  1073 			}

  1074 			m_pCacheFwd->PushCell(AdminCache_Admins);

  1075 			m_pCacheFwd->Execute(&result);

  1076 			g_Players.RecheckAnyAdmins();

  1077 		}

  1078 	}

  1079 }

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

  1082 {

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

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

  1085 	{

  1086 		return NULL;

  1087 	}

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

  1090 }

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

  1093 {

  1094 	List<AuthMethod>::iterator iter;

  1095 	unsigned int index = 0;

  1096 	for (iter=m_AuthMethods.begin();

  1097 		 iter!=m_AuthMethods.end();

  1098 		 iter++,index++)

  1099 	{

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

  1101 		{

  1102 			*_index = index;

  1103 			return true;

  1104 		}

  1105 	}

  1107 	return false;

  1108 }

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

  1111 {

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

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

  1114 	{

  1115 		return false;

  1116 	}

  1118 	Trie *pTable;

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

  1120 	{

  1121 		return false;

  1122 	}

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

  1125 	{

  1126 		return false;

  1127 	}

  1129 	pUser->auth.identidx = m_pStrings->AddString(ident);

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

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

  1133 }

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

  1136 {

  1137 	Trie *pTable;

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

  1139 	{

  1140 		return INVALID_ADMIN_ID;

  1141 	}

  1143 	void *object;

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

  1145 	{

  1146 		return INVALID_ADMIN_ID;

  1147 	}

  1149 	return (AdminId)object;

  1150 }

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

  1153 {

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

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

  1156 	{

  1157 		return;

  1158 	}

  1160 	if (flag < Admin_Reservation

  1161 		|| flag >= AdminFlags_TOTAL)

  1162 	{

  1163 		return;

  1164 	}

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

  1168 	if (enabled)

  1169 	{

  1170 		pUser->flags |= bits;

  1171 		pUser->eflags |= bits;

  1172 	} else {

  1173 		pUser->flags &= ~bits;

  1174 		pUser->eflags &= ~bits;

  1175 	}

  1176 }

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

  1179 {

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

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

  1182 	{

  1183 		return false;

  1184 	}

  1186 	if (flag < Admin_Reservation

  1187 		|| flag >= AdminFlags_TOTAL)

  1188 	{

  1189 		return false;

  1190 	}

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

  1194 	if (mode == Access_Real)

  1195 	{

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

  1197 	} else if (mode == Access_Effective) {

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

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

  1200 		{

  1201 			has_bit = true;

  1202 		}

  1203 		return has_bit;

  1204 	}

  1206 	return false;

  1207 }

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

  1210 {

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

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

  1213 	{

  1214 		return 0;

  1215 	}

  1217 	if (mode == Access_Real)

  1218 	{

  1219 		return pUser->flags;

  1220 	} else if (mode == Access_Effective) {

  1221 		return pUser->eflags;

  1222 	}

  1224 	return 0;

  1225 }

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

  1228 {

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

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

  1231 	{

  1232 		return;

  1233 	}

  1235 	if (mode == Access_Real)

  1236 	{

  1237 		pUser->flags = bits;

  1238 		pUser->eflags = bits;

  1239 	} else if (mode == Access_Effective) {

  1240 		pUser->eflags = bits;

  1241 	}

  1242 }

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

  1245 {

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

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

  1248 	{

  1249 		return false;

  1250 	}

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

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

  1254 	{

  1255 		return false;

  1256 	}

  1258 	/* First check for duplicates */

  1259 	if (pUser->grp_count != 0)

  1260 	{

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

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

  1263 		{

  1264 			if (temp_table[i] == gid)

  1265 			{

  1266 				return false;

  1267 			}

  1268 		}

  1269 	}

  1271 	int *table;

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

  1273 	{

  1274 		int new_size = 0;

  1275 		int tblidx;

  1277 		if (pUser->grp_size == 0)

  1278 		{

  1279 			new_size = 2;

  1280 		} else {

  1281 			new_size = pUser->grp_size * 2;

  1282 		}

  1284 		/* Create and refresh pointers */

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

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

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

  1289 		/* Copy old data if necessary */

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

  1291 		{

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

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

  1294 		}

  1295 		pUser->grp_table = tblidx;

  1296 		pUser->grp_size = new_size;

  1297 	} else {

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

  1299 	}

  1301 	table[pUser->grp_count] = gid;

  1302 	pUser->grp_count++;

  1304 	/* Compute new effective permissions */

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

  1307 	if (pGroup->immune_default)

  1308 	{

  1309 		pUser->immune_default = true;

  1310 	}

  1311 	if (pGroup->immune_global)

  1312 	{

  1313 		pUser->immune_global = true;

  1314 	}

  1316 	return true;

  1317 }

  1319 bool AdminCache::IsValidAdmin(AdminId id)

  1320 {

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

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

  1323 }

  1325 unsigned int AdminCache::GetAdminGroupCount(AdminId id)

  1326 {

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

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

  1329 	{

  1330 		return 0;

  1331 	}

  1333 	return pUser->grp_count;

  1334 }

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

  1337 {

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

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

  1340 	{

  1341 		return INVALID_GROUP_ID;

  1342 	}

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

  1346 	return table[index];

  1347 }

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

  1350 {

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

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

  1353 	{

  1354 		return NULL;

  1355 	}

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

  1358 }

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

  1361 {

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

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

  1364 	{

  1365 		return;

  1366 	}

  1368 	pUser->password = m_pStrings->AddString(password);

  1369 }

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

  1372 {

  1373 	unsigned int i;

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

  1375 	{

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

  1377 	}

  1379 	return i;

  1380 }

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

  1383 {

  1384 	FlagBits bits = 0;

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

  1386 	{

  1387 		if (array[i])

  1388 		{

  1389 			bits |= (1<<i);

  1390 		}

  1391 	}

  1393 	return bits;

  1394 }

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

  1397 {

  1398 	FlagBits bits = 0;

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

  1400 	{

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

  1402 	}

  1404 	return bits;

  1405 }

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

  1408 {

  1409 	unsigned int i, num=0;

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

  1411 	{

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

  1413 		{

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

  1415 		}

  1416 	}

  1418 	return num;

  1419 }

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

  1422 {

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

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

  1425 	{

  1426 		return false;

  1427 	}

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

  1430 }

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

  1433 {

  1434 	/**

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

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

  1437 	 */

  1439 	if (id == INVALID_ADMIN_ID)

  1440 	{

  1441 		return false;

  1442 	}

  1444 	if (target == INVALID_ADMIN_ID)

  1445 	{

  1446 		return true;

  1447 	}

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

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

  1451 	{

  1452 		return false;

  1453 	}

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

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

  1457 	{

  1458 		return false;

  1459 	}

  1461 	/**

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

  1463 	 */

  1464 	if (pUser->eflags & ADMFLAG_ROOT)

  1465 	{

  1466 		return true;

  1467 	}

  1469 	/** Fourth, if the targeted admin has global immunity, targeting fails. */

  1470 	if (pTarget->immune_global)

  1471 	{

  1472 		return false;

  1473 	}

  1475 	/**

  1476 	 * Fifth, if the targeted admin has default immunity

  1477 	 *  and the admin belongs to no groups, targeting fails.

  1478 	 */

  1479 	if (pTarget->immune_default && pUser->grp_count < 1)

  1480 	{

  1481 		return false;

  1482 	}

  1484 	/**

  1485 	 * Sixth, if the targeted admin has specific immunity from the

  1486 	 *  targeting admin via group immunities, targeting fails.

  1487 	 */

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

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

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

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

  1492 	{

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

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

  1495 		GroupId id, other;

  1496 		unsigned int num;

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

  1498 		{

  1499 			id = grp_table[i];

  1500 			num = GetGroupImmunityCount(id);

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

  1502 			{

  1503 				other = GetGroupImmunity(id, j);

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

  1505 				{

  1506 					if (other == src_table[k])

  1507 					{

  1508 						return false;

  1509 					}

  1510 				}

  1511 			}

  1512 		}

  1513 	}

  1515 	return true;

  1516 }

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

  1519 {

  1520 	if (c < 'a' || c > 'z')

  1521 	{

  1522 		return false;

  1523 	}

  1525 	if (*pAdmFlag)

  1526 	{

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

  1528 	}

  1530 	return true;

  1531 }

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

  1534 {

  1535 	FlagBits bits = 0;

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

  1538 	{

  1539 		AdminFlag flag;

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

  1541 		{

  1542 			break;

  1543 		}

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

  1545 		flags++;

  1546 	}

  1548 	if (end)

  1549 	{

  1550 		*end = flags;

  1551 	}

  1553 	return bits;

  1554 }

author	David Anderson <dvander@alliedmods.net>
	Fri Aug 10 05:08:14 2007 +0000 (2007-08-10)
changeset 1299	10f58032bc78
parent 1298	9cddbed74581
child 1305	72711a64a086
permissions	-rw-r--r--