renamed this plugin

--HG--
extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%40443

plugins/admin-flatfile/admin-base.sp

@@ -0,0 +1,33 @@
+#include <sourcemod>
+#include <textparse>
+
+public Plugin:myinfo = 
+{
+	name = "Admin Base",
+	author = "AlliedModders LLC",
+	description = "Reads admin files",
+	version = "1.0.0.0",
+	url = "http://www.sourcemod.net/"
+};
+
+/** Various globals */
+new AdminFlag:g_FlagLetters[26];			/* Maps the flag letters */		
+new bool:g_LoggedFileName = false;			/* Whether or not the file name has been logged */
+new g_ErrorCount = 0;
+
+#include "admin-levels.sp"
+#include "admin-overrides.sp"
+#include "admin-groups.sp"
+
+public OnRebuildAdminCache(cache_flags)
+{
+	RefreshLevels();
+	if (cache_flags & ADMIN_CACHE_OVERRIDES)
+	{
+		ReadOverrides();
+	}
+	if (cache_flags & ADMIN_CACHE_GROUPS)
+	{
+		ReadGroups();
+	}
+}

plugins/admin-flatfile/admin-groups.sp

@@ -0,0 +1,196 @@
+#define GROUP_STATE_NONE		0
+#define GROUP_STATE_GROUPS		1
+#define GROUP_STATE_INGROUP		2
+#define GROUP_STATE_OVERRIDES	3
+#define GROUP_PASS_FIRST		1
+#define GROUP_PASS_SECOND		2
+
+static Handle:g_hGroupParser = INVALID_HANDLE;
+static GroupId:g_CurGrp = INVALID_GROUP_ID;
+static g_GroupState = GROUP_STATE_NONE;
+static g_GroupPass = 0
+static bool:g_NeedReparse = false;
+
+//:TODO: immunity needs to self-check itself for redundancy in core
+//:TODO: invalidating groups internally needs to check immunities
+//:TODO: reparsing
+
+static LogGroupError(const String:fmt[], {Handle,String,Float,_}:...)
+{
+	decl String:buffer[512];
+	
+	if (!g_LoggedFileName)
+	{
+		LogError("Error(s) detected parsing admin_groups.cfg:");
+		g_LoggedFileName = true;
+	}
+	
+	VFormat(buffer, sizeof(buffer), fmt, 2);
+	
+	LogError(" (%d) %s", ++g_ErrorCount, buffer);
+}
+
+public SMCResult:ReadGroups_NewSection(Handle:smc, const String:name[], bool:opt_quotes)
+{
+	if (g_GroupState == GROUP_STATE_NONE)
+	{
+		if (StrEqual(name, "Groups"))
+		{
+			g_GroupState = GROUP_STATE_GROUPS;
+		}
+	} else if (g_GroupState == GROUP_STATE_GROUPS) {
+		if ((g_CurGrp = CreateAdmGroup(name)) == INVALID_GROUP_ID)
+		{
+			g_CurGrp = FindAdmGroup(name);
+		}
+		g_GroupState = GROUP_STATE_INGROUP;
+	} else if (g_GroupState == GROUP_STATE_INGROUP) {
+		if (StrEqual(name, "Overrides"))
+		{
+			g_GroupState = GROUP_STATE_OVERRIDES;
+		}
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadGroups_KeyValue(Handle:smc, 
+										const String:key[], 
+										const String:value[], 
+										bool:key_quotes, 
+										bool:value_quotes)
+{
+	if (g_CurGrp == INVALID_GROUP_ID)
+	{
+		return SMCParse_Continue;
+	}
+	
+	new AdminFlag:flag;
+	
+	if (g_GroupPass == GROUP_PASS_FIRST)
+	{
+		if (g_GroupState == GROUP_STATE_INGROUP)
+		{
+			if (StrEqual(key, "flags"))
+			{
+				new len = strlen(value);
+				for (new i=0; i<len; i++)
+				{
+					if (value[i] < 'a' || value[i] > 'z')
+					{
+						continue;
+					}
+					flag = g_FlagLetters[value[i] - 'a'];
+					if (flag == Admin_None)
+					{
+						continue;
+					}
+					SetAdmGroupAddFlag(g_CurGrp, flag, true);
+				}
+			} else if (StrEqual(key, "immunity")) {
+				/* If it's a value we know about, use it */
+				if (StrEqual(value, "*"))
+				{
+					SetAdmGroupImmunity(g_CurGrp, Immunity_Global, true);
+				} else if (StrEqual(value, "$")) {
+					SetAdmGroupImmunity(g_CurGrp, Immunity_Default, true);
+				} else {
+					/* If we can't find the group, we'll need to schedule a reparse */
+					new GroupId:id = FindAdmGroup(value);
+					if (id == INVALID_GROUP_ID)
+					{
+						SetAdmGroupImmuneFrom(g_CurGrp, id);
+					} else {
+						g_NeedReparse = true;
+					}
+				}
+			}
+		} else if (g_GroupState == GROUP_STATE_OVERRIDES) {
+			new OverrideRule:rule = Command_Deny;
+			
+			if (StrEqual(value, "allow", false))
+			{
+				rule = Command_Allow;
+			}
+			
+			if (key[0] == '@')
+			{
+				AddAdmGroupCmdOverride(g_CurGrp, key[1], Override_CommandGroup, rule);
+			} else {
+				AddAdmGroupCmdOverride(g_CurGrp, key, Override_Command, rule);
+			}
+		}
+	} else if (g_GroupPass == GROUP_PASS_SECOND
+			   && g_GroupState == GROUP_STATE_INGROUP) {
+		/* Check for immunity again, core should handle double inserts */
+		if (StrEqual(key, "immunity"))
+		{
+			new GroupId:id = FindAdmGroup(value);
+			if (id != INVALID_GROUP_ID)
+			{
+				SetAdmGroupImmuneFrom(g_CurGrp, id);
+			} else {
+				LogGroupError("Unable to find group: \"%s\"", value);
+			}
+		}
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadGroups_EndSection(Handle:smc)
+{
+	if (g_GroupState == GROUP_STATE_OVERRIDES)
+	{
+		g_GroupState = GROUP_STATE_INGROUP;
+	} else if (g_GroupState == GROUP_STATE_INGROUP) {
+		g_GroupState = GROUP_STATE_GROUPS;
+		g_CurGrp = INVALID_GROUP_ID;
+	} else if (g_GroupState == GROUP_STATE_GROUPS) {
+		g_GroupState = GROUP_STATE_NONE;
+	}
+	
+	return SMCParse_Continue;
+}
+
+static InitializeGroupParser()
+{
+	if (g_hGroupParser == INVALID_HANDLE)
+	{
+		g_hGroupParser = SMC_CreateParser();
+		SMC_SetReaders(g_hGroupParser,
+					   ReadGroups_NewSection,
+					   ReadGroups_KeyValue,
+					   ReadGroups_EndSection);
+	}
+}
+
+ReadGroups()
+{
+	new String:path[PLATFORM_MAX_PATH];
+	
+	InitializeGroupParser();
+	
+	BuildPath(Path_SM, path, sizeof(path), "configs/admin_groups.cfg");
+	
+	/* Set states */
+	g_GroupState = GROUP_STATE_NONE;
+	g_LoggedFileName = false;
+	g_ErrorCount = 0;
+	g_CurGrp = INVALID_GROUP_ID;
+	g_GroupPass = GROUP_PASS_FIRST;
+	g_NeedReparse = false;
+		
+	new SMCError:err = SMC_ParseFile(g_hGroupParser, path);
+	if (err != SMCError_Okay)
+	{
+		decl String:buffer[64];
+		if (SMC_GetErrorString(err, buffer, sizeof(buffer)))
+		{
+			LogGroupError("%s", buffer);
+		} else {
+			LogGroupError("Fatal parse error");
+		}
+	}
+}
+

plugins/admin-flatfile/admin-levels.sp

@@ -0,0 +1,173 @@
+#define LEVEL_STATE_NONE		0
+#define LEVEL_STATE_LEVELS		1
+#define LEVEL_STATE_FLAGS		2
+
+static Handle:g_hLevelParser = INVALID_HANDLE;
+static g_LevelState = LEVEL_STATE_NONE;
+
+/* :TODO: log line numbers? */
+
+LoadDefaultLetters()
+{
+	/* Clear letters first */
+	for (new i='a'; i<='z'; i++)
+	{
+		g_FlagLetters[i-'a'] = Admin_None;
+	}
+	
+	g_FlagLetters['a'-'a'] = Admin_Reservation;
+	g_FlagLetters['b'-'a'] = Admin_Kick;
+	g_FlagLetters['c'-'a'] = Admin_Ban;
+	g_FlagLetters['d'-'a'] = Admin_Unban;
+	g_FlagLetters['e'-'a'] = Admin_Slay;
+	g_FlagLetters['f'-'a'] = Admin_Changemap;
+	g_FlagLetters['g'-'a'] = Admin_Convars;
+	g_FlagLetters['h'-'a'] = Admin_Configs;
+	g_FlagLetters['i'-'a'] = Admin_Chat;
+	g_FlagLetters['j'-'a'] = Admin_Vote;
+	g_FlagLetters['h'-'a'] = Admin_Password;
+	g_FlagLetters['i'-'a'] = Admin_RCON;
+	g_FlagLetters['j'-'a'] = Admin_Cheats;
+	g_FlagLetters['z'-'a'] = Admin_Root;
+}
+
+static LogLevelError(const String:format[], {Handle,String,Float,_}:...)
+{
+	decl String:buffer[512];
+	
+	if (!g_LoggedFileName)
+	{
+		LogError("Error(s) detected parsing admin_levels.cfg:");
+		g_LoggedFileName = true;
+	}
+	
+	VFormat(buffer, sizeof(buffer), format, 2);
+	
+	LogError(" (%d) %s", ++g_ErrorCount, buffer);
+}
+
+public SMCResult:ReadLevels_NewSection(Handle:smc, const String:name[], bool:opt_quotes)
+{
+	if (g_LevelState == LEVEL_STATE_NONE)
+	{
+		if (StrEqual(name, "Levels"))
+		{
+			g_LevelState = LEVEL_STATE_LEVELS;
+		}
+	} else if (g_LevelState == LEVEL_STATE_LEVELS) {
+		if (StrEqual(name, "Flags"))
+		{
+			g_LevelState = LEVEL_STATE_FLAGS;
+		}
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadLevels_KeyValue(Handle:smc, const String:key[], const String:value[], bool:key_quotes, bool:value_quotes)
+{
+	if (g_LevelState == LEVEL_STATE_FLAGS)
+	{
+		new chr = value[0];
+		
+		if (chr < 'a' || chr > 'z')
+		{
+			LogLevelError("Unrecognized character: \"%s\"", value);
+			return SMCParse_Continue;
+		}
+		
+		chr -= 'a';
+		
+		new AdminFlag:flag = Admin_None;
+		
+		if (StrEqual(key, "reservation"))
+		{
+			flag = Admin_Reservation;
+		} else if (StrEqual(key, "kick")) {
+			flag = Admin_Kick;
+		} else if (StrEqual(key, "ban")) {
+			flag = Admin_Ban;
+		} else if (StrEqual(key, "unban")) {
+			flag = Admin_Unban;
+		} else if (StrEqual(key, "slay")) {
+			flag = Admin_Slay;
+		} else if (StrEqual(key, "changemap")) {
+			flag = Admin_Changemap;
+		} else if (StrEqual(key, "cvars")) {
+			flag = Admin_Convars;
+		} else if (StrEqual(key, "configs")) {
+			flag = Admin_Configs;
+		} else if (StrEqual(key, "chat")) {
+			flag = Admin_Chat;
+		} else if (StrEqual(key, "vote")) {
+			flag = Admin_Vote;
+		} else if (StrEqual(key, "password")) {
+			flag = Admin_Password;
+		} else if (StrEqual(key, "rcon")) {
+			flag = Admin_RCON;
+		} else if (StrEqual(key, "cheats")) {
+			flag = Admin_Cheats;
+		} else if (StrEqual(key, "root")) {
+			flag = Admin_Root;
+		} else {
+			LogLevelError("Unrecognized flag type: %s", key);
+		}
+		
+		g_FlagLetters[chr] = flag;
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadLevels_EndSection(Handle:smc)
+{
+	if (g_LevelState == LEVEL_STATE_FLAGS)
+	{
+		/* We're totally done parsing */
+		g_LevelState = LEVEL_STATE_LEVELS;
+		return SMCParse_Halt;
+	} else if (g_LevelState == LEVEL_STATE_LEVELS) {
+		g_LevelState = LEVEL_STATE_NONE;
+	}
+	
+	return SMCParse_Continue;
+}
+
+static InitializeLevelParser()
+{
+	if (g_hLevelParser == INVALID_HANDLE)
+	{
+		g_hLevelParser = SMC_CreateParser();
+		SMC_SetReaders(g_hLevelParser, 
+				   	ReadLevels_NewSection,
+				   	ReadLevels_KeyValue,
+				   	ReadLevels_EndSection);
+	}
+}
+
+RefreshLevels()
+{
+	new String:path[PLATFORM_MAX_PATH];
+	
+	LoadDefaultLetters();
+	InitializeLevelParser();
+	
+	BuildPath(Path_SM, path, sizeof(path), "configs/admin_levels.cfg");
+	
+	/* Set states */
+	g_LevelState = LEVEL_STATE_NONE;
+	g_LoggedFileName = false;
+	g_ErrorCount = 0;
+		
+	new SMCError:err = SMC_ParseFile(g_hLevelParser, path);
+	if (err != SMCError_Okay)
+	{
+		decl String:buffer[64];
+		if (SMC_GetErrorString(err, buffer, sizeof(buffer)))
+		{
+			LogLevelError("%s", buffer);
+		} else {
+			LogLevelError("Fatal parse error");
+		}
+	}
+}

plugins/admin-flatfile/admin-overrides.sp

@@ -0,0 +1,127 @@
+#define OVERRIDE_STATE_NONE			0
+#define OVERRIDE_STATE_LEVELS		1
+#define OVERRIDE_STATE_OVERRIDES	2
+
+static Handle:g_hOverrideParser = INVALID_HANDLE;
+static g_OverrideState = OVERRIDE_STATE_NONE;
+
+static LogOverrideError(const String:format[], {Handle,String,Float,_}:...)
+{
+	decl String:buffer[512];
+	
+	if (!g_LoggedFileName)
+	{
+		LogError("Error(s) detected parsing admin_levels.cfg:");
+		g_LoggedFileName = true;
+	}
+	
+	VFormat(buffer, sizeof(buffer), format, 2);
+	
+	LogError(" (%d) %s", ++g_ErrorCount, buffer);
+}
+
+
+public SMCResult:ReadOverrides_NewSection(Handle:smc, const String:name[], bool:opt_quotes)
+{
+	if (g_OverrideState == OVERRIDE_STATE_NONE)
+	{
+		if (StrEqual(name, "Levels"))
+		{
+			g_OverrideState = OVERRIDE_STATE_LEVELS;
+		}
+	} else if (g_OverrideState == OVERRIDE_STATE_LEVELS) {
+		if (StrEqual(name, "Overrides"))
+		{
+			g_OverrideState = OVERRIDE_STATE_OVERRIDES;
+		}
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadOverrides_KeyValue(Handle:smc, 
+										const String:key[], 
+										const String:value[], 
+										bool:key_quotes, 
+										bool:value_quotes)
+{
+	if (g_OverrideState != OVERRIDE_STATE_OVERRIDES)
+	{
+		return SMCParse_Continue;
+	}
+	
+	new AdminFlag:flag = Admin_None;
+	
+	if (strlen(value) > 1)
+	{
+		LogOverrideError("Unrecognized access level: %s", value);
+		return SMCParse_Continue;
+	}
+	
+	if (value[0] >= 'a' && value[0] <= 'z')
+	{
+		flag = g_FlagLetters[value[0] - 'a'];
+	}
+	
+	if (key[0] == '@')
+	{
+		AddCommandOverride(key[1], Override_CommandGroup, flag);
+	} else {
+		AddCommandOverride(key, Override_Command, flag);
+	}
+	
+	return SMCParse_Continue;
+}
+
+public SMCResult:ReadOverrides_EndSection(Handle:smc)
+{
+	if (g_OverrideState == OVERRIDE_STATE_LEVELS)
+	{
+		g_OverrideState = OVERRIDE_STATE_NONE;
+	} else if (g_OverrideState == OVERRIDE_STATE_OVERRIDES) {
+		/* We're totally done parsing */
+		g_OverrideState = OVERRIDE_STATE_LEVELS;
+		return SMCParse_Halt;
+	}
+	
+	return SMCParse_Continue;
+}
+
+static InitializeOverrideParser()
+{
+	if (g_hOverrideParser == INVALID_HANDLE)
+	{
+		g_hOverrideParser = SMC_CreateParser();
+		SMC_SetReaders(g_hOverrideParser,
+					   ReadOverrides_NewSection,
+					   ReadOverrides_KeyValue,
+					   ReadOverrides_EndSection);
+	}
+}
+
+ReadOverrides()
+{
+	new String:path[PLATFORM_MAX_PATH];
+	
+	InitializeOverrideParser();
+	
+	BuildPath(Path_SM, path, sizeof(path), "configs/admin_levels.cfg");
+	
+	/* Set states */
+	g_OverrideState = OVERRIDE_STATE_NONE;
+	g_LoggedFileName = false;
+	g_ErrorCount = 0;
+		
+	new SMCError:err = SMC_ParseFile(g_hOverrideParser, path);
+	if (err != SMCError_Okay)
+	{
+		decl String:buffer[64];
+		if (SMC_GetErrorString(err, buffer, sizeof(buffer)))
+		{
+			LogOverrideError("%s", buffer);
+		} else {
+			LogOverrideError("Fatal parse error");
+		}
+	}
+}
+