sourcemod/plugins/admin-sql-prefetch.sp

/**
 * 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 Admins (Prefetch)",
	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;
	
	if (SQL_CheckConfig("admins"))
	{
		db = SQL_Connect("admins", true, error, sizeof(error));
	} else {
		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);
				}
			}
		}
		
		if (immunity_list != INVALID_HANDLE)
		{
			CloseHandle(immunity_list);
		}
	}
	
	CloseHandle(groups);
}

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;
}