mirror of https://github.com/FWGS/xash3d-fwgs
463 lines
10 KiB
C
463 lines
10 KiB
C
/*
|
|
sv_filter.c - server ID/IP filter
|
|
Copyright (C) 2017 a1batross
|
|
|
|
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
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include "server.h"
|
|
|
|
|
|
typedef struct ipfilter_s
|
|
{
|
|
float time;
|
|
float endTime; // -1 for permanent ban
|
|
struct ipfilter_s *next;
|
|
uint mask;
|
|
uint ip;
|
|
} ipfilter_t;
|
|
|
|
static ipfilter_t *ipfilter = NULL;
|
|
|
|
|
|
// TODO: Is IP filter really needed?
|
|
// TODO: Make it IPv6 compatible, for future expansion
|
|
|
|
typedef struct cidfilter_s
|
|
{
|
|
float endTime;
|
|
struct cidfilter_s *next;
|
|
string id;
|
|
} cidfilter_t;
|
|
|
|
static cidfilter_t *cidfilter = NULL;
|
|
|
|
static void SV_RemoveID( const char *id )
|
|
{
|
|
cidfilter_t *filter, *prevfilter = NULL;
|
|
|
|
for( filter = cidfilter; filter; filter = filter->next )
|
|
{
|
|
if( Q_strcmp( filter->id, id ) )
|
|
{
|
|
prevfilter = filter;
|
|
continue;
|
|
}
|
|
|
|
if( filter == cidfilter )
|
|
{
|
|
cidfilter = cidfilter->next;
|
|
Mem_Free( filter );
|
|
return;
|
|
}
|
|
|
|
if( prevfilter )
|
|
prevfilter->next = filter->next;
|
|
Mem_Free( filter );
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void SV_RemoveIP( uint ip, uint mask )
|
|
{
|
|
ipfilter_t *filter, *prevfilter = NULL;
|
|
|
|
for( filter = ipfilter; filter; filter = filter->next )
|
|
{
|
|
if( filter->ip != ip || mask != filter->mask )
|
|
{
|
|
prevfilter = filter;
|
|
continue;
|
|
}
|
|
|
|
if( filter == ipfilter )
|
|
{
|
|
ipfilter = ipfilter->next;
|
|
Mem_Free( filter );
|
|
return;
|
|
}
|
|
|
|
if( prevfilter )
|
|
prevfilter->next = filter->next;
|
|
Mem_Free( filter );
|
|
return;
|
|
}
|
|
}
|
|
|
|
qboolean SV_CheckID( const char *id )
|
|
{
|
|
qboolean ret = false;
|
|
cidfilter_t *filter;
|
|
|
|
for( filter = cidfilter; filter; filter = filter->next )
|
|
{
|
|
int len1 = Q_strlen( id ), len2 = Q_strlen( filter->id );
|
|
int len = Q_min( len1, len2 );
|
|
|
|
while( filter->endTime && host.realtime > filter->endTime )
|
|
{
|
|
char *fid = filter->id;
|
|
filter = filter->next;
|
|
SV_RemoveID( fid );
|
|
if( !filter )
|
|
return false;
|
|
}
|
|
|
|
if( !Q_strncmp( id, filter->id, len ) )
|
|
{
|
|
ret = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
qboolean SV_CheckIP( netadr_t *addr )
|
|
{
|
|
uint ip = addr->ip[0] << 24 | addr->ip[1] << 16 | addr->ip[2] << 8 | addr->ip[3];
|
|
qboolean ret = false;
|
|
ipfilter_t *filter;
|
|
|
|
for( filter = ipfilter; filter; filter = filter->next )
|
|
{
|
|
while( filter->endTime && host.realtime > filter->endTime )
|
|
{
|
|
uint rip = filter->ip;
|
|
uint rmask = filter->mask;
|
|
SV_RemoveIP( rip, rmask );
|
|
filter = filter->next;
|
|
if( !filter )
|
|
return false;
|
|
}
|
|
|
|
if( (ip & filter->mask) == (filter->ip & filter->mask) )
|
|
{
|
|
ret = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void SV_BanID_f( void )
|
|
{
|
|
float time = Q_atof( Cmd_Argv( 1 ) );
|
|
const char *id = Cmd_Argv( 2 );
|
|
sv_client_t *cl = NULL;
|
|
cidfilter_t *filter;
|
|
|
|
if( time )
|
|
time = host.realtime + time * 60.0f;
|
|
|
|
if( !id[0] )
|
|
{
|
|
Con_Reportf( S_USAGE "banid <minutes> <#userid or unique id>\n0 minutes for permanent ban\n" );
|
|
return;
|
|
}
|
|
|
|
if( !Q_strnicmp( id, "STEAM_", 6 ) || !Q_strnicmp( id, "VALVE_", 6 ) )
|
|
id += 6;
|
|
if( !Q_strnicmp( id, "XASH_", 5 ) )
|
|
id += 5;
|
|
|
|
if( svs.clients )
|
|
{
|
|
if( id[0] == '#' )
|
|
cl = SV_ClientById( Q_atoi( id + 1 ) );
|
|
|
|
if( !cl )
|
|
{
|
|
int i;
|
|
sv_client_t *cl1;
|
|
int len = Q_strlen( id );
|
|
|
|
for( i = 0, cl1 = svs.clients; i < sv_maxclients->value; i++, cl1++ )
|
|
{
|
|
if( !Q_strncmp( id, Info_ValueForKey( cl1->useragent, "uuid" ), len ) )
|
|
{
|
|
cl = cl1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !cl )
|
|
{
|
|
Con_DPrintf( S_WARN "banid: no such player\n" );
|
|
}
|
|
else
|
|
id = Info_ValueForKey( cl->useragent, "uuid" );
|
|
|
|
if( !id[0] )
|
|
{
|
|
Con_DPrintf( S_ERROR "Could not ban, not implemented yet\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( !id[0] || id[0] == '#' )
|
|
{
|
|
Con_DPrintf( S_ERROR "banid: bad id\n" );
|
|
return;
|
|
}
|
|
|
|
SV_RemoveID( id );
|
|
|
|
filter = Mem_Malloc( host.mempool, sizeof( cidfilter_t ) );
|
|
filter->endTime = time;
|
|
filter->next = cidfilter;
|
|
Q_strncpy( filter->id, id, sizeof( filter->id ) );
|
|
cidfilter = filter;
|
|
|
|
if( cl && !Q_stricmp( Cmd_Argv( Cmd_Argc() - 1 ), "kick" ) )
|
|
Cbuf_AddText( va( "kick #%d \"Kicked and banned\"\n", cl->userid ) );
|
|
}
|
|
|
|
static void SV_ListID_f( void )
|
|
{
|
|
cidfilter_t *filter;
|
|
|
|
Con_Reportf( "id ban list\n" );
|
|
Con_Reportf( "-----------\n" );
|
|
|
|
for( filter = cidfilter; filter; filter = filter->next )
|
|
{
|
|
if( filter->endTime && host.realtime > filter->endTime )
|
|
continue; // no negative time
|
|
|
|
if( filter->endTime )
|
|
Con_Reportf( "%s expries in %f minutes\n", filter->id, ( filter->endTime - host.realtime ) / 60.0f );
|
|
else
|
|
Con_Reportf( "%s permanent\n", filter->id );
|
|
}
|
|
}
|
|
|
|
static void SV_RemoveID_f( void )
|
|
{
|
|
const char *id = Cmd_Argv( 1 );
|
|
|
|
if( id[0] == '#' && svs.clients )
|
|
{
|
|
int num = Q_atoi( id + 1 );
|
|
|
|
if( num >= sv_maxclients->value || num < 0 )
|
|
return;
|
|
|
|
id = Info_ValueForKey( svs.clients[num].useragent, "uuid" );
|
|
}
|
|
|
|
if( !id[0] )
|
|
{
|
|
Con_Reportf( S_USAGE "removeid <#slotnumber or uniqueid>\n");
|
|
return;
|
|
}
|
|
|
|
SV_RemoveID( id );
|
|
}
|
|
|
|
static void SV_WriteID_f( void )
|
|
{
|
|
file_t *f = FS_Open( Cvar_VariableString( "bannedcfgfile" ), "w", false );
|
|
cidfilter_t *filter;
|
|
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "Could not write %s\n", Cvar_VariableString( "bannedcfgfile" ) );
|
|
return;
|
|
}
|
|
|
|
FS_Printf( f, "//=======================================================================\n" );
|
|
FS_Printf( f, "//\t\tCopyright Flying With Gauss Team %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
|
|
FS_Printf( f, "//\t\t %s - archive of id blacklist\n", Cvar_VariableString( "bannedcfgfile" ) );
|
|
FS_Printf( f, "//=======================================================================\n" );
|
|
|
|
for( filter = cidfilter; filter; filter = filter->next )
|
|
if( !filter->endTime ) // only permanent
|
|
FS_Printf( f, "banid 0 %s\n", filter->id );
|
|
|
|
FS_Close( f );
|
|
}
|
|
|
|
static qboolean StringToIP( const char *str, const char *maskstr, uint *outip, uint *outmask )
|
|
{
|
|
byte ip[4] = {0};
|
|
byte mask[4] = {0};
|
|
int i = 0;
|
|
|
|
if( *str > '9' || *str < '0' )
|
|
return false;
|
|
|
|
do
|
|
{
|
|
while( *str <= '9' && *str >= '0' )
|
|
{
|
|
ip[i] *=10;
|
|
ip[i] += *str - '0';
|
|
str++;
|
|
}
|
|
mask[i] = 255;
|
|
i++;
|
|
if( *str != '.' ) break;
|
|
str++;
|
|
} while( i < 4 );
|
|
|
|
i = 0;
|
|
|
|
if( !maskstr || *maskstr > '9' || *maskstr < '0' )
|
|
goto end;
|
|
|
|
do
|
|
{
|
|
byte mask1 = 0;
|
|
while( *maskstr <= '9' && *maskstr >= '0' )
|
|
{
|
|
mask1 *=10;
|
|
mask1 += *maskstr - '0';
|
|
maskstr++;
|
|
}
|
|
mask[i] &= mask1;
|
|
i++;
|
|
if( *maskstr != '.' ) break;
|
|
maskstr++;
|
|
} while( i < 4 );
|
|
|
|
end:
|
|
*outip = ip[0] << 24 | ip[1] << 16 | ip[2] << 8 | ip[3];
|
|
if( outmask )
|
|
*outmask = mask[0] << 24 | mask[1] << 16 | mask[2] << 8 | mask[3];
|
|
|
|
return true;
|
|
}
|
|
|
|
#define IPARGS(ip) (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, ip & 0xFF
|
|
static void SV_AddIP_f( void )
|
|
{
|
|
float time = Q_atof( Cmd_Argv( 1 ) );
|
|
const char *ipstr = Cmd_Argv( 2 );
|
|
const char *maskstr = Cmd_Argv( 3 );
|
|
uint ip, mask;
|
|
ipfilter_t *filter;
|
|
|
|
if( time )
|
|
time = host.realtime + time * 60.0f;
|
|
|
|
if( !StringToIP( ipstr, maskstr, &ip, &mask ) )
|
|
{
|
|
Con_Reportf( S_USAGE "addip <minutes> <ip> [mask]\n0 minutes for permanent ban\n");
|
|
return;
|
|
}
|
|
|
|
SV_RemoveIP( ip, mask );
|
|
|
|
filter = Mem_Malloc( host.mempool, sizeof( ipfilter_t ) );
|
|
filter->endTime = time;
|
|
filter->ip = ip;
|
|
filter->mask = mask;
|
|
filter->next = ipfilter;
|
|
|
|
ipfilter = filter;
|
|
}
|
|
|
|
static void SV_ListIP_f( void )
|
|
{
|
|
ipfilter_t *filter;
|
|
|
|
Con_Reportf( "ip ban list\n" );
|
|
Con_Reportf( "-----------\n" );
|
|
|
|
for( filter = ipfilter; filter; filter = filter->next )
|
|
{
|
|
if( filter->endTime && host.realtime > filter->endTime )
|
|
continue; // no negative time
|
|
|
|
if( filter->endTime )
|
|
Con_Reportf( "%d.%d.%d.%d %d.%d.%d.%d expries in %f minutes\n", IPARGS( filter->ip ), IPARGS( filter->mask ), ( filter->endTime - host.realtime ) / 60.0f );
|
|
else
|
|
Con_Reportf( "%d.%d.%d.%d %d.%d.%d.%d permanent\n", IPARGS( filter->ip ), IPARGS( filter->mask ) );
|
|
}
|
|
}
|
|
|
|
static void SV_RemoveIP_f( void )
|
|
{
|
|
uint ip, mask;
|
|
|
|
if( !StringToIP( Cmd_Argv(1), Cmd_Argv(2), &ip, &mask ) )
|
|
{
|
|
Con_Reportf( S_USAGE "removeip <ip> [mask]\n" );
|
|
return;
|
|
}
|
|
|
|
SV_RemoveIP( ip, mask );
|
|
}
|
|
|
|
static void SV_WriteIP_f( void )
|
|
{
|
|
file_t *f = FS_Open( Cvar_VariableString( "listipcfgfile" ), "w", false );
|
|
ipfilter_t *filter;
|
|
|
|
if( !f )
|
|
{
|
|
Con_DPrintf( S_ERROR "Could not write %s\n", Cvar_VariableString( "listipcfgfile" ) );
|
|
return;
|
|
}
|
|
|
|
FS_Printf( f, "//=======================================================================\n" );
|
|
FS_Printf( f, "//\t\tCopyright Flying With Gauss Team %s ©\n", Q_timestamp( TIME_YEAR_ONLY ));
|
|
FS_Printf( f, "//\t\t %s - archive of IP blacklist\n", Cvar_VariableString( "listipcfgfile" ) );
|
|
FS_Printf( f, "//=======================================================================\n" );
|
|
|
|
for( filter = ipfilter; filter; filter = filter->next )
|
|
if( !filter->endTime ) // only permanent
|
|
FS_Printf( f, "addip 0 %d.%d.%d.%d %d.%d.%d.%d\n", IPARGS(filter->ip), IPARGS(filter->mask) );
|
|
|
|
FS_Close( f );
|
|
}
|
|
|
|
void SV_InitFilter( void )
|
|
{
|
|
Cmd_AddRestrictedCommand( "banid", SV_BanID_f, "ban player by ID" );
|
|
Cmd_AddRestrictedCommand( "listid", SV_ListID_f, "list banned players" );
|
|
Cmd_AddRestrictedCommand( "removeid", SV_RemoveID_f, "remove player from banned list" );
|
|
Cmd_AddRestrictedCommand( "writeid", SV_WriteID_f, "write banned.cfg" );
|
|
Cmd_AddRestrictedCommand( "addip", SV_AddIP_f, "add entry to IP filter" );
|
|
Cmd_AddRestrictedCommand( "listip", SV_ListIP_f, "list current IP filter" );
|
|
Cmd_AddRestrictedCommand( "removeip", SV_RemoveIP_f, "remove IP filter" );
|
|
Cmd_AddRestrictedCommand( "writeip", SV_WriteIP_f, "write listip.cfg" );
|
|
}
|
|
|
|
void SV_ShutdownFilter( void )
|
|
{
|
|
ipfilter_t *ipList, *ipNext;
|
|
cidfilter_t *cidList, *cidNext;
|
|
|
|
// should be called manually because banned.cfg is not executed by engine
|
|
//SV_WriteIP_f();
|
|
//SV_WriteID_f();
|
|
|
|
for( ipList = ipfilter; ipList; ipList = ipNext )
|
|
{
|
|
ipNext = ipList->next;
|
|
Mem_Free( ipList );
|
|
}
|
|
|
|
for( cidList = cidfilter; cidList; cidList = cidNext )
|
|
{
|
|
cidNext = cidList->next;
|
|
Mem_Free( cidList );
|
|
}
|
|
|
|
cidfilter = NULL;
|
|
ipfilter = NULL;
|
|
}
|