/*
==================
SV_Kick_f
Kick a user off of the server
==================
*/
void SV_Kick_f( void )
{
if( Cmd_Argc() != 2 )
{
Msg( "Usage: kick <userid> | <name>\n" );
return;
}
if( !SV_SetPlayer( )) return;
if( NET_IsLocalAddress( svs.currentPlayer->netchan.remote_address ))
{
Msg( "The local player cannot be kicked!\n" );
return;
}
SV_BroadcastPrintf( PRINT_HIGH, "%s was kicked\n", svs.currentPlayer->name );
SV_ClientPrintf( svs.currentPlayer, PRINT_HIGH, "You were kicked from the game\n" );
SV_DropClient( svs.currentPlayer );
Log_Printf( "Kick: \"%s<%i><%s><>\" was kicked by \"Console\"\n", svs.currentPlayer->name,
svs.currentPlayer->userid, SV_GetClientIDString ( svs.currentPlayer ) );
// min case there is a funny zombie
svs.currentPlayer->lastmessage = host.realtime;
}
void CL_ReadPackets( void )
{
CL_ReadNetMessage();
cl.lerpFrac = CL_LerpPoint();
cl.thirdperson = clgame.dllFuncs.CL_IsThirdPerson();
#if 0
// keep cheat cvars are unchanged
if( cl.maxclients > 1 && cls.state == ca_active && host.developer <= 1 )
Cvar_SetCheatState();
#endif
// singleplayer never has connection timeout
if( NET_IsLocalAddress( cls.netchan.remote_address ))
return;
// check timeout
if( cls.state >= ca_connected && !cls.demoplayback && cls.state != ca_cinematic )
{
if( host.realtime - cls.netchan.last_received > cl_timeout->value )
{
if( ++cl.timeoutcount > 5 ) // timeoutcount saves debugger
{
Msg( "\nServer connection timed out.\n" );
CL_Disconnect();
CL_ClearEdicts();
return;
}
}
}
else cl.timeoutcount = 0;
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
char *val=NULL, *ip=NULL;
int i=0, len=0;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 && sv_lanForceRate->integer == 1 ) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
// snaps command
//Note: cl->snapshotMsec is also validated in sv_main.cpp -> SV_CheckCvars if sv_fps, sv_snapsMin or sv_snapsMax is changed
int minSnaps = Com_Clampi( 1, sv_snapsMax->integer, sv_snapsMin->integer ); // between 1 and sv_snapsMax ( 1 <-> 40 )
int maxSnaps = min( sv_fps->integer, sv_snapsMax->integer ); // can't produce more than sv_fps snapshots/sec, but can send less than sv_fps snapshots/sec
val = Info_ValueForKey( cl->userinfo, "snaps" );
cl->wishSnaps = atoi( val );
i = Com_Clampi( minSnaps, maxSnaps, cl->wishSnaps );
cl->snapshotMsec = 1000/i;
// TTimo
// maintain the IP information
// the banning code relies on this being consistently present
if( NET_IsLocalAddress(cl->netchan.remoteAddress) )
ip = "localhost";
else
ip = (char*)NET_AdrToString( cl->netchan.remoteAddress );
val = Info_ValueForKey( cl->userinfo, "ip" );
if( val[0] )
len = strlen( ip ) - strlen( val ) + strlen( cl->userinfo );
else
len = strlen( ip ) + 4 + strlen( cl->userinfo );
if( len >= MAX_INFO_STRING )
SV_DropClient( cl, "userinfo string length exceeded" );
else
Info_SetValueForKey( cl->userinfo, "ip", ip );
}
/*
===============
Netchan_CanPacket
Returns true if the bandwidth choke isn't active
================
*/
qboolean Netchan_CanPacket( netchan_t *chan )
{
// never choke loopback packets.
if( !net_chokeloopback->integer && NET_IsLocalAddress( chan->remote_address ))
{
chan->cleartime = host.realtime;
return true;
}
if( chan->cleartime < host.realtime )
{
return true;
}
return false;
}
/*
* NET_IsLANAddress
*
* FIXME: This function apparently doesn't support CIDR
*/
qboolean NET_IsLANAddress( const netadr_t *address )
{
if( NET_IsLocalAddress( address ) )
return qtrue;
switch( address->type )
{
case NA_IP:
{
const netadr_ipv4_t *addr4 = &address->address.ipv4;
// RFC1918:
// 10.0.0.0 - 10.255.255.255 (10/8 prefix)
// 172.16.0.0 - 172.31.255.255 (172.16/12 prefix)
// 192.168.0.0 - 192.168.255.255 (192.168/16 prefix)
if( addr4->ip[0] == 10 )
return qtrue;
if( addr4->ip[0] == 172 && ( addr4->ip[1]&0xf0 ) == 16 )
return qtrue;
if( addr4->ip[0] == 192 && addr4->ip[1] == 168 )
return qtrue;
}
case NA_IP6:
{
const netadr_ipv6_t *addr6 = &address->address.ipv6;
// Local addresses are either the loopback adress (tested earlier), or fe80::/10
if ( addr6->ip[0] == 0xFE && ( addr6->ip[1] & 0xC0 ) == 0x80 ) {
return qtrue;
}
// private address space
if ( ( addr6->ip[0] & 0xFE ) == 0xFC ) {
return qtrue;
}
}
default:
return qfalse;
}
return qfalse;
}
/*
=======================
SV_RateDrop
Returns true if the client is over its current
bandwidth estimation and should not be sent another packet
=======================
*/
bool SV_RateDrop( sv_client_t *cl )
{
int i, total = 0;
// never drop over the loopback
if( NET_IsLocalAddress( cl->netchan.remote_address ))
return false;
for( i = 0; i < RATE_MESSAGES; i++ )
total += cl->message_size[i];
if( total > cl->rate )
{
cl->surpressCount++;
cl->message_size[sv.framenum % RATE_MESSAGES] = 0;
return true;
}
return false;
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
char *val;
int i;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 && sv_lanForceRate->integer == 1) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
val = Info_ValueForKey (cl->userinfo, "handicap");
if (strlen(val)) {
i = atoi(val);
if (i<=0 || i>100 || strlen(val) > 4) {
Info_SetValueForKey( cl->userinfo, "handicap", "100" );
}
}
// snaps command
val = Info_ValueForKey (cl->userinfo, "snaps");
if (strlen(val)) {
i = atoi(val);
if ( i < 1 ) {
i = 1;
} else if ( i > sv_fps->integer ) {
i = sv_fps->integer;
}
cl->snapshotMsec = 1000/i;
} else {
cl->snapshotMsec = 50;
}
// TTimo
// maintain the IP information
// this is set in SV_DirectConnect (directly on the server, not transmitted), may be lost when client updates it's userinfo
// the banning code relies on this being consistently present
val = Info_ValueForKey (cl->userinfo, "ip");
if (!val[0])
{
//Com_DPrintf("Maintain IP in userinfo for '%s'\n", cl->name);
if ( !NET_IsLocalAddress(cl->netchan.remoteAddress) )
Info_SetValueForKey( cl->userinfo, "ip", NET_AdrToString( cl->netchan.remoteAddress ) );
else
// force the "ip" info key to "localhost" for local clients
Info_SetValueForKey( cl->userinfo, "ip", "localhost" );
}
}
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
client_t temp;
sharedEntity_t *ent;
int clientNum;
int qport;
int challenge;
char *password;
int startIndex;
intptr_t denied;
int count;
Com_DPrintf ("SVC_DirectConnect ()\n");
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
if ( Q_stricmp( Info_ValueForKey( userinfo, "protocol" ), PROTOCOL_VERSION ) ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version "PROTOCOL_VERSION".\n" );
Com_DPrintf (" rejected connect from version %s\n", Info_ValueForKey( userinfo, "protocol" ));
return;
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
if (( svs.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000)) {
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
break;
}
}
// see if the challenge is valid (LAN clients don't need to challenge)
if ( !NET_IsLocalAddress (from) ) {
int ping;
for (i=0 ; i<MAX_CHALLENGES ; i++) {
if (NET_CompareAdr(from, svs.challenges[i].adr)) {
if ( challenge == svs.challenges[i].challenge ) {
break; // good
}
}
}
if (i == MAX_CHALLENGES) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for address.\n" );
return;
}
// force the IP key/value pair so the game can filter based on ip
Info_SetValueForKey( userinfo, "ip", NET_AdrToString( from ) );
ping = svs.time - svs.challenges[i].pingTime;
Com_Printf( "Client %i connecting with %i challenge ping\n", i, ping );
svs.challenges[i].connected = qtrue;
// never reject a LAN client based on ping
if ( !Sys_IsLANAddress( from ) ) {
if ( sv_minPing->value && ping < sv_minPing->value ) {
// don't let them keep trying until they get a big delay
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for high pings only\n" );
Com_DPrintf ("Client %i rejected on a too low ping\n", i);
// reset the address otherwise their ping will keep increasing
// with each connect message and they'd eventually be able to connect
svs.challenges[i].adr.port = 0;
return;
}
if ( sv_maxPing->value && ping > sv_maxPing->value ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for low pings only\n" );
Com_DPrintf ("Client %i rejected on a too high ping\n", i);
return;
}
}
} else {
// force the "ip" info key to "localhost"
Info_SetValueForKey( userinfo, "ip", "localhost" );
}
newcl = &temp;
Com_Memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
// this doesn't work because it nukes the players userinfo
// // disconnect the client from the game first so any flags the
// // player might have are dropped
// VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( !strcmp( password, sv_privatePassword->string ) ) {
startIndex = 0;
} else {
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = NULL;
for ( i = startIndex; i < MAX_PLAYERS ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
if ( NET_IsLocalAddress( from ) ) {
count = 0;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->netchan.remoteAddress.type == NA_BOT) {
count++;
}
}
// if they're all bots
if (count >= sv_maxclients->integer - startIndex) {
SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
newcl = &svs.clients[sv_maxclients->integer - 1];
}
else {
Com_Error( ERR_FATAL, "server is full on local connect\n" );
return;
}
}
else {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is full.\n" );
Com_DPrintf ("Rejected a connection.\n");
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the challenge
newcl->challenge = challenge;
// save the address
Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
// init the netchan queue
newcl->netchan_end_queue = &newcl->netchan_start_queue;
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
// get the game a chance to reject this connection or modify the userinfo
denied = VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) {
// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
char *str = VM_ExplicitArgPtr( gvm, denied );
NET_OutOfBandPrint( NS_SERVER, from, "error\n%s\n", str );
Com_DPrintf ("Game rejected a connection: %s.\n", str);
return;
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
newcl->state = CS_CONNECTED;
newcl->nextSnapshotTime = svs.time;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
===================
CL_WritePacket
Create and send the command packet to the server
Including both the reliable commands and the usercmds
===================
*/
void CL_WritePacket( void )
{
sizebuf_t buf;
qboolean send_command = false;
byte data[MAX_CMD_BUFFER];
int i, from, to, key, size;
int numbackup = 2;
int numcmds;
int newcmds;
int cmdnumber;
// don't send anything if playing back a demo
if( cls.demoplayback || cls.state == ca_cinematic )
return;
if( cls.state == ca_disconnected || cls.state == ca_connecting )
return;
CL_ComputePacketLoss ();
#ifndef _DEBUG
if( cl_cmdrate->value < MIN_CMD_RATE )
{
Cvar_SetFloat( "cl_cmdrate", MIN_CMD_RATE );
}
#endif
Q_memset( data, 0, MAX_CMD_BUFFER );
BF_Init( &buf, "ClientData", data, sizeof( data ));
// Determine number of backup commands to send along
numbackup = bound( 0, cl_cmdbackup->integer, MAX_BACKUP_COMMANDS );
if( cls.state == ca_connected ) numbackup = 0;
// Check to see if we can actually send this command
// In single player, send commands as fast as possible
// Otherwise, only send when ready and when not choking bandwidth
if(( cl.maxclients == 1 ) || ( NET_IsLocalAddress( cls.netchan.remote_address ) && !host_limitlocal->integer ))
send_command = true;
else if(( host.realtime >= cls.nextcmdtime ) && Netchan_CanPacket( &cls.netchan ))
send_command = true;
if( cl.force_send_usercmd )
{
send_command = true;
cl.force_send_usercmd = false;
}
if(( cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged ) >= CL_UPDATE_MASK )
{
if(( host.realtime - cls.netchan.last_received ) > CONNECTION_PROBLEM_TIME )
{
Con_NPrintf( 1, "^3Warning:^1 Connection Problem^7\n" );
cl.validsequence = 0;
}
}
if( cl_nodelta->integer )
{
cl.validsequence = 0;
}
// send a userinfo update if needed
if( userinfo->modified )
{
BF_WriteByte( &cls.netchan.message, clc_userinfo );
BF_WriteString( &cls.netchan.message, Cvar_Userinfo( ));
}
if( send_command )
{
int outgoing_sequence;
if( cl_cmdrate->integer > 0 )
cls.nextcmdtime = host.realtime + ( 1.0f / cl_cmdrate->value );
else cls.nextcmdtime = host.realtime; // always able to send right away
if( cls.lastoutgoingcommand == -1 )
{
outgoing_sequence = cls.netchan.outgoing_sequence;
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
}
else outgoing_sequence = cls.lastoutgoingcommand + 1;
// begin a client move command
BF_WriteByte( &buf, clc_move );
// save the position for a checksum byte
key = BF_GetRealBytesWritten( &buf );
BF_WriteByte( &buf, 0 );
// write packet lossage percentation
BF_WriteByte( &buf, cls.packet_loss );
// say how many backups we'll be sending
BF_WriteByte( &buf, numbackup );
// how many real commands have queued up
newcmds = ( cls.netchan.outgoing_sequence - cls.lastoutgoingcommand );
// put an upper/lower bound on this
newcmds = bound( 0, newcmds, MAX_TOTAL_CMDS );
if( cls.state == ca_connected ) newcmds = 0;
BF_WriteByte( &buf, newcmds );
numcmds = newcmds + numbackup;
from = -1;
for( i = numcmds - 1; i >= 0; i-- )
{
cmdnumber = ( cls.netchan.outgoing_sequence - i ) & CL_UPDATE_MASK;
to = cmdnumber;
CL_WriteUsercmd( &buf, from, to );
from = to;
if( BF_CheckOverflow( &buf ))
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// calculate a checksum over the move commands
size = BF_GetRealBytesWritten( &buf ) - key - 1;
buf.pData[key] = CRC32_BlockSequence( buf.pData + key + 1, size, cls.netchan.outgoing_sequence );
// message we are constructing.
i = cls.netchan.outgoing_sequence & CL_UPDATE_MASK;
// determine if we need to ask for a new set of delta's.
if( cl.validsequence && (cls.state == ca_active) && !( cls.demorecording && cls.demowaiting ))
{
cl.delta_sequence = cl.validsequence;
BF_WriteByte( &buf, clc_delta );
BF_WriteByte( &buf, cl.validsequence & 0xFF );
}
else
{
// request delta compression of entities
cl.delta_sequence = -1;
}
if( BF_CheckOverflow( &buf ))
{
Host_Error( "CL_Move, overflowed command buffer (%i bytes)\n", MAX_CMD_BUFFER );
}
// remember outgoing command that we are sending
cls.lastoutgoingcommand = cls.netchan.outgoing_sequence;
// composite the rest of the datagram..
if( BF_GetNumBitsWritten( &cls.datagram ) <= BF_GetNumBitsLeft( &buf ))
BF_WriteBits( &buf, BF_GetData( &cls.datagram ), BF_GetNumBitsWritten( &cls.datagram ));
BF_Clear( &cls.datagram );
// deliver the message (or update reliable)
Netchan_Transmit( &cls.netchan, BF_GetNumBytesWritten( &buf ), BF_GetData( &buf ));
}
else
{
// increment sequence number so we can detect that we've held back packets.
cls.netchan.outgoing_sequence++;
}
if( cls.demorecording )
{
// Back up one because we've incremented outgoing_sequence each frame by 1 unit
cmdnumber = ( cls.netchan.outgoing_sequence - 1 ) & CL_UPDATE_MASK;
CL_WriteDemoUserCmd( cmdnumber );
}
// update download/upload slider.
Netchan_UpdateProgress( &cls.netchan );
}
/*
==================
cDirectConnect
A connection request that did not come from the master
==================
*/
static void cDirectConnect(int argc, char **argv)
{
int i;
netadr_t adr = net_from;
Com_DPrintf("SVC_DirectConnect()\n");
int version = atoi(argv[1]);
if (version != PROTOCOL_VERSION)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nServer is version %4.2f.\n", VERSION);
Com_DPrintf(" rejected connect from version %d\n", version);
return;
}
int port = atoi(argv[2]);
int challenge = atoi(argv[3]);
// get userinfo
char userinfo[MAX_INFO_STRING];
appStrncpyz(userinfo, argv[4], sizeof(userinfo));
// force the IP key/value pair to be in userinfo (for game-side IP filters)
Info_SetValueForKey(userinfo, "ip", NET_AdrToString(&net_from));
// attractloop servers are ONLY for local clients
if (sv.attractloop)
{
if (!NET_IsLocalAddress(&adr))
{
appPrintf("Remote connect in attract loop. Ignored.\n");
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n");
return;
}
}
// see if the challenge is valid
if (!NET_IsLocalAddress(&adr))
{
for (i = 0; i < MAX_CHALLENGES; i++)
if (NET_CompareBaseAdr(&net_from, &svs.challenges[i].adr))
{
if (challenge == svs.challenges[i].challenge)
break; // good
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nBad challenge.\n");
return;
}
if (i == MAX_CHALLENGES)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nNo challenge for address.\n");
return;
}
}
client_t temp, *cl;
memset(&temp, 0, sizeof(client_t));
client_t *newcl = NULL;
// if there is already a slot for this ip, reuse it
for (i = 0, cl = svs.clients; i < sv_maxclients->integer; i++,cl++)
{
if (cl->state == cs_free) continue;
if (NET_CompareBaseAdr(&adr, &cl->netchan.remote_address) &&
(cl->netchan.port == port || adr.port == cl->netchan.remote_address.port))
{
if (!NET_IsLocalAddress(&adr) && (svs.realtime - cl->lastconnect) < (sv_reconnect_limit->integer * 1000))
{
Com_DPrintf("%s:reconnect rejected : too soon\n", NET_AdrToString(&adr));
return;
}
appPrintf("%s:reconnect\n", NET_AdrToString(&adr));
newcl = cl;
break;
}
}
// find a client slot
if (!newcl)
{
for (i = 0, cl = svs.clients; i < sv_maxclients->integer; i++,cl++)
if (cl->state == cs_free)
{
newcl = cl;
break;
}
}
if (!newcl)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nServer is full.\n");
Com_DPrintf("Rejected a connection.\n");
return;
}
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
sv_client = newcl;
int edictnum = (newcl-svs.clients)+1;
edict_t *ent = EDICT_NUM(edictnum);
newcl->edict = ent;
newcl->challenge = challenge; // save challenge for checksumming
// get the game a chance to reject this connection or modify the userinfo
qboolean result;
guardGame(ge.ClientConnect);
result = ge->ClientConnect(ent, userinfo);
unguardGame;
if (!result)
{
if (*Info_ValueForKey(userinfo, "rejmsg"))
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\n%s\nConnection refused.\n",
Info_ValueForKey(userinfo, "rejmsg"));
else
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n" );
Com_DPrintf("Game rejected a connection.\n");
return;
}
// parse some info from the info strings
newcl->Userinfo = userinfo;
SV_UserinfoChanged(newcl);
// check if client trying to connect with a new protocol
newcl->newprotocol = !strcmp(argv [5], NEW_PROTOCOL_ID) && sv_extProtocol->integer;
// send the connect packet to the client
if (newcl->newprotocol)
{
int ver = atoi(argv[6]);
if (ver != NEW_PROTOCOL_VERSION)
{
//?? we may also perform extended protocol checking by adding "[cl_]extprotocol" to userinfo
Com_DPrintf("Client used extended protocol %d != "STR(NEW_PROTOCOL_VERSION)"\n", ver);
if (ver < NEW_PROTOCOL_VERSION)
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\n"
S_YELLOW"Server provides newer version of extended protocol\nPlease upgrade your client\n" );
newcl->newprotocol = false;
}
}
if (newcl->newprotocol)
{
Com_DPrintf("Connecting client using extended protocol\n");
Netchan_OutOfBandPrint(NS_SERVER, adr, "client_connect "NEW_PROTOCOL_ID" "STR(NEW_PROTOCOL_VERSION));
}
else
Netchan_OutOfBandPrint(NS_SERVER, adr, "client_connect");
newcl->netchan.Setup(NS_SERVER, adr, port);
newcl->maxPacketSize = cl->newprotocol ? MAX_MSGLEN : MAX_MSGLEN_OLD;
newcl->state = cs_connected;
newcl->datagram.Init(newcl->datagram_buf, sizeof(newcl->datagram_buf));
newcl->datagram.allowoverflow = true;
newcl->lastmessage = svs.realtime; // don't timeout
newcl->lastconnect = svs.realtime;
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
MAC_STATIC client_t temp;
gentity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
char *denied;
Com_DPrintf ("SVC_DirectConnect ()\n");
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
if ( version != PROTOCOL_VERSION ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i.\n", PROTOCOL_VERSION );
Com_DPrintf (" rejected connect from version %i\n", version);
return;
}
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
// see if the challenge is valid (local clients don't need to challenge)
if ( !NET_IsLocalAddress (from) ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nNo challenge for address.\n" );
return;
} else {
// force the "ip" info key to "localhost"
Info_SetValueForKey( userinfo, "ip", "localhost" );
}
newcl = &temp;
memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < 1 ; i++,cl++)
{
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) )
{
if (( sv.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000))
{
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
goto gotnewcl;
}
}
newcl = NULL;
for ( i = 0; i < 1 ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is full.\n" );
Com_DPrintf ("Rejected a connection.\n");
return;
}
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the address
Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
// get the game a chance to reject this connection or modify the userinfo
denied = ge->ClientConnect( clientNum, qtrue, eSavedGameJustLoaded ); // firstTime = qtrue
if ( denied ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
Com_DPrintf ("Game rejected a connection: %s.\n", denied);
return;
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
newcl->state = CS_CONNECTED;
newcl->nextSnapshotTime = sv.time;
newcl->lastPacketTime = sv.time;
newcl->lastConnectTime = sv.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from, const Cmd::Args& args )
{
char userinfo[ MAX_INFO_STRING ];
int i;
client_t *cl, *newcl;
client_t temp;
sharedEntity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
const char *password;
int startIndex;
bool denied;
char reason[ MAX_STRING_CHARS ];
int count;
const char *ip;
#ifdef HAVE_GEOIP
const char *country = nullptr;
#endif
if ( args.Argc() < 2 )
{
return;
}
Log::Debug( "SVC_DirectConnect ()" );
Q_strncpyz( userinfo, args.Argv(1).c_str(), sizeof( userinfo ) );
// DHM - Nerve :: Update Server allows any protocol to connect
// NOTE TTimo: but we might need to store the protocol around for potential non http/ftp clients
version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
if ( version != PROTOCOL_VERSION )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\nServer uses protocol version %i (yours is %i).", PROTOCOL_VERSION, version );
Log::Debug( " rejected connect from version %i", version );
return;
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for ( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
// DHM - Nerve :: This check was allowing clients to reconnect after zombietime(2 secs)
//if ( cl->state == CS_FREE ) {
//continue;
//}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) )
{
if ( ( svs.time - cl->lastConnectTime )
< ( sv_reconnectlimit->integer * 1000 ) )
{
Log::Debug( "%s: reconnect rejected: too soon", NET_AdrToString( from ) );
return;
}
break;
}
}
if ( NET_IsLocalAddress( from ) )
{
ip = "localhost";
}
else
{
ip = NET_AdrToString( from );
}
if ( ( strlen( ip ) + strlen( userinfo ) + 4 ) >= MAX_INFO_STRING )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from,
"print\nUserinfo string length exceeded. "
"Try removing setu cvars from your config." );
return;
}
Info_SetValueForKey( userinfo, "ip", ip, false );
// see if the challenge is valid (local clients don't need to challenge)
if ( !NET_IsLocalAddress( from ) )
{
int ping;
for ( i = 0; i < MAX_CHALLENGES; i++ )
{
if ( NET_CompareAdr( from, svs.challenges[ i ].adr ) )
{
if ( challenge == svs.challenges[ i ].challenge )
{
break; // good
}
}
}
if ( i == MAX_CHALLENGES )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]No or bad challenge for address." );
return;
}
// force the IP address key/value pair, so the game can filter based on it
Info_SetValueForKey( userinfo, "ip", NET_AdrToString( from ), false );
if ( svs.challenges[ i ].firstPing == 0 )
{
ping = svs.time - svs.challenges[ i ].pingTime;
svs.challenges[ i ].firstPing = ping;
}
else
{
ping = svs.challenges[ i ].firstPing;
}
#ifdef HAVE_GEOIP
country = NET_GeoIP_Country( &from );
if ( country )
{
Log::Notice( "Client %i connecting from %s with %i challenge ping\n", i, country, ping );
}
else
{
Log::Notice( "Client %i connecting from somewhere unknown with %i challenge ping\n", i, ping );
}
#else
Log::Notice( "Client %i connecting with %i challenge ping\n", i, ping );
#endif
svs.challenges[ i ].connected = true;
// never reject a LAN client based on ping
if ( !Sys_IsLANAddress( from ) )
{
if ( sv_minPing->value && ping < sv_minPing->value )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]Server is for high pings only" );
Log::Debug( "Client %i rejected on a too low ping", i );
return;
}
if ( sv_maxPing->value && ping > sv_maxPing->value )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]Server is for low pings only" );
Log::Debug( "Client %i rejected on a too high ping: %i", i, ping );
return;
}
}
}
else
{
// force the "ip" info key to "localhost"
Info_SetValueForKey( userinfo, "ip", "localhost", false );
}
newcl = &temp;
memset( newcl, 0, sizeof( client_t ) );
// if there is already a slot for this IP address, reuse it
for ( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if ( cl->state == clientState_t::CS_FREE )
{
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) )
{
Log::Notice( "%s:reconnect\n", NET_AdrToString( from ) );
newcl = cl;
// this doesn't work because it nukes the players userinfo
// // disconnect the client from the game first so any flags the
// // player might have are dropped
// VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( !strcmp( password, sv_privatePassword->string ) )
{
startIndex = 0;
}
else
{
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = nullptr;
for ( i = startIndex; i < sv_maxclients->integer; i++ )
{
cl = &svs.clients[ i ];
if ( cl->state == clientState_t::CS_FREE )
{
newcl = cl;
break;
}
}
if ( !newcl )
{
if ( NET_IsLocalAddress( from ) )
{
count = 0;
for ( i = startIndex; i < sv_maxclients->integer; i++ )
{
cl = &svs.clients[ i ];
if ( SV_IsBot(cl) )
{
count++;
}
}
// if they're all bots
if ( count >= sv_maxclients->integer - startIndex )
{
SV_DropClient( &svs.clients[ sv_maxclients->integer - 1 ], "only bots on server" );
newcl = &svs.clients[ sv_maxclients->integer - 1 ];
}
else
{
Com_Error( errorParm_t::ERR_FATAL, "server is full on local connect" );
}
}
else
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n%s", sv_fullmsg->string );
Log::Debug( "Rejected a connection." );
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = std::move(temp);
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
ent->r.svFlags = 0;
#ifdef HAVE_GEOIP
if ( country )
{
Info_SetValueForKey( userinfo, "geoip", country, false );
}
#endif
// save the challenge
newcl->challenge = challenge;
// save the address
Netchan_Setup( netsrc_t::NS_SERVER, &newcl->netchan, from, qport );
// init the netchan queue
// Save the pubkey
Q_strncpyz( newcl->pubkey, Info_ValueForKey( userinfo, "pubkey" ), sizeof( newcl->pubkey ) );
Info_RemoveKey( userinfo, "pubkey", false );
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof( newcl->userinfo ) );
// get the game a chance to reject this connection or modify the userinfo
denied = gvm.GameClientConnect( reason, sizeof( reason ), clientNum, true, false ); // firstTime = true
if ( denied )
{
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]%s", reason );
Log::Debug( "Game rejected a connection: %s.", reason );
return;
}
SV_UserinfoChanged( newcl );
// DHM - Nerve :: Clear out firstPing now that client is connected
svs.challenges[ i ].firstPing = 0;
// send the connect packet to the client
NET_OutOfBandPrint( netsrc_t::NS_SERVER, from, "connectResponse" );
Log::Debug( "Going from CS_FREE to CS_CONNECTED for %s", newcl->name );
newcl->state = clientState_t::CS_CONNECTED;
newcl->nextSnapshotTime = svs.time;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for ( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if ( svs.clients[ i ].state >= clientState_t::CS_CONNECTED )
{
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer )
{
SV_Heartbeat_f();
}
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl )
{
const char *val;
int i;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey( cl->userinfo, "name" ), sizeof( cl->name ) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// Internet server, assume that they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress )
&& SV_Private(ServerPrivate::LanOnly)
&& sv_lanForceRate->integer == 1 )
{
cl->rate = 99999; // lans should not rate limit
}
else
{
val = Info_ValueForKey( cl->userinfo, "rate" );
if ( strlen( val ) )
{
i = atoi( val );
cl->rate = i;
if ( cl->rate < 1000 )
{
cl->rate = 1000;
}
else if ( cl->rate > 90000 )
{
cl->rate = 90000;
}
}
else
{
cl->rate = 5000;
}
}
// snaps command
val = Info_ValueForKey( cl->userinfo, "snaps" );
if ( strlen( val ) )
{
i = atoi( val );
if ( i < 1 )
{
i = 1;
}
else if ( i > sv_fps->integer )
{
i = sv_fps->integer;
}
cl->snapshotMsec = 1000 / i;
}
else
{
cl->snapshotMsec = 50;
}
// TTimo
// maintain the IP information
// this is set in SV_DirectConnect (directly on the server, not transmitted), may be lost when client updates its userinfo
// the banning code relies on this being consistently present
// zinx - modified to always keep this consistent, instead of only
// when "ip" is 0-length, so users can't supply their own IP address
//Log::Debug("Maintain IP address in userinfo for '%s'", cl->name);
if ( !NET_IsLocalAddress( cl->netchan.remoteAddress ) )
{
Info_SetValueForKey( cl->userinfo, "ip", NET_AdrToString( cl->netchan.remoteAddress ), false );
#ifdef HAVE_GEOIP
Info_SetValueForKey( cl->userinfo, "geoip", NET_GeoIP_Country( &cl->netchan.remoteAddress ), false );
#endif
}
else
{
// force the "ip" info key to "loopback" for local clients
Info_SetValueForKey( cl->userinfo, "ip", "loopback", false );
#ifdef HAVE_GEOIP
Info_SetValueForKey( cl->userinfo, "geoip", nullptr, false );
#endif
}
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
char *val;
char *ip;
int i;
int len;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 ) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
val = Info_ValueForKey (cl->userinfo, "handicap");
if (strlen(val)) {
i = atoi(val);
if (i<=0 || i>100 || strlen(val) > 4) {
Info_SetValueForKey( cl->userinfo, "handicap", "100" );
}
}
// snaps command
val = Info_ValueForKey (cl->userinfo, "snaps");
if (strlen(val)) {
i = atoi(val);
if ( i < 1 ) {
i = 1;
} else if ( i > 30 ) {
i = 30;
}
cl->snapshotMsec = 1000/i;
} else {
cl->snapshotMsec = 50;
}
// TTimo
// maintain the IP information
// the banning code relies on this being consistently present
if( NET_IsLocalAddress(cl->netchan.remoteAddress) )
ip = "localhost";
else
ip = (char*)NET_AdrToString( cl->netchan.remoteAddress );
val = Info_ValueForKey( cl->userinfo, "ip" );
if( val[0] )
len = strlen( ip ) - strlen( val ) + strlen( cl->userinfo );
else
len = strlen( ip ) + 4 + strlen( cl->userinfo );
if( len >= MAX_INFO_STRING )
SV_DropClient( cl, "userinfo string length exceeded" );
else
Info_SetValueForKey( cl->userinfo, "ip", ip );
}
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
client_t temp;
sharedEntity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
char *password;
int startIndex;
intptr_t denied;
int count;
char *ip;
const char *stringEd;
#ifdef LEGACY_PROTOCOL
qboolean compat = qfalse;
#endif
Com_DPrintf ("SVC_DirectConnect ()\n");
// Check whether this client is banned.
if(SV_IsBanned(&from, qfalse))
{
NET_OutOfBandPrint(NS_SERVER, from, "print\nYou are banned from this server.\n");
return;
}
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
version = atoi(Info_ValueForKey(userinfo, "protocol"));
#ifdef LEGACY_PROTOCOL
if(version > 0 && com_legacyprotocol->integer == version)
compat = qtrue;
else
#endif
{
if(version != com_protocol->integer)
{
NET_OutOfBandPrint(NS_SERVER, from, "print\nServer uses protocol version %i "
"(yours is %i).\n", com_protocol->integer, version);
Com_DPrintf(" rejected connect from version %i\n", version);
return;
}
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
if (( svs.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000)) {
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
break;
}
}
// don't let "ip" overflow userinfo string
if ( NET_IsLocalAddress (from) )
ip = "localhost";
else
ip = (char *)NET_AdrToString( from );
if( ( strlen( ip ) + strlen( userinfo ) + 4 ) >= MAX_INFO_STRING ) {
NET_OutOfBandPrint( NS_SERVER, from,
"print\nUserinfo string length exceeded. "
"Try removing setu cvars from your config.\n" );
return;
}
Info_SetValueForKey( userinfo, "ip", ip );
// see if the challenge is valid (LAN clients don't need to challenge)
if (!NET_IsLocalAddress(from))
{
int ping;
challenge_t *challengeptr;
for (i=0; i<MAX_CHALLENGES; i++)
{
if (NET_CompareAdr(from, svs.challenges[i].adr))
{
if(challenge == svs.challenges[i].challenge)
break;
}
}
if (i == MAX_CHALLENGES)
{
NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for your address.\n" );
return;
}
challengeptr = &svs.challenges[i];
if(challengeptr->wasrefused)
{
// Return silently, so that error messages written by the server keep being displayed.
return;
}
ping = svs.time - challengeptr->pingTime;
// never reject a LAN client based on ping
if ( !Sys_IsLANAddress( from ) ) {
if ( sv_minPing->value && ping < sv_minPing->value ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s", SV_StringEdString("SERVER_FOR_HIGH_PING") );
stringEd = SV_GetString("CLIENT_REJECTED_LOW_PING");
Com_DPrintf (stringEd, i);
challengeptr->wasrefused = qtrue;
return;
}
if ( sv_maxPing->value && ping > sv_maxPing->value ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s", SV_StringEdString("SERVER_FOR_LOW_PING") );
stringEd = SV_GetString("CLIENT_REJECTED_LOW_PING");
Com_DPrintf (stringEd, i);
challengeptr->wasrefused = qtrue;
return;
}
}
stringEd = SV_GetString("CLIENT_CONN_WITH_PING");
Com_Printf(stringEd, i, ping);
challengeptr->connected = qtrue;
}
newcl = &temp;
Com_Memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
// this doesn't work because it nukes the players userinfo
// // disconnect the client from the game first so any flags the
// // player might have are dropped
// VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( !strcmp( password, sv_privatePassword->string ) ) {
startIndex = 0;
} else {
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = NULL;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
if ( NET_IsLocalAddress( from ) ) {
count = 0;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->netchan.remoteAddress.type == NA_BOT) {
count++;
}
}
// if they're all bots
if (count >= sv_maxclients->integer - startIndex) {
SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
newcl = &svs.clients[sv_maxclients->integer - 1];
}
else {
Com_Error( ERR_FATAL, "server is full on local connect" );
return;
}
}
else {
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", SV_StringEdString("SERVER_IS_FULL") );
Com_DPrintf ("Rejected a connection.\n");
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the challenge
newcl->challenge = challenge;
// save the address
#ifdef LEGACY_PROTOCOL
newcl->compat = compat;
Netchan_Setup(NS_SERVER, &newcl->netchan, from, qport, challenge, compat);
#else
Netchan_Setup(NS_SERVER, &newcl->netchan, from, qport, challenge, qfalse);
#endif
// init the netchan queue
newcl->netchan_end_queue = &newcl->netchan_start_queue;
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
// get the game a chance to reject this connection or modify the userinfo
denied = VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) {
// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
char *str = VM_ExplicitArgPtr( gvm, denied );
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", str );
Com_DPrintf ("Game rejected a connection: %s.\n", str);
return;
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint(NS_SERVER, from, "connectResponse %d", challenge);
Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
newcl->state = CS_CONNECTED;
newcl->lastSnapshotTime = 0;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
char *val;
char *ip;
int i;
int len;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 && sv_lanForceRate->integer == 1) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
val = Info_ValueForKey (cl->userinfo, "handicap");
if (strlen(val)) {
i = atoi(val);
if (i<=0 || i>100 || strlen(val) > 4) {
Info_SetValueForKey( cl->userinfo, "handicap", "100" );
}
}
// snaps command
val = Info_ValueForKey (cl->userinfo, "snaps");
if(strlen(val))
{
i = atoi(val);
if(i < 1)
i = 1;
else if(i > sv_fps->integer)
i = sv_fps->integer;
i = 1000 / i;
}
else
i = 50;
if(i != cl->snapshotMsec)
{
// Reset last sent snapshot so we avoid desync between server frame time and snapshot send time
cl->lastSnapshotTime = 0;
cl->snapshotMsec = i;
}
#ifdef USE_VOIP
#ifdef LEGACY_PROTOCOL
if(cl->compat)
cl->hasVoip = qfalse;
else
#endif
{
val = Info_ValueForKey(cl->userinfo, "cl_voip");
cl->hasVoip = atoi(val);
}
#endif
// TTimo
// maintain the IP information
// the banning code relies on this being consistently present
if( NET_IsLocalAddress(cl->netchan.remoteAddress) )
ip = "localhost";
else
ip = (char*)NET_AdrToString( cl->netchan.remoteAddress );
val = Info_ValueForKey( cl->userinfo, "ip" );
if( val[0] )
len = strlen( ip ) - strlen( val ) + strlen( cl->userinfo );
else
len = strlen( ip ) + 4 + strlen( cl->userinfo );
if( len >= MAX_INFO_STRING )
SV_DropClient( cl, "userinfo string length exceeded" );
else
Info_SetValueForKey( cl->userinfo, "ip", ip );
}
/*
=================
CL_ConnectionlessPacket
Responses to broadcasts, etc
=================
*/
void CL_ConnectionlessPacket( netadr_t from, sizebuf_t *msg )
{
char *args;
char *c, buf[MAX_SYSPATH];
int len = sizeof( buf );
int dataoffset = 0;
netadr_t servadr;
BF_Clear( msg );
BF_ReadLong( msg ); // skip the -1
args = BF_ReadStringLine( msg );
Cmd_TokenizeString( args );
c = Cmd_Argv( 0 );
MsgDev( D_NOTE, "CL_ConnectionlessPacket: %s : %s\n", NET_AdrToString( from ), c );
// server connection
if( !Q_strcmp( c, "client_connect" ))
{
if( cls.state == ca_connected )
{
MsgDev( D_INFO, "dup connect received. ignored\n");
return;
}
Netchan_Setup( NS_CLIENT, &cls.netchan, from, Cvar_VariableValue( "net_qport" ));
BF_WriteByte( &cls.netchan.message, clc_stringcmd );
BF_WriteString( &cls.netchan.message, "new" );
cls.state = ca_connected;
cl.validsequence = 0; // haven't gotten a valid frame update yet
cl.delta_sequence = -1; // we'll request a full delta from the baseline
cls.lastoutgoingcommand = -1; // we don't have a backed up cmd history yet
cls.nextcmdtime = host.realtime; // we can send a cmd right away
CL_StartupDemoHeader ();
UI_SetActiveMenu( false );
}
else if( !Q_strcmp( c, "info" ))
{
// server responding to a status broadcast
CL_ParseStatusMessage( from, msg );
}
else if( !Q_strcmp( c, "netinfo" ))
{
// server responding to a status broadcast
CL_ParseNETInfoMessage( from, msg );
}
else if( !Q_strcmp( c, "cmd" ))
{
// remote command from gui front end
if( !NET_IsLocalAddress( from ))
{
Msg( "Command packet from remote host. Ignored.\n" );
return;
}
ShowWindow( host.hWnd, SW_RESTORE );
SetForegroundWindow ( host.hWnd );
args = BF_ReadString( msg );
Cbuf_AddText( args );
Cbuf_AddText( "\n" );
}
else if( !Q_strcmp( c, "print" ))
{
// print command from somewhere
args = BF_ReadString( msg );
Msg( args );
}
else if( !Q_strcmp( c, "ping" ))
{
// ping from somewhere
Netchan_OutOfBandPrint( NS_CLIENT, from, "ack" );
}
else if( !Q_strcmp( c, "challenge" ))
{
// challenge from the server we are connecting to
cls.challenge = Q_atoi( Cmd_Argv( 1 ));
CL_SendConnectPacket();
return;
}
else if( !Q_strcmp( c, "echo" ))
{
// echo request from server
Netchan_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv( 1 ));
}
else if( !Q_strcmp( c, "disconnect" ))
{
// a disconnect message from the server, which will happen if the server
// dropped the connection but it is still getting packets from us
CL_Disconnect();
}
else if( clgame.dllFuncs.pfnConnectionlessPacket( &from, args, buf, &len ))
{
// user out of band message (must be handled in CL_ConnectionlessPacket)
if( len > 0 ) Netchan_OutOfBand( NS_SERVER, from, len, buf );
}
else if( msg->pData[0] == 0xFF && msg->pData[1] == 0xFF && msg->pData[2] == 0xFF && msg->pData[3] == 0xFF && msg->pData[4] == 0x66 && msg->pData[5] == 0x0A )
{
dataoffset = 6;
while( 1 )
{
servadr.type = NA_IP;
servadr.ip[0] = msg->pData[dataoffset + 0];
servadr.ip[1] = msg->pData[dataoffset + 1];
servadr.ip[2] = msg->pData[dataoffset + 2];
servadr.ip[3] = msg->pData[dataoffset + 3];
servadr.port = *(word *)&msg->pData[dataoffset + 4];
if( !servadr.port )
break;
MsgDev( D_INFO, "Found server: %s\n", NET_AdrToString( servadr ));
NET_Config( true ); // allow remote
Netchan_OutOfBandPrint( NS_CLIENT, servadr, "info %i", PROTOCOL_VERSION );
dataoffset += 6;
}
}
else MsgDev( D_ERROR, "bad connectionless packet from %s:\n%s\n", NET_AdrToString( from ), args );
}
/*
* TV_Downstream_DirectConnect
* A upstream request that did not come from the master
*/
static void TV_Downstream_DirectConnect( const socket_t *socket, const netadr_t *address )
{
#ifdef TCP_ALLOW_TVCONNECT
int incoming = 0;
#endif
char userinfo[MAX_INFO_STRING], *name;
client_t *cl, *newcl;
int i, version, game_port, challenge;
bool tv_client;
version = atoi( Cmd_Argv( 1 ) );
if( version != APP_PROTOCOL_VERSION )
{
if( version <= 6 )
{ // before reject packet was added
Netchan_OutOfBandPrint( socket, address, "print\nServer is version %4.2f. Protocol %3i\n",
APP_VERSION, APP_PROTOCOL_VERSION );
}
else
{
Netchan_OutOfBandPrint( socket, address,
"reject\n%i\n%i\nServer and client don't have the same version\n", DROP_TYPE_GENERAL, 0 );
}
return;
}
game_port = atoi( Cmd_Argv( 2 ) );
challenge = atoi( Cmd_Argv( 3 ) );
tv_client = ( atoi( Cmd_Argv( 5 ) ) & 1 ? true : false );
if( !Info_Validate( Cmd_Argv( 4 ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nInvalid userinfo string\n", DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Upstream from %s refused: invalid userinfo string\n", NET_AddressToString( address ) );
return;
}
Q_strncpyz( userinfo, Cmd_Argv( 4 ), sizeof( userinfo ) );
// force the IP key/value pair so the game can filter based on ip
if( !Info_SetValueForKey( userinfo, "socket", NET_SocketTypeToString( socket->type ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nError: Couldn't set userinfo (socket)\n",
DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Upstream from %s refused: couldn't set userinfo (socket)\n", NET_AddressToString( address ) );
return;
}
if( !Info_SetValueForKey( userinfo, "ip", NET_AddressToString( address ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nError: Couldn't set userinfo (ip)\n",
DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Upstream from %s refused: couldn't set userinfo (ip)\n", NET_AddressToString( address ) );
return;
}
// we handle name ourselves here, since tv module doesn't know about all the players
name = TV_Downstream_FixName( Info_ValueForKey( userinfo, "name" ), NULL );
if( !Info_SetValueForKey( userinfo, "name", name ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nError: Couldn't set userinfo (name)\n",
DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Upstream from %s refused: couldn't set userinfo (name)\n", NET_AddressToString( address ) );
return;
}
#ifdef TCP_ALLOW_TVCONNECT
if( socket->type == SOCKET_TCP )
{
// find the upstream
for( i = 0; i < MAX_INCOMING_CONNECTIONS; i++ )
{
if( !tvs.incoming[i].active )
continue;
if( NET_CompareAddress( &tvs.incoming[i].address, address ) && socket == &tvs.incoming[i].socket )
break;
}
if( i == MAX_INCOMING_CONNECTIONS )
{
Com_Error( ERR_FATAL, "Incoming upstream not found.\n" );
return;
}
incoming = i;
}
#endif
// see if the challenge is valid
for( i = 0; i < MAX_CHALLENGES; i++ )
{
if( NET_CompareBaseAddress( address, &tvs.challenges[i].adr ) )
{
if( challenge == tvs.challenges[i].challenge )
{
tvs.challenges[i].challenge = 0; // wsw : r1q2 : reset challenge
tvs.challenges[i].time = 0;
NET_InitAddress( &tvs.challenges[i].adr, NA_NOTRANSMIT );
break; // good
}
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nBad challenge\n",
DROP_TYPE_GENERAL, DROP_FLAG_AUTORECONNECT );
return;
}
}
if( i == MAX_CHALLENGES )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nNo challenge for address\n",
DROP_TYPE_GENERAL, DROP_FLAG_AUTORECONNECT );
return;
}
newcl = NULL;
// if there is already a slot for this ip, reuse it
for( i = 0, cl = tvs.clients; i < tv_maxclients->integer; i++, cl++ )
{
if( cl->state == CS_FREE )
continue;
if( NET_CompareAddress( address, &cl->netchan.remoteAddress ) ||
( NET_CompareBaseAddress( address, &cl->netchan.remoteAddress ) && cl->netchan.game_port == game_port ) )
{
if( !NET_IsLocalAddress( address ) &&
( tvs.realtime - cl->lastconnect ) < (unsigned)( tv_reconnectlimit->integer * 1000 ) )
{
return;
}
newcl = cl;
break;
}
}
// find a client slot
if( !newcl )
{
for( i = 0, cl = tvs.clients; i < tv_maxclients->integer; i++, cl++ )
{
if( cl->state == CS_FREE )
{
newcl = cl;
break;
}
}
if( !newcl )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nServer is full\n", DROP_TYPE_GENERAL,
DROP_FLAG_AUTORECONNECT );
return;
}
}
// get the game a chance to reject this upstream or modify the userinfo
if( !TV_Downstream_ClientConnect( socket, address, newcl, userinfo, game_port, challenge, tv_client ) )
{
char *rejtypeflag, *rejmsg;
// hax because Info_ValueForKey can only be called twice in a row
rejtypeflag = va( "%s\n%s", Info_ValueForKey( userinfo, "rejtype" ), Info_ValueForKey( userinfo, "rejflag" ) );
rejmsg = Info_ValueForKey( userinfo, "rejmsg" );
Netchan_OutOfBandPrint( socket, address, "reject\n%s\n%s\n", rejtypeflag, rejmsg );
return;
}
// send the connect packet to the client
Netchan_OutOfBandPrint( socket, address, "client_connect" );
// free the incoming entry
#ifdef TCP_ALLOW_TVCONNECT
if( socket->type == SOCKET_TCP )
{
tvs.incoming[incoming].active = false;
tvs.incoming[incoming].socket.open = false;
}
#endif
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
const char *ip;
char *val;
int i;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 ) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
val = Info_ValueForKey (cl->userinfo, "handicap");
if (strlen(val)) {
i = atoi(val);
if (i<=0 || i>100 || strlen(val) > 4) {
Info_SetValueForKey( cl->userinfo, "handicap", "100" );
}
}
// snaps command
val = Info_ValueForKey (cl->userinfo, "snaps");
if (strlen(val)) {
i = atoi(val);
if ( i < 1 ) {
i = 1;
} else if ( i > 30 ) {
i = 30;
}
cl->snapshotMsec = 1000/i;
} else {
cl->snapshotMsec = 50;
}
if (mv_fixnamecrash->integer && !(sv.fixes & MVFIX_NAMECRASH)) {
char name[61], cleanedName[61]; // 60 because some mods increased this
Q_strncpyz(name, Info_ValueForKey(cl->userinfo, "name"), sizeof(name));
int count = 0;
for (int i = 0; i < (int)strlen(name); i++) {
char ch = name[i];
if (isascii(ch) ||
ch == '\x0A' || // underscore cursor (console only)
ch == '\x0B' || // block cursor (console only)
ch == '\xB7' || // section sign (§)
ch == '\xB4' || // accute accent (´)
ch == '\xC4' || // A umlaut (Ä)
ch == '\xD6' || // O umlaut (Ö)
ch == '\xDC' || // U umlaut (Ü)
ch == '\xDF' || // sharp S (ß)
ch == '\xE4' || // a umlaut (ä)
ch == '\xF6' || // o umlaut (ö)
ch == '\xFC') // u umlaut (ü)
{
cleanedName[count++] = ch;
}
}
cleanedName[count] = 0;
Info_SetValueForKey(cl->userinfo, "name", cleanedName);
}
// forcecrash fix
if (mv_fixforcecrash->integer && !(sv.fixes & MVFIX_FORCECRASH)) {
char forcePowers[30];
Q_strncpyz(forcePowers, Info_ValueForKey(cl->userinfo, "forcepowers"), sizeof(forcePowers));
int len = (int)strlen(forcePowers);
bool badForce = false;
if (len >= 22 && len <= 24) {
byte seps = 0;
for (int i = 0; i < len; i++) {
if (forcePowers[i] != '-' && (forcePowers[i] < '0' || forcePowers[i] > '9')) {
badForce = true;
break;
}
if (forcePowers[i] == '-' && (i < 1 || i > 5)) {
badForce = true;
break;
}
if (i && forcePowers[i - 1] == '-' && forcePowers[i] == '-') {
badForce = true;
break;
}
if (forcePowers[i] == '-') {
seps++;
}
}
if (seps != 2) {
badForce = true;
}
} else {
badForce = true;
}
if (badForce) {
Q_strncpyz(forcePowers, "7-1-030000000000003332", sizeof(forcePowers));
}
if ( !Info_SetValueForKey(cl->userinfo, "forcepowers", forcePowers) )
{
{
SV_DropClient( cl, "userinfo string length exceeded");
return;
}
}
}
// serverside galaking fix
if (mv_fixgalaking->integer && !(sv.fixes & MVFIX_GALAKING)) {
char model[80];
Q_strncpyz(model, Info_ValueForKey(cl->userinfo, "model"), sizeof(model));
if (!Q_stricmp(model, "galak_mech") || !Q_stricmpn(model, "galak_mech/", 11))
{
if ( !Info_SetValueForKey(cl->userinfo, "model", "galak/default") )
{
SV_DropClient( cl, "userinfo string length exceeded");
return;
}
}
Q_strncpyz(model, Info_ValueForKey(cl->userinfo, "team_model"), sizeof(model));
if (!Q_stricmp(model, "galak_mech") || !Q_stricmpn(model, "galak_mech/", 11))
{
if ( !Info_SetValueForKey(cl->userinfo, "team_model", "galak/default") )
{
SV_DropClient( cl, "userinfo string length exceeded");
return;
}
}
}
// serverside broken models fix (head only model)
if (mv_fixbrokenmodels->integer && !(sv.fixes & MVFIX_BROKENMODEL)) {
char model[80];
Q_strncpyz(model, Info_ValueForKey(cl->userinfo, "model"), sizeof(model));
if (!Q_stricmpn(model, "kyle/fpls", 9) || !Q_stricmp(model, "morgan") || (!Q_stricmpn(model, "morgan/", 7) && (Q_stricmp(model, "morgan/default_mp") && Q_stricmp(model, "morgan/red") && Q_stricmp(model, "morgan/blue"))))
{
if ( !Info_SetValueForKey(cl->userinfo, "model", "kyle/default") )
{
SV_DropClient( cl, "userinfo string length exceeded");
return;
}
}
}
// TTimo
// maintain the IP information
// the banning code relies on this being consistently present
if( NET_IsLocalAddress(cl->netchan.remoteAddress) )
ip = "localhost";
else
ip = NET_AdrToString( cl->netchan.remoteAddress );
if ( !Info_SetValueForKey(cl->userinfo, "ip", ip) )
SV_DropClient( cl, "userinfo string length exceeded" );
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
MAC_STATIC client_t temp;
sharedEntity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
char *password;
int startIndex;
char *denied;
int count;
char *ip;
#ifdef _XBOX
bool reconnect = false;
#endif
Com_DPrintf ("SVC_DirectConnect ()\n");
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
if ( version != PROTOCOL_VERSION ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i.\n", PROTOCOL_VERSION );
Com_DPrintf (" rejected connect from version %i\n", version);
return;
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
/* This was preventing sv_reconnectlimit from working. It seems like commenting this
out has solved the problem. HOwever, if there is a future problem then it could
be this.
if ( cl->state == CS_FREE ) {
continue;
}
*/
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
if (( svs.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000)) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nReconnect rejected : too soon\n" );
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
break;
}
}
// don't let "ip" overflow userinfo string
if ( NET_IsLocalAddress (from) )
ip = "localhost";
else
ip = (char *)NET_AdrToString( from );
if( ( strlen( ip ) + strlen( userinfo ) + 4 ) >= MAX_INFO_STRING ) {
NET_OutOfBandPrint( NS_SERVER, from,
"print\nUserinfo string length exceeded. "
"Try removing setu cvars from your config.\n" );
return;
}
Info_SetValueForKey( userinfo, "ip", ip );
// see if the challenge is valid (LAN clients don't need to challenge)
if ( !NET_IsLocalAddress (from) ) {
int ping;
for (i=0 ; i<MAX_CHALLENGES ; i++) {
if (NET_CompareAdr(from, svs.challenges[i].adr)) {
if ( challenge == svs.challenges[i].challenge ) {
break; // good
}
}
}
if (i == MAX_CHALLENGES) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for address.\n" );
return;
}
ping = svs.time - svs.challenges[i].pingTime;
Com_Printf( SE_GetString("MP_SVGAME", "CLIENT_CONN_WITH_PING"), i, ping);//"Client %i connecting with %i challenge ping\n", i, ping );
svs.challenges[i].connected = qtrue;
// never reject a LAN client based on ping
if ( !Sys_IsLANAddress( from ) ) {
if ( sv_minPing->value && ping < sv_minPing->value ) {
// don't let them keep trying until they get a big delay
NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SE_GetString("MP_SVGAME", "SERVER_FOR_HIGH_PING")));//Server is for high pings only\n" );
Com_DPrintf (SE_GetString("MP_SVGAME", "CLIENT_REJECTED_LOW_PING"), i);//"Client %i rejected on a too low ping\n", i);
// reset the address otherwise their ping will keep increasing
// with each connect message and they'd eventually be able to connect
svs.challenges[i].adr.port = 0;
return;
}
if ( sv_maxPing->value && ping > sv_maxPing->value ) {
NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SE_GetString("MP_SVGAME", "SERVER_FOR_LOW_PING")));//Server is for low pings only\n" );
Com_DPrintf (SE_GetString("MP_SVGAME", "CLIENT_REJECTED_HIGH_PING"), i);//"Client %i rejected on a too high ping\n", i);
return;
}
}
} else {
// force the "ip" info key to "localhost"
Info_SetValueForKey( userinfo, "ip", "localhost" );
}
newcl = &temp;
Com_Memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
#ifdef _XBOX
reconnect = true;
#endif
// VVFIXME - both SOF2 and Wolf remove this call, claiming it blows away the user's info
// disconnect the client from the game first so any flags the
// player might have are dropped
VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( !strcmp( password, sv_privatePassword->string ) ) {
startIndex = 0;
} else {
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = NULL;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
if ( NET_IsLocalAddress( from ) ) {
count = 0;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->netchan.remoteAddress.type == NA_BOT) {
count++;
}
}
// if they're all bots
if (count >= sv_maxclients->integer - startIndex) {
SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
newcl = &svs.clients[sv_maxclients->integer - 1];
}
else {
Com_Error( ERR_FATAL, "server is full on local connect\n" );
return;
}
}
else {
const char *SV_GetStringEdString(char *refSection, char *refName);
NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SV_GetStringEdString("MP_SVGAME","SERVER_IS_FULL")));
Com_DPrintf ("Rejected a connection.\n");
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the challenge
newcl->challenge = challenge;
// save the address
Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
// get the game a chance to reject this connection or modify the userinfo
denied = (char *)VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) {
// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
denied = (char *)VM_ExplicitArgPtr( gvm, (int)denied );
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
Com_DPrintf ("Game rejected a connection: %s.\n", denied);
return;
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
newcl->state = CS_CONNECTED;
newcl->nextSnapshotTime = svs.time;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
newcl->lastUserInfoChange = 0; //reset the delay
newcl->lastUserInfoCount = 0; //reset the count
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
=================
SV_UserinfoChanged
Pull specific info from a newly changed userinfo string
into a more C friendly form.
=================
*/
void SV_UserinfoChanged( client_t *cl ) {
char *val;
char *ip;
int i;
int len;
// name for C code
Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
// rate command
// if the client is on the same subnet as the server and we aren't running an
// internet public server, assume they don't need a rate choke
if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 && sv_lanForceRate->integer == 1) {
cl->rate = 99999; // lans should not rate limit
} else {
val = Info_ValueForKey (cl->userinfo, "rate");
if (strlen(val)) {
i = atoi(val);
cl->rate = i;
if (cl->rate < 1000) {
cl->rate = 1000;
} else if (cl->rate > 90000) {
cl->rate = 90000;
}
} else {
cl->rate = 3000;
}
}
val = Info_ValueForKey (cl->userinfo, "handicap");
if (strlen(val)) {
i = atoi(val);
if (i<=0 || i>100 || strlen(val) > 4) {
Info_SetValueForKey( cl->userinfo, "handicap", "100" );
}
}
// snaps command
val = Info_ValueForKey (cl->userinfo, "snaps");
if (strlen(val)) {
i = atoi(val);
if ( i < 1 ) {
i = 1;
} else if ( i > sv_fps->integer ) {
i = sv_fps->integer;
}
cl->snapshotMsec = 1000/i;
} else {
cl->snapshotMsec = 50;
}
#ifdef USE_VOIP
// in the future, (val) will be a protocol version string, so only
// accept explicitly 1, not generally non-zero.
val = Info_ValueForKey (cl->userinfo, "cl_voip");
cl->hasVoip = (atoi(val) == 1) ? qtrue : qfalse;
#endif
// TTimo
// maintain the IP information
// the banning code relies on this being consistently present
if( NET_IsLocalAddress(cl->netchan.remoteAddress) )
ip = "localhost";
else
ip = (char*)NET_AdrToString( cl->netchan.remoteAddress );
val = Info_ValueForKey( cl->userinfo, "ip" );
if( val[0] )
len = strlen( ip ) - strlen( val ) + strlen( cl->userinfo );
else
len = strlen( ip ) + 4 + strlen( cl->userinfo );
if( len >= MAX_INFO_STRING )
SV_DropClient( cl, "userinfo string length exceeded" );
else
Info_SetValueForKey( cl->userinfo, "ip", ip );
}
/*
* ==================
* SVC_DirectConnect
*
* A connection request that did not come from the master
* ==================
*/
void SVC_DirectConnect(void)
{
char userinfo[MAX_INFO_STRING];
netadr_t adr;
int i;
client_t *cl, *newcl;
client_t temp;
edict_t *ent;
int edictnum;
int version;
int qport;
int challenge;
int previousclients; // rich: connection limit per IP
adr = net_from;
Com_DPrintf("SVC_DirectConnect ()\n");
version = atoi(Cmd_Argv(1));
if (version != PROTOCOL_VERSION)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nServer is version %4.2f.\n", VERSION);
Com_DPrintf(" rejected connect from version %i\n", version);
return;
}
qport = atoi(Cmd_Argv(2));
challenge = atoi(Cmd_Argv(3));
// r1ch: limit connections from a single IP
previousclients = 0;
for (i = 0, cl = svs.clients; i < (int)maxclients->value; i++, cl++)
{
if (cl->state == cs_free)
{
continue;
}
if (NET_CompareBaseAdr(adr, cl->netchan.remote_address))
{
// r1ch: zombies are less dangerous
if (cl->state == cs_zombie)
{
previousclients++;
}
else
{
previousclients += 2;
}
}
}
if (previousclients >= (int)sv_iplimit->value * 2)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nToo many connections from your host.\n");
Com_DPrintf(" too many connections\n");
return;
}
// end r1ch fix
strncpy(userinfo, Cmd_Argv(4), sizeof(userinfo) - 1);
userinfo[sizeof(userinfo) - 1] = 0;
// force the IP key/value pair so the game can filter based on ip
Info_SetValueForKey(userinfo, "ip", NET_AdrToString(net_from));
// attractloop servers are ONLY for local clients
if (sv.attractloop)
{
if (!NET_IsLocalAddress(adr))
{
Com_Printf("Remote connect in attract loop. Ignored.\n");
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n");
return;
}
}
// see if the challenge is valid
if (!NET_IsLocalAddress(adr))
{
for (i = 0; i < MAX_CHALLENGES; i++)
{
if (NET_CompareBaseAdr(net_from, svs.challenges[i].adr))
{
if (challenge == svs.challenges[i].challenge)
{
break; // good
}
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nBad challenge.\n");
return;
}
}
if (i == MAX_CHALLENGES)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nNo challenge for address.\n");
return;
}
}
newcl = &temp;
memset(newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i = 0, cl = svs.clients; i < maxclients->value; i++, cl++)
{
if (cl->state == cs_free)
{
continue;
}
if (NET_CompareBaseAdr(adr, cl->netchan.remote_address) &&
((cl->netchan.qport == qport) ||
(adr.port == cl->netchan.remote_address.port)))
{
if (!NET_IsLocalAddress(adr) && ((svs.realtime - cl->lastconnect) < ((int)sv_reconnect_limit->value * 1000)))
{
Com_DPrintf("%s:reconnect rejected : too soon\n", NET_AdrToString(adr));
return;
}
// r1ch: !! fix nasty bug where non-disconnected clients (from dropped disconnect
// packets) could be overwritten!
if (cl->state != cs_zombie)
{
Com_DPrintf(" client already found\n");
// If we legitly get here, spoofed udp isn't possible (passed challenge) and client addr/port combo
// is exactly the same, so we can assume its really a dropped/crashed client. i hope...
Com_Printf("Dropping %s, ghost reconnect\n", cl->name);
SV_DropClient(cl);
}
// end r1ch fix
Com_Printf("%s:reconnect\n", NET_AdrToString(adr));
SV_CleanClient(cl); // r1ch: clean up last client data
newcl = cl;
goto gotnewcl;
}
}
// find a client slot
newcl = NULL;
for (i = 0, cl = svs.clients; i < maxclients->value; i++, cl++)
{
if (cl->state == cs_free)
{
newcl = cl;
break;
}
}
if (!newcl)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nServer is full.\n");
Com_DPrintf("Rejected a connection.\n");
return;
}
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
sv_client = newcl;
edictnum = (newcl - svs.clients) + 1;
ent = EDICT_NUM(edictnum);
newcl->edict = ent;
newcl->challenge = challenge; // save challenge for checksumming
// get the game a chance to reject this connection or modify the userinfo
if (!(ge->ClientConnect(ent, userinfo)))
{
if (*Info_ValueForKey(userinfo, "rejmsg"))
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\n%s\nConnection refused.\n",
Info_ValueForKey(userinfo, "rejmsg"));
}
else
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n");
}
Com_DPrintf("Game rejected a connection.\n");
return;
}
// parse some info from the info strings
strncpy(newcl->userinfo, userinfo, sizeof(newcl->userinfo) - 1);
SV_UserinfoChanged(newcl);
// send the connect packet to the client
Netchan_OutOfBandPrint(NS_SERVER, adr, "client_connect");
Netchan_Setup(NS_SERVER, &newcl->netchan, adr, qport);
newcl->state = cs_connected;
SZ_Init(&newcl->datagram, newcl->datagram_buf, sizeof(newcl->datagram_buf));
newcl->datagram.allowoverflow = true;
newcl->lastmessage = svs.realtime; // don't timeout
newcl->lastconnect = svs.realtime;
}
/*
=======================
SV_SendClientMessages
=======================
*/
void SV_SendClientMessages( void )
{
sv_client_t *cl;
int i;
svs.currentPlayer = NULL;
svs.currentPlayerNum = 0;
if( sv.state == ss_dead )
return;
SV_UpdateToReliableMessages ();
// send a message to each connected client
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if( !cl->state || cl->fakeclient )
continue;
if( cl->skip_message )
{
cl->skip_message = false;
continue;
}
if( !host_limitlocal->integer && NET_IsLocalAddress( cl->netchan.remote_address ))
cl->send_message = true;
if( cl->state == cs_spawned )
{
// Try to send a message as soon as we can.
// If the target time for sending is within the next frame interval ( based on last frame ),
// trigger the send now. Note that in single player,
// send_message is also set to true any time a packet arrives from the client.
float time_unti_next_message = cl->next_messagetime - (host.realtime + host.frametime);
if( time_unti_next_message <= 0.0f )
cl->send_message = true;
// something got hosed
if( time_unti_next_message > 2.0f )
cl->send_message = true;
}
// if the reliable message overflowed, drop the client
if( BF_CheckOverflow( &cl->netchan.message ))
{
BF_Clear( &cl->netchan.message );
BF_Clear( &cl->datagram );
SV_BroadcastPrintf( PRINT_HIGH, "%s overflowed\n", cl->name );
MsgDev( D_WARN, "reliable overflow for %s\n", cl->name );
SV_DropClient( cl );
cl->send_message = true;
cl->netchan.cleartime = 0; // don't choke this message
}
else if( cl->send_message )
{
// If we haven't gotten a message in sv_failuretime seconds, then stop sending messages to this client
// until we get another packet in from the client. This prevents crash/drop and reconnect where they are
// being hosed with "sequenced packet without connection" packets.
if(( host.realtime - cl->netchan.last_received ) > sv_failuretime->value )
cl->send_message = false;
}
// only send messages if the client has sent one
// and the bandwidth is not choked
if( !cl->send_message ) continue;
// Bandwidth choke active?
if( !Netchan_CanPacket( &cl->netchan ))
{
cl->chokecount++;
continue;
}
cl->send_message = false;
// Now that we were able to send, reset timer to point to next possible send time.
cl->next_messagetime = host.realtime + host.frametime + cl->cl_updaterate;
if( cl->state == cs_spawned )
{
SV_SendClientDatagram( cl );
}
else
{
// just update reliable
Netchan_Transmit( &cl->netchan, 0, NULL );
}
}
// reset current client
svs.currentPlayer = NULL;
svs.currentPlayerNum = 0;
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from, const Cmd::Args& args )
{
if ( args.Argc() < 2 )
{
return;
}
Log::Debug( "SVC_DirectConnect ()" );
InfoMap userinfo = InfoStringToMap(args.Argv(1));
// DHM - Nerve :: Update Server allows any protocol to connect
// NOTE TTimo: but we might need to store the protocol around for potential non http/ftp clients
int version = atoi( userinfo["protocol"].c_str() );
if ( version != PROTOCOL_VERSION )
{
Net::OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\nServer uses protocol version %i (yours is %i).", PROTOCOL_VERSION, version );
Log::Debug( " rejected connect from version %i", version );
return;
}
int qport = atoi( userinfo["qport"].c_str() );
auto clients_begin = svs.clients;
auto clients_end = clients_begin + sv_maxclients->integer;
client_t* reconnecting = std::find_if(clients_begin, clients_end,
[&from, qport](const client_t& client)
{
return NET_CompareBaseAdr( from, client.netchan.remoteAddress )
&& ( client.netchan.qport == qport || from.port == client.netchan.remoteAddress.port );
}
);
if ( reconnecting != clients_end &&
svs.time - reconnecting->lastConnectTime < sv_reconnectlimit->integer * 1000 )
{
Log::Debug( "%s: reconnect rejected: too soon", NET_AdrToString( from ) );
return;
}
if ( NET_IsLocalAddress( from ) )
{
userinfo["ip"] = "loopback";
}
else
{
// see if the challenge is valid (local clients don't need to challenge)
Challenge::Duration ping_duration;
if ( !ChallengeManager::MatchString( from, userinfo["challenge"], &ping_duration ) )
{
Net::OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]No or bad challenge for address." );
return;
}
userinfo["ip"] = NET_AdrToString( from );
}
client_t *new_client = nullptr;
// if there is already a slot for this IP address, reuse it
if ( reconnecting != clients_end )
{
Log::Notice( "%s:reconnect\n", NET_AdrToString( from ) );
new_client = reconnecting;
}
else
{
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
int startIndex = 0;
if ( userinfo["password"] != sv_privatePassword->string )
{
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
new_client = std::find_if(clients_begin, clients_end,
[](const client_t& client) {
return client.state == clientState_t::CS_FREE;
});
if ( new_client == clients_end )
{
if ( NET_IsLocalAddress( from ) )
{
int count = std::count_if(clients_begin+startIndex, clients_end,
[](const client_t& client) { return SV_IsBot(&client); }
);
// if they're all bots
if ( count >= sv_maxclients->integer - startIndex )
{
SV_DropClient( &svs.clients[ sv_maxclients->integer - 1 ], "only bots on server" );
new_client = &svs.clients[ sv_maxclients->integer - 1 ];
}
else
{
Com_Error( errorParm_t::ERR_FATAL, "server is full on local connect" );
}
}
else
{
Net::OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n%s", sv_fullmsg->string );
Log::Debug( "Rejected a connection." );
return;
}
}
}
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
memset( new_client, 0, sizeof( client_t ) );
int clientNum = new_client - svs.clients;
#ifdef HAVE_GEOIP
const char * country = NET_GeoIP_Country( &from );
if ( country )
{
Log::Notice( "Client %i connecting from %s\n", clientNum, country );
userinfo["geoip"] = country;
}
else
{
Log::Notice( "Client %i connecting from somewhere unknown\n", clientNum );
}
#else
Log::Notice( "Client %i connecting\n", clientNum );
#endif
new_client->gentity = SV_GentityNum( clientNum );
new_client->gentity->r.svFlags = 0;
// save the address
Netchan_Setup( netsrc_t::NS_SERVER, &new_client->netchan, from, qport );
// init the netchan queue
// Save the pubkey
Q_strncpyz( new_client->pubkey, userinfo["pubkey"].c_str(), sizeof( new_client->pubkey ) );
userinfo.erase("pubkey");
// save the userinfo
Q_strncpyz( new_client->userinfo, InfoMapToString(userinfo).c_str(), sizeof( new_client->userinfo ) );
// get the game a chance to reject this connection or modify the userinfo
char reason[ MAX_STRING_CHARS ];
if ( gvm.GameClientConnect( reason, sizeof( reason ), clientNum, true, false ) )
{
Net::OutOfBandPrint( netsrc_t::NS_SERVER, from, "print\n[err_dialog]%s", reason );
Log::Debug( "Game rejected a connection: %s.", reason );
return;
}
SV_UserinfoChanged( new_client );
// send the connect packet to the client
Net::OutOfBandPrint( netsrc_t::NS_SERVER, from, "connectResponse" );
Log::Debug( "Going from CS_FREE to CS_CONNECTED for %s", new_client->name );
new_client->state = clientState_t::CS_CONNECTED;
new_client->nextSnapshotTime = svs.time;
new_client->lastPacketTime = svs.time;
new_client->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
new_client->gamestateMessageNum = -1;
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
int count = std::count_if(clients_begin, clients_end,
[](const client_t& client) {
return client.state >= clientState_t::CS_CONNECTED;
});
if ( count == 1 || count == sv_maxclients->integer )
{
SV_Heartbeat_f();
}
}
/*
==================
SV_DirectConnect
A "connect" OOB command has been received
==================
*/
void SV_DirectConnect( netadr_t from ) {
char userinfo[MAX_INFO_STRING];
int i;
client_t *cl, *newcl;
client_t temp;
sharedEntity_t *ent;
int clientNum;
int version;
int qport;
int challenge;
char *password;
int startIndex;
char *denied;
int count;
char *ip;
Com_DPrintf ("SVC_DirectConnect ()\n");
// Check whether this client is banned.
if ( SV_IsBanned( &from, qfalse ) )
{
NET_OutOfBandPrint( NS_SERVER, from, "print\nYou are banned from this server.\n" );
Com_DPrintf( " rejected connect from %s (banned)\n", NET_AdrToString(from) );
return;
}
Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
if ( version != PROTOCOL_VERSION ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i (yours is %i).\n", PROTOCOL_VERSION, version );
Com_DPrintf (" rejected connect from version %i\n", version);
return;
}
challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
// quick reject
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
/* This was preventing sv_reconnectlimit from working. It seems like commenting this
out has solved the problem. HOwever, if there is a future problem then it could
be this.
if ( cl->state == CS_FREE ) {
continue;
}
*/
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
if (( svs.time - cl->lastConnectTime)
< (sv_reconnectlimit->integer * 1000)) {
NET_OutOfBandPrint( NS_SERVER, from, "print\nReconnect rejected : too soon\n" );
Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
return;
}
break;
}
}
// don't let "ip" overflow userinfo string
if ( NET_IsLocalAddress (from) )
ip = "localhost";
else
ip = (char *)NET_AdrToString( from );
if( ( strlen( ip ) + strlen( userinfo ) + 4 ) >= MAX_INFO_STRING ) {
NET_OutOfBandPrint( NS_SERVER, from,
"print\nUserinfo string length exceeded. "
"Try removing setu cvars from your config.\n" );
return;
}
Info_SetValueForKey( userinfo, "ip", ip );
// see if the challenge is valid (localhost clients don't need to challenge)
if (!NET_IsLocalAddress(from))
{
// Verify the received challenge against the expected challenge
if (!SV_VerifyChallenge(challenge, from))
{
NET_OutOfBandPrint( NS_SERVER, from, "print\nIncorrect challenge for your address.\n" );
return;
}
}
newcl = &temp;
Com_Memset (newcl, 0, sizeof(client_t));
// if there is already a slot for this ip, reuse it
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
&& ( cl->netchan.qport == qport
|| from.port == cl->netchan.remoteAddress.port ) ) {
Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
newcl = cl;
// VVFIXME - both SOF2 and Wolf remove this call, claiming it blows away the user's info
// disconnect the client from the game first so any flags the
// player might have are dropped
GVM_ClientDisconnect( newcl - svs.clients );
//
goto gotnewcl;
}
}
// find a client slot
// if "sv_privateClients" is set > 0, then that number
// of client slots will be reserved for connections that
// have "password" set to the value of "sv_privatePassword"
// Info requests will report the maxclients as if the private
// slots didn't exist, to prevent people from trying to connect
// to a full server.
// This is to allow us to reserve a couple slots here on our
// servers so we can play without having to kick people.
// check for privateClient password
password = Info_ValueForKey( userinfo, "password" );
if ( !strcmp( password, sv_privatePassword->string ) ) {
startIndex = 0;
} else {
// skip past the reserved slots
startIndex = sv_privateClients->integer;
}
newcl = NULL;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->state == CS_FREE) {
newcl = cl;
break;
}
}
if ( !newcl ) {
if ( NET_IsLocalAddress( from ) ) {
count = 0;
for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
cl = &svs.clients[i];
if (cl->netchan.remoteAddress.type == NA_BOT) {
count++;
}
}
// if they're all bots
if (count >= sv_maxclients->integer - startIndex) {
SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
newcl = &svs.clients[sv_maxclients->integer - 1];
}
else {
Com_Error( ERR_FATAL, "server is full on local connect\n" );
return;
}
}
else {
const char *SV_GetStringEdString(char *refSection, char *refName);
NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SV_GetStringEdString("MP_SVGAME","SERVER_IS_FULL")));
Com_DPrintf ("Rejected a connection.\n");
return;
}
}
// we got a newcl, so reset the reliableSequence and reliableAcknowledge
cl->reliableAcknowledge = 0;
cl->reliableSequence = 0;
gotnewcl:
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
clientNum = newcl - svs.clients;
ent = SV_GentityNum( clientNum );
newcl->gentity = ent;
// save the challenge
newcl->challenge = challenge;
// save the address
Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
// save the userinfo
Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
// get the game a chance to reject this connection or modify the userinfo
denied = GVM_ClientConnect( clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) {
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
Com_DPrintf ("Game rejected a connection: %s.\n", denied);
return;
}
SV_UserinfoChanged( newcl );
// send the connect packet to the client
NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
newcl->state = CS_CONNECTED;
newcl->nextSnapshotTime = svs.time;
newcl->lastPacketTime = svs.time;
newcl->lastConnectTime = svs.time;
// when we receive the first packet from the client, we will
// notice that it is from a different serverid and that the
// gamestate message was not just sent, forcing a retransmit
newcl->gamestateMessageNum = -1;
newcl->lastUserInfoChange = 0; //reset the delay
newcl->lastUserInfoCount = 0; //reset the count
// if this was the first client on the server, or the last client
// the server can hold, send a heartbeat to the master.
count = 0;
for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
if ( svs.clients[i].state >= CS_CONNECTED ) {
count++;
}
}
if ( count == 1 || count == sv_maxclients->integer ) {
SV_Heartbeat_f();
}
}
/*
* SVC_DirectConnect
* A connection request that did not come from the master
*/
static void SVC_DirectConnect( const socket_t *socket, const netadr_t *address )
{
#ifdef TCP_ALLOW_CONNECT
int incoming = 0;
#endif
char userinfo[MAX_INFO_STRING];
client_t *cl, *newcl;
int i, version, game_port, challenge;
int previousclients;
int session_id;
char *session_id_str;
unsigned int ticket_id;
qboolean tv_client;
Com_DPrintf( "SVC_DirectConnect (%s)\n", Cmd_Args() );
version = atoi( Cmd_Argv( 1 ) );
if( version != APP_PROTOCOL_VERSION )
{
if( version <= 6 )
{ // before reject packet was added
Netchan_OutOfBandPrint( socket, address, "print\nServer is version %4.2f. Protocol %3i\n",
APP_VERSION, APP_PROTOCOL_VERSION );
}
else
{
Netchan_OutOfBandPrint( socket, address,
"reject\n%i\n%i\nServer and client don't have the same version\n", DROP_TYPE_GENERAL, 0 );
}
Com_DPrintf( " rejected connect from protocol %i\n", version );
return;
}
game_port = atoi( Cmd_Argv( 2 ) );
challenge = atoi( Cmd_Argv( 3 ) );
tv_client = ( atoi( Cmd_Argv( 5 ) ) & 1 ? qtrue : qfalse );
if( !Info_Validate( Cmd_Argv( 4 ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nInvalid userinfo string\n", DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Connection from %s refused: invalid userinfo string\n", NET_AddressToString( address ) );
return;
}
Q_strncpyz( userinfo, Cmd_Argv( 4 ), sizeof( userinfo ) );
// force the IP key/value pair so the game can filter based on ip
if( !Info_SetValueForKey( userinfo, "socket", NET_SocketTypeToString( socket->type ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nError: Couldn't set userinfo (socket)\n",
DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Connection from %s refused: couldn't set userinfo (socket)\n", NET_AddressToString( address ) );
return;
}
if( !Info_SetValueForKey( userinfo, "ip", NET_AddressToString( address ) ) )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nError: Couldn't set userinfo (ip)\n",
DROP_TYPE_GENERAL, 0 );
Com_DPrintf( "Connection from %s refused: couldn't set userinfo (ip)\n", NET_AddressToString( address ) );
return;
}
if( Cmd_Argc() >= 7 )
{
// we have extended information, ticket-id and session-id
Com_Printf("Extended information %s\n", Cmd_Argv(6) );
ticket_id = (unsigned int)atoi( Cmd_Argv(6) );
session_id_str = Info_ValueForKey( userinfo, "cl_mm_session" );
if( session_id_str != NULL )
session_id = atoi( session_id_str );
else
session_id = 0;
}
else
{
ticket_id = 0;
session_id = 0;
}
#ifdef TCP_ALLOW_CONNECT
if( socket->type == SOCKET_TCP )
{
// find the connection
for( i = 0; i < MAX_INCOMING_CONNECTIONS; i++ )
{
if( !svs.incoming[i].active )
continue;
if( NET_CompareAddress( &svs.incoming[i].address, address ) && socket == &svs.incoming[i].socket )
break;
}
if( i == MAX_INCOMING_CONNECTIONS )
{
Com_Error( ERR_FATAL, "Incoming connection not found.\n" );
return;
}
incoming = i;
}
#endif
// see if the challenge is valid
for( i = 0; i < MAX_CHALLENGES; i++ )
{
if( NET_CompareBaseAddress( address, &svs.challenges[i].adr ) )
{
if( challenge == svs.challenges[i].challenge )
{
svs.challenges[i].challenge = 0; // wsw : r1q2 : reset challenge
svs.challenges[i].time = 0;
NET_InitAddress( &svs.challenges[i].adr, NA_NOTRANSMIT );
break; // good
}
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nBad challenge\n",
DROP_TYPE_GENERAL, DROP_FLAG_AUTORECONNECT );
return;
}
}
if( i == MAX_CHALLENGES )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nNo challenge for address\n",
DROP_TYPE_GENERAL, DROP_FLAG_AUTORECONNECT );
return;
}
//r1: limit connections from a single IP
if( sv_iplimit->integer )
{
previousclients = 0;
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if( cl->state == CS_FREE )
continue;
if( NET_CompareBaseAddress( address, &cl->netchan.remoteAddress ) )
{
//r1: zombies are less dangerous
if( cl->state == CS_ZOMBIE )
previousclients++;
else
previousclients += 2;
}
}
if( previousclients >= sv_iplimit->integer * 2 )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nToo many connections from your host\n", DROP_TYPE_GENERAL,
DROP_FLAG_AUTORECONNECT );
Com_DPrintf( "%s:connect rejected : too many connections\n", NET_AddressToString( address ) );
return;
}
}
newcl = NULL;
// if there is already a slot for this ip, reuse it
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if( cl->state == CS_FREE )
continue;
if( NET_CompareAddress( address, &cl->netchan.remoteAddress ) ||
( NET_CompareBaseAddress( address, &cl->netchan.remoteAddress ) && cl->netchan.game_port == game_port ) )
{
if( !NET_IsLocalAddress( address ) &&
( svs.realtime - cl->lastconnect ) < (unsigned)( sv_reconnectlimit->integer * 1000 ) )
{
Com_DPrintf( "%s:reconnect rejected : too soon\n", NET_AddressToString( address ) );
return;
}
Com_Printf( "%s:reconnect\n", NET_AddressToString( address ) );
newcl = cl;
break;
}
}
// find a client slot
if( !newcl )
{
for( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ )
{
if( cl->state == CS_FREE )
{
newcl = cl;
break;
}
// overwrite fakeclient if no free spots found
if( cl->state && cl->edict && ( cl->edict->r.svflags & SVF_FAKECLIENT ) )
newcl = cl;
}
if( !newcl )
{
Netchan_OutOfBandPrint( socket, address, "reject\n%i\n%i\nServer is full\n", DROP_TYPE_GENERAL,
DROP_FLAG_AUTORECONNECT );
Com_DPrintf( "Server is full. Rejected a connection.\n" );
return;
}
if( newcl->state && newcl->edict && ( newcl->edict->r.svflags & SVF_FAKECLIENT ) )
SV_DropClient( newcl, DROP_TYPE_GENERAL, "Need room for a real player" );
}
// get the game a chance to reject this connection or modify the userinfo
if( !SV_ClientConnect( socket, address, newcl, userinfo, game_port, challenge, qfalse,
tv_client, ticket_id, session_id ) )
{
char *rejtype, *rejflag, *rejtypeflag, *rejmsg;
rejtype = Info_ValueForKey( userinfo, "rejtype" );
if( !rejtype )
rejtype = "0";
rejflag = Info_ValueForKey( userinfo, "rejflag" );
if( !rejflag )
rejflag = "0";
// hax because Info_ValueForKey can only be called twice in a row
rejtypeflag = va( "%s\n%s", rejtype, rejflag );
rejmsg = Info_ValueForKey( userinfo, "rejmsg" );
if( !rejmsg )
rejmsg = "Game module rejected connection";
Netchan_OutOfBandPrint( socket, address, "reject\n%s\n%s\n", rejtypeflag, rejmsg );
Com_DPrintf( "Game rejected a connection.\n" );
return;
}
// send the connect packet to the client
Netchan_OutOfBandPrint( socket, address, "client_connect\n%s", newcl->session );
// free the incoming entry
#ifdef TCP_ALLOW_CONNECT
if( socket->type == SOCKET_TCP )
{
svs.incoming[incoming].active = qfalse;
svs.incoming[incoming].socket.open = qfalse;
}
#endif
}
/*
* A connection request that did not come from the master
*/
void
SVC_DirectConnect(void)
{
char userinfo[MAX_INFO_STRING];
netadr_t adr;
int i;
client_t *cl, *newcl;
client_t temp;
edict_t *ent;
int edictnum;
int version;
int qport;
int challenge;
adr = net_from;
Com_DPrintf("SVC_DirectConnect ()\n");
version = (int)strtol(Cmd_Argv(1), (char **)NULL, 10);
if (version != PROTOCOL_VERSION)
{
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\nServer is version %s.\n", YQ2VERSION);
Com_DPrintf(" rejected connect from version %i\n", version);
return;
}
qport = (int)strtol(Cmd_Argv(2), (char **)NULL, 10);
challenge = (int)strtol(Cmd_Argv(3), (char **)NULL, 10);
Q_strlcpy(userinfo, Cmd_Argv(4), sizeof(userinfo));
/* force the IP key/value pair so the game can filter based on ip */
Info_SetValueForKey(userinfo, "ip", NET_AdrToString(net_from));
/* attractloop servers are ONLY for local clients */
if (sv.attractloop)
{
if (!NET_IsLocalAddress(adr))
{
Com_Printf("Remote connect in attract loop. Ignored.\n");
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\nConnection refused.\n");
return;
}
}
/* see if the challenge is valid */
if (!NET_IsLocalAddress(adr))
{
for (i = 0; i < MAX_CHALLENGES; i++)
{
if (NET_CompareBaseAdr(net_from, svs.challenges[i].adr))
{
if (challenge == svs.challenges[i].challenge)
{
break; /* good */
}
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\nBad challenge.\n");
return;
}
}
if (i == MAX_CHALLENGES)
{
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\nNo challenge for address.\n");
return;
}
}
newcl = &temp;
memset(newcl, 0, sizeof(client_t));
/* if there is already a slot for this ip, reuse it */
for (i = 0, cl = svs.clients; i < maxclients->value; i++, cl++)
{
if (cl->state < cs_connected)
{
continue;
}
if (NET_CompareBaseAdr(adr, cl->netchan.remote_address) &&
((cl->netchan.qport == qport) ||
(adr.port == cl->netchan.remote_address.port)))
{
if (!NET_IsLocalAddress(adr))
{
Com_DPrintf("%s:reconnect rejected : too soon\n",
NET_AdrToString(adr));
return;
}
Com_Printf("%s:reconnect\n", NET_AdrToString(adr));
newcl = cl;
goto gotnewcl;
}
}
/* find a client slot */
newcl = NULL;
for (i = 0, cl = svs.clients; i < maxclients->value; i++, cl++)
{
if (cl->state == cs_free)
{
newcl = cl;
break;
}
}
if (!newcl)
{
Netchan_OutOfBandPrint(NS_SERVER, adr, "print\nServer is full.\n");
Com_DPrintf("Rejected a connection.\n");
return;
}
gotnewcl:
/* build a new connection accept the new client this
is the only place a client_t is ever initialized */
*newcl = temp;
sv_client = newcl;
edictnum = (newcl - svs.clients) + 1;
ent = EDICT_NUM(edictnum);
newcl->edict = ent;
newcl->challenge = challenge; /* save challenge for checksumming */
/* get the game a chance to reject this connection or modify the userinfo */
if (!(ge->ClientConnect(ent, userinfo)))
{
if (*Info_ValueForKey(userinfo, "rejmsg"))
{
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\n%s\nConnection refused.\n",
Info_ValueForKey(userinfo, "rejmsg"));
}
else
{
Netchan_OutOfBandPrint(NS_SERVER, adr,
"print\nConnection refused.\n");
}
Com_DPrintf("Game rejected a connection.\n");
return;
}
/* parse some info from the info strings */
Q_strlcpy(newcl->userinfo, userinfo, sizeof(newcl->userinfo));
SV_UserinfoChanged(newcl);
/* send the connect packet to the client */
Netchan_OutOfBandPrint(NS_SERVER, adr, "client_connect");
Netchan_Setup(NS_SERVER, &newcl->netchan, adr, qport);
newcl->state = cs_connected;
SZ_Init(&newcl->datagram, newcl->datagram_buf, sizeof(newcl->datagram_buf));
newcl->datagram.allowoverflow = true;
newcl->lastmessage = svs.realtime; /* don't timeout */
newcl->lastconnect = svs.realtime;
}
/*
===============
SVC_RemoteCommand
An rcon packet arrived from the network.
Shift down the remaining args
Redirect all printfs
===============
*/
void SVC_RemoteCommand( netadr_t from, msg_t *msg ) {
qboolean valid;
unsigned int time;
char remaining[1024];
netadr_t allowedSpamIPAdress;
// TTimo - scaled down to accumulate, but not overflow anything network wise, print wise etc.
// (OOB messages are the bottleneck here)
#define SV_OUTPUTBUF_LENGTH (1024 - 16)
char sv_outputbuf[SV_OUTPUTBUF_LENGTH];
static unsigned int lasttime = 0;
char *cmd_aux;
// TTimo - https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=534
time = Com_Milliseconds();
NET_StringToAdr( sv_rconAllowedSpamIP->string , &allowedSpamIPAdress);
if ( !strlen( sv_rconPassword->string ) || strcmp (Cmd_Argv(1), sv_rconPassword->string) )
{
// let's the sv_rconAllowedSpamIP do spam rcon
if ( ( !strlen( sv_rconAllowedSpamIP->string ) || !NET_CompareBaseAdr( from , allowedSpamIPAdress ) ) && !NET_IsLocalAddress(from) ){
// MaJ - If the rconpassword is bad and one just happned recently, don't spam the log file, just die.
if ( (unsigned)( time - lasttime ) < 600u )
return;
}
valid = qfalse;
Com_Printf ("Bad rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) );
} else {
// let's the sv_rconAllowedSpamIP do spam rcon
if ( ( !strlen( sv_rconAllowedSpamIP->string ) || !NET_CompareBaseAdr( from , allowedSpamIPAdress ) ) && !NET_IsLocalAddress(from) ){
// MaJ - If the rconpassword is good, allow it much sooner than a bad one.
if ( (unsigned)( time - lasttime ) < 180u )
return;
}
valid = qtrue;
Com_Printf ("Rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) );
}
lasttime = time;
// start redirecting all print outputs to the packet
svs.redirectAddress = from;
Com_BeginRedirect (sv_outputbuf, SV_OUTPUTBUF_LENGTH, SV_FlushRedirect);
if ( !strlen( sv_rconPassword->string ) ) {
Com_Printf ("No rconpassword set on the server.\n");
} else if ( !valid ) {
Com_Printf ("Bad rconpassword.\n");
} else {
remaining[0] = 0;
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543
// get the command directly, "rcon <pass> <command>" to avoid quoting issues
// extract the command by walking
// since the cmd formatting can fuckup (amount of spaces), using a dumb step by step parsing
cmd_aux = Cmd_Cmd();
cmd_aux+=4;
while(cmd_aux[0]==' ')
cmd_aux++;
while(cmd_aux[0] && cmd_aux[0]!=' ') // password
cmd_aux++;
while(cmd_aux[0]==' ')
cmd_aux++;
Q_strcat( remaining, sizeof(remaining), cmd_aux);
Cmd_ExecuteString (remaining);
}
Com_EndRedirect ();
}
/*
=================
CL_ConnectionlessPacket
Responses to broadcasts, etc
=================
*/
void CL_ConnectionlessPacket( netadr_t from, sizebuf_t *msg )
{
char *args;
char *c, buf[MAX_SYSPATH];
int len = sizeof( buf ), i = 0;
netadr_t servadr;
BF_Clear( msg );
BF_ReadLong( msg ); // skip the -1
args = BF_ReadStringLine( msg );
Cmd_TokenizeString( args );
c = Cmd_Argv( 0 );
MsgDev( D_NOTE, "CL_ConnectionlessPacket: %s : %s\n", NET_AdrToString( from ), c );
// server connection
if( !Q_strcmp( c, "client_connect" ))
{
if( cls.state == ca_connected )
{
MsgDev( D_INFO, "Dup connect received. Ignored.\n");
return;
}
Netchan_Setup( NS_CLIENT, &cls.netchan, from, net_qport->integer);
BF_WriteByte( &cls.netchan.message, clc_stringcmd );
BF_WriteString( &cls.netchan.message, "new" );
cls.state = ca_connected;
cl.validsequence = 0; // haven't gotten a valid frame update yet
cl.delta_sequence = -1; // we'll request a full delta from the baseline
cls.lastoutgoingcommand = -1; // we don't have a backed up cmd history yet
cls.nextcmdtime = host.realtime; // we can send a cmd right away
CL_StartupDemoHeader ();
}
else if( !Q_strcmp( c, "info" ))
{
// server responding to a status broadcast
CL_ParseStatusMessage( from, msg );
}
else if( !Q_strcmp( c, "netinfo" ))
{
// server responding to a status broadcast
CL_ParseNETInfoMessage( from, msg );
}
else if( !Q_strcmp( c, "cmd" ))
{
// remote command from gui front end
if( !NET_IsLocalAddress( from ))
{
Msg( "Command packet from remote host. Ignored.\n" );
return;
}
#ifdef XASH_SDL
SDL_RestoreWindow( host.hWnd );
#endif
args = BF_ReadString( msg );
Cbuf_AddText( args );
Cbuf_AddText( "\n" );
}
else if( !Q_strcmp( c, "print" ))
{
// print command from somewhere
Msg("remote: %s\n", BF_ReadString( msg ) );
}
else if( !Q_strcmp( c, "ping" ))
{
// ping from somewhere
Netchan_OutOfBandPrint( NS_CLIENT, from, "ack" );
}
else if( !Q_strcmp( c, "challenge" ))
{
// challenge from the server we are connecting to
cls.challenge = Q_atoi( Cmd_Argv( 1 ));
CL_SendConnectPacket();
return;
}
else if( !Q_strcmp( c, "echo" ))
{
// echo request from server
Netchan_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv( 1 ));
}
else if( !Q_strcmp( c, "disconnect" ))
{
// a disconnect message from the server, which will happen if the server
// dropped the connection but it is still getting packets from us
CL_Disconnect();
CL_ClearEdicts();
}
else if( !Q_strcmp( c, "f") )
{
// serverlist got from masterserver
while( !msg->bOverflow )
{
servadr.type = NA_IP;
// 4 bytes for IP
BF_ReadBytes( msg, servadr.ip, sizeof( servadr.ip ));
// 2 bytes for Port
servadr.port = BF_ReadShort( msg );
if( !servadr.port )
break;
MsgDev( D_INFO, "Found server: %s\n", NET_AdrToString( servadr ));
NET_Config( true ); // allow remote
Netchan_OutOfBandPrint( NS_CLIENT, servadr, "info %i", PROTOCOL_VERSION );
}
// execute at next frame preventing relation on fps
Cbuf_AddText("menu_resetping\n");
}
else if( clgame.dllFuncs.pfnConnectionlessPacket( &from, args, buf, &len ))
{
// user out of band message (must be handled in CL_ConnectionlessPacket)
if( len > 0 ) Netchan_OutOfBand( NS_SERVER, from, len, (byte *)buf );
}
else MsgDev( D_ERROR, "Bad connectionless packet from %s:\n%s\n", NET_AdrToString( from ), args );
}