/*
* TV_Init
*
* Only called at plat.exe startup, not for each game
*/
void TV_Init( void )
{
Com_Printf( "Initializing " APPLICATION " TV server\n" );
tv_mempool = Mem_AllocPool( NULL, "TV" );
TV_AddCommands();
Cvar_Get( "protocol", va( "%i", APP_PROTOCOL_VERSION ), CVAR_SERVERINFO | CVAR_NOSET );
Cvar_Get( "gamename", Cvar_String( "gamename" ), CVAR_SERVERINFO | CVAR_NOSET );
tv_password = Cvar_Get( "tv_password", "", 0 );
tv_ip = Cvar_Get( "tv_ip", "", CVAR_ARCHIVE | CVAR_NOSET );
tv_port = Cvar_Get( "tv_port", va( "%i", PORT_TV_SERVER ), CVAR_ARCHIVE | CVAR_NOSET );
tv_ip6 = Cvar_Get( "tv_ip6", "::", CVAR_ARCHIVE | CVAR_NOSET );
tv_port6 = Cvar_Get( "tv_port6", va( "%i", PORT_TV_SERVER ), CVAR_ARCHIVE | CVAR_NOSET );
#ifdef TCP_ALLOW_TVCONNECT
tv_udp = Cvar_Get( "tv_udp", "1", CVAR_SERVERINFO | CVAR_NOSET );
tv_tcp = Cvar_Get( "tv_tcp", "1", CVAR_SERVERINFO | CVAR_NOSET );
#else
tv_udp = Cvar_Get( "tv_udp", "1", CVAR_NOSET );
#endif
#ifndef TCP_ALLOW_TVCONNECT
Cvar_FullSet( "tv_tcp", "0", CVAR_READONLY, true );
#endif
tv_reconnectlimit = Cvar_Get( "tv_reconnectlimit", "3", CVAR_ARCHIVE );
tv_timeout = Cvar_Get( "tv_timeout", "125", 0 );
tv_zombietime = Cvar_Get( "tv_zombietime", "2", 0 );
tv_name = Cvar_Get( "tv_name", APPLICATION "[TV]", CVAR_SERVERINFO | CVAR_ARCHIVE );
tv_compresspackets = Cvar_Get( "tv_compresspackets", "1", 0 );
tv_maxclients = Cvar_Get( "tv_maxclients", "32", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_NOSET );
tv_maxmvclients = Cvar_Get( "tv_maxmvclients", "4", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_NOSET );
tv_public = Cvar_Get( "tv_public", "1", CVAR_ARCHIVE | CVAR_SERVERINFO );
tv_rcon_password = Cvar_Get( "tv_rcon_password", "", 0 );
tv_autorecord = Cvar_Get( "tv_autorecord", "", CVAR_ARCHIVE );
tv_lobbymusic = Cvar_Get( "tv_lobbymusic", "", CVAR_ARCHIVE );
tv_masterservers = Cvar_Get( "tv_masterservers", DEFAULT_MASTER_SERVERS_IPS, CVAR_LATCH );
tv_masterservers_steam = Cvar_Get( "tv_masterservers_steam", DEFAULT_MASTER_SERVERS_STEAM_IPS, CVAR_LATCH );
// flood control
tv_floodprotection_messages = Cvar_Get( "tv_floodprotection_messages", "10", 0 );
tv_floodprotection_messages->modified = true;
tv_floodprotection_seconds = Cvar_Get( "tv_floodprotection_seconds", "4", 0 );
tv_floodprotection_seconds->modified = true;
tv_floodprotection_penalty = Cvar_Get( "tv_floodprotection_delay", "20", 0 );
tv_floodprotection_penalty->modified = true;
if( tv_maxclients->integer < 0 )
Cvar_ForceSet( "tv_maxclients", "0" );
if( tv_maxclients->integer )
{
tvs.clients = ( client_t * )Mem_Alloc( tv_mempool, sizeof( client_t ) * tv_maxclients->integer );
}
else
{
tvs.clients = NULL;
}
tvs.lobby.spawncount = rand();
tvs.lobby.snapFrameTime = 100;
// IPv4
if( !NET_StringToAddress( tv_ip->string, &tvs.address ) )
Com_Error( ERR_FATAL, "Couldn't understand address of tv_ip cvar: %s\n", NET_ErrorString() );
NET_SetAddressPort( &tvs.address, tv_port->integer );
if( tv_udp->integer )
{
if( !NET_OpenSocket( &tvs.socket_udp, SOCKET_UDP, &tvs.address, true ) )
{
Com_Printf( "Error: Couldn't open UDP socket: %s\n", NET_ErrorString() );
Cvar_ForceSet( tv_udp->name, "0" );
}
}
// IPv6
if( !NET_StringToAddress( tv_ip6->string, &tvs.addressIPv6 ) )
Com_Error( ERR_FATAL, "Couldn't understand address of tv_ip6 cvar: %s\n", NET_ErrorString() );
NET_SetAddressPort( &tvs.addressIPv6, tv_port6->integer );
if( tvs.addressIPv6.type != NA_NOTRANSMIT )
{
if( !NET_OpenSocket( &tvs.socket_udp6, SOCKET_UDP, &tvs.addressIPv6, true ) )
{
Com_Printf( "Error: Couldn't open UDP6 socket: %s\n", NET_ErrorString() );
}
}
#ifdef TCP_ALLOW_TVCONNECT
if( tv_tcp->integer )
{
bool err = true;
if( !NET_OpenSocket( &tvs.socket_tcp, SOCKET_TCP, &tvs.address, true ) )
{
Com_Printf( "Error: Couldn't open TCP socket: %s\n", NET_ErrorString() );
}
else
{
NET_SetSocketNoDelay( &tvs.socket_tcp, 1 );
if( !NET_Listen( &tvs.socket_tcp ) )
{
Com_Printf( "Error: Couldn't listen to TCP socket: %s\n", NET_ErrorString() );
}
else
{
err = false;
}
}
if( tvs.addressIPv6.type != NA_NOTRANSMIT )
{
if( !NET_OpenSocket( &tvs.socket_tcp6, SOCKET_TCP, &tvs.addressIPv6, true ) )
{
Com_Printf( "Error: Couldn't open TCP6 socket: %s\n", NET_ErrorString() );
}
else
{
NET_SetSocketNoDelay( &tvs.socket_tcp6, 1 );
if( !NET_Listen( &tvs.socket_tcp6 ) )
{
Com_Printf( "Error: Couldn't listen to TCP6 socket: %s\n", NET_ErrorString() );
}
else
{
err = false;
}
}
}
if( err ) {
Cvar_ForceSet( tv_tcp->name, "0" );
}
}
#endif
TV_Downstream_InitMaster();
}
/*
* SV_InitGame
* A brand new game has been started
*/
void SV_InitGame( void ) {
int i;
edict_t *ent;
netadr_t address, ipv6_address;
bool socket_opened = false;
// make sure the client is down
CL_Disconnect( NULL );
SCR_BeginLoadingPlaque();
if( svs.initialized ) {
// cause any connected clients to reconnect
SV_ShutdownGame( "Server restarted", true );
// SV_ShutdownGame will also call Cvar_GetLatchedVars
} else {
// get any latched variable changes (sv_maxclients, etc)
Cvar_GetLatchedVars( CVAR_LATCH );
}
svs.initialized = true;
if( sv_skilllevel->integer > 2 ) {
Cvar_ForceSet( "sv_skilllevel", "2" );
}
if( sv_skilllevel->integer < 0 ) {
Cvar_ForceSet( "sv_skilllevel", "0" );
}
// init clients
if( sv_maxclients->integer < 1 ) {
Cvar_FullSet( "sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH, true );
} else if( sv_maxclients->integer > MAX_CLIENTS ) {
Cvar_FullSet( "sv_maxclients", va( "%i", MAX_CLIENTS ), CVAR_SERVERINFO | CVAR_LATCH, true );
}
svs.spawncount = rand();
svs.clients = Mem_Alloc( sv_mempool, sizeof( client_t ) * sv_maxclients->integer );
svs.client_entities.num_entities = sv_maxclients->integer * UPDATE_BACKUP * MAX_SNAP_ENTITIES;
svs.client_entities.entities = Mem_Alloc( sv_mempool, sizeof( entity_state_t ) * svs.client_entities.num_entities );
// init network stuff
address.type = NA_NOTRANSMIT;
ipv6_address.type = NA_NOTRANSMIT;
if( !dedicated->integer ) {
NET_InitAddress( &address, NA_LOOPBACK );
if( !NET_OpenSocket( &svs.socket_loopback, SOCKET_LOOPBACK, &address, true ) ) {
Com_Error( ERR_FATAL, "Couldn't open loopback socket: %s\n", NET_ErrorString() );
}
}
if( dedicated->integer || sv_maxclients->integer > 1 ) {
// IPv4
NET_StringToAddress( sv_ip->string, &address );
NET_SetAddressPort( &address, sv_port->integer );
if( !NET_OpenSocket( &svs.socket_udp, SOCKET_UDP, &address, true ) ) {
Com_Printf( "Error: Couldn't open UDP socket: %s\n", NET_ErrorString() );
} else {
socket_opened = true;
}
// IPv6
NET_StringToAddress( sv_ip6->string, &ipv6_address );
if( ipv6_address.type == NA_IP6 ) {
NET_SetAddressPort( &ipv6_address, sv_port6->integer );
if( !NET_OpenSocket( &svs.socket_udp6, SOCKET_UDP, &ipv6_address, true ) ) {
Com_Printf( "Error: Couldn't open UDP6 socket: %s\n", NET_ErrorString() );
} else {
socket_opened = true;
}
} else {
Com_Printf( "Error: invalid IPv6 address: %s\n", sv_ip6->string );
}
}
#ifdef TCP_ALLOW_CONNECT
if( sv_tcp->integer && ( dedicated->integer || sv_maxclients->integer > 1 ) ) {
bool err = true;
if( !NET_OpenSocket( &svs.socket_tcp, SOCKET_TCP, &address, true ) ) {
Com_Printf( "Error: Couldn't open TCP socket: %s\n", NET_ErrorString() );
} else {
NET_SetSocketNoDelay( &svs.socket_tcp, 1 );
if( !NET_Listen( &svs.socket_tcp ) ) {
Com_Printf( "Error: Couldn't listen to TCP socket: %s\n", NET_ErrorString() );
NET_CloseSocket( &svs.socket_tcp );
} else {
err = false;
socket_opened = true;
}
}
if( ipv6_address.type == NA_IP6 ) {
if( !NET_OpenSocket( &svs.socket_tcp6, SOCKET_TCP, &ipv6_address, true ) ) {
Com_Printf( "Error: Couldn't open TCP6 socket: %s\n", NET_ErrorString() );
} else {
NET_SetSocketNoDelay( &svs.socket_tcp6, 1 );
if( !NET_Listen( &svs.socket_tcp6 ) ) {
Com_Printf( "Error: Couldn't listen to TCP6 socket: %s\n", NET_ErrorString() );
NET_CloseSocket( &svs.socket_tcp6 );
} else {
err = false;
socket_opened = true;
}
}
}
if( err ) {
Cvar_ForceSet( "sv_tcp", "0" );
}
}
#endif
if( dedicated->integer && !socket_opened ) {
Com_Error( ERR_FATAL, "Couldn't open any socket\n" );
}
// init mm
// SV_MM_Init();
// init game
SV_InitGameProgs();
for( i = 0; i < sv_maxclients->integer; i++ ) {
ent = EDICT_NUM( i + 1 );
ent->s.number = i + 1;
svs.clients[i].edict = ent;
}
// load the map
assert( !svs.cms );
svs.cms = CM_New( NULL );
CM_AddReference( svs.cms );
// keep CPU awake
assert( !svs.wakelock );
svs.wakelock = Sys_AcquireWakeLock();
}
