sourcemod-central: core/AdminCache.cpp@591f6d2fd11d

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

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

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

     7  *

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

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

    10  * Free Software Foundation.

    11  *

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

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

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

    15  * details.

    16  *

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

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

    19  *

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

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

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

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

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

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

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

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

    28  *

    29  * Version: $Id$

    30  */

    32 #include <string.h>

    33 #include <assert.h>

    34 #include "AdminCache.h"

    35 #include "ShareSys.h"

    36 #include "ForwardSys.h"

    37 #include "PlayerManager.h"

    38 #include "ConCmdManager.h"

    39 #include "TextParsers.h"

    40 #include "Logger.h"

    41 #include "sourcemod.h"

    42 #include "sm_stringutil.h"

    44 #define LEVEL_STATE_NONE		0

    45 #define LEVEL_STATE_LEVELS		1

    46 #define LEVEL_STATE_FLAGS		2

    48 AdminCache g_Admins;

    49 AdminFlag g_FlagLetters[26];

    50 bool g_FlagSet[26];

    52 /* Default flags */

    53 AdminFlag g_DefaultFlags[26] =

    54 {

    55 	Admin_Reservation, Admin_Generic, Admin_Kick, Admin_Ban, Admin_Unban,

    56 	Admin_Slay, Admin_Changemap, Admin_Convars, Admin_Config, Admin_Chat,

    57 	Admin_Vote, Admin_Password, Admin_RCON, Admin_Cheats, Admin_Custom1,

    58 	Admin_Custom2, Admin_Custom3, Admin_Custom4, Admin_Custom5, Admin_Custom6,

    59 	Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic,

    60 	Admin_Root

    61 };

    64 class FlagReader : public ITextListener_SMC

    65 {

    66 public:

    67 	void LoadLevels()

    68 	{

    69 		if (!Parse())

    70 		{

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

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

    73 			{

    74 				g_FlagSet[i] = true;

    75 			}

    76 			g_FlagSet[25] = true;

    77 		}

    78 	}

    79 private:

    80 	bool Parse()

    81 	{

    82 		unsigned int line = 0;

    83 		SMCParseError error;

    85 		m_Line = 0;

    86 		m_bFileNameLogged = false;

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

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

    90 			!= SMCParse_Okay)

    91 		{

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

    93 			if (!err_string)

    94 			{

    95 				err_string = "Unknown error";

    96 			}

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

    98 			return false;

    99 		}

   101 		return true;

   102 	}

   103 	void ReadSMC_ParseStart()

   104 	{

   105 		m_LevelState = LEVEL_STATE_NONE;

   106 		m_IgnoreLevel = 0;

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

   108 	}

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

   110 	{

   111 		if (m_IgnoreLevel)

   112 		{

   113 			m_IgnoreLevel++;

   114 			return SMCParse_Continue;

   115 		}

   117 		if (m_LevelState == LEVEL_STATE_NONE)

   118 		{

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

   120 			{

   121 				m_LevelState = LEVEL_STATE_LEVELS;

   122 			} else {

   123 				m_IgnoreLevel++;

   124 			}

   125 		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

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

   127 			{

   128 				m_LevelState = LEVEL_STATE_FLAGS;

   129 			} else {

   130 				m_IgnoreLevel++;

   131 			}

   132 		} else {

   133 			m_IgnoreLevel++;

   134 		}

   136 		return SMCParse_Continue;

   137 	}

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

   139 	{

   140 		if (m_LevelState != LEVEL_STATE_FLAGS || m_IgnoreLevel)

   141 		{

   142 			return SMCParse_Continue;

   143 		}

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

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

   148 		{

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

   150 			return SMCParse_Continue;

   151 		}

   153 		c -= (unsigned)'a';

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

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

   158 		{

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

   160 			return SMCParse_Continue;

   161 		}

   163 		g_FlagSet[c] = true;

   165 		return SMCParse_Continue;

   166 	}

   167 	SMCParseResult ReadSMC_LeavingSection()

   168 	{

   169 		if (m_IgnoreLevel)

   170 		{

   171 			m_IgnoreLevel--;

   172 			return SMCParse_Continue;

   173 		}

   175 		if (m_LevelState == LEVEL_STATE_FLAGS)

   176 		{

   177 			m_LevelState = LEVEL_STATE_LEVELS;

   178 			return SMCParse_Halt;

   179 		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

   180 			m_LevelState = LEVEL_STATE_NONE;

   181 		}

   183 		return SMCParse_Continue;

   184 	}

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

   186 	{

   187 		m_Line = curline;

   188 		return SMCParse_Continue;

   189 	}

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

   191 	{

   192 		va_list ap;

   193 		char buffer[256];

   195 		va_start(ap, message);

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

   197 		va_end(ap);

   199 		if (!m_bFileNameLogged)

   200 		{

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

   202 			m_bFileNameLogged = true;

   203 		}

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

   206 	}

   207 private:

   208 	bool m_bFileNameLogged;

   209 	char m_File[PLATFORM_MAX_PATH];

   210 	int m_LevelState;

   211 	int m_IgnoreLevel;

   212 	unsigned int m_Line;

   213 } s_FlagReader;

   215 AdminCache::AdminCache()

   216 {

   217 	m_pCmdOverrides = sm_trie_create();

   218 	m_pCmdGrpOverrides = sm_trie_create();

   219 	m_pStrings = new BaseStringTable(1024);

   220 	m_pMemory = m_pStrings->GetMemTable();

   221 	m_FreeGroupList = m_FirstGroup = m_LastGroup = INVALID_GROUP_ID;

   222 	m_FreeUserList = m_FirstUser = m_LastUser = INVALID_ADMIN_ID;

   223 	m_pGroups = sm_trie_create();

   224 	m_pCacheFwd = NULL;

   225 	m_FirstGroup = -1;

   226 	m_pAuthTables = sm_trie_create();

   227 	m_InvalidatingAdmins = false;

   228 	m_destroying = false;

   229 	m_pLevelNames = sm_trie_create();

   230 }

   232 AdminCache::~AdminCache()

   233 {

   234 	m_destroying = true;

   235 	DumpAdminCache(AdminCache_Overrides, false);

   236 	DumpAdminCache(AdminCache_Groups, false);

   238 	sm_trie_destroy(m_pCmdGrpOverrides);

   239 	sm_trie_destroy(m_pCmdOverrides);

   241 	if (m_pGroups)

   242 	{

   243 		sm_trie_destroy(m_pGroups);

   244 	}

   246 	List<AuthMethod>::iterator iter;

   247 	for (iter=m_AuthMethods.begin();

   248 		 iter!=m_AuthMethods.end();

   249 		 iter++)

   250 	{

   251 		sm_trie_destroy((*iter).table);

   252 	}

   254 	sm_trie_destroy(m_pAuthTables);

   256 	delete m_pStrings;

   258 	sm_trie_destroy(m_pLevelNames);

   259 }

   261 void AdminCache::OnSourceModStartup(bool late)

   262 {

   263 	RegisterAuthIdentType("steam");

   264 	RegisterAuthIdentType("name");

   265 	RegisterAuthIdentType("ip");

   267 	NameFlag("reservation", Admin_Reservation);

   268 	NameFlag("kick", Admin_Kick);

   269 	NameFlag("generic", Admin_Generic);

   270 	NameFlag("ban", Admin_Ban);

   271 	NameFlag("unban", Admin_Unban);

   272 	NameFlag("slay", Admin_Slay);

   273 	NameFlag("changemap", Admin_Changemap);

   274 	NameFlag("cvars", Admin_Convars);

   275 	NameFlag("config", Admin_Config);

   276 	NameFlag("chat", Admin_Chat);

   277 	NameFlag("vote", Admin_Vote);

   278 	NameFlag("password", Admin_Password);

   279 	NameFlag("rcon", Admin_RCON);

   280 	NameFlag("cheats", Admin_Cheats);

   281 	NameFlag("root", Admin_Root);

   282 	NameFlag("custom1", Admin_Custom1);

   283 	NameFlag("custom2", Admin_Custom2);

   284 	NameFlag("custom3", Admin_Custom3);

   285 	NameFlag("custom4", Admin_Custom4);

   286 	NameFlag("custom5", Admin_Custom5);

   287 	NameFlag("custom6", Admin_Custom6);

   288 }

   290 void AdminCache::OnSourceModAllInitialized()

   291 {

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

   293 	g_ShareSys.AddInterface(NULL, this);

   294 }

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

   297 {

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

   299 	s_FlagReader.LoadLevels();

   300 }

   302 void AdminCache::OnSourceModShutdown()

   303 {

   304 	g_Forwards.ReleaseForward(m_pCacheFwd);

   305 	m_pCacheFwd = NULL;

   306 }

   308 void AdminCache::OnSourceModPluginsLoaded()

   309 {

   310 	DumpAdminCache(AdminCache_Overrides, true);

   311 	DumpAdminCache(AdminCache_Groups, true);

   312 }

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

   315 {

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

   317 }

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

   320 {

   321 	void *obj;

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

   323 	{

   324 		return false;

   325 	}

   327 	if (pFlag)

   328 	{

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

   330 	}

   332 	return true;

   333 }

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

   336 {

   337 	Trie *pTrie = NULL;

   338 	if (type == Override_Command)

   339 	{

   340 		pTrie = m_pCmdOverrides;

   341 	} else if (type == Override_CommandGroup) {

   342 		pTrie = m_pCmdGrpOverrides;

   343 	} else {

   344 		return;

   345 	}

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

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

   350 }

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

   353 {

   354 	Trie *pTrie = NULL;

   356 	if (type == Override_Command)

   357 	{

   358 		pTrie = m_pCmdOverrides;

   359 	} else if (type == Override_CommandGroup) {

   360 		pTrie = m_pCmdGrpOverrides;

   361 	} else {

   362 		return false;

   363 	}

   365 	void *object;

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

   367 	{

   368 		if (pFlags)

   369 		{

   370 			*pFlags = (FlagBits)object;

   371 		}

   372 		return true;

   373 	}

   375 	return false;

   376 }

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

   379 {

   380 	if (type == Override_Command)

   381 	{

   382 		return _UnsetCommandOverride(cmd);

   383 	} else if (type == Override_CommandGroup) {

   384 		return _UnsetCommandGroupOverride(cmd);

   385 	}

   386 }

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

   389 {

   390 	if (!m_pCmdGrpOverrides)

   391 	{

   392 		return;

   393 	}

   395 	sm_trie_delete(m_pCmdGrpOverrides, group);

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

   398 }

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

   401 {

   402 	if (!m_pCmdOverrides)

   403 	{

   404 		return;

   405 	}

   407 	sm_trie_delete(m_pCmdOverrides, cmd);

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

   410 }

   412 void AdminCache::DumpCommandOverrideCache(OverrideType type)

   413 {

   414 	if (type == Override_Command && m_pCmdOverrides)

   415 	{

   416 		sm_trie_clear(m_pCmdOverrides);

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

   418 		sm_trie_clear(m_pCmdGrpOverrides);

   419 	}

   420 }

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

   423 {

   424 	AdminId id;

   425 	AdminUser *pUser;

   427 	if (m_FreeUserList != INVALID_ADMIN_ID)

   428 	{

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

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

   431 		id = m_FreeUserList;

   432 		m_FreeUserList = pUser->next_user;

   433 	} else {

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

   435 		pUser->grp_size = 0;

   436 		pUser->grp_table = -1;

   437 	}

   439 	pUser->flags = 0;

   440 	pUser->eflags = 0;

   441 	pUser->grp_count = 0;

   442 	pUser->password = -1;

   443 	pUser->magic = USR_MAGIC_SET;

   444 	pUser->auth.identidx = -1;

   445 	pUser->auth.index = 0;

   446 	pUser->immune_default = false;

   447 	pUser->immune_global = false;

   448 	pUser->serialchange = 1;

   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 		int nameidx = m_pStrings->AddString(name);

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

   465 		pUser->nameidx = nameidx;

   466 	}

   468 	return id;

   469 }

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

   472 {

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

   474 	{

   475 		return INVALID_GROUP_ID;

   476 	}

   478 	GroupId id;

   479 	AdminGroup *pGroup;

   480 	if (m_FreeGroupList != INVALID_GROUP_ID)

   481 	{

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

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

   484 		id = m_FreeGroupList;

   485 		m_FreeGroupList = pGroup->next_grp;

   486 	} else {

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

   488 	}

   490 	pGroup->immune_default = false;

   491 	pGroup->immune_global = false;

   492 	pGroup->immune_table = -1;

   493 	pGroup->magic = GRP_MAGIC_SET;

   494 	pGroup->next_grp = INVALID_GROUP_ID;

   495 	pGroup->pCmdGrpTable = NULL;

   496 	pGroup->pCmdTable = NULL;

   497 	pGroup->addflags = 0;

   499 	if (m_FirstGroup == INVALID_GROUP_ID)

   500 	{

   501 		m_FirstGroup = id;

   502 		m_LastGroup = id;

   503 		pGroup->prev_grp = INVALID_GROUP_ID;

   504 	} else {

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

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

   507 		pPrev->next_grp = id;

   508 		pGroup->prev_grp = m_LastGroup;

   509 		m_LastGroup = id;

   510 	}

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

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

   514 	pGroup->nameidx = nameidx;

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

   518 	return id;

   519 }

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

   522 {

   523 	void *object;

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

   526 	{

   527 		return INVALID_GROUP_ID;

   528 	}

   530 	GroupId id = (GroupId)object;

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

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

   534 	{

   535 		return INVALID_GROUP_ID;

   536 	}

   538 	return id;

   539 }

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

   542 {

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

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

   545 	{

   546 		return;

   547 	}

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

   550 	{

   551 		return;

   552 	}

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

   556 	if (enabled)

   557 	{

   558 		pGroup->addflags |= bits;

   559 	} else {

   560 		pGroup->addflags &= ~bits;

   561 	}

   562 }

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

   565 {

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

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

   568 	{

   569 		return false;

   570 	}

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

   573 	{

   574 		return false;

   575 	}

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

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

   579 }

   581 FlagBits AdminCache::GetGroupAddFlags(GroupId id)

   582 {

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

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

   585 	{

   586 		return 0;

   587 	}

   589 	return pGroup->addflags;

   590 }

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

   593 {

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

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

   596 	{

   597 		return 0;

   598 	}

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

   601 }

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

   604 {

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

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

   607 	{

   608 		return;

   609 	}

   611 	if (type == Immunity_Default)

   612 	{

   613 		pGroup->immune_default = enabled;

   614 	} else if (type == Immunity_Global) {

   615 		pGroup->immune_global = enabled;

   616 	}

   617 }

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

   620 {

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

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

   623 	{

   624 		return false;

   625 	}

   627 	if (type == Immunity_Default)

   628 	{

   629 		return pGroup->immune_default;

   630 	} else if (type == Immunity_Global) {

   631 		return pGroup->immune_global;

   632 	}

   634 	return false;

   635 }

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

   638 {

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

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

   641 	{

   642 		return;

   643 	}

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

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

   647 	{

   648 		return;

   649 	}

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

   652 	int *table, tblidx;

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

   654 	{

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

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

   657 		table[0] = 0;

   658 	} else {

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

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

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

   662 		{

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

   664 			{

   665 				return;

   666 			}

   667 		}

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

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

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

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

   672 		table[0] = old_table[0];

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

   674 		{

   675 			table[i] = old_table[i];

   676 		}

   677 	}

   679 	/* Assign */

   680 	pGroup->immune_table = tblidx;

   682 	/* Add to the array */

   683 	table[0]++;

   684 	table[table[0]] = other_id;

   685 }

   687 unsigned int AdminCache::GetGroupImmunityCount(GroupId id)

   688 {

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

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

   691 	{

   692 		return 0;

   693 	}

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

   696 	{

   697 		return 0;

   698 	}

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

   702 	return table[0];

   703 }

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

   706 {

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

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

   709 	{

   710 		return INVALID_GROUP_ID;

   711 	}

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

   714 	{

   715 		return INVALID_GROUP_ID;

   716 	}

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

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

   720 	{

   721 		return INVALID_GROUP_ID;

   722 	}

   724 	return table[1 + number];

   725 }

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

   728 {

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

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

   731 	{

   732 		return;

   733 	}

   735 	Trie *pTrie = NULL;

   736 	if (type == Override_Command)

   737 	{

   738 		if (pGroup->pCmdTable == NULL)

   739 		{

   740 			pGroup->pCmdTable = sm_trie_create();

   741 		}

   742 		pTrie = pGroup->pCmdTable;

   743 	} else if (type == Override_CommandGroup) {

   744 		if (pGroup->pCmdGrpTable == NULL)

   745 		{

   746 			pGroup->pCmdGrpTable = sm_trie_create();

   747 		}

   748 		pTrie = pGroup->pCmdGrpTable;

   749 	} else {

   750 		return;

   751 	}

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

   754 }

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

   757 {

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

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

   760 	{

   761 		return false;

   762 	}

   764 	Trie *pTrie = NULL;

   765 	if (type == Override_Command)

   766 	{

   767 		if (pGroup->pCmdTable == NULL)

   768 		{

   769 			return false;

   770 		}

   771 		pTrie = pGroup->pCmdTable;

   772 	} else if (type == Override_CommandGroup) {

   773 		if (pGroup->pCmdGrpTable == NULL)

   774 		{

   775 			return false;

   776 		}

   777 		pTrie = pGroup->pCmdGrpTable;

   778 	} else {

   779 		return false;

   780 	}

   782 	void *object;

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

   784 	{

   785 		return false;

   786 	}

   788 	if (pRule)

   789 	{

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

   791 	}

   793 	return true;

   794 }

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

   797 {

   798 	List<AuthMethod>::iterator iter;

   799 	for (iter=m_AuthMethods.begin();

   800 		 iter!=m_AuthMethods.end();

   801 		 iter++)

   802 	{

   803 		if (index-- == 0)

   804 		{

   805 			return (*iter).table;

   806 		}

   807 	}

   809 	return NULL;

   810 }

   812 bool AdminCache::InvalidateAdmin(AdminId id)

   813 {

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

   815 	AdminUser *pOther;

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

   817 	{

   818 		return false;

   819 	}

   821 	if (!m_InvalidatingAdmins && !m_destroying)

   822 	{

   823 		g_Players.ClearAdminId(id);

   824 	}

   826 	/* Unlink from the dbl link list */

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

   828 	{

   829 		m_FirstUser = INVALID_ADMIN_ID;

   830 		m_LastUser = INVALID_ADMIN_ID;

   831 	} else if (id == m_FirstUser) {

   832 		m_FirstUser = pUser->next_user;

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

   834 		pOther->prev_user = INVALID_ADMIN_ID;

   835 	} else if (id == m_LastUser) {

   836 		m_LastUser = pUser->prev_user;

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

   838 		pOther->next_user = INVALID_ADMIN_ID;

   839 	} else {

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

   841 		pOther->next_user = pUser->next_user;

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

   843 		pOther->prev_user = pUser->prev_user;

   844 	}

   846 	/* Unlink from auth tables */

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

   848 	{

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

   850 		if (pTrie)

   851 		{

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

   853 		}

   854 	}

   856 	/* Clear table counts */

   857 	pUser->grp_count = 0;

   859 	/* Link into free list */

   860 	pUser->magic = USR_MAGIC_UNSET;

   861 	pUser->next_user = m_FreeUserList;

   862 	m_FreeUserList = id;

   864 	/* Unset serial change */

   865 	pUser->serialchange = 0;

   867 	return true;

   868 }

   871 void AdminCache::InvalidateGroup(GroupId id)

   872 {

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

   874 	AdminGroup *pOther;

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

   877 	{

   878 		return;

   879 	}

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

   882 	sm_trie_delete(m_pGroups, str);

   884 	/* Unlink from the live dbllink list */

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

   886 	{

   887 		m_LastGroup = INVALID_GROUP_ID;

   888 		m_FirstGroup = INVALID_GROUP_ID;

   889 	} else if (id == m_FirstGroup) {

   890 		m_FirstGroup = pGroup->next_grp;

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

   892 		pOther->prev_grp = INVALID_GROUP_ID;

   893 	} else if (id == m_LastGroup) {

   894 		m_LastGroup = pGroup->prev_grp;

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

   896 		pOther->next_grp = INVALID_GROUP_ID;

   897 	} else {

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

   899 		pOther->next_grp = pGroup->next_grp;

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

   901 		pOther->prev_grp = pGroup->prev_grp;

   902 	}

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

   905 	if (pGroup->pCmdGrpTable)

   906 	{

   907 		sm_trie_destroy(pGroup->pCmdGrpTable);

   908 		pGroup->pCmdGrpTable = NULL;

   909 	}

   910 	if (pGroup->pCmdTable)

   911 	{

   912 		sm_trie_destroy(pGroup->pCmdTable);

   913 		pGroup->pCmdTable = NULL;

   914 	}

   916 	/* Link into the free list */

   917 	pGroup->magic = GRP_MAGIC_UNSET;

   918 	pGroup->next_grp = m_FreeGroupList;

   919 	m_FreeGroupList = id;

   921 	int idx = m_FirstUser;

   922 	AdminUser *pUser;

   923 	int *table;

   924 	while (idx != INVALID_ADMIN_ID)

   925 	{

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

   927 		if (pUser->grp_count > 0)

   928 		{

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

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

   931 			{

   932 				if (table[i] == id)

   933 				{

   934 					/* We have to remove this entry */

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

   936 					{

   937 						/* Move everything down by one */

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

   939 					}

   940 					/* Decrease count */

   941 					pUser->grp_count--;

   942 					/* Recalculate effective flags */

   943 					pUser->eflags = pUser->flags;

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

   945 					{

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

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

   948 					}

   949 					/* Mark as changed */

   950 					pUser->serialchange++;

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

   952 					break;

   953 				}

   954 			}

   955 		}

   956 		idx = pUser->next_user;

   957 	}

   958 }

   960 void AdminCache::InvalidateGroupCache()

   961 {

   962 	/* Nuke the free list */

   963 	m_FreeGroupList = -1;

   965 	/* Nuke reverse lookups */

   966 	sm_trie_clear(m_pGroups);

   968 	/* Free memory on groups */

   969 	GroupId cur = m_FirstGroup;

   970 	AdminGroup *pGroup;

   971 	while (cur != INVALID_GROUP_ID)

   972 	{

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

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

   975 		if (pGroup->pCmdGrpTable)

   976 		{

   977 			sm_trie_destroy(pGroup->pCmdGrpTable);

   978 		}

   979 		if (pGroup->pCmdTable)

   980 		{

   981 			sm_trie_destroy(pGroup->pCmdTable);

   982 		}

   983 		cur = pGroup->next_grp;

   984 	}

   986 	m_FirstGroup = INVALID_GROUP_ID;

   987 	m_LastGroup = INVALID_GROUP_ID;

   989 	InvalidateAdminCache(false);

   991 	/* Reset the memory table */

   992 	m_pMemory->Reset();

   993 }

   995 void AdminCache::AddAdminListener(IAdminListener *pListener)

   996 {

   997 	m_hooks.push_back(pListener);

   998 }

  1000 void AdminCache::RemoveAdminListener(IAdminListener *pListener)

  1001 {

  1002 	m_hooks.remove(pListener);

  1003 }

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

  1006 {

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

  1008 	{

  1009 		return;

  1010 	}

  1012 	Trie *pAuth = sm_trie_create();

  1014 	AuthMethod method;

  1015 	method.name.assign(name);

  1016 	method.table = pAuth;

  1018 	m_AuthMethods.push_back(method);

  1020 	sm_trie_insert(m_pAuthTables, name, pAuth);

  1021 }

  1023 void AdminCache::InvalidateAdminCache(bool unlink_admins)

  1024 {

  1025 	m_InvalidatingAdmins = true;

  1026 	if (!m_destroying)

  1027 	{

  1028 		g_Players.ClearAllAdmins();

  1029 	}

  1030 	/* Wipe the identity cache first */

  1031 	List<AuthMethod>::iterator iter;

  1032 	for (iter=m_AuthMethods.begin();

  1033 		 iter!=m_AuthMethods.end();

  1034 		 iter++)

  1035 	{

  1036 		sm_trie_clear((*iter).table);

  1037 	}

  1039 	if (unlink_admins)

  1040 	{

  1041 		while (m_FirstUser != INVALID_ADMIN_ID)

  1042 		{

  1043 			InvalidateAdmin(m_FirstUser);

  1044 		}

  1045 	} else {

  1046 		m_FirstUser = -1;

  1047 		m_LastUser = -1;

  1048 		m_FreeUserList = -1;

  1049 	}

  1050 	m_InvalidatingAdmins = false;

  1051 }

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

  1054 {

  1055 	List<IAdminListener *>::iterator iter;

  1056 	IAdminListener *pListener;

  1057 	cell_t result;

  1059 	if (part == AdminCache_Overrides)

  1060 	{

  1061 		DumpCommandOverrideCache(Override_Command);

  1062 		DumpCommandOverrideCache(Override_CommandGroup);

  1063 		if (rebuild && !m_destroying)

  1064 		{

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

  1066 			{

  1067 				pListener = (*iter);

  1068 				pListener->OnRebuildOverrideCache();

  1069 			}

  1070 			m_pCacheFwd->PushCell(part);

  1071 			m_pCacheFwd->Execute(&result);

  1072 		}

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

  1074 		if (part == AdminCache_Groups)

  1075 		{

  1076 			InvalidateGroupCache();

  1077 			if (rebuild && !m_destroying)

  1078 			{

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

  1080 				{

  1081 					pListener = (*iter);

  1082 					pListener->OnRebuildGroupCache();

  1083 				}

  1084 				m_pCacheFwd->PushCell(part);

  1085 				m_pCacheFwd->Execute(&result);

  1086 			}

  1087 		}

  1088 		InvalidateAdminCache(true);

  1089 		if (rebuild && !m_destroying)

  1090 		{

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

  1092 			{

  1093 				pListener = (*iter);

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

  1095 			}

  1096 			m_pCacheFwd->PushCell(AdminCache_Admins);

  1097 			m_pCacheFwd->Execute(&result);

  1098 			g_Players.RecheckAnyAdmins();

  1099 		}

  1100 	}

  1101 }

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

  1104 {

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

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

  1107 	{

  1108 		return NULL;

  1109 	}

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

  1112 }

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

  1115 {

  1116 	List<AuthMethod>::iterator iter;

  1117 	unsigned int index = 0;

  1118 	for (iter=m_AuthMethods.begin();

  1119 		 iter!=m_AuthMethods.end();

  1120 		 iter++,index++)

  1121 	{

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

  1123 		{

  1124 			*_index = index;

  1125 			return true;

  1126 		}

  1127 	}

  1129 	return false;

  1130 }

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

  1133 {

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

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

  1136 	{

  1137 		return false;

  1138 	}

  1140 	Trie *pTable;

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

  1142 	{

  1143 		return false;

  1144 	}

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

  1147 	{

  1148 		return false;

  1149 	}

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

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

  1154 	pUser->auth.identidx = i_ident;

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

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

  1158 }

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

  1161 {

  1162 	Trie *pTable;

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

  1164 	{

  1165 		return INVALID_ADMIN_ID;

  1166 	}

  1168 	void *object;

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

  1170 	{

  1171 		return INVALID_ADMIN_ID;

  1172 	}

  1174 	return (AdminId)object;

  1175 }

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

  1178 {

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

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

  1181 	{

  1182 		return;

  1183 	}

  1185 	if (flag < Admin_Reservation

  1186 		|| flag >= AdminFlags_TOTAL)

  1187 	{

  1188 		return;

  1189 	}

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

  1193 	if (enabled)

  1194 	{

  1195 		pUser->flags |= bits;

  1196 		pUser->eflags |= bits;

  1197 	} else {

  1198 		pUser->flags &= ~bits;

  1199 		pUser->eflags &= ~bits;

  1200 	}

  1202 	pUser->serialchange++;

  1203 }

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

  1206 {

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

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

  1209 	{

  1210 		return false;

  1211 	}

  1213 	if (flag < Admin_Reservation

  1214 		|| flag >= AdminFlags_TOTAL)

  1215 	{

  1216 		return false;

  1217 	}

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

  1221 	if (mode == Access_Real)

  1222 	{

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

  1224 	} else if (mode == Access_Effective) {

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

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

  1227 		{

  1228 			has_bit = true;

  1229 		}

  1230 		return has_bit;

  1231 	}

  1233 	return false;

  1234 }

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

  1237 {

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

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

  1240 	{

  1241 		return 0;

  1242 	}

  1244 	if (mode == Access_Real)

  1245 	{

  1246 		return pUser->flags;

  1247 	} else if (mode == Access_Effective) {

  1248 		return pUser->eflags;

  1249 	}

  1251 	return 0;

  1252 }

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

  1255 {

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

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

  1258 	{

  1259 		return;

  1260 	}

  1262 	if (mode == Access_Real)

  1263 	{

  1264 		pUser->flags = bits;

  1265 		pUser->eflags = bits;

  1266 	} else if (mode == Access_Effective) {

  1267 		pUser->eflags = bits;

  1268 	}

  1270 	pUser->serialchange++;

  1271 }

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

  1274 {

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

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

  1277 	{

  1278 		return false;

  1279 	}

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

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

  1283 	{

  1284 		return false;

  1285 	}

  1287 	/* First check for duplicates */

  1288 	if (pUser->grp_count != 0)

  1289 	{

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

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

  1292 		{

  1293 			if (temp_table[i] == gid)

  1294 			{

  1295 				return false;

  1296 			}

  1297 		}

  1298 	}

  1300 	int *table;

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

  1302 	{

  1303 		int new_size = 0;

  1304 		int tblidx;

  1306 		if (pUser->grp_size == 0)

  1307 		{

  1308 			new_size = 2;

  1309 		} else {

  1310 			new_size = pUser->grp_size * 2;

  1311 		}

  1313 		/* Create and refresh pointers */

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

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

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

  1318 		/* Copy old data if necessary */

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

  1320 		{

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

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

  1323 		}

  1324 		pUser->grp_table = tblidx;

  1325 		pUser->grp_size = new_size;

  1326 	} else {

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

  1328 	}

  1330 	table[pUser->grp_count] = gid;

  1331 	pUser->grp_count++;

  1333 	/* Compute new effective permissions */

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

  1336 	if (pGroup->immune_default)

  1337 	{

  1338 		pUser->immune_default = true;

  1339 	}

  1340 	if (pGroup->immune_global)

  1341 	{

  1342 		pUser->immune_global = true;

  1343 	}

  1345 	pUser->serialchange++;

  1347 	return true;

  1348 }

  1350 bool AdminCache::IsValidAdmin(AdminId id)

  1351 {

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

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

  1354 }

  1356 unsigned int AdminCache::GetAdminGroupCount(AdminId id)

  1357 {

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

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

  1360 	{

  1361 		return 0;

  1362 	}

  1364 	return pUser->grp_count;

  1365 }

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

  1368 {

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

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

  1371 	{

  1372 		return INVALID_GROUP_ID;

  1373 	}

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

  1377 	GroupId gid = table[index];

  1379 	if (name)

  1380 	{

  1381 		*name = GetGroupName(gid);

  1382 	}

  1384 	return gid;

  1385 }

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

  1388 {

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

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

  1391 	{

  1392 		return NULL;

  1393 	}

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

  1396 }

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

  1399 {

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

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

  1402 	{

  1403 		return;

  1404 	}

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

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

  1408 	pUser->password = i_password;

  1409 }

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

  1412 {

  1413 	unsigned int i;

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

  1415 	{

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

  1417 	}

  1419 	return i;

  1420 }

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

  1423 {

  1424 	FlagBits bits = 0;

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

  1426 	{

  1427 		if (array[i])

  1428 		{

  1429 			bits |= (1<<i);

  1430 		}

  1431 	}

  1433 	return bits;

  1434 }

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

  1437 {

  1438 	FlagBits bits = 0;

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

  1440 	{

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

  1442 	}

  1444 	return bits;

  1445 }

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

  1448 {

  1449 	unsigned int i, num=0;

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

  1451 	{

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

  1453 		{

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

  1455 		}

  1456 	}

  1458 	return num;

  1459 }

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

  1462 {

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

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

  1465 	{

  1466 		return false;

  1467 	}

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

  1470 }

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

  1473 {

  1474 	/**

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

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

  1477 	 */

  1479 	if (id == INVALID_ADMIN_ID)

  1480 	{

  1481 		return false;

  1482 	}

  1484 	if (target == INVALID_ADMIN_ID)

  1485 	{

  1486 		return true;

  1487 	}

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

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

  1491 	{

  1492 		return false;

  1493 	}

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

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

  1497 	{

  1498 		return false;

  1499 	}

  1501 	/**

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

  1503 	 */

  1504 	if (pUser->eflags & ADMFLAG_ROOT)

  1505 	{

  1506 		return true;

  1507 	}

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

  1510 	if (pTarget->immune_global)

  1511 	{

  1512 		return false;

  1513 	}

  1515 	/**

  1516 	 * Fifth, if the targeted admin has default immunity

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

  1518 	 */

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

  1520 	{

  1521 		return false;

  1522 	}

  1524 	/**

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

  1526 	 *  targeting admin via group immunities, targeting fails.

  1527 	 */

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

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

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

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

  1532 	{

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

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

  1535 		GroupId id, other;

  1536 		unsigned int num;

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

  1538 		{

  1539 			id = grp_table[i];

  1540 			num = GetGroupImmunityCount(id);

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

  1542 			{

  1543 				other = GetGroupImmunity(id, j);

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

  1545 				{

  1546 					if (other == src_table[k])

  1547 					{

  1548 						return false;

  1549 					}

  1550 				}

  1551 			}

  1552 		}

  1553 	}

  1555 	return true;

  1556 }

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

  1559 {

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

  1561 	{

  1562 		return false;

  1563 	}

  1565 	if (pAdmFlag)

  1566 	{

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

  1568 	}

  1570 	return true;

  1571 }

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

  1574 {

  1575 	FlagBits bits = 0;

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

  1578 	{

  1579 		AdminFlag flag;

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

  1581 		{

  1582 			break;

  1583 		}

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

  1585 		flags++;

  1586 	}

  1588 	if (end)

  1589 	{

  1590 		*end = flags;

  1591 	}

  1593 	return bits;

  1594 }

  1596 unsigned int AdminCache::GetAdminSerialChange(AdminId id)

  1597 {

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

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

  1600 	{

  1601 		return 0;

  1602 	}

  1604 	return pUser->serialchange;

  1605 }

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

  1608 {

  1609 	FlagBits bits;

  1610 	OverrideType otype = Override_Command;

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

  1613 	{

  1614 		otype = Override_CommandGroup;

  1615 		cmd++;

  1616 	}

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

  1619 	{

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

  1621 		{

  1622 			bits = 0;

  1623 		}

  1624 	}

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

  1627 }

author	David Anderson <dvander@alliedmods.net>
	Sun Aug 19 18:34:36 2007 +0000 (2007-08-19)
changeset 1361	591f6d2fd11d
parent 1356	4688fae59bcf
child 1403	ecb9c66fd4bb
permissions	-rw-r--r--