From 6943dece8789c56462d9647f5c1c19a597a4a0d0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@alliedmods.net>
Date: Mon, 13 Aug 2007 01:46:58 +0000
Subject: [PATCH] initial import of sql admins prefetch plugin and associated
 table schemas

--HG--
extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401322
---
 configs/sql-init-scripts/admins-mysql.sql  |  41 ++
 configs/sql-init-scripts/admins-sqlite.sq3 | Bin 0 -> 13312 bytes
 configs/sql-init-scripts/admins-sqlite.sql |  41 ++
 plugins/admin-sql-prefetch.sp              | 436 +++++++++++++++++++++
 4 files changed, 518 insertions(+)
 create mode 100644 configs/sql-init-scripts/admins-mysql.sql
 create mode 100644 configs/sql-init-scripts/admins-sqlite.sq3
 create mode 100644 configs/sql-init-scripts/admins-sqlite.sql
 create mode 100644 plugins/admin-sql-prefetch.sp

diff --git a/configs/sql-init-scripts/admins-mysql.sql b/configs/sql-init-scripts/admins-mysql.sql
new file mode 100644
index 00000000..46c4fadf
--- /dev/null
+++ b/configs/sql-init-scripts/admins-mysql.sql
@@ -0,0 +1,41 @@
+
+CREATE TABLE sm_admins (
+  id int(10) unsigned NOT NULL auto_increment,
+  authtype enum('steam','name','ip') NOT NULL,
+  identity varchar(65) NOT NULL,
+  password varchar(65),
+  flags varchar(30) NOT NULL,
+  name varchar(65) NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_groups (
+  id int(10) unsigned NOT NULL auto_increment,
+  immunity enum('none','all','default') NOT NULL,
+  flags varchar(30) NOT NULL,
+  name varchar(120) NOT NULL,
+  groups_immune varchar(255) NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_group_overrides (
+  group_id int(10) unsigned NOT NULL,
+  type enum('command','group') NOT NULL,
+  name varchar(32) NOT NULL,
+  access enum('allow','deny') NOT NULL,
+  PRIMARY KEY (group_id, type, name)
+);
+
+CREATE TABLE sm_overrides (
+  type enum('command','group') NOT NULL,
+  name varchar(32) NOT NULL,
+  flags varchar(30) NOT NULL,
+  PRIMARY KEY (type,name)
+);
+
+CREATE TABLE sm_admins_groups (
+  admin_id int(10) unsigned NOT NULL,
+  group_id int(10) unsigned NOT NULL,
+  inherit_order int(10) NOT NULL,
+  PRIMARY KEY (admin_id, group_id)
+);
diff --git a/configs/sql-init-scripts/admins-sqlite.sq3 b/configs/sql-init-scripts/admins-sqlite.sq3
new file mode 100644
index 0000000000000000000000000000000000000000..f10a22fe788dd2409a5c09c875eeda60b0e2fa35
GIT binary patch
literal 13312
zcmeI2F>l&H6vuto*nu`uH%}F}Ab|=}4NW?xG-9Yi(w0zFnJgDOU<upQHfb`Fe1(3H
zF8KzLI#eAybneIKQu~ZA_Jt79!FYH`h`Z;z`@i>l_wHng<M%z&H}I+BTAGjBoWLQ(
zy~3E|xMJ{4e!@OV7?SOT`EHX;<o|{b9z{QQ$AAS00D-Itl!fh3Qpj2t^nd^m$OD0L
z=mgY%9#R250D;U2!2O>&au5Upxgh}ee{NC%jsSto3BdiIIdTvL0=Xdo_kV6u0geEH
z%n88#pE+_61OmAs0QY}xQUQ(tfy@bn_rHLyIdon4R`|pJ%-jJGT%W-F97%Geg0A*_
z?bF2YELGDj)Aneiu;1@?23<VpyzX@|HRD<tV^hbb?bnp&b$s-8fR8@(dX2!W&HS-{
zF*Wd+<_^c2TT^z^15Dkpebc|719o@P1E!kieQ{hpIUrp5bfS$sYHTyQwr1UGvP-_}
zzd7vmPw+wa1lLTxUal(zQSMd{XWF`P?tPvFe_m4q*B#PVX{4$`oBVvlN3@>Cv_`Ho
zn})QahQQK_%&TabmNm1JFj!h^1g*3fB$2#IG;Z0nb{O7E;0O=ES*#qwiJHZ2^otX@
z8xH+0{NSJP-?<y~b^Q&w*%|Z0k|Z~q=<+a5a8wS980k(}^dGb7PK_p6Cl>XdN+IO#
zduZBY!!><1r~|`YT4<@X#X=1nuNv&}y|O4DHy_^PiEO4qAZPmADN3@UpsP|0B~ozC
z4A%{6nQniTT0|BMGlQUs{ahN`$^#@->Frkf@X&_Cz$JQ0u;rA37Q4{Ep<V-r3kTTt
zMN$5!tiZ;EL(T}sCe2?+l3cB#%V#k*iYM4dw7tcmqE85<|L3s!+(=;{!7pNexh2X6
k)fKT*|47udSAzHd&7NJL4g@wy0N(#MNguR<z-9^j17Y>jyZ`_I

literal 0
HcmV?d00001

diff --git a/configs/sql-init-scripts/admins-sqlite.sql b/configs/sql-init-scripts/admins-sqlite.sql
new file mode 100644
index 00000000..f9f75f9c
--- /dev/null
+++ b/configs/sql-init-scripts/admins-sqlite.sql
@@ -0,0 +1,41 @@
+
+CREATE TABLE sm_admins (
+  id int(10) NOT NULL,
+  authtype varchar(16) NOT NULL,
+  identity varchar(65) NOT NULL,
+  password varchar(65),
+  flags varchar(30) NOT NULL,
+  name varchar(65) NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_groups (
+  id int(10) NOT NULL,
+  immunity varchar(16) NOT NULL,
+  flags varchar(30) NOT NULL,
+  name varchar(120) NOT NULL,
+  groups_immune varchar(255) NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_group_overrides (
+  group_id int(10) NOT NULL,
+  type varchar(16) NOT NULL,
+  name varchar(32) NOT NULL,
+  access varchar(16) NOT NULL,
+  PRIMARY KEY (group_id, type, name)
+);
+
+CREATE TABLE sm_overrides (
+  type varchar(16) NOT NULL,
+  name varchar(32) NOT NULL,
+  flags varchar(30) NOT NULL,
+  PRIMARY KEY (type,name)
+);
+
+CREATE TABLE sm_admins_groups (
+  admin_id int(10) NOT NULL,
+  group_id int(10) NOT NULL,
+  inherit_order int(10) NOT NULL,
+  PRIMARY KEY (admin_id, group_id)
+);
diff --git a/plugins/admin-sql-prefetch.sp b/plugins/admin-sql-prefetch.sp
new file mode 100644
index 00000000..179390d6
--- /dev/null
+++ b/plugins/admin-sql-prefetch.sp
@@ -0,0 +1,436 @@
+/**
+ * admin-sql-prefetch.sp
+ * Prefetches admins from an SQL database without threading.
+ * This file is part of SourceMod, Copyright (C) 2004-2007 AlliedModders LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Version: $Id$
+ */
+
+/* We like semicolons */
+#pragma semicolon 1
+
+#include <sourcemod>
+
+public Plugin:myinfo = 
+{
+	name = "SQL Admin Prefetcher",
+	author = "AlliedModders LLC",
+	description = "Reads all admins from SQL",
+	version = SOURCEMOD_VERSION,
+	url = "http://www.sourcemod.net/"
+};
+
+public OnRebuildAdminCache(AdminCachePart:part)
+{
+	/* First try to get a database connection */
+	decl String:error[255];
+	new Handle:db = SQL_Connect("default", true, error, sizeof(error));
+	if (db == INVALID_HANDLE)
+	{
+		LogError("Could not connect to database \"default\": %s", error);
+		return;
+	}
+	
+	if (part == AdminCache_Overrides)
+	{
+		FetchOverrides(db);
+	} else if (part == AdminCache_Groups) {
+		FetchGroups(db);
+	} else if (part == AdminCache_Admins) {
+		FetchUsers(db);
+	}
+	
+	CloseHandle(db);
+}
+
+FetchUserGroups(Handle:hQuery, AdminId:adm, id)
+{
+	SQL_BindParamInt(hQuery, 0, id);
+	if (!SQL_Execute(hQuery))
+	{
+		decl String:error[255];
+		SQL_GetError(hQuery, error, sizeof(error));
+		LogError("FetchUserGroups() statement execute failed: %s", error);
+		return;
+	}
+	
+	decl String:name[80];
+	new GroupId:gid;
+	while (SQL_FetchRow(hQuery))
+	{
+		SQL_FetchString(hQuery, 0, name, sizeof(name));
+		
+		if ((gid = FindAdmGroup(name)) == INVALID_GROUP_ID)
+		{
+			/* Group wasn't found, don't bother with it.  */
+			continue;
+		}
+		
+		#if defined _DEBUG
+		PrintToServer("Found admin group (%d, %d, %d)", id, gid, adm);
+		#endif
+		
+		AdminInheritGroup(adm, gid);
+	}
+}
+
+FetchUsers(Handle:db)
+{
+	decl String:query[255], String:error[255];
+	new Handle:hQuery, Handle:hGroupQuery;
+	
+	Format(query, sizeof(query), "SELECT id, authtype, identity, passwd, flags, name FROM sm_admins");
+	if ((hQuery = SQL_Query(db, query)) == INVALID_HANDLE)
+	{
+		SQL_GetError(db, error, sizeof(error));
+		LogError("FetchUsers() query failed: %s", query);
+		LogError("Query error: %s", error);
+		return;
+	}
+	
+	/* If this fails it's non-fatal */
+	Format(query,
+		sizeof(query), 
+		"SELECT g.name FROM sm_admins_groups ag JOIN sm_groups g ON ag.group_id = g.id WHERE ag.admin_id = ? ORDER BY inherit_order ASC");
+	if ((hGroupQuery = SQL_PrepareQuery(db, query, error, sizeof(error))) == INVALID_HANDLE)
+	{
+		LogError("FetchUsers() group query preparation failed: %s", query);
+		LogError("Query error: %s", error);
+	}
+	
+	decl String:authtype[16];
+	decl String:identity[80];
+	decl String:password[80];
+	decl String:flags[32];
+	decl String:name[80];
+	new AdminId:adm, id;
+	
+	while (SQL_FetchRow(hQuery))
+	{
+		id = SQL_FetchInt(hQuery, 0);
+		SQL_FetchString(hQuery, 1, authtype, sizeof(authtype));
+		SQL_FetchString(hQuery, 2, identity, sizeof(identity));
+		SQL_FetchString(hQuery, 3, password, sizeof(password));
+		SQL_FetchString(hQuery, 4, flags, sizeof(flags));
+		SQL_FetchString(hQuery, 5, name, sizeof(name));
+		
+		/* Use a pre-existing admin if we can */
+		if ((adm = FindAdminByIdentity(authtype, identity)) == INVALID_ADMIN_ID)
+		{
+			adm = CreateAdmin(name);
+			if (!BindAdminIdentity(adm, authtype, identity))
+			{
+				LogError("Could not bind prefetched SQL admin (authtype \"%s\") (identity \"%s\")", authtype, identity);
+				continue;
+			}
+		}
+		
+		#if defined _DEBUG
+		PrintToServer("Found SQL admin (%d,%s,%s,%s,%s,%s):%d", id, authtype, identity, password, flags, name, adm);
+		#endif
+		
+		/* See if this admin wants a password */
+		if (password[0] != '\0')
+		{
+			SetAdminPassword(adm, password);
+		}
+		
+		/* Apply each flag */
+		new len = strlen(flags);
+		new AdminFlag:flag;
+		for (new i=0; i<len; i++)
+		{
+			if (!FindFlagByChar(flags[i], flag))
+			{
+				continue;
+			}
+			SetAdminFlag(adm, flag, true);
+		}
+		
+		/* Look up groups */
+		if (hGroupQuery != INVALID_HANDLE)
+		{
+			FetchUserGroups(hGroupQuery, adm, id);
+		}
+	}
+	
+	CloseHandle(hGroupQuery);
+	CloseHandle(hQuery);
+}
+
+FetchGroups(Handle:db)
+{
+	decl String:query[255];
+	new Handle:hQuery;
+	
+	Format(query, sizeof(query), "SELECT id, immunity, flags, name, groups_immune FROM sm_groups");
+
+	if ((hQuery = SQL_Query(db, query)) == INVALID_HANDLE)
+	{
+		decl String:error[255];
+		SQL_GetError(db, error, sizeof(error));
+		LogError("FetchGroups() query failed: %s", query);
+		LogError("Query error: %s", error);
+		return;
+	}
+	
+	/* We cache basic group info so we can do reverse lookups */
+	new Handle:groups = CreateArray(3);
+	
+	/* Now start fetching groups */
+	decl String:immunity[16];
+	decl String:flags[32];
+	decl String:name[128];
+	decl String:grp_immunity[256];
+	while (SQL_FetchRow(hQuery))
+	{
+		new id = SQL_FetchInt(hQuery, 0);
+		SQL_FetchString(hQuery, 1, immunity, sizeof(immunity));
+		SQL_FetchString(hQuery, 2, flags, sizeof(flags));
+		SQL_FetchString(hQuery, 3, name, sizeof(name));
+		SQL_FetchString(hQuery, 4, grp_immunity, sizeof(grp_immunity));
+		
+#if defined _DEBUG
+		PrintToServer("Adding group (%d, %s, %s, %s, %s)", id, immunity, flags, name, grp_immunity);
+#endif
+		
+		/* Find or create the group */
+		new GroupId:gid;
+		if ((gid = FindAdmGroup(name)) == INVALID_GROUP_ID)
+		{
+			gid = CreateAdmGroup(name);
+		}
+		
+		/* Add flags from the database to the group */
+		new num_flag_chars = strlen(flags);
+		for (new i=0; i<num_flag_chars; i++)
+		{
+			decl AdminFlag:flag;
+			if (!FindFlagByChar(flags[i], flag))
+			{
+				continue;
+			}
+			SetAdmGroupAddFlag(gid, flag, true);
+		}
+		
+		/* Set the immunity level this group has */
+		if (StrEqual(immunity, "all"))
+		{
+			SetAdmGroupImmunity(gid, Immunity_Default, true);
+			SetAdmGroupImmunity(gid, Immunity_Global, true);
+		} else if (StrEqual(immunity, "default")) {
+			SetAdmGroupImmunity(gid, Immunity_Default, true);
+		} else if (StrEqual(immunity, "global")) {
+			SetAdmGroupImmunity(gid, Immunity_Global, true);
+		}
+		
+		new Handle:immunity_list = UTIL_ExplodeNumberString(grp_immunity);
+		
+		/* Now, save all this for later */
+		decl data[3];
+		data[0] = id;
+		data[1] = _:gid;
+		data[2] = _:immunity_list;
+		
+		PushArrayArray(groups, data);
+	}
+	
+	CloseHandle(hQuery);
+	
+	/* Second pass - resolve immunity and group overrides */
+	new num_groups = GetArraySize(groups);
+	for (new i=0; i<num_groups; i++)
+	{
+		decl data[3];
+		GetArrayArray(groups, i, data);
+		
+		new id = data[0];
+		new GroupId:gid = GroupId:data[1];
+		new Handle:immunity_list = Handle:data[2];
+		
+		/* Query to get per-group override list */
+		Format(query, 
+			sizeof(query),
+			"SELECT type, name, access FROM sm_group_overrides WHERE group_id = %d",
+			id);
+		
+		/* Fetch the override query results */
+		if ((hQuery = SQL_Query(db, query)) == INVALID_HANDLE)
+		{
+			decl String:error[255];
+			SQL_GetError(db, error, sizeof(error));
+			LogError("FetchOverrides() query failed: %s", query);
+			LogError("Query error: %s", error);
+		} else {
+			decl String:type[16];
+			decl String:cmd[64];
+			decl String:access[16];
+			while (SQL_FetchRow(hQuery))
+			{
+				SQL_FetchString(hQuery, 0, type, sizeof(type));
+				SQL_FetchString(hQuery, 1, cmd, sizeof(cmd));
+				SQL_FetchString(hQuery, 2, access, sizeof(access));
+				
+				new OverrideType:o_type = Override_Command;
+				if (StrEqual(type, "group"))
+				{
+					o_type = Override_CommandGroup;
+				}
+				
+				new OverrideRule:o_rule = Command_Deny;
+				if (StrEqual(access, "allow"))
+				{
+					o_rule = Command_Allow;
+				}
+				
+				#if defined _DEBUG
+				PrintToServer("AddAdmGroupCmdOverride(%d, %s, %d, %d)", gid, cmd, o_type, o_rule);
+				#endif
+				
+				AddAdmGroupCmdOverride(gid, cmd, o_type, o_rule);
+			}
+			CloseHandle(hQuery);
+		}
+		
+		/* Lastly, resolve the immunity list if any */
+		new immunity_count;
+		if (immunity_list != INVALID_HANDLE 
+			&& ((immunity_count = GetArraySize(immunity_list)) > 0))
+		{
+			for (new j=0; j<immunity_count; j++)
+			{
+				new other_id = GetArrayCell(immunity_list, j);
+				
+				if (other_id == id)
+				{
+					continue;
+				}
+				
+				/* See if we can find this other ID */
+				new GroupId:other_gid;
+				if ((other_gid = UTIL_FindGroupInCache(groups, other_id)) != INVALID_GROUP_ID)
+				{
+					#if defined _DEBUG
+					PrintToServer("SetAdmGroupImmuneFrom(%d, %d)", gid, other_gid);
+					#endif
+					SetAdmGroupImmuneFrom(gid, other_gid);
+				}
+			}
+		}
+	}
+}
+
+FetchOverrides(Handle:db)
+{
+	decl String:query[255];
+	new Handle:hQuery;
+	
+	Format(query, sizeof(query), "SELECT type, name, flags FROM sm_overrides");
+
+	if ((hQuery = SQL_Query(db, query)) == INVALID_HANDLE)
+	{
+		decl String:error[255];
+		SQL_GetError(db, error, sizeof(error));
+		LogError("FetchOverrides() query failed: %s", query);
+		LogError("Query error: %s", error);
+		return;
+	}
+	
+	decl String:type[64];
+	decl String:name[64];
+	decl String:flags[32];
+	new flag_bits;
+	while (SQL_FetchRow(hQuery))
+	{
+		SQL_FetchString(hQuery, 0, type, sizeof(type));
+		SQL_FetchString(hQuery, 1, name, sizeof(name));
+		SQL_FetchString(hQuery, 2, flags, sizeof(flags));
+		
+#if defined _DEBUG
+		PrintToServer("Adding override (%s, %s, %s)", type, name, flags);
+#endif
+		
+		flag_bits = ReadFlagString(flags);
+		if (StrEqual(type, "command"))
+		{
+			AddCommandOverride(name, Override_Command, flag_bits);
+		} else if (StrEqual(type, "group")) {
+			AddCommandOverride(name, Override_CommandGroup, flag_bits);
+		}
+	}
+	
+	CloseHandle(hQuery);
+}
+
+stock GroupId:UTIL_FindGroupInCache(Handle:group_list, id)
+{
+	new size = GetArraySize(group_list);
+	
+	for (new i=0; i<size; i++)
+	{
+		decl data[3];
+		GetArrayArray(group_list, i, data);
+		
+		if (data[0] == id)
+		{
+			return GroupId:data[1];
+		}
+	}
+	
+	return INVALID_GROUP_ID;
+}
+
+/**
+ * Breaks a comma-delimited string into a list of numbers, returning a new 
+ * dynamic array.
+ *
+ * @param text				The string to split.
+ * @return					A new array Handle which must be closed, or 
+ *							INVALID_HANDLE on no strings found.
+ */
+stock Handle:UTIL_ExplodeNumberString(const String:text[])
+{
+	new Handle:array = INVALID_HANDLE;
+	decl String:buffer[32];
+	new reloc_idx, idx;
+	
+	while ((idx = SplitString(text[reloc_idx], ",", buffer, sizeof(buffer))) != -1)
+	{
+		reloc_idx += idx;
+		if (text[reloc_idx] == '\0')
+		{
+			break;
+		}
+		if (array == INVALID_HANDLE)
+		{
+			array = CreateArray();
+		}
+		PushArrayCell(array, StringToInt(buffer));
+	}
+	
+	if (text[reloc_idx] != '\0')
+	{
+		if (array == INVALID_HANDLE)
+		{
+			array = CreateArray();
+		}
+		PushArrayCell(array, StringToInt(text[reloc_idx]));
+	}
+	
+	return array;
+}
+