1419 lines
30 KiB
SourcePawn
1419 lines
30 KiB
SourcePawn
/**
|
|
* -----------------------------------------------------
|
|
* File calladmin.sp
|
|
* Authors Impact, dordnung
|
|
* License GPLv3
|
|
* Web http://gugyclan.eu, https://dordnung.de
|
|
* -----------------------------------------------------
|
|
*
|
|
* CallAdmin
|
|
* Copyright (C) 2013-2018 Impact, dordnung
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
#include <sourcemod>
|
|
#include "include/autoexecconfig"
|
|
#include "include/calladmin"
|
|
#include "include/calladmin_stocks"
|
|
|
|
#undef REQUIRE_PLUGIN
|
|
#include <clientprefs>
|
|
#pragma semicolon 1
|
|
#pragma newdecls required
|
|
|
|
|
|
|
|
// Banreasons
|
|
ArrayList g_hReasonAdt;
|
|
char g_sReasonConfigFile[PLATFORM_MAX_PATH];
|
|
|
|
|
|
// Global Stuff
|
|
ConVar g_hServerName;
|
|
char g_sServerName[64];
|
|
|
|
ConVar g_hVersion;
|
|
|
|
ConVar g_hHostPort;
|
|
int g_iHostPort;
|
|
|
|
ConVar g_hHostIP;
|
|
char g_sHostIP[16];
|
|
|
|
Handle g_hAdvertTimer;
|
|
ConVar g_hAdvertInterval;
|
|
float g_fAdvertInterval;
|
|
|
|
ConVar g_hPublicMessage;
|
|
bool g_bPublicMessage;
|
|
|
|
ConVar g_hOwnReason;
|
|
bool g_bOwnReason;
|
|
|
|
ConVar g_hConfirmCall;
|
|
bool g_bConfirmCall;
|
|
|
|
ConVar g_hSpamTime;
|
|
int g_iSpamTime;
|
|
|
|
ConVar g_hReportTime;
|
|
int g_iReportTime;
|
|
|
|
ConVar g_hAdminAction;
|
|
int g_iAdminAction;
|
|
|
|
|
|
|
|
// Report id used for handling
|
|
int g_iCurrentReportID;
|
|
|
|
// List of not handled IDs
|
|
ArrayList g_hActiveReports;
|
|
|
|
|
|
|
|
// Log file
|
|
char g_sLogFile[PLATFORM_MAX_PATH];
|
|
|
|
|
|
#define ADMIN_ACTION_PASS 0
|
|
#define ADMIN_ACTION_BLOCK_MESSAGE 1
|
|
|
|
|
|
int g_iCurrentTrackers;
|
|
|
|
|
|
|
|
// Current target info
|
|
g_iTarget[MAXPLAYERS + 1];
|
|
char g_sTargetReason[MAXPLAYERS + 1][REASON_MAX_LENGTH];
|
|
|
|
// Is this player writing his own reason?
|
|
bool g_bAwaitingReason[MAXPLAYERS +1];
|
|
|
|
// When has this user reported the last time
|
|
g_iLastReport[MAXPLAYERS +1];
|
|
|
|
// When was this user reported the last time?
|
|
g_iLastReported[MAXPLAYERS +1];
|
|
|
|
// Whether or not a client saw the antispam message
|
|
bool g_bSawMessage[MAXPLAYERS +1];
|
|
|
|
|
|
// Cookies
|
|
Handle g_hLastReportCookie;
|
|
Handle g_hLastReportedCookie;
|
|
|
|
|
|
// Api
|
|
Handle g_hOnReportPreForward;
|
|
Handle g_hOnReportPostForward;
|
|
Handle g_hOnDrawMenuForward;
|
|
Handle g_hOnDrawOwnReasonForward;
|
|
Handle g_hOnTrackerCountChangedForward;
|
|
Handle g_hOnDrawTargetForward;
|
|
Handle g_hOnAddToAdminCountForward;
|
|
Handle g_hOnServerDataChangedForward;
|
|
Handle g_hOnLogMessageForward;
|
|
Handle g_hOnReportHandledForward;
|
|
|
|
|
|
|
|
public Plugin myinfo =
|
|
{
|
|
name = "CallAdmin",
|
|
author = "Impact, dordnung",
|
|
description = "Call an Admin for help",
|
|
version = CALLADMIN_VERSION,
|
|
url = "http://gugyclan.eu"
|
|
}
|
|
|
|
|
|
|
|
public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max)
|
|
{
|
|
RegPluginLibrary("calladmin");
|
|
|
|
|
|
// Api
|
|
CreateNative("CallAdmin_GetTrackersCount", Native_GetCurrentTrackers);
|
|
CreateNative("CallAdmin_RequestTrackersCountRefresh", Native_RequestTrackersCountRefresh);
|
|
CreateNative("CallAdmin_GetHostName", Native_GetHostName);
|
|
CreateNative("CallAdmin_GetHostIP", Native_GetHostIP);
|
|
CreateNative("CallAdmin_GetHostPort", Native_GetHostPort);
|
|
CreateNative("CallAdmin_ReportClient", Native_ReportClient);
|
|
CreateNative("CallAdmin_LogMessage", Native_LogMessage);
|
|
CreateNative("CallAdmin_GetReportID", Native_GetReportID);
|
|
|
|
|
|
return APLRes_Success;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public int Native_GetCurrentTrackers(Handle plugin, int numParams)
|
|
{
|
|
return g_iCurrentTrackers;
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_RequestTrackersCountRefresh(Handle plugin, int numParams)
|
|
{
|
|
Timer_UpdateTrackersCount(null);
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_GetHostName(Handle plugin, int numParams)
|
|
{
|
|
int max_size = GetNativeCell(2);
|
|
SetNativeString(1, g_sServerName, max_size);
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_GetHostIP(Handle plugin, int numParams)
|
|
{
|
|
int max_size = GetNativeCell(2);
|
|
SetNativeString(1, g_sHostIP, max_size);
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_GetHostPort(Handle plugin, int numParams)
|
|
{
|
|
return g_iHostPort;
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_ReportClient(Handle plugin, int numParams)
|
|
{
|
|
int client;
|
|
int target;
|
|
char sReason[REASON_MAX_LENGTH];
|
|
|
|
client = GetNativeCell(1);
|
|
target = GetNativeCell(2);
|
|
GetNativeString(3, sReason, sizeof(sReason));
|
|
|
|
|
|
// We check for the REPORTER_CONSOLE define here, if this is set we have no valid client and the report comes from server
|
|
if (!IsClientValid(client) && client != REPORTER_CONSOLE)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!IsClientValid(target))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!Forward_OnReportPre(client, target, sReason))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
g_iCurrentReportID++;
|
|
g_hActiveReports.Push(g_iCurrentReportID);
|
|
|
|
Forward_OnReportPost(client, target, sReason);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_LogMessage(Handle plugin, int numParams)
|
|
{
|
|
char sPluginName[64];
|
|
char sMessage[256];
|
|
GetPluginInfo(plugin, PlInfo_Name, sPluginName, sizeof(sPluginName));
|
|
|
|
FormatNativeString(0, 1, 2, sizeof(sMessage), _, sMessage);
|
|
|
|
LogToFileEx(g_sLogFile, "[%s] %s", sPluginName, sMessage);
|
|
|
|
Forward_OnLogMessage(plugin, sMessage);
|
|
}
|
|
|
|
|
|
|
|
|
|
public int Native_GetReportID(Handle plugin, int numParams)
|
|
{
|
|
return g_iCurrentReportID;
|
|
}
|
|
|
|
|
|
|
|
|
|
public void OnConfigsExecuted()
|
|
{
|
|
g_iHostPort = g_hHostPort.IntValue;
|
|
UpdateHostIp();
|
|
|
|
g_hServerName.GetString(g_sServerName, sizeof(g_sServerName));
|
|
g_bPublicMessage = g_hPublicMessage.BoolValue;
|
|
g_bOwnReason = g_hOwnReason.BoolValue;
|
|
g_bConfirmCall = g_hConfirmCall.BoolValue;
|
|
g_iSpamTime = g_hSpamTime.IntValue;
|
|
g_iReportTime = g_hReportTime.IntValue;
|
|
g_iAdminAction = g_hAdminAction.IntValue;
|
|
|
|
g_fAdvertInterval = g_hAdvertInterval.FloatValue;
|
|
|
|
delete g_hAdvertTimer;
|
|
|
|
if (g_fAdvertInterval != 0.0)
|
|
{
|
|
g_hAdvertTimer = CreateTimer(g_fAdvertInterval, Timer_Advert, _, TIMER_REPEAT);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public void OnPluginStart()
|
|
{
|
|
BuildPath(Path_SM, g_sLogFile, sizeof(g_sLogFile), "logs/calladmin.log");
|
|
|
|
g_hHostPort = FindConVar("hostport");
|
|
g_hHostIP = FindConVar("hostip");
|
|
g_hServerName = FindConVar("hostname");
|
|
|
|
|
|
if (g_hHostPort == null)
|
|
{
|
|
CallAdmin_LogMessage("Couldn't find cvar 'hostport'");
|
|
SetFailState("Couldn't find cvar 'hostport'");
|
|
}
|
|
|
|
if (g_hHostIP == null)
|
|
{
|
|
CallAdmin_LogMessage("Couldn't find cvar 'hostip'");
|
|
SetFailState("Couldn't find cvar 'hostip'");
|
|
}
|
|
|
|
if (g_hServerName == null)
|
|
{
|
|
CallAdmin_LogMessage("Couldn't find cvar 'hostname'");
|
|
SetFailState("Couldn't find cvar 'hostname'");
|
|
}
|
|
|
|
|
|
RegConsoleCmd("sm_call", Command_Call);
|
|
RegConsoleCmd("sm_calladmin", Command_Call);
|
|
|
|
RegConsoleCmd("sm_call_handle", Command_HandleCall);
|
|
RegConsoleCmd("sm_calladmin_handle", Command_HandleCall);
|
|
|
|
RegConsoleCmd("sm_calladmin_reload", Command_Reload);
|
|
|
|
|
|
AutoExecConfig_SetFile("plugin.calladmin");
|
|
|
|
g_hVersion = AutoExecConfig_CreateConVar("sm_calladmin_version", CALLADMIN_VERSION, "Plugin version", FCVAR_NOTIFY|FCVAR_DONTRECORD);
|
|
g_hAdvertInterval = AutoExecConfig_CreateConVar("sm_calladmin_advert_interval", "60.0", "Interval to advert the use of calladmin, 0.0 deactivates the feature", FCVAR_NONE, true, 0.0, true, 1800.0);
|
|
g_hPublicMessage = AutoExecConfig_CreateConVar("sm_calladmin_public_message", "0", "Whether or not a report should be notified to all players or only the reporter.", FCVAR_NONE, true, 0.0, true, 1.0);
|
|
g_hOwnReason = AutoExecConfig_CreateConVar("sm_calladmin_own_reason", "1", "Whether or not a client can submit their own reason.", FCVAR_NONE, true, 0.0, true, 1.0);
|
|
g_hConfirmCall = AutoExecConfig_CreateConVar("sm_calladmin_confirm_call", "1", "Whether or not a call must be confirmed by the client", FCVAR_NONE, true, 0.0, true, 1.0);
|
|
g_hSpamTime = AutoExecConfig_CreateConVar("sm_calladmin_spamtime", "25", "An user must wait this many seconds after a report before he can issue a new one", FCVAR_NONE, true, 0.0);
|
|
g_hReportTime = AutoExecConfig_CreateConVar("sm_calladmin_reporttime", "300", "An user cannot be reported again for this many seconds", FCVAR_NONE, true, 0.0);
|
|
g_hAdminAction = AutoExecConfig_CreateConVar("sm_calladmin_admin_action", "0", "What happens when admins are in-game on report: 0 - Do nothing, let the report pass, 1 - Block the report and notify the caller and admins in-game about it", FCVAR_NONE, true, 0.0, true, 1.0);
|
|
|
|
|
|
|
|
AutoExecConfig(true, "plugin.CallAdmin");
|
|
AutoExecConfig_CleanFile();
|
|
|
|
|
|
LoadTranslations("calladmin.phrases");
|
|
|
|
// This is done so that when the plugin is updated its version stays up to date too
|
|
g_hVersion.SetString(CALLADMIN_VERSION, false, false);
|
|
g_hVersion.AddChangeHook(OnCvarChanged);
|
|
|
|
|
|
g_hServerName.AddChangeHook(OnCvarChanged);
|
|
g_hHostPort.AddChangeHook(OnCvarChanged);
|
|
g_hHostIP.AddChangeHook(OnCvarChanged);
|
|
g_hAdvertInterval.AddChangeHook(OnCvarChanged);
|
|
g_hPublicMessage.AddChangeHook(OnCvarChanged);
|
|
g_hOwnReason.AddChangeHook(OnCvarChanged);
|
|
g_hConfirmCall.AddChangeHook(OnCvarChanged);
|
|
g_hSpamTime.AddChangeHook(OnCvarChanged);
|
|
g_hReportTime.AddChangeHook(OnCvarChanged);
|
|
g_hAdminAction.AddChangeHook(OnCvarChanged);
|
|
|
|
|
|
// Modules must create their own updaters
|
|
CreateTimer(10.0, Timer_UpdateTrackersCount, _, TIMER_REPEAT);
|
|
|
|
|
|
// Used to allow a client to input their own reason
|
|
AddCommandListener(ChatListener, "say");
|
|
AddCommandListener(ChatListener, "say2");
|
|
AddCommandListener(ChatListener, "say_team");
|
|
|
|
|
|
// Api
|
|
g_hOnReportPreForward = CreateGlobalForward("CallAdmin_OnReportPre", ET_Event, Param_Cell, Param_Cell, Param_String);
|
|
g_hOnReportPostForward = CreateGlobalForward("CallAdmin_OnReportPost", ET_Ignore, Param_Cell, Param_Cell, Param_String);
|
|
g_hOnDrawMenuForward = CreateGlobalForward("CallAdmin_OnDrawMenu", ET_Event, Param_Cell);
|
|
g_hOnDrawOwnReasonForward = CreateGlobalForward("CallAdmin_OnDrawOwnReason", ET_Event, Param_Cell);
|
|
g_hOnTrackerCountChangedForward = CreateGlobalForward("CallAdmin_OnTrackerCountChanged", ET_Ignore, Param_Cell, Param_Cell);
|
|
g_hOnDrawTargetForward = CreateGlobalForward("CallAdmin_OnDrawTarget", ET_Event, Param_Cell, Param_Cell);
|
|
g_hOnAddToAdminCountForward = CreateGlobalForward("CallAdmin_OnAddToAdminCount", ET_Event, Param_Cell);
|
|
g_hOnServerDataChangedForward = CreateGlobalForward("CallAdmin_OnServerDataChanged", ET_Ignore, Param_Cell, Param_Cell, Param_String, Param_String);
|
|
g_hOnLogMessageForward = CreateGlobalForward("CallAdmin_OnLogMessage", ET_Ignore, Param_Cell, Param_String);
|
|
g_hOnReportHandledForward = CreateGlobalForward("CallAdmin_OnReportHandled", ET_Ignore, Param_Cell, Param_Cell);
|
|
|
|
|
|
// Cookies
|
|
if (LibraryExists("clientprefs"))
|
|
{
|
|
g_hLastReportCookie = RegClientCookie("CallAdmin_LastReport", "Contains a timestamp when this user has reported the last time", CookieAccess_Private);
|
|
g_hLastReportedCookie = RegClientCookie("CallAdmin_LastReported", "Contains a timestamp when this user was reported the last time", CookieAccess_Private);
|
|
|
|
FetchClientCookies();
|
|
}
|
|
|
|
|
|
// Report handling
|
|
g_hActiveReports = new ArrayList();
|
|
|
|
// Reason handling
|
|
g_hReasonAdt = new ArrayList(ByteCountToCells(REASON_MAX_LENGTH));
|
|
|
|
BuildPath(Path_SM, g_sReasonConfigFile, sizeof(g_sReasonConfigFile), "configs/calladmin_reasons.cfg");
|
|
|
|
if (!FileExists(g_sReasonConfigFile))
|
|
{
|
|
CreateReasonList();
|
|
}
|
|
|
|
ParseReasonList();
|
|
}
|
|
|
|
|
|
|
|
|
|
void CreateReasonList()
|
|
{
|
|
File hFile;
|
|
hFile = OpenFile(g_sReasonConfigFile, "w");
|
|
|
|
if (hFile == null)
|
|
{
|
|
CallAdmin_LogMessage("Failed to open configfile 'calladmin_reasons.cfg' for writing");
|
|
SetFailState("Failed to open configfile 'calladmin_reasons.cfg' for writing");
|
|
}
|
|
|
|
hFile.WriteLine("// List of reasons seperated by a new line, max %d in length", REASON_MAX_LENGTH);
|
|
hFile.WriteLine("Aimbot");
|
|
hFile.WriteLine("Wallhack");
|
|
hFile.WriteLine("Speedhack");
|
|
hFile.WriteLine("Spinhack");
|
|
hFile.WriteLine("Multihack");
|
|
hFile.WriteLine("No-Recoil Hack");
|
|
hFile.WriteLine("Other");
|
|
|
|
hFile.Close();
|
|
}
|
|
|
|
|
|
|
|
|
|
void ParseReasonList()
|
|
{
|
|
File hFile;
|
|
|
|
hFile = OpenFile(g_sReasonConfigFile, "r");
|
|
|
|
|
|
if (hFile == null)
|
|
{
|
|
CallAdmin_LogMessage("Failed to open configfile 'calladmin_reasons.cfg' for reading");
|
|
SetFailState("Failed to open configfile 'calladmin_reasons.cfg' for reading");
|
|
}
|
|
|
|
|
|
// Buffer must be a little bit bigger to have enough room for possible comments and being able to check for too long reasons
|
|
char sReadBuffer[PLATFORM_MAX_PATH];
|
|
|
|
|
|
int len;
|
|
while (!hFile.EndOfFile() && hFile.ReadLine(sReadBuffer, sizeof(sReadBuffer)))
|
|
{
|
|
if (sReadBuffer[0] == '/' || IsCharSpace(sReadBuffer[0]))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ReplaceString(sReadBuffer, sizeof(sReadBuffer), "\n", "");
|
|
ReplaceString(sReadBuffer, sizeof(sReadBuffer), "\r", "");
|
|
ReplaceString(sReadBuffer, sizeof(sReadBuffer), "\t", "");
|
|
|
|
len = strlen(sReadBuffer);
|
|
|
|
|
|
if (len < 3 || len > REASON_MAX_LENGTH)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
// Add the reason to the list only if it doesn't already exist
|
|
if (g_hReasonAdt.FindString(sReadBuffer) == -1)
|
|
{
|
|
g_hReasonAdt.PushString(sReadBuffer);
|
|
}
|
|
}
|
|
|
|
hFile.Close();
|
|
}
|
|
|
|
|
|
|
|
|
|
public void OnClientCookiesCached(int client)
|
|
{
|
|
char sCookieBuf[24];
|
|
GetClientCookie(client, g_hLastReportCookie, sCookieBuf, sizeof(sCookieBuf));
|
|
|
|
if (strlen(sCookieBuf) > 0)
|
|
{
|
|
g_iLastReport[client] = StringToInt(sCookieBuf);
|
|
}
|
|
|
|
|
|
// Just to be safe
|
|
sCookieBuf[0] = '\0';
|
|
|
|
GetClientCookie(client, g_hLastReportedCookie, sCookieBuf, sizeof(sCookieBuf));
|
|
|
|
if (strlen(sCookieBuf) > 0)
|
|
{
|
|
g_iLastReported[client] = StringToInt(sCookieBuf);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void FetchClientCookies()
|
|
{
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (IsClientValid(i) && !IsFakeClient(i) && !IsClientSourceTV(i) && !IsClientReplay(i) && AreClientCookiesCached(i))
|
|
{
|
|
OnClientCookiesCached(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Forward_OnDrawMenu(int client)
|
|
{
|
|
Action result;
|
|
|
|
Call_StartForward(g_hOnDrawMenuForward);
|
|
Call_PushCell(client);
|
|
|
|
Call_Finish(result);
|
|
|
|
return (result == Plugin_Continue);
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Forward_OnReportPre(int client, int target, const char[] reason)
|
|
{
|
|
Action result;
|
|
|
|
Call_StartForward(g_hOnReportPreForward);
|
|
Call_PushCell(client);
|
|
Call_PushCell(target);
|
|
Call_PushString(reason);
|
|
|
|
Call_Finish(result);
|
|
|
|
return (result == Plugin_Continue);
|
|
}
|
|
|
|
|
|
|
|
|
|
void Forward_OnReportPost(int client, int target, const char[] reason)
|
|
{
|
|
Call_StartForward(g_hOnReportPostForward);
|
|
Call_PushCell(client);
|
|
Call_PushCell(target);
|
|
Call_PushString(reason);
|
|
|
|
Call_Finish();
|
|
}
|
|
|
|
|
|
|
|
bool Forward_OnDrawOwnReason(int client)
|
|
{
|
|
Action result;
|
|
|
|
Call_StartForward(g_hOnDrawOwnReasonForward);
|
|
Call_PushCell(client);
|
|
|
|
Call_Finish(result);
|
|
|
|
return (result == Plugin_Continue);
|
|
}
|
|
|
|
|
|
|
|
bool Forward_OnAddToAdminCount(int client)
|
|
{
|
|
Action result;
|
|
|
|
Call_StartForward(g_hOnAddToAdminCountForward);
|
|
Call_PushCell(client);
|
|
|
|
Call_Finish(result);
|
|
|
|
return (result == Plugin_Continue);
|
|
}
|
|
|
|
|
|
|
|
void Forward_OnTrackerCountChanged(int oldVal, int newVal)
|
|
{
|
|
Call_StartForward(g_hOnTrackerCountChangedForward);
|
|
Call_PushCell(oldVal);
|
|
Call_PushCell(newVal);
|
|
|
|
Call_Finish();
|
|
}
|
|
|
|
|
|
|
|
bool Forward_OnDrawTarget(int client, int target)
|
|
{
|
|
Action result;
|
|
|
|
Call_StartForward(g_hOnDrawTargetForward);
|
|
Call_PushCell(client);
|
|
Call_PushCell(target);
|
|
|
|
Call_Finish(result);
|
|
|
|
return (result == Plugin_Continue);
|
|
}
|
|
|
|
|
|
|
|
void Forward_OnServerDataChanged(ConVar convar, ServerData type, const char[] oldVal, const char[] newVal)
|
|
{
|
|
Call_StartForward(g_hOnServerDataChangedForward);
|
|
Call_PushCell(convar);
|
|
Call_PushCell(type);
|
|
Call_PushString(oldVal);
|
|
Call_PushString(newVal);
|
|
|
|
Call_Finish();
|
|
}
|
|
|
|
|
|
|
|
void Forward_OnLogMessage(Handle plugin, const char[] message)
|
|
{
|
|
Call_StartForward(g_hOnLogMessageForward);
|
|
Call_PushCell(plugin);
|
|
Call_PushString(message);
|
|
|
|
Call_Finish();
|
|
}
|
|
|
|
|
|
|
|
void Forward_OnReportHandled(int client, int id)
|
|
{
|
|
Call_StartForward(g_hOnReportHandledForward);
|
|
Call_PushCell(client);
|
|
Call_PushCell(id);
|
|
|
|
Call_Finish();
|
|
}
|
|
|
|
|
|
|
|
|
|
public Action Timer_Advert(Handle timer)
|
|
{
|
|
if (g_iCurrentTrackers > 0)
|
|
{
|
|
// Spelling is different (0 admins, 1 admin, 2 admins, 3 admins...)
|
|
if (g_iCurrentTrackers == 1)
|
|
{
|
|
PrintToChatAll("\x04[CALLADMIN]\x03 %t", "CallAdmin_AdvertMessageSingular", g_iCurrentTrackers);
|
|
}
|
|
else
|
|
{
|
|
PrintToChatAll("\x04[CALLADMIN]\x03 %t", "CallAdmin_AdvertMessagePlural", g_iCurrentTrackers);
|
|
}
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
|
|
public void OnCvarChanged(ConVar cvar, const char[] oldValue, const char[] newValue)
|
|
{
|
|
if (cvar == g_hHostPort)
|
|
{
|
|
g_iHostPort = g_hHostPort.IntValue;
|
|
|
|
Forward_OnServerDataChanged(cvar, ServerData_HostPort, oldValue, newValue);
|
|
}
|
|
else if (cvar == g_hHostIP)
|
|
{
|
|
UpdateHostIp();
|
|
|
|
Forward_OnServerDataChanged(cvar, ServerData_HostIP, g_sHostIP, g_sHostIP);
|
|
}
|
|
else if (cvar == g_hServerName)
|
|
{
|
|
g_hServerName.GetString(g_sServerName, sizeof(g_sServerName));
|
|
|
|
Forward_OnServerDataChanged(cvar, ServerData_HostName, oldValue, newValue);
|
|
}
|
|
else if (cvar == g_hVersion)
|
|
{
|
|
g_hVersion.SetString(CALLADMIN_VERSION, false, false);
|
|
}
|
|
else if (cvar == g_hAdvertInterval)
|
|
{
|
|
delete g_hAdvertTimer;
|
|
|
|
g_fAdvertInterval = g_hAdvertInterval.FloatValue;
|
|
|
|
if (g_fAdvertInterval != 0.0)
|
|
{
|
|
g_hAdvertTimer = CreateTimer(g_fAdvertInterval, Timer_Advert, _, TIMER_REPEAT);
|
|
}
|
|
}
|
|
else if (cvar == g_hPublicMessage)
|
|
{
|
|
g_bPublicMessage = g_hPublicMessage.BoolValue;
|
|
}
|
|
else if (cvar == g_hOwnReason)
|
|
{
|
|
g_bOwnReason = g_hOwnReason.BoolValue;
|
|
}
|
|
else if (cvar == g_hConfirmCall)
|
|
{
|
|
g_bConfirmCall = g_hConfirmCall.BoolValue;
|
|
}
|
|
else if (cvar == g_hSpamTime)
|
|
{
|
|
g_iSpamTime = g_hSpamTime.IntValue;
|
|
}
|
|
else if (cvar == g_hReportTime)
|
|
{
|
|
g_iReportTime = g_hReportTime.IntValue;
|
|
}
|
|
else if (cvar == g_hAdminAction)
|
|
{
|
|
g_iAdminAction = g_hAdminAction.IntValue;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public Action Command_Call(int client, int argc)
|
|
{
|
|
// Console cannot use this
|
|
if (client == 0)
|
|
{
|
|
ReplyToCommand(client, "This command can't be used from console");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (!Forward_OnDrawMenu(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (g_iLastReport[client] == 0 || LastReportTimeCheck(client))
|
|
{
|
|
g_bSawMessage[client] = false;
|
|
|
|
ShowClientSelectMenu(client);
|
|
}
|
|
else if (!g_bSawMessage[client])
|
|
{
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_CommandNotAllowed", g_iSpamTime - ( GetTime() - g_iLastReport[client] ));
|
|
g_bSawMessage[client] = true;
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
|
|
public Action Command_HandleCall(int client, int argc)
|
|
{
|
|
if (client == 0)
|
|
{
|
|
ReplyToCommand(client, "This command can't be used from console");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (!CheckCommandAccess(client, "sm_calladmin_admin", ADMFLAG_BAN, false))
|
|
{
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_NoAdmin");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (argc != 1)
|
|
{
|
|
char cmdName[64];
|
|
GetCmdArg(0, cmdName, sizeof(cmdName));
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t: %s <id>", "CallAdmin_WrongNumberOfArguments", cmdName);
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
char sArgID[10];
|
|
int reportID;
|
|
|
|
GetCmdArg(1, sArgID, sizeof(sArgID));
|
|
reportID = StringToInt(sArgID);
|
|
|
|
|
|
if (reportID > g_iCurrentReportID)
|
|
{
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_WrongReportID");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
// Report was already handled
|
|
int reportIndex = g_hActiveReports.FindValue(reportID);
|
|
if (reportIndex == -1)
|
|
{
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_ReportAlreadyHandled");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
g_hActiveReports.Erase(reportIndex);
|
|
Forward_OnReportHandled(client, reportID);
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
|
|
public Action Command_Reload(int client, int argc)
|
|
{
|
|
if (!CheckCommandAccess(client, "sm_calladmin_admin", ADMFLAG_BAN, false))
|
|
{
|
|
ReplyToCommand(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_NoAdmin");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
g_hActiveReports.Clear();
|
|
g_hReasonAdt.Clear();
|
|
ParseReasonList();
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
|
|
bool LastReportTimeCheck(int client)
|
|
{
|
|
if (g_iLastReport[client] <= ( GetTime() - g_iSpamTime ))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
bool LastReportedTimeCheck(int client)
|
|
{
|
|
if (g_iLastReported[client] <= ( GetTime() - g_iReportTime ))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// Updates the timestamps of lastreport and lastreported
|
|
void SetStates(int client, int target)
|
|
{
|
|
int currentTime = GetTime();
|
|
|
|
g_iLastReport[client] = currentTime;
|
|
g_iLastReported[target] = currentTime;
|
|
|
|
|
|
// Cookies
|
|
if (LibraryExists("clientprefs"))
|
|
{
|
|
SetClientCookieEx(client, g_hLastReportCookie, "%d", currentTime);
|
|
SetClientCookieEx(target, g_hLastReportedCookie, "%d", currentTime);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void ConfirmCall(int client)
|
|
{
|
|
Menu menu = new Menu(MenuHandler_ConfirmCall);
|
|
menu.SetTitle("%T", "CallAdmin_ConfirmCall", client);
|
|
|
|
char sConfirm[24];
|
|
|
|
Format(sConfirm, sizeof(sConfirm), "%T", "CallAdmin_Yes", client);
|
|
menu.AddItem("Yes", sConfirm);
|
|
|
|
Format(sConfirm, sizeof(sConfirm), "%T", "CallAdmin_No", client);
|
|
menu.AddItem("No", sConfirm);
|
|
|
|
menu.Display(client, 30);
|
|
}
|
|
|
|
|
|
|
|
public int MenuHandler_ConfirmCall(Menu menu, MenuAction action, int client, int param2)
|
|
{
|
|
if (action == MenuAction_Select)
|
|
{
|
|
char sInfo[24];
|
|
menu.GetItem(param2, sInfo, sizeof(sInfo));
|
|
|
|
// Client has chosen to confirm the call
|
|
if (StrEqual("Yes", sInfo))
|
|
{
|
|
if (!ReportPlayer(client, g_iTarget[client], g_sTargetReason[client]))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_CallAborted");
|
|
}
|
|
}
|
|
else if (action == MenuAction_End)
|
|
{
|
|
menu.Close();
|
|
}
|
|
}
|
|
|
|
|
|
bool PreReportCheck(int client, int target)
|
|
{
|
|
// Selected target isn't valid anymore
|
|
if (!IsClientValid(target))
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_NotInGame");
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Already reported (race condition)
|
|
if (!LastReportedTimeCheck(target))
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_AlreadyReported");
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool ReportPlayer(int client, int target, char[] sReason)
|
|
{
|
|
if (!PreReportCheck(client, target))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
// Admins available and we want to notify them instead of sending the report
|
|
if (GetAdminCount() > 0 && g_iAdminAction == ADMIN_ACTION_BLOCK_MESSAGE)
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_IngameAdminNotified");
|
|
PrintNotifyMessageToAdmins(client, g_iTarget[client]);
|
|
|
|
SetStates(client, g_iTarget[client]);
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
if (!Forward_OnReportPre(client, g_iTarget[client], g_sTargetReason[client]))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (g_bPublicMessage)
|
|
{
|
|
PrintToChatAll("\x04[CALLADMIN]\x03 %t", "CallAdmin_HasReported", client, target, sReason);
|
|
}
|
|
else
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_YouHaveReported", target, sReason);
|
|
}
|
|
|
|
SetStates(client, target);
|
|
|
|
|
|
g_iCurrentReportID++;
|
|
g_hActiveReports.Push(g_iCurrentReportID);
|
|
|
|
Forward_OnReportPost(client, target, sReason);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public Action Timer_UpdateTrackersCount(Handle timer)
|
|
{
|
|
int temp = GetTotalTrackers();
|
|
|
|
if (temp != g_iCurrentTrackers)
|
|
{
|
|
Forward_OnTrackerCountChanged(g_iCurrentTrackers, temp);
|
|
}
|
|
|
|
g_iCurrentTrackers = temp;
|
|
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
|
|
|
|
|
|
int GetTotalTrackers()
|
|
{
|
|
Handle hIter;
|
|
Handle hPlugin;
|
|
Function func;
|
|
int count;
|
|
int tempcount;
|
|
|
|
hIter = GetPluginIterator();
|
|
|
|
while (MorePlugins(hIter))
|
|
{
|
|
hPlugin = ReadPlugin(hIter);
|
|
|
|
if (GetPluginStatus(hPlugin) == Plugin_Running)
|
|
{
|
|
// We check if the plugin has the public CallAdmin_OnRequestTrackersCountRefresh function
|
|
if ( (func = GetFunctionByName(hPlugin, "CallAdmin_OnRequestTrackersCountRefresh") ) != INVALID_FUNCTION)
|
|
{
|
|
Call_StartFunction(hPlugin, func);
|
|
Call_PushCellRef(tempcount);
|
|
|
|
Call_Finish();
|
|
|
|
if (tempcount > 0)
|
|
{
|
|
count += tempcount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete hIter;
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
|
|
|
|
void ShowClientSelectMenu(int client)
|
|
{
|
|
char sName[MAX_NAME_LENGTH];
|
|
char sID[24];
|
|
|
|
Menu menu = new Menu(MenuHandler_ClientSelect);
|
|
menu.SetTitle("%T", "CallAdmin_SelectClient", client);
|
|
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (i != client && LastReportedTimeCheck(i) && IsClientValid(i) && !IsFakeClient(i) && !IsClientSourceTV(i) && !IsClientReplay(i) && Forward_OnDrawTarget(client, i))
|
|
{
|
|
GetClientName(i, sName, sizeof(sName));
|
|
Format(sID, sizeof(sID), "%d", GetClientSerial(i));
|
|
|
|
menu.AddItem(sID, sName);
|
|
}
|
|
}
|
|
|
|
// Menu has no items, no players to report
|
|
if (menu.ItemCount < 1)
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_NoPlayers");
|
|
}
|
|
else
|
|
{
|
|
menu.Display(client, 30);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public int MenuHandler_ClientSelect(Menu menu, MenuAction action, int client, int param2)
|
|
{
|
|
if (action == MenuAction_Select)
|
|
{
|
|
char sInfo[24];
|
|
int iSerial;
|
|
int iID;
|
|
|
|
menu.GetItem(param2, sInfo, sizeof(sInfo));
|
|
|
|
iSerial = StringToInt(sInfo);
|
|
iID = GetClientFromSerial(iSerial);
|
|
|
|
|
|
if (!PreReportCheck(client, iID))
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_iTarget[client] = iID;
|
|
|
|
ShowBanReasonMenu(client);
|
|
}
|
|
else if (action == MenuAction_End)
|
|
{
|
|
menu.Close();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public void OnClientDisconnect_Post(int client)
|
|
{
|
|
g_iTarget[client] = 0;
|
|
g_sTargetReason[client][0] = '\0';
|
|
g_iLastReport[client] = 0;
|
|
g_iLastReported[client] = 0;
|
|
g_bSawMessage[client] = false;
|
|
g_bAwaitingReason[client] = false;
|
|
|
|
RemoveAsTarget(client);
|
|
}
|
|
|
|
|
|
|
|
|
|
void RemoveAsTarget(int client)
|
|
{
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (g_iTarget[i] == client)
|
|
{
|
|
g_iTarget[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void ShowBanReasonMenu(int client)
|
|
{
|
|
int count;
|
|
char sReasonBuffer[REASON_MAX_LENGTH];
|
|
count = g_hReasonAdt.Length;
|
|
|
|
|
|
Menu menu = new Menu(MenuHandler_BanReason);
|
|
menu.SetTitle("%T", "CallAdmin_SelectReason", client, g_iTarget[client]);
|
|
|
|
for (int i; i < count; i++)
|
|
{
|
|
g_hReasonAdt.GetString(i, sReasonBuffer, sizeof(sReasonBuffer));
|
|
|
|
if (strlen(sReasonBuffer) < 3)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
menu.AddItem(sReasonBuffer, sReasonBuffer);
|
|
}
|
|
|
|
// Own reason, call the forward
|
|
if (g_bOwnReason && Forward_OnDrawOwnReason(client))
|
|
{
|
|
char sOwnReason[REASON_MAX_LENGTH];
|
|
|
|
Format(sOwnReason, sizeof(sOwnReason), "%T", "CallAdmin_OwnReason", client);
|
|
menu.AddItem("Own reason", sOwnReason);
|
|
}
|
|
|
|
menu.Display(client, 30);
|
|
}
|
|
|
|
|
|
|
|
|
|
public int MenuHandler_BanReason(Menu menu, MenuAction action, int client, int param2)
|
|
{
|
|
if (action == MenuAction_Select)
|
|
{
|
|
char sInfo[REASON_MAX_LENGTH];
|
|
menu.GetItem(param2, sInfo, sizeof(sInfo));
|
|
|
|
// User has chosen to use his own reason
|
|
if (StrEqual("Own reason", sInfo))
|
|
{
|
|
g_bAwaitingReason[client] = true;
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_TypeOwnReason");
|
|
return;
|
|
}
|
|
|
|
Format(g_sTargetReason[client], sizeof(g_sTargetReason[]), sInfo);
|
|
|
|
if (!PreReportCheck(client, g_iTarget[client]))
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
if (g_bConfirmCall)
|
|
{
|
|
ConfirmCall(client);
|
|
}
|
|
else
|
|
{
|
|
if (!ReportPlayer(client, g_iTarget[client], g_sTargetReason[client]))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if (action == MenuAction_End)
|
|
{
|
|
menu.Close();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public Action ChatListener(int client, const char[] command, int argc)
|
|
{
|
|
// There were a few cases were the client index was invalid which caused an index out-of-bounds error
|
|
// Invalid clients shouldn't be able to trigger this callback so the reason why this happens has yet to be found out
|
|
// Until then we have this check here to prevent it
|
|
if (!IsClientValid(client))
|
|
{
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
|
|
if (g_bAwaitingReason[client] && !IsChatTrigger())
|
|
{
|
|
// 2 more for quotes
|
|
char sReason[REASON_MAX_LENGTH + 2];
|
|
|
|
GetCmdArgString(sReason, sizeof(sReason));
|
|
StripQuotes(sReason);
|
|
strcopy(g_sTargetReason[client], sizeof(g_sTargetReason[]), sReason);
|
|
|
|
g_bAwaitingReason[client] = false;
|
|
|
|
|
|
// Has aborted
|
|
if (StrEqual(sReason, "!noreason") || StrEqual(sReason, "!abort"))
|
|
{
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_CallAborted");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
// Reason was too short
|
|
if (strlen(sReason) < 3)
|
|
{
|
|
g_bAwaitingReason[client] = true;
|
|
PrintToChat(client, "\x04[CALLADMIN]\x03 %t", "CallAdmin_OwnReasonTooShort");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (!PreReportCheck(client, g_iTarget[client]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
|
|
if (g_bConfirmCall)
|
|
{
|
|
ConfirmCall(client);
|
|
}
|
|
else
|
|
{
|
|
if (!ReportPlayer(client, g_iTarget[client], g_sTargetReason[client]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
}
|
|
|
|
|
|
// Block the chatmessage
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
|
|
|
|
stock int GetRealClientCount()
|
|
{
|
|
int count;
|
|
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (IsClientValid(i) && !IsFakeClient(i) && !IsClientSourceTV(i) && !IsClientReplay(i))
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
|
|
stock int GetAdminCount()
|
|
{
|
|
int count;
|
|
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (IsClientValid(i) && !IsFakeClient(i) && !IsClientSourceTV(i) && !IsClientReplay(i) && CheckCommandAccess(i, "sm_calladmin_admin", ADMFLAG_BAN, false) && Forward_OnAddToAdminCount(i))
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
stock void PrintNotifyMessageToAdmins(int client, int target)
|
|
{
|
|
for (int i; i <= MaxClients; i++)
|
|
{
|
|
if (IsClientValid(i) && !IsFakeClient(i) && !IsClientSourceTV(i) && !IsClientReplay(i) && CheckCommandAccess(i, "sm_calladmin_admin", ADMFLAG_BAN, false) && Forward_OnAddToAdminCount(i))
|
|
{
|
|
PrintToChat(i, "\x04[CALLADMIN]\x03 %t", "CallAdmin_AdminNotification", client, target, g_sTargetReason[client]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
stock void LongToIp(int long, char[] str, int maxlen)
|
|
{
|
|
int pieces[4];
|
|
|
|
pieces[0] = ((long >>> 24) & 255);
|
|
pieces[1] = ((long >>> 16) & 255);
|
|
pieces[2] = ((long >>> 8) & 255);
|
|
pieces[3] = (long & 255);
|
|
|
|
Format(str, maxlen, "%d.%d.%d.%d", pieces[0], pieces[1], pieces[2], pieces[3]);
|
|
}
|
|
|
|
|
|
|
|
// Updates the global g_sHostIP variable to the current ip of the server
|
|
// Using the int value directly provides incorrect results, when given the time it should be examined why
|
|
void UpdateHostIp()
|
|
{
|
|
char tmpString[sizeof(g_sHostIP)];
|
|
g_hHostIP.GetString(tmpString, sizeof(tmpString));
|
|
|
|
int tmpInt = StringToInt(tmpString);
|
|
LongToIp(tmpInt, g_sHostIP, sizeof(g_sHostIP));
|
|
}
|
|
|
|
|
|
|
|
stock void SetClientCookieEx(int client, Handle cookie, const char[] format, any:...)
|
|
{
|
|
char sFormatBuf[1024];
|
|
VFormat(sFormatBuf, sizeof(sFormatBuf), format, 4);
|
|
|
|
SetClientCookie(client, cookie, sFormatBuf);
|
|
} |