PZ9uaetD

1 public PlVers:__version =
2{
3	version = 5,
4	filevers = "1.9.0.6241",
5	date = "04/09/2019",
6	time = "19:27:31"
7};
8new Float:NULL_VECTOR[3];
9new String:NULL_STRING[4];
10public Extension:__ext_core =
11{
12	name = "Core",
13	file = "core",
14	autoload = 0,
15	required = 0,
16};
17new MaxClients;
18public SharedPlugin:__pl_sourcebanspp =
19{
20	name = "sourcebans++",
21	file = "sbpp_main.smx",
22	required = 1,
23};
24public Extension:__ext_topmenus =
25{
26	name = "TopMenus",
27	file = "topmenus.ext",
28	autoload = 1,
29	required = 0,
30};
31public SharedPlugin:__pl_adminmenu =
32{
33	name = "adminmenu",
34	file = "adminmenu.smx",
35	required = 0,
36};
37public SharedPlugin:__pl_updater =
38{
39	name = "updater",
40	file = "updater.smx",
41	required = 0,
42};
43new State:ConfigState;
44new AdminCachePart:loadPart;
45new AdminFlag:g_FlagLetters[26];
46new ConVar:CvarHostIp;
47new ConVar:CvarPort;
48new Database:DB;
49new Database:SQLiteDB;
50new String:ServerIp[24];
51new String:ServerPort[8];
52new String:DatabasePrefix[12] = "sb";
53new String:WebsiteAddress[128];
54new String:groupsLoc[128];
55new String:adminsLoc[128];
56new String:overridesLoc[128];
57new String:logFile[256];
58new Float:RetryTime = 1097859072;
59new bool:loadAdmins;
60new bool:loadGroups;
61new bool:loadOverrides;
62new bool:LateLoaded;
63new bool:AutoAdd;
64new bool:g_bConnecting;
65new bool:requireSiteLogin;
66new bool:backupConfig = 1;
67new bool:enableAdmins = 1;
68new bool:PlayerStatus[66];
69new g_BanTarget[66] =
70{
71	-1, ...
72};
73new g_BanTime[66] =
74{
75	-1, ...
76};
77new curLoading;
78new serverID = -1;
79new ProcessQueueTime = 5;
80new g_ownReasons[66];
81new CommandDisable;
82new SMCParser:ConfigParser;
83new Handle:g_hFwd_OnBanAdded;
84new Handle:g_hFwd_OnReportAdded;
85new Handle:PlayerRecheck[66];
86new DataPack:PlayerDataPack[66];
87new TopMenu:hTopMenu;
88new Menu:TimeMenuHandle;
89new Menu:ReasonMenuHandle;
90new Menu:HackingMenuHandle;
91public Plugin:myinfo =
92{
93	name = "SourceBans++: Main Plugin",
94	description = "Advanced ban management for the Source engine",
95	author = "SourceBans Development Team, SourceBans++ Dev Team",
96	version = "1.7.0",
97	url = "https://sbpp.github.io"
98};
99public void:__ext_core_SetNTVOptional()
100{
101	MarkNativeAsOptional("GetFeatureStatus");
102	MarkNativeAsOptional("RequireFeature");
103	MarkNativeAsOptional("AddCommandListener");
104	MarkNativeAsOptional("RemoveCommandListener");
105	MarkNativeAsOptional("BfWriteBool");
106	MarkNativeAsOptional("BfWriteByte");
107	MarkNativeAsOptional("BfWriteChar");
108	MarkNativeAsOptional("BfWriteShort");
109	MarkNativeAsOptional("BfWriteWord");
110	MarkNativeAsOptional("BfWriteNum");
111	MarkNativeAsOptional("BfWriteFloat");
112	MarkNativeAsOptional("BfWriteString");
113	MarkNativeAsOptional("BfWriteEntity");
114	MarkNativeAsOptional("BfWriteAngle");
115	MarkNativeAsOptional("BfWriteCoord");
116	MarkNativeAsOptional("BfWriteVecCoord");
117	MarkNativeAsOptional("BfWriteVecNormal");
118	MarkNativeAsOptional("BfWriteAngles");
119	MarkNativeAsOptional("BfReadBool");
120	MarkNativeAsOptional("BfReadByte");
121	MarkNativeAsOptional("BfReadChar");
122	MarkNativeAsOptional("BfReadShort");
123	MarkNativeAsOptional("BfReadWord");
124	MarkNativeAsOptional("BfReadNum");
125	MarkNativeAsOptional("BfReadFloat");
126	MarkNativeAsOptional("BfReadString");
127	MarkNativeAsOptional("BfReadEntity");
128	MarkNativeAsOptional("BfReadAngle");
129	MarkNativeAsOptional("BfReadCoord");
130	MarkNativeAsOptional("BfReadVecCoord");
131	MarkNativeAsOptional("BfReadVecNormal");
132	MarkNativeAsOptional("BfReadAngles");
133	MarkNativeAsOptional("BfGetNumBytesLeft");
134	MarkNativeAsOptional("BfWrite.WriteBool");
135	MarkNativeAsOptional("BfWrite.WriteByte");
136	MarkNativeAsOptional("BfWrite.WriteChar");
137	MarkNativeAsOptional("BfWrite.WriteShort");
138	MarkNativeAsOptional("BfWrite.WriteWord");
139	MarkNativeAsOptional("BfWrite.WriteNum");
140	MarkNativeAsOptional("BfWrite.WriteFloat");
141	MarkNativeAsOptional("BfWrite.WriteString");
142	MarkNativeAsOptional("BfWrite.WriteEntity");
143	MarkNativeAsOptional("BfWrite.WriteAngle");
144	MarkNativeAsOptional("BfWrite.WriteCoord");
145	MarkNativeAsOptional("BfWrite.WriteVecCoord");
146	MarkNativeAsOptional("BfWrite.WriteVecNormal");
147	MarkNativeAsOptional("BfWrite.WriteAngles");
148	MarkNativeAsOptional("BfRead.ReadBool");
149	MarkNativeAsOptional("BfRead.ReadByte");
150	MarkNativeAsOptional("BfRead.ReadChar");
151	MarkNativeAsOptional("BfRead.ReadShort");
152	MarkNativeAsOptional("BfRead.ReadWord");
153	MarkNativeAsOptional("BfRead.ReadNum");
154	MarkNativeAsOptional("BfRead.ReadFloat");
155	MarkNativeAsOptional("BfRead.ReadString");
156	MarkNativeAsOptional("BfRead.ReadEntity");
157	MarkNativeAsOptional("BfRead.ReadAngle");
158	MarkNativeAsOptional("BfRead.ReadCoord");
159	MarkNativeAsOptional("BfRead.ReadVecCoord");
160	MarkNativeAsOptional("BfRead.ReadVecNormal");
161	MarkNativeAsOptional("BfRead.ReadAngles");
162	MarkNativeAsOptional("BfRead.GetNumBytesLeft");
163	MarkNativeAsOptional("PbReadInt");
164	MarkNativeAsOptional("PbReadFloat");
165	MarkNativeAsOptional("PbReadBool");
166	MarkNativeAsOptional("PbReadString");
167	MarkNativeAsOptional("PbReadColor");
168	MarkNativeAsOptional("PbReadAngle");
169	MarkNativeAsOptional("PbReadVector");
170	MarkNativeAsOptional("PbReadVector2D");
171	MarkNativeAsOptional("PbGetRepeatedFieldCount");
172	MarkNativeAsOptional("PbSetInt");
173	MarkNativeAsOptional("PbSetFloat");
174	MarkNativeAsOptional("PbSetBool");
175	MarkNativeAsOptional("PbSetString");
176	MarkNativeAsOptional("PbSetColor");
177	MarkNativeAsOptional("PbSetAngle");
178	MarkNativeAsOptional("PbSetVector");
179	MarkNativeAsOptional("PbSetVector2D");
180	MarkNativeAsOptional("PbAddInt");
181	MarkNativeAsOptional("PbAddFloat");
182	MarkNativeAsOptional("PbAddBool");
183	MarkNativeAsOptional("PbAddString");
184	MarkNativeAsOptional("PbAddColor");
185	MarkNativeAsOptional("PbAddAngle");
186	MarkNativeAsOptional("PbAddVector");
187	MarkNativeAsOptional("PbAddVector2D");
188	MarkNativeAsOptional("PbRemoveRepeatedFieldValue");
189	MarkNativeAsOptional("PbReadMessage");
190	MarkNativeAsOptional("PbReadRepeatedMessage");
191	MarkNativeAsOptional("PbAddMessage");
192	MarkNativeAsOptional("Protobuf.ReadInt");
193	MarkNativeAsOptional("Protobuf.ReadFloat");
194	MarkNativeAsOptional("Protobuf.ReadBool");
195	MarkNativeAsOptional("Protobuf.ReadString");
196	MarkNativeAsOptional("Protobuf.ReadColor");
197	MarkNativeAsOptional("Protobuf.ReadAngle");
198	MarkNativeAsOptional("Protobuf.ReadVector");
199	MarkNativeAsOptional("Protobuf.ReadVector2D");
200	MarkNativeAsOptional("Protobuf.GetRepeatedFieldCount");
201	MarkNativeAsOptional("Protobuf.SetInt");
202	MarkNativeAsOptional("Protobuf.SetFloat");
203	MarkNativeAsOptional("Protobuf.SetBool");
204	MarkNativeAsOptional("Protobuf.SetString");
205	MarkNativeAsOptional("Protobuf.SetColor");
206	MarkNativeAsOptional("Protobuf.SetAngle");
207	MarkNativeAsOptional("Protobuf.SetVector");
208	MarkNativeAsOptional("Protobuf.SetVector2D");
209	MarkNativeAsOptional("Protobuf.AddInt");
210	MarkNativeAsOptional("Protobuf.AddFloat");
211	MarkNativeAsOptional("Protobuf.AddBool");
212	MarkNativeAsOptional("Protobuf.AddString");
213	MarkNativeAsOptional("Protobuf.AddColor");
214	MarkNativeAsOptional("Protobuf.AddAngle");
215	MarkNativeAsOptional("Protobuf.AddVector");
216	MarkNativeAsOptional("Protobuf.AddVector2D");
217	MarkNativeAsOptional("Protobuf.RemoveRepeatedFieldValue");
218	MarkNativeAsOptional("Protobuf.ReadMessage");
219	MarkNativeAsOptional("Protobuf.ReadRepeatedMessage");
220	MarkNativeAsOptional("Protobuf.AddMessage");
221	VerifyCoreVersion();
222	return void:0;
223}
224
225bool:StrEqual(String:str1[], String:str2[], bool:caseSensitive)
226{
227	return strcmp(str1, str2, caseSensitive) == 0;
228}
229
230Database:SQLite_UseDatabase(String:database[], String:error[], maxlength)
231{
232	new KeyValues:kv = KeyValues.KeyValues("", "", "");
233	KeyValues.SetString(kv, "driver", "sqlite");
234	KeyValues.SetString(kv, "database", database);
235	new Database:db = SQL_ConnectCustom(kv, error, maxlength, false);
236	CloseHandle(kv);
237	kv = MissingTAG:0;
238	return db;
239}
240
241void:ReplyToTargetError(client, reason)
242{
243	switch (reason)
244	{
245		case -7:
246		{
247			ReplyToCommand(client, "[SM] %t", "More than one client matched");
248		}
249		case -6:
250		{
251			ReplyToCommand(client, "[SM] %t", "Cannot target bot");
252		}
253		case -5:
254		{
255			ReplyToCommand(client, "[SM] %t", "No matching clients");
256		}
257		case -4:
258		{
259			ReplyToCommand(client, "[SM] %t", "Unable to target");
260		}
261		case -3:
262		{
263			ReplyToCommand(client, "[SM] %t", "Target is not in game");
264		}
265		case -2:
266		{
267			ReplyToCommand(client, "[SM] %t", "Target must be dead");
268		}
269		case -1:
270		{
271			ReplyToCommand(client, "[SM] %t", "Target must be alive");
272		}
273		case 0:
274		{
275			ReplyToCommand(client, "[SM] %t", "No matching client");
276		}
277		default:
278		{
279		}
280	}
281	return void:0;
282}
283
284FindTarget(client, String:target[], bool:nobots, bool:immunity)
285{
286	new String:target_name[64];
287	new target_list[1];
288	new target_count;
289	new bool:tn_is_ml;
290	new flags = 16;
291	if (nobots)
292	{
293		flags |= 32;
294	}
295	if (!immunity)
296	{
297		flags |= 8;
298	}
299	if (0 < (target_count = ProcessTargetString(target, client, target_list, 1, flags, target_name, 64, tn_is_ml)))
300	{
301		return target_list[0];
302	}
303	ReplyToTargetError(client, target_count);
304	return -1;
305}
306
307public void:__ext_topmenus_SetNTVOptional()
308{
309	MarkNativeAsOptional("CreateTopMenu");
310	MarkNativeAsOptional("LoadTopMenuConfig");
311	MarkNativeAsOptional("AddToTopMenu");
312	MarkNativeAsOptional("RemoveFromTopMenu");
313	MarkNativeAsOptional("DisplayTopMenu");
314	MarkNativeAsOptional("DisplayTopMenuCategory");
315	MarkNativeAsOptional("FindTopMenuCategory");
316	MarkNativeAsOptional("SetTopMenuTitleCaching");
317	return void:0;
318}
319
320public void:__pl_adminmenu_SetNTVOptional()
321{
322	MarkNativeAsOptional("GetAdminTopMenu");
323	MarkNativeAsOptional("AddTargetsToMenu");
324	MarkNativeAsOptional("AddTargetsToMenu2");
325	return void:0;
326}
327
328public __pl_updater_SetNTVOptional()
329{
330	MarkNativeAsOptional("Updater_AddPlugin");
331	MarkNativeAsOptional("Updater_RemovePlugin");
332	MarkNativeAsOptional("Updater_ForceUpdate");
333	return 0;
334}
335
336public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
337{
338	RegPluginLibrary("sourcebans++");
339	CreateNative("SBBanPlayer", Native_SBBanPlayer);
340	CreateNative("SBPP_BanPlayer", Native_SBBanPlayer);
341	CreateNative("SBPP_ReportPlayer", Native_SBReportPlayer);
342	g_hFwd_OnBanAdded = CreateGlobalForward("SBPP_OnBanPlayer", ExecType:0, 2, 2, 2, 7);
343	g_hFwd_OnReportAdded = CreateGlobalForward("SBPP_OnReportPlayer", ExecType:0, 2, 2, 7);
344	LateLoaded = late;
345	return APLRes:0;
346}
347
348public void:OnPluginStart()
349{
350	LoadTranslations("common.phrases");
351	LoadTranslations("plugin.basecommands");
352	LoadTranslations("sbpp_main.phrases");
353	LoadTranslations("basebans.phrases");
354	new var1 = false;
355	loadOverrides = var1;
356	loadGroups = var1;
357	loadAdmins = var1;
358	CvarHostIp = FindConVar("hostip");
359	CvarPort = FindConVar("hostport");
360	CreateConVar("sb_version", "1.7.0", "", 8512, false, 0.0, false, 0.0);
361	RegServerCmd("sm_rehash", sm_rehash, "Reload SQL admins", 0);
362	RegAdminCmd("sm_ban", CommandBan, 8, "sm_ban <#userid|name> <minutes|0> [reason]", "sourcebans", 0);
363	RegAdminCmd("sm_banip", CommandBanIp, 8, "sm_banip <ip|#userid|name> <time> [reason]", "sourcebans", 0);
364	RegAdminCmd("sm_addban", CommandAddBan, 4096, "sm_addban <time> <steamid> [reason]", "sourcebans", 0);
365	RegAdminCmd("sm_unban", CommandUnban, 16, "sm_unban <steamid|ip> [reason]", "sourcebans", 0);
366	RegAdminCmd("sb_reload", _CmdReload, 4096, "Reload sourcebans config and ban reason menu options", "sourcebans", 0);
367	RegConsoleCmd("say", ChatHook, "", 0);
368	RegConsoleCmd("say_team", ChatHook, "", 0);
369	if ((TimeMenuHandle = CreateMenu(MenuHandler_BanTimeList, MenuAction:268)))
370	{
371		Menu.Pagination.set(TimeMenuHandle, 8);
372		Menu.ExitBackButton.set(TimeMenuHandle, true);
373	}
374	if ((ReasonMenuHandle = Menu.Menu(ReasonSelected, MenuAction:28)))
375	{
376		Menu.Pagination.set(ReasonMenuHandle, 8);
377		Menu.ExitBackButton.set(ReasonMenuHandle, true);
378	}
379	if ((HackingMenuHandle = Menu.Menu(HackingSelected, MenuAction:28)))
380	{
381		Menu.Pagination.set(HackingMenuHandle, 8);
382		Menu.ExitBackButton.set(HackingMenuHandle, true);
383	}
384	CreateFlagLetters();
385	BuildPath(PathType:0, logFile, 256, "logs/sourcebans.log");
386	g_bConnecting = true;
387	if (!SQL_CheckConfig("sourcebans"))
388	{
389		if (ReasonMenuHandle)
390		{
391			CloseHandle(ReasonMenuHandle);
392		}
393		if (HackingMenuHandle)
394		{
395			CloseHandle(HackingMenuHandle);
396		}
397		LogToFile(logFile, "Database failure: Could not find Database conf \"sourcebans\". See Docs: https://sbpp.github.io/docs/");
398		SetFailState("Database failure: Could not find Database conf \"sourcebans\"");
399		return void:0;
400	}
401	Database.Connect(SQLConnectCallback:63, "sourcebans", any:0);
402	BuildPath(PathType:0, groupsLoc, 128, "configs/sourcebans/sb_admin_groups.cfg");
403	BuildPath(PathType:0, adminsLoc, 128, "configs/sourcebans/sb_admins.cfg");
404	BuildPath(PathType:0, overridesLoc, 128, "configs/sourcebans/overrides_backup.cfg");
405	InitializeBackupDB();
406	CreateTimer(float(ProcessQueueTime * 60), ProcessQueue, any:0, 0);
407	if (LateLoaded)
408	{
409		AccountForLateLoading();
410	}
411	if (LibraryExists("updater"))
412	{
413		Updater_AddPlugin("https://sbpp.github.io/updater/updatefile.txt");
414	}
415	return void:0;
416}
417
418public void:OnLibraryAdded(String:name[])
419{
420	if (StrEqual(name, "updater", true))
421	{
422		Updater_AddPlugin("https://sbpp.github.io/updater/updatefile.txt");
423	}
424	return void:0;
425}
426
427public void:OnAllPluginsLoaded()
428{
429	new TopMenu:topmenu;
430	new var1;
431	if (LibraryExists("adminmenu") && (topmenu = GetAdminTopMenu()))
432	{
433		OnAdminMenuReady(topmenu);
434	}
435	return void:0;
436}
437
438public void:OnConfigsExecuted()
439{
440	new String:filename[200];
441	BuildPath(PathType:0, filename, 200, "plugins/basebans.smx");
442	if (FileExists(filename, false, "GAME"))
443	{
444		new String:newfilename[200];
445		BuildPath(PathType:0, newfilename, 200, "plugins/disabled/basebans.smx");
446		ServerCommand("sm plugins unload basebans");
447		if (FileExists(newfilename, false, "GAME"))
448		{
449			DeleteFile(newfilename, false, "DEFAULT_WRITE_PATH");
450		}
451		RenameFile(newfilename, filename, false, "DEFAULT_WRITE_PATH");
452		LogToFile(logFile, "plugins/basebans.smx was unloaded and moved to plugins/disabled/basebans.smx");
453	}
454	return void:0;
455}
456
457public void:OnMapStart()
458{
459	ResetSettings();
460	return void:0;
461}
462
463public void:OnMapEnd()
464{
465	new i;
466	while (i <= MaxClients)
467	{
468		if (PlayerDataPack[i])
469		{
470			new var1 = PlayerDataPack[i];
471			CloseHandle(var1);
472			var1 = 0;
473		}
474		i++;
475	}
476	return void:0;
477}
478
479public Action:OnClientPreAdminCheck(client)
480{
481	new var1;
482	if (!DB || GetUserAdmin(client) == -1)
483	{
484		return Action:0;
485	}
486	new var2;
487	if (curLoading > 0)
488	{
489		var2 = MissingTAG:3;
490	}
491	else
492	{
493		var2 = MissingTAG:0;
494	}
495	return var2;
496}
497
498public void:OnClientDisconnect(client)
499{
500	if (PlayerRecheck[client])
501	{
502		KillTimer(PlayerRecheck[client], false);
503		PlayerRecheck[client] = 0;
504	}
505	g_ownReasons[client] = 0;
506	return void:0;
507}
508
509public bool:OnClientConnect(client, String:rejectmsg[], maxlen)
510{
511	PlayerStatus[client] = 0;
512	return true;
513}
514
515public void:OnClientAuthorized(client, String:auth[])
516{
517	new var1;
518	if (auth[0] == 'B' || auth[2] == 'L' || DB)
519	{
520		PlayerStatus[client] = 1;
521		return void:0;
522	}
523	new String:Query[256];
524	new String:ip[32];
525	GetClientIP(client, ip, 30, true);
526	FormatEx(Query, 256, "SELECT bid, ip FROM %s_bans WHERE ((type = 0 AND authid REGEXP '^STEAM_[0-9]:%s$') OR (type = 1 AND ip = '%s')) AND (length = '0' OR ends > UNIX_TIMESTAMP()) AND RemoveType IS NULL", DatabasePrefix, auth[2], ip);
527	Database.Query(DB, SQLQueryCallback:139, Query, GetClientUserId(client), DBPriority:0);
528	return void:0;
529}
530
531public void:OnRebuildAdminCache(AdminCachePart:part)
532{
533	loadPart = part;
534	switch (loadPart)
535	{
536		case 0:
537		{
538			loadOverrides = true;
539		}
540		case 1:
541		{
542			loadGroups = true;
543		}
544		case 2:
545		{
546			loadAdmins = true;
547		}
548		default:
549		{
550		}
551	}
552	if (DB)
553	{
554		GotDatabase(DB, "", any:0);
555	}
556	else
557	{
558		if (!g_bConnecting)
559		{
560			g_bConnecting = true;
561			Database.Connect(SQLConnectCallback:63, "sourcebans", any:0);
562		}
563	}
564	return void:0;
565}
566
567public Action:ChatHook(client, args)
568{
569	if (g_ownReasons[client])
570	{
571		new String:reason[512];
572		GetCmdArgString(reason, 512);
573		StripQuotes(reason);
574		g_ownReasons[client] = 0;
575		if (StrEqual(reason, "!noreason", true))
576		{
577			PrintToChat(client, "%c[%cSourceBans%c]%c %t", '\x04', '\x02', '\x04', '\x02', "Chat Reason Aborted");
578			return Action:3;
579		}
580		PrepareBan(client, g_BanTarget[client], g_BanTime[client], reason, 512);
581		return Action:3;
582	}
583	return Action:0;
584}
585
586public Action:_CmdReload(client, args)
587{
588	ResetSettings();
589	return Action:3;
590}
591
592public Action:CommandBan(client, args)
593{
594	if (args < 2)
595	{
596		new var1;
597		if (GetCmdReplySource() == 1 && client && args)
598		{
599			DisplayBanTargetMenu(client);
600		}
601		else
602		{
603			ReplyToCommand(client, "%sUsage: sm_ban <#userid|name> <time|0> [reason]", "[SourceBans++] ");
604		}
605		return Action:3;
606	}
607	new admin = client;
608	new String:buffer[100];
609	GetCmdArg(1, buffer, 100);
610	new target = FindTarget(client, buffer, true, true);
611	if (target == -1)
612	{
613		return Action:3;
614	}
615	GetCmdArg(2, buffer, 100);
616	new time = StringToInt(buffer, 10);
617	new var2;
618	if (!time && client && !CheckCommandAccess(client, "sm_unban", 16400, false))
619	{
620		ReplyToCommand(client, "You do not have Perm Ban Permission");
621		return Action:3;
622	}
623	new String:reason[128];
624	if (args >= 3)
625	{
626		GetCmdArg(3, reason, 128);
627		new i = 4;
628		while (i <= args)
629		{
630			GetCmdArg(i, buffer, 100);
631			Format(reason, 128, "%s %s", reason, buffer);
632			i++;
633		}
634	}
635	else
636	{
637		reason[0] = MissingTAG:0;
638	}
639	g_BanTarget[client] = target;
640	g_BanTime[client] = time;
641	if (!PlayerStatus[target])
642	{
643		ReplyToCommand(admin, "%c[%cSourceBans%c]%c %t", '\x04', '\x02', '\x04', '\x02', "Ban Not Verified");
644		return Action:3;
645	}
646	CreateBan(client, target, time, reason);
647	return Action:3;
648}
649
650public Action:CommandBanIp(client, args)
651{
652	if (args < 2)
653	{
654		ReplyToCommand(client, "%sUsage: sm_banip <ip|#userid|name> <time> [reason]", "[SourceBans++] ");
655		return Action:3;
656	}
657	new len;
658	new next_len;
659	new String:Arguments[256];
660	new String:arg[52];
661	new String:time[20];
662	GetCmdArgString(Arguments, 256);
663	len = BreakString(Arguments, arg, 50);
664	if ((next_len = BreakString(Arguments[len], time, 20)) != -1)
665	{
666		len = next_len + len;
667	}
668	else
669	{
670		len = 0;
671		Arguments[0] = MissingTAG:0;
672	}
673	new String:target_name[64];
674	new target_list[1];
675	new bool:tn_is_ml;
676	new target = -1;
677	if (0 < ProcessTargetString(arg, client, target_list, 1, 20, target_name, 64, tn_is_ml))
678	{
679		target = target_list[0];
680		new var1;
681		if (!IsFakeClient(target) && CanUserTarget(client, target))
682		{
683			GetClientIP(target, arg, 50, true);
684		}
685	}
686	new String:adminIp[24];
687	new String:adminAuth[64];
688	new minutes = StringToInt(time, 10);
689	new var2;
690	if (!minutes && client && !CheckCommandAccess(client, "sm_unban", 16400, false))
691	{
692		ReplyToCommand(client, "You do not have Perm Ban Permission");
693		return Action:3;
694	}
695	if (!client)
696	{
697		strcopy(adminAuth, 64, "STEAM_ID_SERVER");
698		strcopy(adminIp, 24, ServerIp);
699	}
700	else
701	{
702		GetClientIP(client, adminIp, 24, true);
703		GetClientAuthId(client, AuthIdType:1, adminAuth, 64, true);
704	}
705	new DataPack:dataPack = DataPack.DataPack();
706	DataPack.WriteCell(dataPack, client);
707	DataPack.WriteCell(dataPack, minutes);
708	DataPack.WriteString(dataPack, Arguments[len]);
709	DataPack.WriteString(dataPack, arg);
710	DataPack.WriteString(dataPack, adminAuth);
711	DataPack.WriteString(dataPack, adminIp);
712	new String:sQuery[256];
713	FormatEx(sQuery, 256, "SELECT bid FROM %s_bans WHERE type = 1 AND ip     = '%s' AND (length = 0 OR ends > UNIX_TIMESTAMP()) AND RemoveType IS NULL", DatabasePrefix, arg);
714	Database.Query(DB, SQLQueryCallback:133, sQuery, dataPack, DBPriority:0);
715	return Action:3;
716}
717
718public Action:CommandUnban(client, args)
719{
720	if (args < 1)
721	{
722		ReplyToCommand(client, "%sUsage: sm_unban <steamid|ip> [reason]", "[SourceBans++] ");
723		return Action:3;
724	}
725	if (CommandDisable & 2)
726	{
727		ReplyToCommand(client, "%s%t", "[SourceBans++] ", "Can Not Unban", WebsiteAddress);
728		return Action:3;
729	}
730	new len;
731	new String:Arguments[256];
732	new String:arg[52];
733	new String:adminAuth[64];
734	GetCmdArgString(Arguments, 256);
735	if ((len = BreakString(Arguments, arg, 50)) == -1)
736	{
737		len = 0;
738		Arguments[0] = MissingTAG:0;
739	}
740	if (!client)
741	{
742		strcopy(adminAuth, 64, "STEAM_ID_SERVER");
743	}
744	else
745	{
746		GetClientAuthId(client, AuthIdType:1, adminAuth, 64, true);
747	}
748	new DataPack:dataPack = DataPack.DataPack();
749	DataPack.WriteCell(dataPack, client);
750	DataPack.WriteString(dataPack, Arguments[len]);
751	DataPack.WriteString(dataPack, arg);
752	DataPack.WriteString(dataPack, adminAuth);
753	new String:query[200];
754	if (strncmp(arg, "STEAM_", 6, true))
755	{
756		Format(query, 200, "SELECT bid FROM %s_bans WHERE (type = 1 AND ip     = '%s') AND (length = '0' OR ends > UNIX_TIMESTAMP()) AND RemoveType IS NULL", DatabasePrefix, arg);
757	}
758	else
759	{
760		Format(query, 200, "SELECT bid FROM %s_bans WHERE (type = 0 AND authid = '%s') AND (length = '0' OR ends > UNIX_TIMESTAMP()) AND RemoveType IS NULL", DatabasePrefix, arg);
761	}
762	Database.Query(DB, SQLQueryCallback:135, query, dataPack, DBPriority:1);
763	return Action:3;
764}
765
766public Action:CommandAddBan(client, args)
767{
768	if (args < 2)
769	{
770		ReplyToCommand(client, "%sUsage: sm_addban <time> <steamid> [reason]", "[SourceBans++] ");
771		return Action:3;
772	}
773	if (CommandDisable & 1)
774	{
775		ReplyToCommand(client, "%s%t", "[SourceBans++] ", "Can Not Add Ban", WebsiteAddress);
776		return Action:3;
777	}
778	new String:arg_string[256];
779	new String:time[52];
780	new String:authid[52];
781	GetCmdArgString(arg_string, 256);
782	new len;
783	new total_len;
784	if ((len = BreakString(arg_string, time, 50)) == -1)
785	{
786		ReplyToCommand(client, "%sUsage: sm_addban <time> <steamid> [reason]", "[SourceBans++] ");
787		return Action:3;
788	}
789	total_len = len + total_len;
790	if ((len = BreakString(arg_string[total_len], authid, 50)) != -1)
791	{
792		total_len = len + total_len;
793	}
794	else
795	{
796		total_len = 0;
797		arg_string[0] = MissingTAG:0;
798	}
799	new String:adminIp[24];
800	new String:adminAuth[64];
801	new minutes = StringToInt(time, 10);
802	new var1;
803	if (!minutes && client && !CheckCommandAccess(client, "sm_unban", 16400, false))
804	{
805		ReplyToCommand(client, "You do not have Perm Ban Permission");
806		return Action:3;
807	}
808	if (!client)
809	{
810		strcopy(adminAuth, 64, "STEAM_ID_SERVER");
811		strcopy(adminIp, 24, ServerIp);
812	}
813	else
814	{
815		GetClientIP(client, adminIp, 24, true);
816		GetClientAuthId(client, AuthIdType:1, adminAuth, 64, true);
817	}
818	new DataPack:dataPack = DataPack.DataPack();
819	DataPack.WriteCell(dataPack, client);
820	DataPack.WriteCell(dataPack, minutes);
821	DataPack.WriteString(dataPack, arg_string[total_len]);
822	DataPack.WriteString(dataPack, authid);
823	DataPack.WriteString(dataPack, adminAuth);
824	DataPack.WriteString(dataPack, adminIp);
825	new String:sQuery[256];
826	FormatEx(sQuery, 256, "SELECT bid FROM %s_bans WHERE type = 0 AND authid = '%s' AND (length = 0 OR ends > UNIX_TIMESTAMP()) AND RemoveType IS NULL", DatabasePrefix, authid);
827	Database.Query(DB, SQLQueryCallback:131, sQuery, dataPack, DBPriority:0);
828	return Action:3;
829}
830
831public Action:sm_rehash(args)
832{
833	if (enableAdmins)
834	{
835		DumpAdminCache(AdminCachePart:1, true);
836	}
837	DumpAdminCache(AdminCachePart:0, true);
838	return Action:3;
839}
840
841public void:OnAdminMenuReady(Handle:hTemp)
842{
843	new TopMenu:topmenu = hTemp;
844	if (hTopMenu == topmenu)
845	{
846		return void:0;
847	}
848	hTopMenu = topmenu;
849	new TopMenuObject:player_commands = TopMenu.FindCategory(hTopMenu, "PlayerCommands");
850	if (player_commands)
851	{
852		TopMenu.AddItem(hTopMenu, "sm_ban", AdminMenu_Ban, player_commands, "sm_ban", 8, "");
853	}
854	return void:0;
855}
856
857public void:AdminMenu_Ban(TopMenu:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
858{
859	g_ownReasons[param] = 0;
860	switch (action)
861	{
862		case 0:
863		{
864			FormatEx(buffer, maxlength, "%T", "Ban player", param);
865		}
866		case 2:
867		{
868			DisplayBanTargetMenu(param);
869		}
870		default:
871		{
872		}
873	}
874	return void:0;
875}
876
877public ReasonSelected(Menu:menu, MenuAction:action, param1, param2)
878{
879	switch (action)
880	{
881		case 4:
882		{
883			new String:info[128];
884			new String:key[128];
885			Menu.GetItem(menu, param2, key, 128, 0, info, 128);
886			if (StrEqual("Hacking", key, true))
887			{
888				Menu.Display(HackingMenuHandle, param1, 0);
889				return 0;
890			}
891			if (StrEqual("Own Reason", key, true))
892			{
893				g_ownReasons[param1] = 1;
894				PrintToChat(param1, "%c[%cSourceBans%c]%c %t", '\x04', '\x02', '\x04', '\x02', "Chat Reason");
895				return 0;
896			}
897			new var1;
898			if (g_BanTarget[param1] != -1 && g_BanTime[param1] != -1)
899			{
900				PrepareBan(param1, g_BanTarget[param1], g_BanTime[param1], info, 128);
901			}
902		}
903		case 8:
904		{
905			if (param2 == -1)
906			{
907				if (PlayerDataPack[param1])
908				{
909					new var2 = PlayerDataPack[param1];
910					CloseHandle(var2);
911					var2 = 0;
912				}
913			}
914			else
915			{
916				DisplayBanTimeMenu(param1);
917			}
918		}
919		default:
920		{
921		}
922	}
923	return 0;
924}
925
926public HackingSelected(Menu:menu, MenuAction:action, param1, param2)
927{
928	switch (action)
929	{
930		case 4:
931		{
932			new String:info[128];
933			new String:key[128];
934			Menu.GetItem(menu, param2, key, 128, 0, info, 128);
935			new var1;
936			if (g_BanTarget[param1] != -1 && g_BanTime[param1] != -1)
937			{
938				PrepareBan(param1, g_BanTarget[param1], g_BanTime[param1], info, 128);
939			}
940		}
941		case 8:
942		{
943			if (param2 == -1)
944			{
945				new DataPack:Pack = PlayerDataPack[param1];
946				if (Pack)
947				{
948					DataPack.ReadCell(Pack);
949					DataPack.ReadCell(Pack);
950					DataPack.ReadCell(Pack);
951					DataPack.ReadCell(Pack);
952					DataPack.ReadCell(Pack);
953					new DataPack:ReasonPack = DataPack.ReadCell(Pack);
954					if (ReasonPack)
955					{
956						CloseHandle(ReasonPack);
957					}
958					CloseHandle(Pack);
959					Pack = MissingTAG:0;
960					PlayerDataPack[param1] = 0;
961				}
962			}
963			else
964			{
965				DisplayMenu(ReasonMenuHandle, param1, 0);
966			}
967		}
968		default:
969		{
970		}
971	}
972	return 0;
973}
974
975public MenuHandler_BanPlayerList(Menu:menu, MenuAction:action, param1, param2)
976{
977	switch (action)
978	{
979		case 4:
980		{
981			new String:info[32];
982			new String:name[32];
983			new userid;
984			new target;
985			Menu.GetItem(menu, param2, info, 32, 0, name, 32);
986			userid = StringToInt(info, 10);
987			if ((target = GetClientOfUserId(userid)))
988			{
989				if (!CanUserTarget(param1, target))
990				{
991					PrintToChat(param1, "%s%t", "[SourceBans++] ", "Unable to target");
992				}
993				g_BanTarget[param1] = target;
994				DisplayBanTimeMenu(param1);
995			}
996			else
997			{
998				PrintToChat(param1, "%s%t", "[SourceBans++] ", "Player no longer available");
999			}
1000		}
1001		case 8:
1002		{
1003			new var1;
1004			if (param2 == -6 && hTopMenu)
1005			{
1006				TopMenu.Display(hTopMenu, param1, TopMenuPosition:3);
1007			}
1008		}
1009		case 16:
1010		{
1011			CloseHandle(menu);
1012			menu = MissingTAG:0;
1013		}
1014		default:
1015		{
1016		}
1017	}
1018	return 0;
1019}
1020
1021public MenuHandler_BanTimeList(Menu:menu, MenuAction:action, param1, param2)
1022{
1023	switch (action)
1024	{
1025		case 4:
1026		{
1027			new String:info[32];
1028			Menu.GetItem(menu, param2, info, 32, 0, "", 0);
1029			g_BanTime[param1] = StringToInt(info, 10);
1030			Menu.Display(ReasonMenuHandle, param1, 0);
1031		}
1032		case 8:
1033		{
1034			new var3;
1035			if (param2 == -6 && hTopMenu)
1036			{
1037				TopMenu.Display(hTopMenu, param1, TopMenuPosition:3);
1038			}
1039		}
1040		case 256:
1041		{
1042			new String:time[16];
1043			Menu.GetItem(menu, param2, time, 16, 0, "", 0);
1044			new var1;
1045			if (StringToInt(time, 10) > 0 || CheckCommandAccess(param1, "sm_unban", 16400, false))
1046			{
1047				var2 = 0;
1048			}
1049			else
1050			{
1051				var2 = 1;
1052			}
1053			return var2;
1054		}
1055		default:
1056		{
1057		}
1058	}
1059	return 0;
1060}
1061
1062void:DisplayBanTargetMenu(client)
1063{
1064	new Menu:menu = Menu.Menu(MenuHandler_BanPlayerList, MenuAction:28);
1065	new String:title[100];
1066	FormatEx(title, 100, "%T:", "Ban player", client);
1067	Menu.SetTitle(menu, title);
1068	Menu.ExitBackButton.set(menu, true);
1069	AddTargetsToMenu(menu, client, false, false);
1070	Menu.Display(menu, client, 0);
1071	return void:0;
1072}
1073
1074void:DisplayBanTimeMenu(client)
1075{
1076	new String:title[100];
1077	FormatEx(title, 100, "%T:", "Ban player", client);
1078	SetMenuTitle(TimeMenuHandle, title);
1079	DisplayMenu(TimeMenuHandle, client, 0);
1080	return void:0;
1081}
1082
1083void:ResetMenu()
1084{
1085	if (TimeMenuHandle)
1086	{
1087		RemoveAllMenuItems(TimeMenuHandle);
1088	}
1089	if (ReasonMenuHandle)
1090	{
1091		RemoveAllMenuItems(ReasonMenuHandle);
1092	}
1093	if (HackingMenuHandle)
1094	{
1095		RemoveAllMenuItems(HackingMenuHandle);
1096	}
1097	return void:0;
1098}
1099
1100public void:GotDatabase(Database:db, String:error[], any:data)
1101{
1102	if (db)
1103	{
1104		DB = db;
1105		new String:query[1024];
1106		Format(query, 1024, "SET NAMES utf8mb4");
1107		Database.Query(DB, SQLQueryCallback:61, query, any:0, DBPriority:1);
1108		InsertServerInfo();
1109		if (loadOverrides)
1110		{
1111			Format(query, 1024, "SELECT type, name, flags FROM %s_overrides", DatabasePrefix);
1112			Database.Query(DB, SQLQueryCallback:113, query, any:0, DBPriority:1);
1113			loadOverrides = false;
1114		}
1115		new var1;
1116		if (loadGroups && enableAdmins)
1117		{
1118			FormatEx(query, 1024, "SELECT name, flags, immunity, groups_immune   FROM %s_srvgroups ORDER BY id", DatabasePrefix);
1119			curLoading += 1;
1120			Database.Query(DB, SQLQueryCallback:65, query, any:0, DBPriority:1);
1121			loadGroups = false;
1122		}
1123		new var2;
1124		if (loadAdmins && enableAdmins)
1125		{
1126			new String:queryLastLogin[52];
1127			if (requireSiteLogin)
1128			{
1129				queryLastLogin = "lastvisit IS NOT NULL AND lastvisit != '' AND";
1130			}
1131			if (serverID == -1)
1132			{
1133				FormatEx(query, 1024, "SELECT authid, srv_password, (SELECT name FROM %s_srvgroups WHERE name = srv_group AND flags != '') AS srv_group, srv_flags, user, immunity  FROM %s_admins_servers_groups AS asg LEFT JOIN %s_admins AS a ON a.aid = asg.admin_id WHERE %s (server_id = (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1)  OR srv_group_id = ANY (SELECT group_id FROM %s_servers_groups WHERE server_id = (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1))) GROUP BY aid, authid, srv_password, srv_group, srv_flags, user", DatabasePrefix, DatabasePrefix, DatabasePrefix, queryLastLogin, DatabasePrefix, ServerIp, ServerPort, DatabasePrefix, DatabasePrefix, ServerIp, ServerPort);
1134			}
1135			else
1136			{
1137				FormatEx(query, 1024, "SELECT authid, srv_password, (SELECT name FROM %s_srvgroups WHERE name = srv_group AND flags != '') AS srv_group, srv_flags, user, immunity  FROM %s_admins_servers_groups AS asg LEFT JOIN %s_admins AS a ON a.aid = asg.admin_id WHERE %s server_id = %d  OR srv_group_id = ANY (SELECT group_id FROM %s_servers_groups WHERE server_id = %d) GROUP BY aid, authid, srv_password, srv_group, srv_flags, user", DatabasePrefix, DatabasePrefix, DatabasePrefix, queryLastLogin, serverID, DatabasePrefix, serverID);
1138			}
1139			curLoading += 1;
1140			Database.Query(DB, SQLQueryCallback:43, query, any:0, DBPriority:1);
1141			loadAdmins = false;
1142		}
1143		g_bConnecting = false;
1144		return void:0;
1145	}
1146	LogToFile(logFile, "Database failure: %s. See Docs: https://sbpp.github.io/docs/", error);
1147	g_bConnecting = false;
1148	ParseBackupConfig_Overrides();
1149	return void:0;
1150}
1151
1152public void:VerifyInsert(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1153{
1154	if (dataPack)
1155	{
1156		if (results)
1157		{
1158			new admin = DataPack.ReadCell(dataPack);
1159			new client = DataPack.ReadCell(dataPack);
1160			new var1;
1161			if (!IsClientConnected(client) || IsFakeClient(client))
1162			{
1163				return void:0;
1164			}
1165			DataPack.ReadCell(dataPack);
1166			new UserId = DataPack.ReadCell(dataPack);
1167			new time = DataPack.ReadCell(dataPack);
1168			new DataPack:ReasonPack = DataPack.ReadCell(dataPack);
1169			new String:Name[64];
1170			new String:Reason[128];
1171			DataPack.ReadString(dataPack, Name, 64);
1172			DataPack.ReadString(ReasonPack, Reason, 128);
1173			if (!time)
1174			{
1175				if (Reason[0])
1176				{
1177					ShowActivityEx(admin, "[SourceBans++] ", "%t", "Permabanned player reason", Name, Reason);
1178				}
1179				else
1180				{
1181					ShowActivityEx(admin, "[SourceBans++] ", "%t", "Permabanned player", Name);
1182				}
1183			}
1184			else
1185			{
1186				if (Reason[0])
1187				{
1188					ShowActivityEx(admin, "[SourceBans++] ", "%t", "Banned player reason", Name, time, Reason);
1189				}
1190				ShowActivityEx(admin, "[SourceBans++] ", "%t", "Banned player", Name, time);
1191			}
1192			LogAction(admin, client, "\"%L\" banned \"%L\" (minutes \"%d\") (reason \"%s\")", admin, client, time, Reason);
1193			if (PlayerDataPack[admin])
1194			{
1195				new var2 = PlayerDataPack[admin];
1196				CloseHandle(var2);
1197				var2 = 0;
1198				CloseHandle(ReasonPack);
1199				ReasonPack = MissingTAG:0;
1200			}
1201			new String:BanEnd[64];
1202			FormatTime(BanEnd, 64, "%d-%m-%Y %H:%M", g_BanTime[client][GetTime({0,0})][time * 60]);
1203			if (UserId == GetClientUserId(client))
1204			{
1205				if (!time)
1206				{
1207					if (Reason[0])
1208					{
1209						KickClient(client, "<font color='#E0753F'><b>4af.pl!</b></font><br /><font color='#c40000'><b>Zostaleś permanentnie zbanowany na tym serwerze!</b></font><br /><br />Admin: <b>%N</b><br />Powód: <b>%s</b>", admin, Reason);
1210					}
1211					else
1212					{
1213						KickClient(client, "<font color='#E0753F'><b>4af.pl!</b></font><br /><font color='#c40000'><b>Zostaleś permanentnie zbanowany na tym serwerze!</b></font><br /><br />Admin: <b>%N</b>", admin);
1214					}
1215				}
1216				if (Reason[0])
1217				{
1218					KickClient(client, "<font color='#E0753F'><b>4af.pl!</b></font><font color='#ff8300'><br /><b>Zostaleś zbanowany na tym serwerze!</b></font><br /><br />Wygasa: <b>%s</b><br />Admin: <b>%N</b><br />Powód: <b>%s</b>", BanEnd, admin, Reason);
1219				}
1220				KickClient(client, "<font color='#E0753F'><b>4af.pl!</b></font><br /><font color='#ff8300'><b>Zostaleś zbanowany na tym serwerze!</b></font><br /><br />Wygasa: <b>%s</b><br />Admin: <b>%N</b>", BanEnd, admin);
1221			}
1222			return void:0;
1223		}
1224		LogToFile(logFile, "Verify Insert Query Failed: %s", error);
1225		new admin = DataPack.ReadCell(dataPack);
1226		DataPack.ReadCell(dataPack);
1227		DataPack.ReadCell(dataPack);
1228		DataPack.ReadCell(dataPack);
1229		new time = DataPack.ReadCell(dataPack);
1230		new DataPack:reasonPack = DataPack.ReadCell(dataPack);
1231		new String:reason[128];
1232		new String:name[52];
1233		new String:auth[32];
1234		new String:ip[20];
1235		new String:adminAuth[32];
1236		new String:adminIp[20];
1237		DataPack.ReadString(reasonPack, reason, 128);
1238		DataPack.ReadString(dataPack, name, 50);
1239		DataPack.ReadString(dataPack, auth, 30);
1240		DataPack.ReadString(dataPack, ip, 20);
1241		DataPack.ReadString(dataPack, adminAuth, 30);
1242		DataPack.ReadString(dataPack, adminIp, 20);
1243		DataPack.Reset(dataPack, false);
1244		DataPack.Reset(reasonPack, false);
1245		PlayerDataPack[admin] = 0;
1246		UTIL_InsertTempBan(time, name, auth, ip, reason, adminAuth, adminIp, dataPack);
1247		return void:0;
1248	}
1249	LogToFile(logFile, "Ban Failed: %s", error);
1250	return void:0;
1251}
1252
1253public void:SelectBanIpCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1254{
1255	new admin;
1256	new minutes;
1257	new String:adminAuth[32];
1258	new String:adminIp[32];
1259	new String:banReason[256];
1260	new String:ip[16];
1261	new String:Query[512];
1262	new String:reason[128];
1263	DataPack.Reset(dataPack, false);
1264	admin = DataPack.ReadCell(dataPack);
1265	minutes = DataPack.ReadCell(dataPack);
1266	DataPack.ReadString(dataPack, reason, 128);
1267	DataPack.ReadString(dataPack, ip, 16);
1268	DataPack.ReadString(dataPack, adminAuth, 30);
1269	DataPack.ReadString(dataPack, adminIp, 30);
1270	Database.Escape(DB, reason, banReason, 256, 0);
1271	if (results)
1272	{
1273		if (DBResultSet.RowCount.get(results))
1274		{
1275			new var2;
1276			if (admin && IsClientInGame(admin))
1277			{
1278				PrintToChat(admin, "%s%s is already banned.", "[SourceBans++] ", ip);
1279			}
1280			else
1281			{
1282				PrintToServer("%s%s is already banned.", "[SourceBans++] ", ip);
1283			}
1284			return void:0;
1285		}
1286		if (serverID == -1)
1287		{
1288			FormatEx(Query, 512, "INSERT INTO %s_bans (type, ip, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES (1, '%s', '', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1), ' ')", DatabasePrefix, ip, minutes * 60, minutes * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, DatabasePrefix, ServerIp, ServerPort);
1289		}
1290		else
1291		{
1292			FormatEx(Query, 512, "INSERT INTO %s_bans (type, ip, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES (1, '%s', '', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', %d, ' ')", DatabasePrefix, ip, minutes * 60, minutes * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, serverID);
1293		}
1294		Database.Query(db, SQLQueryCallback:75, Query, dataPack, DBPriority:0);
1295		return void:0;
1296	}
1297	LogToFile(logFile, "Ban IP Select Query Failed: %s", error);
1298	new var1;
1299	if (admin && IsClientInGame(admin))
1300	{
1301		PrintToChat(admin, "%sFailed to ban %s.", "[SourceBans++] ", ip);
1302	}
1303	else
1304	{
1305		PrintToServer("%sFailed to ban %s.", "[SourceBans++] ", ip);
1306	}
1307	return void:0;
1308}
1309
1310public void:InsertBanIpCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1311{
1312	new admin;
1313	new minutes;
1314	new String:reason[128];
1315	new String:arg[32];
1316	if (dataPack)
1317	{
1318		DataPack.Reset(dataPack, false);
1319		admin = DataPack.ReadCell(dataPack);
1320		minutes = DataPack.ReadCell(dataPack);
1321		DataPack.ReadString(dataPack, reason, 128);
1322		DataPack.ReadString(dataPack, arg, 30);
1323		CloseHandle(dataPack);
1324		dataPack = MissingTAG:0;
1325	}
1326	else
1327	{
1328		ThrowError("Invalid Handle in InsertBanIpCallback");
1329	}
1330	if (results)
1331	{
1332		LogAction(admin, -1, "\"%L\" added ban (minutes \"%d\") (ip \"%s\") (reason \"%s\")", admin, minutes, arg, reason);
1333		new var2;
1334		if (admin && IsClientInGame(admin))
1335		{
1336			PrintToChat(admin, "%s%s successfully banned", "[SourceBans++] ", arg);
1337		}
1338		else
1339		{
1340			PrintToServer("%s%s successfully banned", "[SourceBans++] ", arg);
1341		}
1342		return void:0;
1343	}
1344	LogToFile(logFile, "Ban IP Insert Query Failed: %s", error);
1345	new var1;
1346	if (admin && IsClientInGame(admin))
1347	{
1348		PrintToChat(admin, "%ssm_banip failed", "[SourceBans++] ");
1349	}
1350	return void:0;
1351}
1352
1353public void:SelectUnbanCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1354{
1355	new admin;
1356	new String:arg[32];
1357	new String:adminAuth[32];
1358	new String:unbanReason[256];
1359	new String:reason[128];
1360	DataPack.Reset(dataPack, false);
1361	admin = DataPack.ReadCell(dataPack);
1362	DataPack.ReadString(dataPack, reason, 128);
1363	DataPack.ReadString(dataPack, arg, 30);
1364	DataPack.ReadString(dataPack, adminAuth, 30);
1365	CloseHandle(dataPack);
1366	dataPack = MissingTAG:0;
1367	Database.Escape(db, reason, unbanReason, 256, 0);
1368	if (results)
1369	{
1370		if (!DBResultSet.RowCount.get(results))
1371		{
1372			new var2;
1373			if (admin && IsClientInGame(admin))
1374			{
1375				PrintToChat(admin, "%sNo active bans found for that filter", "[SourceBans++] ");
1376			}
1377			else
1378			{
1379				PrintToServer("%sNo active bans found for that filter", "[SourceBans++] ");
1380			}
1381			return void:0;
1382		}
1383		new var3;
1384		if (results && DBResultSet.FetchRow(results))
1385		{
1386			new bid = DBResultSet.FetchInt(results, 0, 0);
1387			new String:query[1000];
1388			Format(query, 1000, "UPDATE %s_bans SET RemovedBy = (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), RemoveType = 'U', RemovedOn = UNIX_TIMESTAMP(), ureason = '%s' WHERE bid = %d", DatabasePrefix, DatabasePrefix, adminAuth, adminAuth[2], unbanReason, bid);
1389			Database.Query(db, SQLQueryCallback:77, query, dataPack, DBPriority:1);
1390		}
1391		return void:0;
1392	}
1393	LogToFile(logFile, "Unban Select Query Failed: %s", error);
1394	new var1;
1395	if (admin && IsClientInGame(admin))
1396	{
1397		PrintToChat(admin, "%ssm_unban failed", "[SourceBans++] ");
1398	}
1399	return void:0;
1400}
1401
1402public void:InsertUnbanCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1403{
1404	new admin;
1405	new String:arg[32];
1406	new String:reason[128];
1407	if (dataPack)
1408	{
1409		DataPack.Reset(dataPack, false);
1410		admin = DataPack.ReadCell(dataPack);
1411		DataPack.ReadString(dataPack, reason, 128);
1412		DataPack.ReadString(dataPack, arg, 30);
1413		CloseHandle(dataPack);
1414		dataPack = MissingTAG:0;
1415	}
1416	else
1417	{
1418		ThrowError("Invalid Handle in InsertUnbanCallback");
1419	}
1420	if (results)
1421	{
1422		LogAction(admin, -1, "\"%L\" removed ban (filter \"%s\") (reason \"%s\")", admin, arg, reason);
1423		new var2;
1424		if (admin && IsClientInGame(admin))
1425		{
1426			PrintToChat(admin, "%s%s successfully unbanned", "[SourceBans++] ", arg);
1427		}
1428		else
1429		{
1430			PrintToServer("%s%s successfully unbanned", "[SourceBans++] ", arg);
1431		}
1432		return void:0;
1433	}
1434	LogToFile(logFile, "Unban Insert Query Failed: %s", error);
1435	new var1;
1436	if (admin && IsClientInGame(admin))
1437	{
1438		PrintToChat(admin, "%ssm_unban failed", "[SourceBans++] ");
1439	}
1440	return void:0;
1441}
1442
1443public void:SelectAddbanCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1444{
1445	new admin;
1446	new minutes;
1447	new String:adminAuth[32];
1448	new String:adminIp[32];
1449	new String:authid[20];
1450	new String:banReason[256];
1451	new String:Query[512];
1452	new String:reason[128];
1453	DataPack.Reset(dataPack, false);
1454	admin = DataPack.ReadCell(dataPack);
1455	minutes = DataPack.ReadCell(dataPack);
1456	DataPack.ReadString(dataPack, reason, 128);
1457	DataPack.ReadString(dataPack, authid, 20);
1458	DataPack.ReadString(dataPack, adminAuth, 30);
1459	DataPack.ReadString(dataPack, adminIp, 30);
1460	Database.Escape(db, reason, banReason, 256, 0);
1461	if (results)
1462	{
1463		if (DBResultSet.RowCount.get(results))
1464		{
1465			new var2;
1466			if (admin && IsClientInGame(admin))
1467			{
1468				PrintToChat(admin, "%s%s is already banned.", "[SourceBans++] ", authid);
1469			}
1470			else
1471			{
1472				PrintToServer("%s%s is already banned.", "[SourceBans++] ", authid);
1473			}
1474			return void:0;
1475		}
1476		if (serverID == -1)
1477		{
1478			FormatEx(Query, 512, "INSERT INTO %s_bans (authid, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES ('%s', '', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1), ' ')", DatabasePrefix, authid, minutes * 60, minutes * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, DatabasePrefix, ServerIp, ServerPort);
1479		}
1480		else
1481		{
1482			FormatEx(Query, 512, "INSERT INTO %s_bans (authid, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES ('%s', '', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', %d, ' ')", DatabasePrefix, authid, minutes * 60, minutes * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, serverID);
1483		}
1484		Database.Query(db, SQLQueryCallback:73, Query, dataPack, DBPriority:0);
1485		return void:0;
1486	}
1487	LogToFile(logFile, "Add Ban Select Query Failed: %s", error);
1488	new var1;
1489	if (admin && IsClientInGame(admin))
1490	{
1491		PrintToChat(admin, "%sFailed to ban %s.", "[SourceBans++] ", authid);
1492	}
1493	else
1494	{
1495		PrintToServer("%sFailed to ban %s.", "[SourceBans++] ", authid);
1496	}
1497	return void:0;
1498}
1499
1500public void:InsertAddbanCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1501{
1502	new admin;
1503	new minutes;
1504	new String:authid[20];
1505	new String:reason[128];
1506	DataPack.Reset(dataPack, false);
1507	admin = DataPack.ReadCell(dataPack);
1508	minutes = DataPack.ReadCell(dataPack);
1509	DataPack.ReadString(dataPack, reason, 128);
1510	DataPack.ReadString(dataPack, authid, 20);
1511	CloseHandle(dataPack);
1512	dataPack = MissingTAG:0;
1513	if (results)
1514	{
1515		LogAction(admin, -1, "\"%L\" added ban (minutes \"%i\") (id \"%s\") (reason \"%s\")", admin, minutes, authid, reason);
1516		new var2;
1517		if (admin && IsClientInGame(admin))
1518		{
1519			PrintToChat(admin, "%s%s successfully banned", "[SourceBans++] ", authid);
1520		}
1521		else
1522		{
1523			PrintToServer("%s%s successfully banned", "[SourceBans++] ", authid);
1524		}
1525		return void:0;
1526	}
1527	LogToFile(logFile, "Add Ban Insert Query Failed: %s", error);
1528	new var1;
1529	if (admin && IsClientInGame(admin))
1530	{
1531		PrintToChat(admin, "%ssm_addban failed", "[SourceBans++] ");
1532	}
1533	return void:0;
1534}
1535
1536public void:ProcessQueueCallback(Database:db, DBResultSet:results, String:error[], any:data)
1537{
1538	if (results)
1539	{
1540		new String:auth[32];
1541		new time;
1542		new startTime;
1543		new String:reason[128];
1544		new String:name[64];
1545		new String:ip[20];
1546		new String:adminAuth[32];
1547		new String:adminIp[20];
1548		new String:query[1024];
1549		new String:banName[128];
1550		new String:banReason[256];
1551		while (DBResultSet.MoreRows.get(results))
1552		{
1553			if (DBResultSet.FetchRow(results))
1554			{
1555				DBResultSet.FetchString(results, 0, auth, 30, 0);
1556				time = DBResultSet.FetchInt(results, 1, 0);
1557				startTime = DBResultSet.FetchInt(results, 2, 0);
1558				DBResultSet.FetchString(results, 3, reason, 128, 0);
1559				DBResultSet.FetchString(results, 4, name, 64, 0);
1560				DBResultSet.FetchString(results, 5, ip, 20, 0);
1561				DBResultSet.FetchString(results, 6, adminAuth, 30, 0);
1562				DBResultSet.FetchString(results, 7, adminIp, 20, 0);
1563				Database.Escape(db, name, banName, 128, 0);
1564				Database.Escape(db, reason, banReason, 256, 0);
1565				new var1;
1566				if (time * 60 + startTime > GetTime({0,0}) || time)
1567				{
1568					if (serverID == -1)
1569					{
1570						FormatEx(query, 1024, "INSERT INTO %s_bans (ip, authid, name, created, ends, length, reason, aid, adminIp, sid) VALUES  ('%s', '%s', '%s', %d, %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1))", DatabasePrefix, ip, auth, banName, startTime, time * 60 + startTime, time * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, DatabasePrefix, ServerIp, ServerPort);
1571					}
1572					else
1573					{
1574						FormatEx(query, 1024, "INSERT INTO %s_bans (ip, authid, name, created, ends, length, reason, aid, adminIp, sid) VALUES  ('%s', '%s', '%s', %d, %d, %d, '%s', (SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'), '%s', %d)", DatabasePrefix, ip, auth, banName, startTime, time * 60 + startTime, time * 60, banReason, DatabasePrefix, adminAuth, adminAuth[2], adminIp, serverID);
1575					}
1576					new DataPack:authPack = DataPack.DataPack();
1577					DataPack.WriteString(authPack, auth);
1578					DataPack.Reset(authPack, false);
1579					Database.Query(db, SQLQueryCallback:39, query, authPack, DBPriority:1);
1580				}
1581				else
1582				{
1583					FormatEx(query, 1024, "DELETE FROM queue WHERE steam_id = '%s'", auth);
1584					Database.Query(SQLiteDB, SQLQueryCallback:61, query, any:0, DBPriority:1);
1585				}
1586			}
1587		}
1588		CreateTimer(float(ProcessQueueTime * 60), ProcessQueue, any:0, 0);
1589		return void:0;
1590	}
1591	LogToFile(logFile, "Failed to retrieve queued bans from sqlite database, %s", error);
1592	return void:0;
1593}
1594
1595public void:AddedFromSQLiteCallback(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
1596{
1597	new String:buffer[512];
1598	new String:auth[40];
1599	DataPack.ReadString(dataPack, auth, 40);
1600	if (results)
1601	{
1602		FormatEx(buffer, 512, "banid %d %s", ProcessQueueTime, auth);
1603		ServerCommand(buffer);
1604	}
1605	else
1606	{
1607		FormatEx(buffer, 512, "DELETE FROM queue WHERE steam_id = '%s'", auth);
1608		Database.Query(SQLiteDB, SQLQueryCallback:61, buffer, any:0, DBPriority:1);
1609		RemoveBan(auth, 4, "", any:0);
1610	}
1611	CloseHandle(dataPack);
1612	dataPack = MissingTAG:0;
1613	return void:0;
1614}
1615
1616public void:ServerInfoCallback(Database:db, DBResultSet:results, String:error[], any:data)
1617{
1618	if (results)
1619	{
1620		if (!DBResultSet.RowCount.get(results))
1621		{
1622			new String:desc[64];
1623			new String:query[200];
1624			GetGameFolderName(desc, 64);
1625			FormatEx(query, 200, "INSERT INTO %s_servers (ip, port, rcon, modid) VALUES ('%s', '%s', '', (SELECT mid FROM %s_mods WHERE modfolder = '%s'))", DatabasePrefix, ServerIp, ServerPort, DatabasePrefix, desc);
1626			Database.Query(db, SQLQueryCallback:61, query, any:0, DBPriority:1);
1627		}
1628		return void:0;
1629	}
1630	LogToFile(logFile, "Server Select Query Failed: %s", error);
1631	return void:0;
1632}
1633
1634public void:ErrorCheckCallback(Database:db, DBResultSet:results, String:error[], any:data)
1635{
1636	if (!results)
1637	{
1638		LogToFile(logFile, "Query Failed: %s", error);
1639	}
1640	return void:0;
1641}
1642
1643public void:VerifyBan(Database:db, DBResultSet:results, String:error[], userid)
1644{
1645	new String:clientName[64];
1646	new String:clientAuth[64];
1647	new String:clientIp[64];
1648	new client = GetClientOfUserId(userid);
1649	if (!client)
1650	{
1651		return void:0;
1652	}
1653	if (results)
1654	{
1655		GetClientIP(client, clientIp, 64, true);
1656		GetClientAuthId(client, AuthIdType:1, clientAuth, 64, true);
1657		GetClientName(client, clientName, 64);
1658		if (0 < DBResultSet.RowCount.get(results))
1659		{
1660			new String:buffer[40];
1661			new String:Name[128];
1662			new String:Query[512];
1663			if (DBResultSet.FetchRow(results))
1664			{
1665				new String:sIP[32];
1666				new iBid = DBResultSet.FetchInt(results, 0, 0);
1667				DBResultSet.FetchString(results, 1, sIP, 32, 0);
1668				if (StrEqual(sIP, "", true))
1669				{
1670					new String:sQuery[256];
1671					FormatEx(sQuery, 256, "UPDATE %s_bans SET `ip` = '%s' WHERE `bid` = '%d'", DatabasePrefix, clientIp, iBid);
1672					Database.Query(DB, SQLQueryCallback:127, sQuery, client, DBPriority:1);
1673				}
1674			}
1675			Database.Escape(DB, clientName, Name, 128, 0);
1676			if (serverID == -1)
1677			{
1678				FormatEx(Query, 512, "INSERT INTO %s_banlog (sid ,time ,name ,bid) VALUES  ((SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1), UNIX_TIMESTAMP(), '%s', (SELECT bid FROM %s_bans WHERE ((type = 0 AND authid REGEXP '^STEAM_[0-9]:%s$') OR (type = 1 AND ip = '%s')) AND RemoveType IS NULL LIMIT 0,1))", DatabasePrefix, DatabasePrefix, ServerIp, ServerPort, Name, DatabasePrefix, clientAuth[2], clientIp);
1679			}
1680			else
1681			{
1682				FormatEx(Query, 512, "INSERT INTO %s_banlog (sid ,time ,name ,bid) VALUES  (%d, UNIX_TIMESTAMP(), '%s', (SELECT bid FROM %s_bans WHERE ((type = 0 AND authid REGEXP '^STEAM_[0-9]:%s$') OR (type = 1 AND ip = '%s')) AND RemoveType IS NULL LIMIT 0,1))", DatabasePrefix, serverID, Name, DatabasePrefix, clientAuth[2], clientIp);
1683			}
1684			Database.Query(db, SQLQueryCallback:61, Query, client, DBPriority:0);
1685			FormatEx(buffer, 40, "banid 5 %s", clientAuth);
1686			ServerCommand(buffer);
1687			KickClient(client, "%t", "Banned Check Site", WebsiteAddress);
1688			return void:0;
1689		}
1690		PlayerStatus[client] = 1;
1691		return void:0;
1692	}
1693	LogToFile(logFile, "Verify Ban Query Failed: %s", error);
1694	PlayerRecheck[client] = CreateTimer(RetryTime, ClientRecheck, client, 0);
1695	return void:0;
1696}
1697
1698public void:SQL_OnIPMend(Database:db, DBResultSet:results, String:error[], iClient)
1699{
1700	if (!results)
1701	{
1702		new String:sIP[32];
1703		new String:sSteamID[32];
1704		GetClientAuthId(iClient, AuthIdType:2, sSteamID, 32, true);
1705		GetClientIP(iClient, sIP, 32, true);
1706		LogToFile(logFile, "Failed to mend IP address for %s (%s): %s", sSteamID, sIP, error);
1707	}
1708	return void:0;
1709}
1710
1711public void:AdminsDone(Database:db, DBResultSet:results, String:error[], any:data)
1712{
1713	if (results)
1714	{
1715		new String:authType[8] = "steam";
1716		new String:identity[68];
1717		new String:password[68];
1718		new String:groups[256];
1719		new String:flags[32];
1720		new String:name[68];
1721		new admCount;
1722		new Immunity;
1723		new AdminId:curAdm = -1;
1724		new KeyValues:adminsKV = KeyValues.KeyValues("Admins", "", "");
1725		while (DBResultSet.FetchRow(results))
1726		{
1727			if (!(DBResultSet.IsFieldNull(results, 0)))
1728			{
1729				DBResultSet.FetchString(results, 0, identity, 66, 0);
1730				DBResultSet.FetchString(results, 1, password, 66, 0);
1731				DBResultSet.FetchString(results, 2, groups, 256, 0);
1732				DBResultSet.FetchString(results, 3, flags, 32, 0);
1733				DBResultSet.FetchString(results, 4, name, 66, 0);
1734				Immunity = DBResultSet.FetchInt(results, 5, 0);
1735				TrimString(name);
1736				TrimString(identity);
1737				TrimString(groups);
1738				TrimString(flags);
1739				if (backupConfig)
1740				{
1741					KeyValues.JumpToKey(adminsKV, name, true);
1742					KeyValues.SetString(adminsKV, "auth", authType);
1743					KeyValues.SetString(adminsKV, "identity", identity);
1744					if (0 < strlen(flags))
1745					{
1746						KeyValues.SetString(adminsKV, "flags", flags);
1747					}
1748					if (0 < strlen(groups))
1749					{
1750						KeyValues.SetString(adminsKV, "group", groups);
1751					}
1752					if (0 < strlen(password))
1753					{
1754						KeyValues.SetString(adminsKV, "password", password);
1755					}
1756					if (0 < Immunity)
1757					{
1758						KeyValues.SetNum(adminsKV, "immunity", Immunity);
1759					}
1760					KeyValues.Rewind(adminsKV);
1761				}
1762				if ((curAdm = FindAdminByIdentity(authType, identity)) == -1)
1763				{
1764					curAdm = CreateAdmin(name);
1765					if (!AdminId.BindIdentity(curAdm, authType, identity))
1766					{
1767						LogToFile(logFile, "Unable to bind admin %s to identity %s", name, identity);
1768						RemoveAdmin(curAdm);
1769					}
1770				}
1771				new curPos;
1772				new GroupId:curGrp = -1;
1773				new numGroups;
1774				new String:iterGroupName[64];
1775				if (strcmp(groups[curPos], "", true))
1776				{
1777					curGrp = FindAdmGroup(groups[curPos]);
1778					if (curGrp == GroupId:-1)
1779					{
1780						LogToFile(logFile, "Unknown group \"%s\"", groups[curPos]);
1781					}
1782					numGroups = AdminId.GroupCount.get(curAdm);
1783					new i;
1784					while (i < numGroups)
1785					{
1786						AdminId.GetGroup(curAdm, i, iterGroupName, 64);
1787						if (StrEqual(iterGroupName, groups[curPos], true))
1788						{
1789							numGroups = -2;
1790							new var1;
1791							if (numGroups != -2 && !AdminId.InheritGroup(curAdm, curGrp))
1792							{
1793								LogToFile(logFile, "Unable to inherit group \"%s\"", groups[curPos]);
1794							}
1795							if (AdminId.ImmunityLevel.get(curAdm) < Immunity)
1796							{
1797								AdminId.ImmunityLevel.set(curAdm, Immunity);
1798							}
1799						}
1800						i++;
1801					}
1802					new var1;
1803					if (numGroups != -2 && !AdminId.InheritGroup(curAdm, curGrp))
1804					{
1805						LogToFile(logFile, "Unable to inherit group \"%s\"", groups[curPos]);
1806					}
1807					if (AdminId.ImmunityLevel.get(curAdm) < Immunity)
1808					{
1809						AdminId.ImmunityLevel.set(curAdm, Immunity);
1810					}
1811				}
1812				if (0 < strlen(password))
1813				{
1814					AdminId.SetPassword(curAdm, password);
1815				}
1816				new i;
1817				while (strlen(flags) > i)
1818				{
1819					new var2;
1820					if (flags[i] < 'a' || flags[i] > 'z')
1821					{
1822					}
1823					else
1824					{
1825						if (!(AdminFlag:0 > g_FlagLetters[flags[i] + -97]))
1826						{
1827							AdminId.SetFlag(curAdm, g_FlagLetters[flags[i] + -97], true);
1828						}
1829					}
1830					i++;
1831				}
1832				admCount++;
1833			}
1834		}
1835		if (backupConfig)
1836		{
1837			KeyValues.ExportToFile(adminsKV, adminsLoc);
1838		}
1839		CloseHandle(adminsKV);
1840		adminsKV = MissingTAG:0;
1841		curLoading -= 1;
1842		CheckLoadAdmins();
1843		return void:0;
1844	}
1845	curLoading -= 1;
1846	CheckLoadAdmins();
1847	LogToFile(logFile, "Failed to retrieve admins from the database, %s", error);
1848	return void:0;
1849}
1850
1851public void:GroupsDone(Database:db, DBResultSet:results, String:error[], any:data)
1852{
1853	if (results)
1854	{
1855		new String:grpName[128];
1856		new String:immuneGrpName[128];
1857		new String:grpFlags[32];
1858		new Immunity;
1859		new grpCount;
1860		new KeyValues:groupsKV = KeyValues.KeyValues("Groups", "", "");
1861		new GroupId:curGrp = -1;
1862		while (DBResultSet.FetchRow(results))
1863		{
1864			if (!(DBResultSet.IsFieldNull(results, 0)))
1865			{
1866				DBResultSet.FetchString(results, 0, grpName, 128, 0);
1867				DBResultSet.FetchString(results, 1, grpFlags, 32, 0);
1868				Immunity = DBResultSet.FetchInt(results, 2, 0);
1869				DBResultSet.FetchString(results, 3, immuneGrpName, 128, 0);
1870				TrimString(grpName);
1871				TrimString(grpFlags);
1872				TrimString(immuneGrpName);
1873				if (strlen(grpName))
1874				{
1875					curGrp = CreateAdmGroup(grpName);
1876					if (backupConfig)
1877					{
1878						KeyValues.JumpToKey(groupsKV, grpName, true);
1879						if (0 < strlen(grpFlags))
1880						{
1881							KeyValues.SetString(groupsKV, "flags", grpFlags);
1882						}
1883						if (0 < Immunity)
1884						{
1885							KeyValues.SetNum(groupsKV, "immunity", Immunity);
1886						}
1887						KeyValues.Rewind(groupsKV);
1888					}
1889					if (curGrp == GroupId:-1)
1890					{
1891						curGrp = FindAdmGroup(grpName);
1892					}
1893					new i;
1894					while (strlen(grpFlags) > i)
1895					{
1896						new var1;
1897						if (grpFlags[i] < 'a' || grpFlags[i] > 'z')
1898						{
1899						}
1900						else
1901						{
1902							if (!(AdminFlag:0 > g_FlagLetters[grpFlags[i] + -97]))
1903							{
1904								GroupId.SetFlag(curGrp, g_FlagLetters[grpFlags[i] + -97], true);
1905							}
1906						}
1907						i++;
1908					}
1909					if (0 < Immunity)
1910					{
1911						GroupId.ImmunityLevel.set(curGrp, Immunity);
1912					}
1913					grpCount++;
1914				}
1915			}
1916		}
1917		if (backupConfig)
1918		{
1919			KeyValues.ExportToFile(groupsKV, groupsLoc);
1920		}
1921		CloseHandle(groupsKV);
1922		groupsKV = MissingTAG:0;
1923		new String:query[512];
1924		FormatEx(query, 512, "SELECT sg.name, so.type, so.name, so.access FROM %s_srvgroups_overrides so LEFT JOIN %s_srvgroups sg ON sg.id = so.group_id ORDER BY sg.id", DatabasePrefix, DatabasePrefix);
1925		Database.Query(db, SQLQueryCallback:79, query, any:0, DBPriority:1);
1926		return void:0;
1927	}
1928	curLoading -= 1;
1929	CheckLoadAdmins();
1930	LogToFile(logFile, "Failed to retrieve groups from the database, %s", error);
1931	return void:0;
1932}
1933
1934public void:GroupsSecondPass(Database:db, DBResultSet:results, String:error[], any:data)
1935{
1936	if (results)
1937	{
1938		new String:grpName[128];
1939		new String:immunityGrpName[128];
1940		new GroupId:curGrp = -1;
1941		new GroupId:immuneGrp = -1;
1942		while (DBResultSet.FetchRow(results))
1943		{
1944			if (!(DBResultSet.IsFieldNull(results, 0)))
1945			{
1946				DBResultSet.FetchString(results, 0, grpName, 128, 0);
1947				TrimString(grpName);
1948				if (strlen(grpName))
1949				{
1950					DBResultSet.FetchString(results, 2, immunityGrpName, 128, 0);
1951					TrimString(immunityGrpName);
1952					curGrp = FindAdmGroup(grpName);
1953					if (!(curGrp == GroupId:-1))
1954					{
1955						immuneGrp = FindAdmGroup(immunityGrpName);
1956						if (!(immuneGrp == GroupId:-1))
1957						{
1958							GroupId.AddGroupImmunity(curGrp, immuneGrp);
1959						}
1960					}
1961				}
1962			}
1963		}
1964		curLoading -= 1;
1965		CheckLoadAdmins();
1966		return void:0;
1967	}
1968	curLoading -= 1;
1969	CheckLoadAdmins();
1970	LogToFile(logFile, "Failed to retrieve groups from the database, %s", error);
1971	return void:0;
1972}
1973
1974public void:LoadGroupsOverrides(Database:db, DBResultSet:results, String:error[], any:data)
1975{
1976	if (results)
1977	{
1978		new String:sGroupName[128];
1979		new String:sType[16];
1980		new String:sCommand[64];
1981		new String:sAllowed[16];
1982		new OverrideRule:iRule;
1983		new OverrideType:iType;
1984		new KeyValues:groupsKV = KeyValues.KeyValues("Groups", "", "");
1985		KeyValues.ImportFromFile(groupsKV, groupsLoc);
1986		new GroupId:curGrp = -1;
1987		while (DBResultSet.FetchRow(results))
1988		{
1989			if (!(DBResultSet.IsFieldNull(results, 0)))
1990			{
1991				DBResultSet.FetchString(results, 0, sGroupName, 128, 0);
1992				TrimString(sGroupName);
1993				if (strlen(sGroupName))
1994				{
1995					DBResultSet.FetchString(results, 1, sType, 16, 0);
1996					DBResultSet.FetchString(results, 2, sCommand, 64, 0);
1997					DBResultSet.FetchString(results, 3, sAllowed, 16, 0);
1998					curGrp = FindAdmGroup(sGroupName);
1999					if (!(curGrp == GroupId:-1))
2000					{
2001						new var1;
2002						if (StrEqual(sAllowed, "allow", true))
2003						{
2004							var1 = 1;
2005						}
2006						else
2007						{
2008							var1 = 0;
2009						}
2010						iRule = var1;
2011						new var2;
2012						if (StrEqual(sType, "group", true))
2013						{
2014							var2 = 2;
2015						}
2016						else
2017						{
2018							var2 = 1;
2019						}
2020						iType = var2;
2021						if (KeyValues.JumpToKey(groupsKV, sGroupName, false))
2022						{
2023							KeyValues.JumpToKey(groupsKV, "Overrides", true);
2024							if (iType == OverrideType:1)
2025							{
2026								KeyValues.SetString(groupsKV, sCommand, sAllowed);
2027							}
2028							else
2029							{
2030								Format(sCommand, 64, "@%s", sCommand);
2031								KeyValues.SetString(groupsKV, sCommand, sAllowed);
2032							}
2033							KeyValues.Rewind(groupsKV);
2034						}
2035						GroupId.AddCommandOverride(curGrp, sCommand, iType, iRule);
2036					}
2037				}
2038			}
2039		}
2040		curLoading -= 1;
2041		CheckLoadAdmins();
2042		if (backupConfig)
2043		{
2044			KeyValues.ExportToFile(groupsKV, groupsLoc);
2045		}
2046		CloseHandle(groupsKV);
2047		groupsKV = MissingTAG:0;
2048		return void:0;
2049	}
2050	curLoading -= 1;
2051	CheckLoadAdmins();
2052	LogToFile(logFile, "Failed to retrieve group overrides from the database, %s", error);
2053	return void:0;
2054}
2055
2056public void:OverridesDone(Database:db, DBResultSet:results, String:error[], any:data)
2057{
2058	if (results)
2059	{
2060		new KeyValues:hKV = KeyValues.KeyValues("SB_Overrides", "", "");
2061		new String:sFlags[32];
2062		new String:sName[64];
2063		new String:sType[64];
2064		while (DBResultSet.FetchRow(results))
2065		{
2066			DBResultSet.FetchString(results, 0, sType, 64, 0);
2067			DBResultSet.FetchString(results, 1, sName, 64, 0);
2068			DBResultSet.FetchString(results, 2, sFlags, 32, 0);
2069			if (!sFlags[0])
2070			{
2071				sFlags[0] = MissingTAG:32;
2072				sFlags[0] = MissingTAG:0;
2073			}
2074			if (StrEqual(sType, "command", true))
2075			{
2076				AddCommandOverride(sName, OverrideType:1, ReadFlagString(sFlags, 0));
2077				KeyValues.JumpToKey(hKV, "override_commands", true);
2078				KeyValues.SetString(hKV, sName, sFlags);
2079				KeyValues.GoBack(hKV);
2080			}
2081			else
2082			{
2083				if (StrEqual(sType, "group", true))
2084				{
2085					AddCommandOverride(sName, OverrideType:2, ReadFlagString(sFlags, 0));
2086					KeyValues.JumpToKey(hKV, "override_groups", true);
2087					KeyValues.SetString(hKV, sName, sFlags);
2088					KeyValues.GoBack(hKV);
2089				}
2090			}
2091		}
2092		KeyValues.Rewind(hKV);
2093		if (backupConfig)
2094		{
2095			KeyValues.ExportToFile(hKV, overridesLoc);
2096		}
2097		CloseHandle(hKV);
2098		hKV = MissingTAG:0;
2099		return void:0;
2100	}
2101	LogToFile(logFile, "Failed to retrieve overrides from the database, %s", error);
2102	ParseBackupConfig_Overrides();
2103	return void:0;
2104}
2105
2106public Action:ClientRecheck(Handle:timer, any:client)
2107{
2108	new String:Authid[64];
2109	new var1;
2110	if (!PlayerStatus[client] && IsClientConnected(client) && GetClientAuthId(client, AuthIdType:1, Authid, 64, true))
2111	{
2112		OnClientAuthorized(client, Authid);
2113	}
2114	PlayerRecheck[client] = 0;
2115	return Action:4;
2116}
2117
2118public Action:ProcessQueue(Handle:timer, any:data)
2119{
2120	new String:buffer[512];
2121	Format(buffer, 512, "SELECT steam_id, time, start_time, reason, name, ip, admin_id, admin_ip FROM queue");
2122	Database.Query(SQLiteDB, SQLQueryCallback:117, buffer, any:0, DBPriority:1);
2123	return Action:0;
2124}
2125
2126void:InitializeConfigParser()
2127{
2128	if (!ConfigParser)
2129	{
2130		ConfigParser = SMCParser.SMCParser();
2131		SMCParser.OnEnterSection.set(ConfigParser, ReadConfig_NewSection);
2132		SMCParser.OnKeyValue.set(ConfigParser, ReadConfig_KeyValue);
2133		SMCParser.OnLeaveSection.set(ConfigParser, ReadConfig_EndSection);
2134	}
2135	return void:0;
2136}
2137
2138void:InternalReadConfig(String:path[])
2139{
2140	ConfigState = MissingTAG:0;
2141	new SMCError:err = SMCParser.ParseFile(ConfigParser, path, 0, 0);
2142	if (err)
2143	{
2144		new String:buffer[64];
2145		new var1;
2146		if (SMCParser.GetErrorString(ConfigParser, err, buffer, 64))
2147		{
2148			var1[0] = buffer;
2149		}
2150		else
2151		{
2152			var1[0] = 15872;
2153		}
2154		PrintToServer("%s", var1);
2155	}
2156	return void:0;
2157}
2158
2159public SMCResult:ReadConfig_NewSection(SMCParser:smc, String:name[], bool:opt_quotes)
2160{
2161	if (name[0])
2162	{
2163		if (strcmp("Config", name, false))
2164		{
2165			if (strcmp("BanReasons", name, false))
2166			{
2167				if (strcmp("HackingReasons", name, false))
2168				{
2169					if (!(strcmp("BanTime", name, false)))
2170					{
2171						ConfigState = MissingTAG:4;
2172					}
2173				}
2174				ConfigState = MissingTAG:3;
2175			}
2176			ConfigState = MissingTAG:2;
2177		}
2178		ConfigState = MissingTAG:1;
2179	}
2180	return SMCResult:0;
2181}
2182
2183public SMCResult:ReadConfig_KeyValue(SMCParser:smc, String:key[], String:value[], bool:key_quotes, bool:value_quotes)
2184{
2185	if (!key[0])
2186	{
2187		return SMCResult:0;
2188	}
2189	switch (ConfigState)
2190	{
2191		case 1:
2192		{
2193			if (strcmp("website", key, false))
2194			{
2195				if (strcmp("Addban", key, false))
2196				{
2197					if (strcmp("AutoAddServer", key, false))
2198					{
2199						if (strcmp("Unban", key, false))
2200						{
2201							if (strcmp("DatabasePrefix", key, false))
2202							{
2203								if (strcmp("RetryTime", key, false))
2204								{
2205									if (strcmp("ProcessQueueTime", key, false))
2206									{
2207										if (strcmp("BackupConfigs", key, false))
2208										{
2209											if (strcmp("EnableAdmins", key, false))
2210											{
2211												if (strcmp("RequireSiteLogin", key, false))
2212												{
2213													if (!(strcmp("ServerID", key, false)))
2214													{
2215														serverID = StringToInt(value, 10);
2216													}
2217												}
2218												requireSiteLogin = StringToInt(value, 10) == 1;
2219											}
2220											enableAdmins = StringToInt(value, 10) == 1;
2221										}
2222										backupConfig = StringToInt(value, 10) == 1;
2223									}
2224									ProcessQueueTime = StringToInt(value, 10);
2225								}
2226								RetryTime = StringToFloat(value);
2227								if (RetryTime < 15.0)
2228								{
2229									RetryTime = 15.0;
2230								}
2231								else
2232								{
2233									if (RetryTime > 60.0)
2234									{
2235										RetryTime = 60.0;
2236									}
2237								}
2238							}
2239							strcopy(DatabasePrefix, 10, value);
2240							if (DatabasePrefix[0])
2241							{
2242							}
2243						}
2244						if (StringToInt(value, 10))
2245						{
2246						}
2247						else
2248						{
2249							CommandDisable = CommandDisable | 2;
2250						}
2251					}
2252					AutoAdd = StringToInt(value, 10) == 1;
2253				}
2254				if (StringToInt(value, 10))
2255				{
2256				}
2257				else
2258				{
2259					CommandDisable = CommandDisable | 1;
2260				}
2261			}
2262			else
2263			{
2264				strcopy(WebsiteAddress, 128, value);
2265			}
2266		}
2267		case 2:
2268		{
2269			if (ReasonMenuHandle)
2270			{
2271				AddMenuItem(ReasonMenuHandle, key, value, 0);
2272			}
2273		}
2274		case 3:
2275		{
2276			if (HackingMenuHandle)
2277			{
2278				AddMenuItem(HackingMenuHandle, key, value, 0);
2279			}
2280		}
2281		case 4:
2282		{
2283			new var1;
2284			if (StringToInt(key, 10) > -1 && TimeMenuHandle)
2285			{
2286				AddMenuItem(TimeMenuHandle, key, value, 0);
2287			}
2288		}
2289		default:
2290		{
2291		}
2292	}
2293	return SMCResult:0;
2294}
2295
2296public SMCResult:ReadConfig_EndSection(SMCParser:smc)
2297{
2298	return SMCResult:0;
2299}
2300
2301public Native_SBBanPlayer(Handle:plugin, numParams)
2302{
2303	new client = GetNativeCell(1);
2304	new target = GetNativeCell(2);
2305	new time = GetNativeCell(3);
2306	new String:reason[128];
2307	GetNativeString(4, reason, 128, 0);
2308	if (!reason[0])
2309	{
2310		strcopy(reason, 128, "Banned by SourceBans");
2311	}
2312	new var1;
2313	if (client && IsClientInGame(client))
2314	{
2315		new AdminId:aid = GetUserAdmin(client);
2316		if (aid == AdminId:-1)
2317		{
2318			ThrowNativeError(23, "Ban Error: Player is not an admin.");
2319			return 0;
2320		}
2321		if (!AdminId.HasFlag(aid, AdminFlag:3, AdmAccessMode:1))
2322		{
2323			ThrowNativeError(23, "Ban Error: Player does not have BAN flag.");
2324			return 0;
2325		}
2326	}
2327	PrepareBan(client, target, time, reason, 128);
2328	return 1;
2329}
2330
2331public Native_SBReportPlayer(Handle:plugin, numParams)
2332{
2333	if (numParams < 3)
2334	{
2335		ThrowNativeError(23, "Invalid amount of arguments. Received %d arguments", numParams);
2336		return 0;
2337	}
2338	new iReporter = GetNativeCell(1);
2339	new iTarget = GetNativeCell(2);
2340	new iReasonLen;
2341	new iTime = GetTime({0,0});
2342	GetNativeStringLength(3, iReasonLen);
2343	iReasonLen++;
2344	new sReason[iReasonLen];
2345	GetNativeString(3, sReason, iReasonLen, 0);
2346	new String:sRAuth[32];
2347	new String:sTAuth[32];
2348	new String:sRName[36];
2349	new String:sTName[36];
2350	new String:sRIP[16];
2351	new String:sTIP[16];
2352	new String:sREscapedName[68];
2353	new String:sTEscapedName[68];
2354	new sEscapedReason[iReasonLen * 2 + 1];
2355	GetClientAuthId(iReporter, AuthIdType:1, sRAuth, 32, true);
2356	GetClientAuthId(iTarget, AuthIdType:1, sTAuth, 32, true);
2357	GetClientName(iReporter, sRName, 33);
2358	GetClientName(iTarget, sTName, 33);
2359	GetClientIP(iReporter, sRIP, 16, true);
2360	GetClientIP(iTarget, sTIP, 16, true);
2361	Database.Escape(DB, sRName, sREscapedName, 65, 0);
2362	Database.Escape(DB, sTName, sTEscapedName, 65, 0);
2363	Database.Escape(DB, sReason, sEscapedReason, iReasonLen * 2 + 1, 0);
2364	new sQuery[iReasonLen * 2 + 513];
2365	new var1;
2366	if (serverID != -1)
2367	{
2368		var1 = serverID;
2369	}
2370	else
2371	{
2372		var1 = 0;
2373	}
2374	Format(sQuery, iReasonLen * 2 + 513, "INSERT INTO %s_submissions (`submitted`, `modid`, `SteamId`, `name`, `email`, `reason`, `ip`, `subname`, `sip`, `archiv`, `server`)VALUES ('%d', 0, '%s', '%s', '%s', '%s', '%s', '%s', '%s', 0, '%d')", DatabasePrefix, iTime, sTAuth, sTEscapedName, sRAuth, sEscapedReason, sRIP, sREscapedName, sTIP, var1);
2375	new DataPack:dataPack = DataPack.DataPack();
2376	DataPack.WriteCell(dataPack, iReporter);
2377	DataPack.WriteCell(dataPack, iTarget);
2378	DataPack.WriteCell(dataPack, iReasonLen);
2379	DataPack.WriteString(dataPack, sReason);
2380	Database.Query(DB, SQLQueryCallback:129, sQuery, dataPack, DBPriority:1);
2381	return 0;
2382}
2383
2384public void:SQL_OnReportPlayer(Database:db, DBResultSet:results, String:error[], DataPack:dataPack)
2385{
2386	if (results)
2387	{
2388		DataPack.Reset(dataPack, false);
2389		new iReporter = DataPack.ReadCell(dataPack);
2390		new iTarget = DataPack.ReadCell(dataPack);
2391		new iReasonLen = DataPack.ReadCell(dataPack);
2392		new sReason[iReasonLen];
2393		DataPack.ReadString(dataPack, sReason, iReasonLen);
2394		CloseHandle(dataPack);
2395		dataPack = MissingTAG:0;
2396		Call_StartForward(g_hFwd_OnReportAdded);
2397		Call_PushCell(iReporter);
2398		Call_PushCell(iTarget);
2399		Call_PushString(sReason);
2400		Call_Finish(0);
2401	}
2402	else
2403	{
2404		LogToFile(logFile, "Failed to submit report: %s", error);
2405	}
2406	return void:0;
2407}
2408
2409public void:InitializeBackupDB()
2410{
2411	new String:error[256];
2412	SQLiteDB = SQLite_UseDatabase("sourcebans-queue", error, 255);
2413	if (!SQLiteDB)
2414	{
2415		SetFailState(error);
2416	}
2417	SQL_LockDatabase(SQLiteDB);
2418	SQL_FastQuery(SQLiteDB, "CREATE TABLE IF NOT EXISTS queue (steam_id TEXT PRIMARY KEY ON CONFLICT REPLACE, time INTEGER, start_time INTEGER, reason TEXT, name TEXT, ip TEXT, admin_id TEXT, admin_ip TEXT);", -1);
2419	SQL_UnlockDatabase(SQLiteDB);
2420	return void:0;
2421}
2422
2423public bool:CreateBan(client, target, time, String:reason[])
2424{
2425	new String:adminIp[24];
2426	new String:adminAuth[64];
2427	new admin = client;
2428	if (!admin)
2429	{
2430		if (reason[0])
2431		{
2432			strcopy(adminAuth, 64, "STEAM_ID_SERVER");
2433			strcopy(adminIp, 24, ServerIp);
2434		}
2435		PrintToServer("%s%T", "[SourceBans++] ", "Include Reason", 0);
2436		return false;
2437	}
2438	else
2439	{
2440		GetClientIP(admin, adminIp, 24, true);
2441		GetClientAuthId(admin, AuthIdType:1, adminAuth, 64, true);
2442	}
2443	new String:ip[24];
2444	new String:auth[64];
2445	new String:name[64];
2446	GetClientName(target, name, 64);
2447	GetClientIP(target, ip, 24, true);
2448	if (!GetClientAuthId(target, AuthIdType:1, auth, 64, true))
2449	{
2450		return false;
2451	}
2452	decl userid;
2453	new var1;
2454	if (admin)
2455	{
2456		var1 = GetClientUserId(admin);
2457	}
2458	else
2459	{
2460		var1 = 0;
2461	}
2462	userid = var1;
2463	new DataPack:dataPack = DataPack.DataPack();
2464	new DataPack:reasonPack = DataPack.DataPack();
2465	WritePackString(reasonPack, reason);
2466	DataPack.WriteCell(dataPack, admin);
2467	DataPack.WriteCell(dataPack, target);
2468	DataPack.WriteCell(dataPack, userid);
2469	DataPack.WriteCell(dataPack, GetClientUserId(target));
2470	DataPack.WriteCell(dataPack, time);
2471	DataPack.WriteCell(dataPack, reasonPack);
2472	DataPack.WriteString(dataPack, name);
2473	DataPack.WriteString(dataPack, auth);
2474	DataPack.WriteString(dataPack, ip);
2475	DataPack.WriteString(dataPack, adminAuth);
2476	DataPack.WriteString(dataPack, adminIp);
2477	DataPack.Reset(dataPack, false);
2478	DataPack.Reset(reasonPack, false);
2479	if (reason[0])
2480	{
2481		if (DB)
2482		{
2483			UTIL_InsertBan(time, name, auth, ip, reason, adminAuth, adminIp, dataPack);
2484		}
2485		else
2486		{
2487			UTIL_InsertTempBan(time, name, auth, ip, reason, adminAuth, adminIp, dataPack);
2488		}
2489	}
2490	else
2491	{
2492		PlayerDataPack[admin] = dataPack;
2493		DisplayMenu(ReasonMenuHandle, admin, 0);
2494		ReplyToCommand(admin, "%c[%cSourceBans%c]%c %t", '\x04', '\x02', '\x04', '\x02', "Check Menu");
2495	}
2496	Call_StartForward(g_hFwd_OnBanAdded);
2497	Call_PushCell(client);
2498	Call_PushCell(target);
2499	Call_PushCell(time);
2500	Call_PushString(reason);
2501	Call_Finish(0);
2502	return true;
2503}
2504
2505void:UTIL_InsertBan(time, String:Name[], String:Authid[], String:Ip[], String:Reason[], String:AdminAuthid[], String:AdminIp[], DataPack:dataPack)
2506{
2507	new String:banName[128];
2508	new String:banReason[256];
2509	new String:Query[1024];
2510	Database.Escape(DB, Name, banName, 128, 0);
2511	Database.Escape(DB, Reason, banReason, 256, 0);
2512	if (serverID == -1)
2513	{
2514		FormatEx(Query, 1024, "INSERT INTO %s_bans (ip, authid, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES ('%s', '%s', '%s', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', IFNULL((SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'),'0'), '%s', (SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s' LIMIT 0,1), ' ')", DatabasePrefix, Ip, Authid, banName, time * 60, time * 60, banReason, DatabasePrefix, AdminAuthid, AdminAuthid[2], AdminIp, DatabasePrefix, ServerIp, ServerPort);
2515	}
2516	else
2517	{
2518		FormatEx(Query, 1024, "INSERT INTO %s_bans (ip, authid, name, created, ends, length, reason, aid, adminIp, sid, country) VALUES ('%s', '%s', '%s', UNIX_TIMESTAMP(), UNIX_TIMESTAMP() + %d, %d, '%s', IFNULL((SELECT aid FROM %s_admins WHERE authid = '%s' OR authid REGEXP '^STEAM_[0-9]:%s$'),'0'), '%s', %d, ' ')", DatabasePrefix, Ip, Authid, banName, time * 60, time * 60, banReason, DatabasePrefix, AdminAuthid, AdminAuthid[2], AdminIp, serverID);
2519	}
2520	Database.Query(DB, SQLQueryCallback:141, Query, dataPack, DBPriority:0);
2521	return void:0;
2522}
2523
2524void:UTIL_InsertTempBan(time, String:name[], String:auth[], String:ip[], String:reason[], String:adminAuth[], String:adminIp[], DataPack:dataPack)
2525{
2526	new admin = DataPack.ReadCell(dataPack);
2527	new client = DataPack.ReadCell(dataPack);
2528	DataPack.ReadCell(dataPack);
2529	DataPack.ReadCell(dataPack);
2530	DataPack.ReadCell(dataPack);
2531	new DataPack:reasonPack = DataPack.ReadCell(dataPack);
2532	if (reasonPack)
2533	{
2534		CloseHandle(reasonPack);
2535		reasonPack = MissingTAG:0;
2536	}
2537	CloseHandle(dataPack);
2538	dataPack = MissingTAG:0;
2539	new String:buffer[52];
2540	Format(buffer, 50, "banid %d %s", ProcessQueueTime, auth);
2541	ServerCommand(buffer);
2542	if (IsClientInGame(client))
2543	{
2544		new String:length[32];
2545		if (time)
2546		{
2547			new var1;
2548			if (time == 1)
2549			{
2550				var1[0] = 17444;
2551			}
2552			else
2553			{
2554				var1[0] = 17452;
2555			}
2556			FormatEx(length, 32, "%d %s", time, var1);
2557		}
2558		else
2559		{
2560			FormatEx(length, 32, "permament");
2561		}
2562		KickClient(client, "%t\n\n%t", "Banned Check Site", WebsiteAddress, "Kick Reason", admin, reason, length);
2563	}
2564	new String:banName[128];
2565	new String:banReason[256];
2566	new String:query[512];
2567	Database.Escape(SQLiteDB, name, banName, 128, 0);
2568	Database.Escape(SQLiteDB, reason, banReason, 256, 0);
2569	FormatEx(query, 512, "INSERT INTO queue VALUES ('%s', %i, %i, '%s', '%s', '%s', '%s', '%s')", auth, time, GetTime({0,0}), banReason, banName, ip, adminAuth, adminIp);
2570	Database.Query(SQLiteDB, SQLQueryCallback:61, query, any:0, DBPriority:1);
2571	return void:0;
2572}
2573
2574void:CheckLoadAdmins()
2575{
2576	new i = 1;
2577	while (i <= MaxClients)
2578	{
2579		new var1;
2580		if (IsClientInGame(i) && IsClientAuthorized(i))
2581		{
2582			RunAdminCacheChecks(i);
2583			NotifyPostAdminCheck(i);
2584		}
2585		i++;
2586	}
2587	return void:0;
2588}
2589
2590void:InsertServerInfo()
2591{
2592	if (DB)
2593	{
2594		new String:query[100];
2595		new pieces[4];
2596		new longip = ConVar.IntValue.get(CvarHostIp);
2597		pieces[0] = longip >>> 24 & 255;
2598		pieces[1] = longip >>> 16 & 255;
2599		pieces[2] = longip >>> 8 & 255;
2600		pieces[3] = longip & 255;
2601		FormatEx(ServerIp, 24, "%d.%d.%d.%d", pieces, pieces[1], pieces[2], pieces[3]);
2602		ConVar.GetString(CvarPort, ServerPort, 7);
2603		if (AutoAdd)
2604		{
2605			FormatEx(query, 100, "SELECT sid FROM %s_servers WHERE ip = '%s' AND port = '%s'", DatabasePrefix, ServerIp, ServerPort);
2606			Database.Query(DB, SQLQueryCallback:137, query, any:0, DBPriority:1);
2607		}
2608		return void:0;
2609	}
2610	return void:0;
2611}
2612
2613void:PrepareBan(client, target, time, String:reason[], size)
2614{
2615	new var1;
2616	if (!target || !IsClientInGame(target))
2617	{
2618		return void:0;
2619	}
2620	new String:authid[64];
2621	new String:name[32];
2622	new String:bannedSite[512];
2623	if (!GetClientAuthId(target, AuthIdType:1, authid, 64, true))
2624	{
2625		return void:0;
2626	}
2627	GetClientName(target, name, 32);
2628	if (CreateBan(client, target, time, reason))
2629	{
2630		if (!time)
2631		{
2632			if (reason[0])
2633			{
2634				ShowActivity(client, "%t", "Permabanned player reason", name, reason);
2635			}
2636			else
2637			{
2638				ShowActivity(client, "%t", "Permabanned player", name);
2639			}
2640		}
2641		else
2642		{
2643			if (reason[0])
2644			{
2645				ShowActivity(client, "%t", "Banned player reason", name, time, reason);
2646			}
2647			ShowActivity(client, "%t", "Banned player", name, time);
2648		}
2649		LogAction(client, target, "\"%L\" banned \"%L\" (minutes \"%d\") (reason \"%s\")", client, target, time, reason);
2650		new String:length[32];
2651		if (time)
2652		{
2653			new var2;
2654			if (time == 1)
2655			{
2656				var2[0] = 17816;
2657			}
2658			else
2659			{
2660				var2[0] = 17824;
2661			}
2662			FormatEx(length, 32, "%d %s", time, var2);
2663		}
2664		else
2665		{
2666			FormatEx(length, 32, "permament");
2667		}
2668		new var3;
2669		if (time > 5 || time)
2670		{
2671			time = 5;
2672		}
2673		Format(bannedSite, 512, "%t\n\n%t", "Banned Check Site", WebsiteAddress, "Kick Reason", client, reason, length);
2674		BanClient(target, time, 1, bannedSite, bannedSite, "sm_ban", client);
2675	}
2676	g_BanTarget[client] = -1;
2677	g_BanTime[client] = -1;
2678	return void:0;
2679}
2680
2681void:ReadConfig()
2682{
2683	InitializeConfigParser();
2684	if (ConfigParser)
2685	{
2686		new String:ConfigFile[256];
2687		BuildPath(PathType:0, ConfigFile, 256, "configs/sourcebans/sourcebans.cfg");
2688		if (FileExists(ConfigFile, false, "GAME"))
2689		{
2690			InternalReadConfig(ConfigFile);
2691			PrintToServer("%sLoading configs/sourcebans.cfg config file", "[SourceBans++] ");
2692		}
2693		else
2694		{
2695			new String:Error[320];
2696			FormatEx(Error, 320, "%sFATAL *** ERROR *** can not find %s", "[SourceBans++] ", ConfigFile);
2697			LogToFile(logFile, "FATAL *** ERROR *** can not find %s", ConfigFile);
2698			SetFailState(Error);
2699		}
2700		return void:0;
2701	}
2702	return void:0;
2703}
2704
2705void:ResetSettings()
2706{
2707	CommandDisable = 0;
2708	ResetMenu();
2709	ReadConfig();
2710	return void:0;
2711}
2712
2713void:ParseBackupConfig_Overrides()
2714{
2715	new KeyValues:hKV = KeyValues.KeyValues("SB_Overrides", "", "");
2716	if (!KeyValues.ImportFromFile(hKV, overridesLoc))
2717	{
2718		return void:0;
2719	}
2720	if (!KeyValues.GotoFirstSubKey(hKV, true))
2721	{
2722		return void:0;
2723	}
2724	new String:sSection[16];
2725	new String:sFlags[32];
2726	new String:sName[64];
2727	new OverrideType:type;
2728	do {
2729		KeyValues.GetSectionName(hKV, sSection, 16);
2730		if (StrEqual(sSection, "override_commands", true))
2731		{
2732			type = MissingTAG:1;
2733		}
2734		else
2735		{
2736			if (StrEqual(sSection, "override_groups", true))
2737			{
2738				type = MissingTAG:2;
2739			}
2740		}
2741		if (KeyValues.GotoFirstSubKey(hKV, false))
2742		{
2743			do {
2744				KeyValues.GetSectionName(hKV, sName, 64);
2745				KeyValues.GetString(hKV, NULL_STRING, sFlags, 32, "");
2746				AddCommandOverride(sName, type, ReadFlagString(sFlags, 0));
2747			} while (KeyValues.GotoNextKey(hKV, false));
2748			KeyValues.GoBack(hKV);
2749		}
2750	} while (KeyValues.GotoNextKey(hKV, true));
2751	CloseHandle(hKV);
2752	hKV = MissingTAG:0;
2753	return void:0;
2754}
2755
2756AdminFlag:CreateFlagLetters(_arg0)
2757{
2758	new AdminFlag:FlagLetters[26];
2759	FlagLetters + 4/* ERROR unknown load Binary */ = 1;
2760	FlagLetters + 8/* ERROR unknown load Binary */ = 2;
2761	FlagLetters + 12/* ERROR unknown load Binary */ = 3;
2762	FlagLetters + 16/* ERROR unknown load Binary */ = 4;
2763	FlagLetters + 20/* ERROR unknown load Binary */ = 5;
2764	FlagLetters + 24/* ERROR unknown load Binary */ = 6;
2765	FlagLetters + 28/* ERROR unknown load Binary */ = 7;
2766	FlagLetters + 32/* ERROR unknown load Binary */ = 8;
2767	FlagLetters + 36/* ERROR unknown load Binary */ = 9;
2768	FlagLetters + 40/* ERROR unknown load Binary */ = 10;
2769	FlagLetters + 44/* ERROR unknown load Binary */ = 11;
2770	FlagLetters + 48/* ERROR unknown load Binary */ = 12;
2771	FlagLetters + 52/* ERROR unknown load Binary */ = 13;
2772	FlagLetters + 56/* ERROR unknown load Binary */ = 15;
2773	FlagLetters + 60/* ERROR unknown load Binary */ = 16;
2774	FlagLetters + 64/* ERROR unknown load Binary */ = 17;
2775	FlagLetters + 68/* ERROR unknown load Binary */ = 18;
2776	FlagLetters + 72/* ERROR unknown load Binary */ = 19;
2777	FlagLetters + 76/* ERROR unknown load Binary */ = 20;
2778	FlagLetters + 100/* ERROR unknown load Binary */ = 14;
2779	return FlagLetters;
2780}
2781
2782void:AccountForLateLoading()
2783{
2784	new String:auth[32];
2785	new i = 1;
2786	while (i <= MaxClients)
2787	{
2788		new var1;
2789		if (IsClientConnected(i) && !IsFakeClient(i))
2790		{
2791			PlayerStatus[i] = 0;
2792		}
2793		new var2;
2794		if (IsClientInGame(i) && !IsFakeClient(i) && IsClientAuthorized(i) && GetClientAuthId(i, AuthIdType:1, auth, 30, true))
2795		{
2796			OnClientAuthorized(i, auth);
2797		}
2798		i++;
2799	}
2800	return void:0;
2801}