H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 14:16:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
29985681a1
source-engine/engine/sv_filter.cpp

958 lines
23 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "server_pch.h"
#include "vfilter.h" // Renamed to avoid conflict with Microsoft's filter.h
#include "sv_filter.h"
#include "sv_steamauth.h"
#include "GameEventManager.h"
#include "proto_oob.h"
#include "tier1/CommandBuffer.h"
#ifndef DEDICATED
#include "cl_steamauth.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar sv_filterban( "sv_filterban", "1", 0, "Set packet filtering by IP mode" );
CUtlVector< ipfilter_t > g_IPFilters;
CUtlVector< userfilter_t > g_UserFilters;
#define BANNED_IP_FILENAME "banned_ip.cfg"
#define BANNED_USER_FILENAME "banned_user.cfg"
#define CONFIG_DIR "cfg/"
#define STEAM_PREFIX "STEAM_"
//-----------------------------------------------------------------------------
// Purpose: Sends a message to prospective clients letting them know they're banned
// Input : *adr -
//-----------------------------------------------------------------------------
void Filter_SendBan( const netadr_t& adr )
{
NET_OutOfBandPrintf( NS_SERVER, adr, "%cBanned by server\n", A2A_PRINT );
}
//-----------------------------------------------------------------------------
// Purpose: Checks an IP address to see if it is banned
// Input : *adr -
// Output : bool
//-----------------------------------------------------------------------------
bool Filter_ShouldDiscard( const netadr_t& adr )
{
if ( sv_filterban.GetInt() == 0 )
{
return false;
}
bool bNegativeFilter = sv_filterban.GetInt() == 1;
unsigned in = *(unsigned *)&adr.ip[0];
// Handle timeouts
for ( int i = g_IPFilters.Count() - 1 ; i >= 0 ; i--)
{
if ( ( g_IPFilters[i].compare != 0xffffffff) &&
( g_IPFilters[i].banEndTime != 0.0f ) &&
( g_IPFilters[i].banEndTime <= realtime ) )
{
g_IPFilters.Remove(i);
continue;
}
// Only get here if ban is still in effect.
if ( (in & g_IPFilters[i].mask) == g_IPFilters[i].compare)
{
return bNegativeFilter;
}
}
return !bNegativeFilter;
}
//-----------------------------------------------------------------------------
// Purpose: Takes an IP address string and fills in an ipfilter_t mask and compare (raw address)
// Input : *s -
// *f -
// Output : bool Filter_ConvertString
//-----------------------------------------------------------------------------
bool Filter_ConvertString( const char *s, ipfilter_t *f )
{
char num[128];
int i, j;
byte b[4];
byte m[4];
for (i=0 ; i<4 ; i++)
{
b[i] = 0;
m[i] = 0;
}
for (i=0 ; i<4 ; i++)
{
if (*s < '0' || *s > '9')
{
ConMsg("Bad filter address: %s\n", s);
return false;
}
j = 0;
while (*s >= '0' && *s <= '9')
{
num[j++] = *s++;
}
num[j] = 0;
b[i] = atoi(num);
if (b[i] != 0)
m[i] = 255;
if (!*s)
break;
s++;
}
f->mask = *(unsigned int *)m;
f->compare = *(unsigned int *)b;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Adds an IP ban
//-----------------------------------------------------------------------------
static void Filter_Add_f( const CCommand& args )
{
int i = 0;
float banTime;
bool bKick = true;
bool bFound = false;
char szDuration[256];
CGameClient *client = NULL;
if ( !Q_stricmp( args[0], "banip" ) )
{
ConMsg( "Note: should use \"addip\" instead of \"banip\".\n" );
}
if ( args.ArgC() != 3 )
{
ConMsg( "Usage: addip < minutes > < ipaddress >\nUse 0 minutes for permanent\n" );
return;
}
ipfilter_t f;
if ( !Filter_ConvertString( args[2], &f ) )
return;
for (i=0 ; i<g_IPFilters.Count(); i++)
{
if ( g_IPFilters[i].compare == 0xffffffff || ( g_IPFilters[i].compare == f.compare && g_IPFilters[i].mask == f.mask ) )
break; // free spot
}
if (i == g_IPFilters.Count())
{
if (g_IPFilters.Count() == MAX_IPFILTERS)
{
ConMsg( "addip: IP filter list is full\n" );
return;
}
i = g_IPFilters.AddToTail();
}
else
{
// updating in-place, so don't kick people
bKick = false;
}
banTime = atof( args[1] );
if (banTime < 0.01f)
{
banTime = 0.0f;
}
g_IPFilters[i].banTime = banTime;
// Time to unban.
g_IPFilters[i].banEndTime = ( banTime != 0.0 ) ? ( realtime + 60.0 * banTime ) : 0.0;
if ( !Filter_ConvertString( args[2], &g_IPFilters[i]) )
{
g_IPFilters[i].compare = 0xffffffff;
}
if ( bKick )
{
// Kick him if he's on
for ( i=0; i < sv.GetClientCount(); ++i )
{
client = sv.Client(i);
if ( !client || !client->IsActive() || !client->IsConnected() || !client->IsSpawned() )
continue;
if ( client->IsFakeClient() )
continue;
if ( !Filter_ShouldDiscard( client->GetNetChannel()->GetRemoteAddress() ) )
continue;
bFound = true;
break;
}
}
// Build a duration string for the ban
if ( banTime == 0.0 )
{
Q_snprintf( szDuration, sizeof( szDuration ), "permanently" );
}
else
{
Q_snprintf( szDuration, sizeof( szDuration ), "for %.2f minutes", banTime );
}
// fire the event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_addban" );
if ( event )
{
if ( bFound && client )
{
event->SetString( "name", client->m_Name );
event->SetInt( "userid", client->GetUserID() );
event->SetString( "networkid", client->GetNetworkIDString() );
}
else
{
event->SetString( "name", "" );
event->SetInt( "userid", 0 );
event->SetString( "networkid", "" );
}
event->SetString( "ip", args[2] );
event->SetString( "duration", szDuration );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
event->SetBool( "kicked", bKick && bFound && client );
g_GameEventManager.FireEvent( event );
}
if ( bKick && bFound && client )
{
client->ClientPrintf ( "The server operator has added you to the banned list.\n" );
client->Disconnect( "Added to banned list" );
}
}
// IP Address filtering ConCommands
static ConCommand addip( "addip", Filter_Add_f, "Add an IP address to the ban list." );
static ConCommand banip( "banip", Filter_Add_f, "Add an IP address to the ban list." );
//-----------------------------------------------------------------------------
// Purpose: Removes an IP ban
//-----------------------------------------------------------------------------
CON_COMMAND( removeip, "Remove an IP address from the ban list." )
{
ipfilter_t f;
int i;
if ( args.ArgC() < 1 )
{
ConMsg( "Usage: removeip < slot | ipaddress >\n" );
return;
}
// if no "." in the string we'll assume it's a slot number
if ( !Q_strstr( args[1], "." ) )
{
int slot = Q_atoi( args[1] );
if ( slot > 0 && slot <= g_IPFilters.Count() )
{
byte b[4];
char szIP[32];
// array access is zero based
slot--;
*(unsigned *)b = g_IPFilters[slot].compare;
Q_snprintf( szIP, sizeof( szIP ), "%3i.%3i.%3i.%3i", b[0], b[1], b[2], b[3] );
g_IPFilters.Remove( slot );
// Tell server operator
ConMsg( "removeip: filter removed for %s, IP %s\n", args[1], szIP );
// send an event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_removeban" );
if ( event )
{
event->SetString( "networkid", "" );
event->SetString( "ip", szIP );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
g_GameEventManager.FireEvent( event );
}
}
else
{
ConMsg( "removeip: invalid slot %i\n", slot );
}
return;
}
if ( !Filter_ConvertString( args[1], &f ) )
return;
for ( i = 0 ; i < g_IPFilters.Count() ; i++ )
{
if ( ( g_IPFilters[i].mask == f.mask ) &&
( g_IPFilters[i].compare == f.compare ) )
{
g_IPFilters.Remove(i);
ConMsg( "removeip: filter removed for %s\n", args[1] );
// send an event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_removeban" );
if ( event )
{
event->SetString( "networkid", "" );
event->SetString( "ip", args[1] );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
g_GameEventManager.FireEvent( event );
}
return;
}
}
ConMsg( "removeip: couldn't find %s\n", args[1] );
}
//-----------------------------------------------------------------------------
// Purpose: Lists IP bans
//-----------------------------------------------------------------------------
CON_COMMAND( listip, "List IP addresses on the ban list." )
{
int i;
byte b[4];
int count = g_IPFilters.Count();
if ( !count )
{
ConMsg( "IP filter list: empty\n" );
return;
}
else
{
if ( count == 1 )
{
ConMsg( "IP filter list: %i entry\n", count );
}
else
{
ConMsg( "IP filter list: %i entries\n", count );
}
}
for ( i = 0 ; i < count ; i++ )
{
*(unsigned *)b = g_IPFilters[i].compare;
if ( g_IPFilters[i].banTime != 0.0f )
{
ConMsg( "%i %3i.%3i.%3i.%3i : %.3f min\n", i+1, b[0], b[1], b[2], b[3], g_IPFilters[i].banTime );
}
else
{
ConMsg( "%i %3i.%3i.%3i.%3i : permanent\n", i+1, b[0], b[1], b[2], b[3] );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Saves IP bans to a file
//-----------------------------------------------------------------------------
CON_COMMAND( writeip, "Save the ban list to " BANNED_IP_FILENAME "." )
{
FileHandle_t f;
char name[MAX_OSPATH];
byte b[4];
int i;
float banTime;
Q_strncpy( name, CONFIG_DIR BANNED_IP_FILENAME, sizeof( name ) );
ConMsg( "Writing %s.\n", name );
f = g_pFileSystem->Open ( name, "wb" );
if ( !f )
{
ConMsg( "Couldn't open %s\n", name );
return;
}
for ( i = 0 ; i < g_IPFilters.Count() ; i++ )
{
*(unsigned *)b = g_IPFilters[i].compare;
// Only store out the permanent bad guys from this server.
banTime = g_IPFilters[i].banTime;
if ( banTime != 0.0f )
{
continue;
}
g_pFileSystem->FPrintf( f, "addip 0 %i.%i.%i.%i\r\n", b[0], b[1], b[2], b[3] );
}
g_pFileSystem->Close( f );
}
//-----------------------------------------------------------------------------
// Purpose: Checks a USERID_t to see if the Steam ID has been banned
//-----------------------------------------------------------------------------
bool Filter_IsUserBanned( const USERID_t& userid )
{
#ifndef _XBOX
if ( sv_filterban.GetInt() == 0 )
return false;
bool bNegativeFilter = sv_filterban.GetInt() == 1;
// Handle timeouts
for ( int i =g_UserFilters.Count() - 1 ; i >= 0 ; i-- )
{
// Time out old filters
if ( ( g_UserFilters[i].banEndTime != 0.0f ) &&
( g_UserFilters[i].banEndTime <= realtime ) )
{
g_UserFilters.Remove( i );
continue;
}
// Only get here if ban is still in effect.
if ( Steam3Server().CompareUserID( userid, g_UserFilters[i].userid ) )
{
return bNegativeFilter;
}
}
return !bNegativeFilter;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Converts a "STEAM_X:Y:Z" string into a USERID_t
//-----------------------------------------------------------------------------
USERID_t *Filter_StringToUserID( const char *str )
{
static USERID_t id;
Q_memset( &id, 0, sizeof( id ) );
if ( str && str[ 0 ] )
{
char szTemp[128];
if ( !Q_strnicmp( str, STEAM_PREFIX, strlen( STEAM_PREFIX ) ) )
{
Q_strncpy( szTemp, str + Q_strlen( STEAM_PREFIX ), sizeof( szTemp ) - 1 );
id.idtype = IDTYPE_STEAM;
szTemp[ sizeof( szTemp ) - 1 ] = '\0';
CCommand args;
args.Tokenize( szTemp );
if ( args.ArgC() >= 5 )
{
// allow settings from old style steam2 format
TSteamGlobalUserID steam2ID;
steam2ID.m_SteamInstanceID = (SteamInstanceID_t)atoi( args[ 0 ] );
steam2ID.m_SteamLocalUserID.Split.High32bits = (int)atoi( args[ 2 ] );
steam2ID.m_SteamLocalUserID.Split.Low32bits = (int)atoi( args[ 4 ] );
EUniverse eUniverse = k_EUniversePublic;
if ( Steam3Server().GetGSSteamID().IsValid() )
eUniverse = Steam3Server().GetGSSteamID().GetEUniverse();
#ifndef DEDICATED
else if ( Steam3Client().SteamUser() )
eUniverse = Steam3Client().SteamUser()->GetSteamID().GetEUniverse();
#endif
id.steamid.SetFromSteam2( &steam2ID, eUniverse );
}
}
else
{
id.steamid.SetFromString( str, k_EUniversePublic );
if ( id.steamid.IsValid() )
id.idtype = IDTYPE_STEAM;
}
}
return &id;
}
//-----------------------------------------------------------------------------
// Purpose: Saves Steam ID bans to a file
//-----------------------------------------------------------------------------
CON_COMMAND( writeid, "Writes a list of permanently-banned user IDs to " BANNED_USER_FILENAME "." )
{
FileHandle_t f;
char name[MAX_OSPATH];
int i;
float banTime;
Q_strncpy( name, CONFIG_DIR BANNED_USER_FILENAME, sizeof( name ) );
ConMsg( "Writing %s.\n", name );
f = g_pFileSystem->Open ( name, "wb" );
if ( !f )
{
ConMsg( "Couldn't open %s\n", name );
return;
}
for ( i = 0 ; i < g_UserFilters.Count() ; i++ )
{
banTime = g_UserFilters[i].banTime;
if ( banTime != 0.0f )
{
continue;
}
g_pFileSystem->FPrintf( f, "banid 0 %s\r\n", GetUserIDString( g_UserFilters[i].userid ) );
}
g_pFileSystem->Close( f );
}
//-----------------------------------------------------------------------------
// Purpose: Removes a Steam ID ban
//-----------------------------------------------------------------------------
CON_COMMAND( removeid, "Remove a user ID from the ban list." )
{
int i = 0;
const char *pszArg1 = NULL;
char szSearchString[64];
if ( args.ArgC() != 2 && args.ArgC() != 6 )
{
ConMsg( "Usage: removeid < slot | uniqueid >\n" );
return;
}
// get the first argument
pszArg1 = args[1];
// don't need the # if they're using it
if ( !Q_strncmp( pszArg1, "#", 1 ) )
{
ConMsg( "Usage: removeid < userid | uniqueid >\n" );
ConMsg( "No # necessary\n" );
return;
}
// if the first letter is a character then
// we're searching for a uniqueid ( e.g. STEAM_ )
if ( *pszArg1 < '0' || *pszArg1 > '9' || V_atoi64( pszArg1 ) > ( (uint32)~0 ) )
{
bool bValid = false;
// SteamID ( need to reassemble it )
if ( !Q_strnicmp( pszArg1, STEAM_PREFIX, Q_strlen( STEAM_PREFIX ) ) && Q_strstr( args[2], ":" ) )
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s:%s:%s", pszArg1, args[3], args[5] );
USERID_t *id = Filter_StringToUserID( szSearchString );
if ( id )
{
bValid = id->steamid.IsValid();
if ( bValid )
V_sprintf_safe( szSearchString, "%s", id->steamid.Render() );
}
}
else
{
CSteamID cSteamIDCheck;
const char *pchUUID = args.ArgS();
if ( pchUUID )
{
cSteamIDCheck.SetFromString( pchUUID, k_EUniversePublic );
bValid = cSteamIDCheck.IsValid();
if ( bValid )
V_sprintf_safe( szSearchString, "%s", cSteamIDCheck.Render() );
}
}
// some other ID (e.g. "UNKNOWN", "STEAM_ID_PENDING", "STEAM_ID_LAN")
// NOTE: assumed to be one argument
if ( !bValid )
{
ConMsg( "removeid: invalid ban ID \"%s\"\n", pszArg1 );
return;
}
for ( i = 0 ; i < g_UserFilters.Count() ; i++ )
{
if ( Q_stricmp( GetUserIDString( g_UserFilters[i].userid ), szSearchString ) )
continue;
g_UserFilters.Remove( i );
ConMsg( "removeid: filter removed for %s\n", szSearchString );
// send an event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_removeban" );
if ( event )
{
event->SetString( "networkid", szSearchString );
event->SetString( "ip", "" );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
g_GameEventManager.FireEvent( event );
}
return;
}
ConMsg( "removeid: couldn't find %s\n", szSearchString );
}
// this is a userid
else
{
int slot = Q_atoi( pszArg1 );
if ( slot > 0 && slot <= g_UserFilters.Count() )
{
USERID_t id;
// array access is zero based
slot--;
// Copy off slot
id = g_UserFilters[slot].userid;
g_UserFilters.Remove( slot );
// Tell server operator
ConMsg( "removeid: filter removed for %s, ID %s\n", pszArg1, GetUserIDString( id ) );
// send an event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_removeban" );
if ( event )
{
event->SetString( "networkid", GetUserIDString( id ) );
event->SetString( "ip", "" );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
g_GameEventManager.FireEvent( event );
}
}
else
{
ConMsg( "removeid: invalid slot %i\n", slot );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Prints Steam ID bans to the console
//-----------------------------------------------------------------------------
CON_COMMAND( listid, "Lists banned users." )
{
int i;
int count = g_UserFilters.Count();
if ( !count )
{
ConMsg( "ID filter list: empty\n" );
return;
}
else
{
if ( count == 1 )
{
ConMsg( "ID filter list: %i entry\n", count );
}
else
{
ConMsg( "ID filter list: %i entries\n", count );
}
}
for ( i = 0 ; i < count ; i++ )
{
if ( g_UserFilters[i].banTime != 0.0 )
{
ConMsg( "%i %s : %.3f min\n", i+1, GetUserIDString( g_UserFilters[i].userid ), g_UserFilters[i].banTime );
}
else
{
ConMsg( "%i %s : permanent\n", i+1, GetUserIDString( g_UserFilters[i].userid ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Bans a Steam ID
//-----------------------------------------------------------------------------
CON_COMMAND( banid, "Add a user ID to the ban list." )
{
#ifndef _XBOX
int i;
float banTime;
USERID_t localId;
USERID_t * id = NULL;
int iSearchIndex = -1;
char szDuration[256];
char szSearchString[64];
bool bKick = false;
bool bPlaying = false;
const char *pszArg2 = NULL;
CGameClient *client = NULL;
if ( Steam3Server().BLanOnly() )
{
ConMsg( "Can't ban users on a LAN\n" );
return;
}
if ( args.ArgC() < 3 || args.ArgC() > 8 )
{
ConMsg( "Usage: banid < minutes > < userid | uniqueid > { kick }\n" );
ConMsg( "Use 0 minutes for permanent\n");
return;
}
banTime = Q_atof( args[1] );
if ( banTime < 0.01 )
{
banTime = 0.0;
}
// get the first argument
pszArg2 = args[2];
// don't need the # if they're using it
if ( !Q_strncmp( pszArg2, "#", 1 ) )
{
ConMsg( "Usage: banid < minutes > < userid | uniqueid > { kick }\n" );
ConMsg( "No # necessary\n");
return;
}
bKick = ( args.ArgC() >= 3 && Q_strcasecmp( args[ args.ArgC() - 1 ], "kick" ) == 0 );
// if the first letter is a character then
// we're searching for a uniqueid ( e.g. STEAM_ )
if ( *pszArg2 < '0' || *pszArg2 > '9' || V_atoi64( pszArg2 ) > ((uint32)~0) )
{
bool bValid = false;
iSearchIndex = -1;
// SteamID (need to reassemble it)
if ( !Q_strnicmp( pszArg2, STEAM_PREFIX, strlen( STEAM_PREFIX ) ) && Q_strstr( args[3], ":" ) )
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s:%s:%s", pszArg2, args[4], args[6] );
bValid = true;
}
else
{
CSteamID cSteamIDCheck;
const char *pchArgs = args.ArgS();
const char *pchUUID = strchr( pchArgs, ' ' );
if ( pchUUID )
{
cSteamIDCheck.SetFromString( pchUUID + 1, k_EUniversePublic );
bValid = cSteamIDCheck.IsValid();
if ( bValid )
V_sprintf_safe( szSearchString, "%s", cSteamIDCheck.Render() );
}
}
// some other ID (e.g. "UNKNOWN", "STEAM_ID_PENDING", "STEAM_ID_LAN")
// NOTE: assumed to be one argument
if ( !bValid )
{
ConMsg( "Can't ban users with ID \"%s\"\n", pszArg2 );
return;
}
}
else
{
// see if it is a userid
iSearchIndex = Q_atoi( pszArg2 );
}
// find this client (if they're currently in the server)
for ( i = 0; i < sv.GetClientCount(); i++ )
{
client = sv.Client(i);
if ( !client || !client->IsActive() || !client->IsConnected() || !client->IsSpawned() )
{
continue;
}
if ( client->IsFakeClient() )
{
continue;
}
// searching by UserID
if ( iSearchIndex != -1 )
{
if ( client->GetUserID() == iSearchIndex )
{
// found!
localId = client->GetNetworkID();
id = &localId;
bPlaying = true;
break;
}
}
// searching by UniqueID
else
{
if ( Q_stricmp( client->GetNetworkIDString(), szSearchString ) == 0 )
{
// found!
localId = client->GetNetworkID();
id = &localId;
bPlaying = true;
break;
}
}
}
// if we were searching by userid and we didn't find the person, we're done
if ( iSearchIndex != -1 && !id )
{
ConMsg( "banid: couldn't find userid %d\n", iSearchIndex );
return;
}
if ( !id )
{
// we're searching by SteamID and we haven't found them actively playing
id = Filter_StringToUserID( szSearchString );
if ( !id )
{
ConMsg( "banid: Couldn't resolve uniqueid \"%s\".\n", szSearchString );
ConMsg( "Usage: banid < minutes > < userid | uniqueid > { kick }\n" );
ConMsg( "Use 0 minutes for permanent\n");
return;
}
}
if ( !id )
{
// Should never occur!!!
ConMsg( "SV_BanId_f: id == NULL\n" );
return;
}
// See if it's in the list already
for ( i = 0 ; i < g_UserFilters.Count() ; i++ )
{
// We're just updating an existing id
if ( Steam3Server().CompareUserID( g_UserFilters[i].userid, *id ) )
break;
}
//
// Adding a new one
if ( i >= g_UserFilters.Count() )
{
// See if we have space for it
if ( g_UserFilters.Count() >= MAX_USERFILTERS )
{
ConMsg( "banid: user filter list is full\n" );
return;
}
userfilter_t nullUser;
memset( &nullUser, 0, sizeof(nullUser) );
i = g_UserFilters.AddToTail( nullUser );
}
g_UserFilters[i].banTime = banTime;
g_UserFilters[i].banEndTime = ( banTime != 0.0 ) ? ( realtime + 60.0 * banTime ) : 0.0;
g_UserFilters[i].userid = *id;
// Build a duration string for the ban
if ( banTime == 0.0 )
{
Q_snprintf( szDuration, sizeof( szDuration ), "permanently" );
}
else
{
Q_snprintf( szDuration, sizeof( szDuration ), "for %.2f minutes", banTime );
}
// fire the event
IGameEvent *event = g_GameEventManager.CreateEvent( "server_addban" );
if ( event )
{
if ( bPlaying )
{
event->SetString( "name", client->m_Name );
event->SetInt( "userid", client->GetUserID() );
event->SetString( "networkid", client->GetNetworkIDString() );
}
else
{
event->SetString( "name", "" );
event->SetInt( "userid", 0 );
event->SetString( "networkid", GetUserIDString( *id ) );
}
event->SetString( "ip", "" );
event->SetString( "duration", szDuration );
event->SetString( "by", ( cmd_source == src_command ) ? "Console" : host_client->m_Name );
event->SetInt( "kicked", ( bKick && bPlaying && client ) ? 1 : 0 );
g_GameEventManager.FireEvent( event );
}
if ( bKick && bPlaying && client )
{
client->ClientPrintf ( "You have been kicked and banned %s by the server.\n", szDuration );
client->Disconnect( "Kicked and banned" );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Filter_Init( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Filter_Shutdown( void )
{
}
Reference in New Issue Copy Permalink