diff options
Diffstat (limited to 'source/sv_mvd.c')
| -rw-r--r-- | source/sv_mvd.c | 828 |
1 files changed, 828 insertions, 0 deletions
diff --git a/source/sv_mvd.c b/source/sv_mvd.c new file mode 100644 index 0000000..24b501e --- /dev/null +++ b/source/sv_mvd.c @@ -0,0 +1,828 @@ +/* +Copyright (C) 2003-2006 Andrey Nazarov + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +// +// sv_mvd.c - MVD server and local recorder +// + +#include "sv_local.h" +#include "mvd_local.h" + +cvar_t *sv_mvd_enable; +cvar_t *sv_mvd_auth; +cvar_t *sv_mvd_wait; +cvar_t *sv_mvd_noblend; +cvar_t *sv_mvd_nogun; +cvar_t *sv_mvd_max_size; +cvar_t *sv_mvd_max_duration; + +static cmdbuf_t dummy_buffer; +static char dummy_buffer_text[MAX_STRING_CHARS]; + +/* +================== +SV_MvdPlayerIsActive + +Determines if the given player entity is active, +e.g. fully in game and visible to other players. + +Should work both for human players, as well as bots, +and should never attempt to capture spectators. +FIXME: If intermission is running, capture everyone. + +Tested to work with CTF, OSP Tourney, AQ2 TNG, Gladiator bots. +Ideally a compatible game DLL should provide us with information +whether given player is to be captured, instead of relying on this hack. +================== +*/ +qboolean SV_MvdPlayerIsActive( edict_t *ent ) { + if( !ent->inuse ) { + return qfalse; + } + + // not a client at all? + if( !ent->client ) { + return qfalse; + } + + // HACK: make sure player_state_t is valid + if( !ent->client->ps.fov ) { + return qfalse; + } + + // HACK: if pm_type == PM_FREEZE, assume intermission is running + // if PMF_NO_PREDICTION is set, they are following someone! + if( ent->client->ps.pmove.pm_type == PM_FREEZE && + !( ent->client->ps.pmove.pm_flags & PMF_NO_PREDICTION ) ) + { + return qtrue; + } + + // if set to invisible, skip + if( ent->svflags & SVF_NOCLIENT ) { + return qfalse; + } + + if( ent->s.modelindex || ent->s.effects || ent->s.sound || ent->s.event ) { + return qtrue; + } + + // if it has no effects, skip + return qfalse; +} + +/* +================== +SV_MvdBuildFrame + +Builds new MVD frame by capturing all entity and player states +and calculating portalbits. The same frame is used for all MVD +clients, as well as local recorder. +================== +*/ +static void SV_MvdBuildFrame( void ) { + client_frame_t *frame; + edict_t *ent; + entity_state_t *es, *s; + player_state_t *ps; + int i; + + frame = &sv.mvdframes[++sv.mvdframenum & 1]; + frame->senttime = svs.realtime; + frame->areabytes = CM_WritePortalBits( &sv.cm, frame->areabits ); + frame->numEntities = 0; + frame->firstEntity = svs.nextEntityStates; + frame->numPlayers = 0; + frame->firstPlayer = svs.nextPlayerStates; + + for( i = 1; i < ge->num_edicts; i++ ) { + ent = EDICT_NUM( i ); + + if( ent->svflags & SVF_NOCLIENT ) { + continue; + } + + s = &ent->s; + if( !s->modelindex && !s->effects && !s->sound && !s->event ) { + continue; + } + + es = &svs.entityStates[svs.nextEntityStates % svs.numEntityStates]; + *es = *s; + es->number = i; + + svs.nextEntityStates++; + frame->numEntities++; + } + + for( i = 0; i < sv_maxclients->integer; i++ ) { + ent = EDICT_NUM( i + 1 ); + if( !svs.mvdummy || i != svs.mvdummy->number ) { + if( !SV_MvdPlayerIsActive( ent ) ) { + continue; + } + } + + ps = &svs.playerStates[svs.nextPlayerStates % svs.numPlayerStates]; + *ps = ent->client->ps; + PPS_NUM( ps ) = i; + + svs.nextPlayerStates++; + frame->numPlayers++; + } +} + +static void SV_DummyWait_f( void ) { + dummy_buffer.waitCount = 1; +} + +static const ucmd_t dummy_cmds[] = { + //{ "cmd", SV_DummyForward_f }, + //{ "connect", MVD_Connect_f }, + { "set", Cvar_Set_f }, + { "alias", Cmd_Alias_f }, + { "play", NULL }, + { "exec", NULL }, + { "wait", SV_DummyWait_f }, + { NULL, NULL } +}; + +static void SV_DummyExecuteString( const char *line ) { + char *cmd, *alias; + const ucmd_t *u; + cvar_t *v; + + if( !line[0] ) { + return; + } + + Cmd_TokenizeString( line, qtrue ); + + cmd = Cmd_Argv( 0 ); + if( !cmd[0] ) { + return; + } + for( u = dummy_cmds; u->name; u++ ) { + if( !strcmp( cmd, u->name ) ) { + if( u->func ) { + u->func(); + } + return; + } + } + + alias = Cmd_AliasCommand( cmd ); + if( alias ) { + if( ++dummy_buffer.aliasCount == ALIAS_LOOP_COUNT ) { + Com_WPrintf( "SV_DummyExecuteString: runaway alias loop\n" ); + return; + } + Cbuf_InsertTextEx( &dummy_buffer, alias ); + return; + } + + v = Cvar_FindVar( cmd ); + if( v ) { + Cvar_Command( v ); + return; + } + + Com_Printf( "dummy stufftext: %s\n", line ); + sv_client = svs.mvdummy; + sv_player = svs.mvdummy->edict; + ge->ClientCommand( sv_player ); + sv_client = NULL; + sv_player = NULL; +} + +static void SV_DummyAddMessage( client_t *client, byte *data, + int length, qboolean reliable ) +{ + tcpClient_t *t; + + if( !length || !reliable ) { + return; + } + + if( data[0] == svc_stufftext ) { + data[length] = 0; + Cbuf_AddTextEx( &dummy_buffer, ( char * )( data + 1 ) ); + return; + } + + LIST_FOR_EACH( tcpClient_t, t, &svs.mvdClients, mvdEntry ) { + if( t->state >= cs_primed ) { + } + } + +} +void SV_MvdSpawnDummy( void ) { + client_t *c = svs.mvdummy; + + if( !c ) { + return; + } + + sv_client = c; + sv_player = c->edict; + + SV_CreateBaselines( c->param.baselines ); + c->param.basesize = sizeof( entity_state_t ); + c->param.maxplayers = sv_maxclients->integer; + + ge->ClientBegin( sv_player ); + + sv_client = NULL; + sv_player = NULL; + + Cbuf_AddTextEx( &dummy_buffer, "wait 50; putaway; wait 10; help\n" ); + + SV_MvdBuildFrame(); + + c->state = cs_spawned; +} + +qboolean SV_MvdCreateDummy( void ) { + client_t *newcl, *lastcl; + char userinfo[MAX_INFO_STRING]; + char *s; + qboolean allow; + int number; + + if( svs.mvdummy ) { + return qtrue; // already created + } + + // find a free client slot + lastcl = svs.clientpool + sv_maxclients->integer; + for( newcl = svs.clientpool; newcl < lastcl; newcl++ ) { + if( !newcl->state ) { + break; + } + } + if( newcl == lastcl ) { + return qfalse; + } + + memset( newcl, 0, sizeof( *newcl ) ); + number = newcl - svs.clientpool; + newcl->number = number; + newcl->protocol = -1; + newcl->state = cs_connected; + newcl->AddMessage = SV_DummyAddMessage; + newcl->edict = EDICT_NUM( number + 1 ); + + List_Init( &newcl->entry ); + + Com_sprintf( userinfo, sizeof( userinfo ), + "\\name\\[MVDSPEC]\\skin\\male/grunt\\mvdversion\\%d\\ip\\loopback", + PROTOCOL_VERSION_MVD_MINOR ); + + svs.mvdummy = newcl; + + // get the game a chance to reject this connection or modify the userinfo + sv_client = newcl; + sv_player = newcl->edict; + allow = ge->ClientConnect( newcl->edict, userinfo ); + sv_client = NULL; + sv_player = NULL; + if ( !allow ) { + s = Info_ValueForKey( userinfo, "rejmsg" ); + if( *s ) { + Com_Printf( "Dummy MVD client rejected by game DLL: %s\n", s ); + } + svs.mvdummy = NULL; + return qfalse; + } + + // parse some info from the info strings + Q_strncpyz( newcl->userinfo, userinfo, sizeof( newcl->userinfo ) ); + SV_UserinfoChanged( newcl ); + + SV_MvdSpawnDummy(); + + return qtrue; +} + +/* +================== +SV_MvdBeginFrame + +Checks whether there are active clients on server +and pauses/resumes MVD frame builing proccess accordingly. + +On resume, dumps all configstrings clobbered by game DLL +into the multicast buffer. +================== +*/ +void SV_MvdBeginFrame( void ) { + int i, j; + int index, length; + client_t *client; + qboolean found; + + if( sv_mvd_wait->integer > 0 ) { + found = qfalse; + if( sv_mvd_wait->integer == 1 ) { + for( i = 1; i <= sv_maxclients->integer; i++ ) { + edict_t *ent = EDICT_NUM( i ); + if( SV_MvdPlayerIsActive( ent ) ) { + found = qtrue; + break; + } + } + } else { + FOR_EACH_CLIENT( client ) { + if( client->state == cs_spawned ) { + found = qtrue; + break; + } + } + } + + if( !found ) { + if( sv.mvdpaused == PAUSED_FRAMES ) { + Com_Printf( "MVD stream paused, no active clients.\n" ); + for( i = 0; i < DCS_DWORDS; i++ ) { + (( uint32 * )sv.dirty_configstrings)[i] = 0; + } + //SV_MvdBroadcastCommand( "mvdpause\n" ); + } + sv.mvdpaused++; + return; + } + } + + if( sv.mvdpaused >= PAUSED_FRAMES ) { + for( i = 0; i < DCS_DWORDS; i++ ) { + if( (( uint32 * )sv.dirty_configstrings)[i] == 0 ) { + continue; + } + index = i << 5; + for( j = 0; j < 32; j++, index++ ) { + if( !Q_IsBitSet( sv.dirty_configstrings, index ) ) { + continue; + } + SZ_WriteByte( &sv.multicast, svc_configstring ); + SZ_WriteShort( &sv.multicast, index ); + length = strlen( sv.configstrings[index] ); + if( length > MAX_QPATH ) { + length = MAX_QPATH; + } + SZ_Write( &sv.multicast, sv.configstrings[index], length ); + SZ_WriteByte( &sv.multicast, 0 ); + } + } + + Com_Printf( "MVD stream resumed, flushed %d bytes.\n", + sv.multicast.cursize ); + // will be subsequently written to disk by SV_MvdEndFrame + } + + sv.mvdpaused = 0; +} + + +/* +================== +SV_MvdEmitFrame + +Writes new MVD frame, delta compressed from the previous one. +================== +*/ +static void SV_MvdEmitFrame( qboolean delta ) { + client_frame_t *frame, *oldframe; + msgPsFlags_t flags; + + frame = &sv.mvdframes[sv.mvdframenum & 1]; + + if( delta ) { + oldframe = &sv.mvdframes[( sv.mvdframenum - 1 ) & 1]; + MSG_WriteByte( mvd_frame ); + } else { + oldframe = NULL; + MSG_WriteByte( mvd_frame_nodelta ); + } + + MSG_WriteLong( sv.framenum ); + + MSG_WriteByte( frame->areabytes ); + MSG_WriteData( frame->areabits, frame->areabytes ); + + flags = MSG_PS_IGNORE_PREDICTION|MSG_PS_IGNORE_DELTAANGLES; + if( sv_mvd_noblend->integer ) { + flags |= MSG_PS_IGNORE_BLEND; + } + if( sv_mvd_nogun->integer ) { + flags |= MSG_PS_IGNORE_GUNINDEX|MSG_PS_IGNORE_GUNFRAMES; + } + SV_EmitPacketPlayers( oldframe, frame, flags ); + SV_EmitPacketEntities( oldframe, frame, MAX_EDICTS, + &svs.mvdummy->param ); +} + +/* +================== +SV_MvdRecFrame +================== +*/ +static void SV_MvdRecFrame( void ) { + FS_Write( msg_write.data, msg_write.cursize, sv.demofile ); + FS_Write( sv.multicast.data, sv.multicast.cursize, sv.demofile ); + + if( sv_mvd_max_size->value > 0 ) { + int numbytes = FS_RawTell( sv.demofile ); + + if( numbytes > sv_mvd_max_size->value * 1000 ) { + Com_Printf( "Stopping MVD recording, maximum size reached.\n" ); + SV_MvdRecStop(); + } + } else if( sv_mvd_max_duration->value > 0 && + sv.mvdframenum > sv_mvd_max_duration->value * 600 ) + { + Com_Printf( "Stopping MVD recording, maximum duration reached.\n" ); + SV_MvdRecStop(); + } +} + +void SV_MvdEndFrame( void ) { + tcpClient_t *client; + uint16 *patch; + + Cbuf_ExecuteEx( &dummy_buffer ); + if( dummy_buffer.waitCount > 0 ) { + dummy_buffer.waitCount--; + } + + if( sv.mvdpaused >= PAUSED_FRAMES ) { + SZ_Clear( &sv.multicast ); + return; + } + + SV_MvdBuildFrame(); + + patch = SZ_GetSpace( &msg_write, 2 ); + SV_MvdEmitFrame( qtrue ); + *patch = LittleShort( msg_write.cursize + sv.multicast.cursize - 2 ); + + LIST_FOR_EACH( tcpClient_t, client, &svs.mvdClients, mvdEntry ) { + if( client->state == cs_spawned ) { + SV_HttpWrite( client, msg_write.data, msg_write.cursize ); + SV_HttpWrite( client, sv.multicast.data, sv.multicast.cursize ); +#if USE_ZLIB + client->noflush++; +#endif + } + } + + if( sv.mvdrecording ) { + SV_MvdRecFrame(); + } + + SZ_Clear( &msg_write ); + SZ_Clear( &sv.multicast ); +} + +/* +================== +SV_MvdEmitGamestate + +Writes a single giant message with all the startup info. +================== +*/ +static void SV_MvdEmitGamestate( void ) { + char *string; + int i, j; + entity_state_t *base; + int length; + uint16 *patch; + + patch = SZ_GetSpace( &msg_write, 2 ); + + // send the serverdata + MSG_WriteByte( mvd_serverdata ); + MSG_WriteLong( PROTOCOL_VERSION_MVD ); + MSG_WriteShort( PROTOCOL_VERSION_MVD_MINOR ); + MSG_WriteLong( sv.spawncount ); + MSG_WriteString( fs_game->string ); + MSG_WriteShort( svs.mvdummy->number ); + + // send configstrings + for( i = 0; i < MAX_CONFIGSTRINGS; i++ ) { + string = sv.configstrings[i]; + if( !string[0] ) { + continue; + } + length = strlen( string ); + if( length > MAX_QPATH ) { + length = MAX_QPATH; + } + + MSG_WriteShort( i ); + MSG_WriteData( string, length ); + MSG_WriteByte( 0 ); + } + MSG_WriteShort( MAX_CONFIGSTRINGS ); + + // send baselines + for( i = 0; i < SV_BASELINES_CHUNKS; i++ ) { + base = svs.mvdummy->param.baselines[i]; + if( !base ) { + continue; + } + for( j = 0; j < SV_BASELINES_PER_CHUNK; j++ ) { + if( base->number ) { + MSG_WriteDeltaEntity( NULL, base, MSG_ES_FORCE ); + } + base++; + } + } + MSG_WriteShort( 0 ); + + // send uncompressed frame + SV_MvdEmitFrame( qfalse ); + + *patch = LittleShort( msg_write.cursize - 2 ); +} + +void SV_MvdClientNew( tcpClient_t *client ) { + Com_DPrintf( "Sending gamestate to MVD client %s\n", + NET_AdrToString( &client->stream.address ) ); + client->state = cs_spawned; + + SV_MvdEmitGamestate(); + +#if USE_ZLIB + client->noflush = 99999; +#endif + + SV_HttpWrite( client, msg_write.data, msg_write.cursize ); + SZ_Clear( &msg_write ); +} + + +void SV_MvdGetStream( const char *uri ) { + uint32 magic; + + if( http_client->method == HTTP_METHOD_HEAD ) { + SV_HttpPrintf( "HTTP/1.0 200 OK\r\n\r\n" ); + SV_HttpDrop( http_client, "200 OK " ); + return; + } + + if( !SV_MvdCreateDummy() ) { + SV_HttpReject( "503 Service Unavailable", + "Unable to create dummy MVD client. Server is full." ); + return; + } + + List_Append( &svs.mvdClients, &http_client->mvdEntry ); + + SV_HttpPrintf( + "HTTP/1.0 200 OK\r\n" +#ifdef USE_ZLIB + "Content-Encoding: deflate\r\n" +#endif + "Content-Type: application/octet-stream\r\n" + "Content-Disposition: attachment; filename=\"stream.mvd2\"\r\n" + "\r\n" ); + +#if USE_ZLIB + deflateInit( &http_client->z, Z_DEFAULT_COMPRESSION ); +#endif + + magic = MVD_MAGIC; + SV_HttpWrite( http_client, &magic, 4 ); + + SV_MvdClientNew( http_client ); +} + +/* +============== +SV_MvdMulticast + +TODO: attempt to combine several identical unicast/multicast messages +into one message to save space (useful for shotgun patterns +as they often occur in the same BSP leaf) +============== +*/ +void SV_MvdMulticast( int leafnum, mvd_ops_t op ) { + int bits; + + if( sv.mvdpaused >= PAUSED_FRAMES ) { + return; + } + + bits = ( msg_write.cursize >> 8 ) & 7; + SZ_WriteByte( &sv.multicast, op | ( bits << SVCMD_BITS ) ); + SZ_WriteByte( &sv.multicast, msg_write.cursize & 255 ); + + if( op != mvd_multicast_all && op != mvd_multicast_all_r ) { + SZ_WriteShort( &sv.multicast, leafnum ); + } + + SZ_Write( &sv.multicast, msg_write.data, msg_write.cursize ); +} + +/* +============== +SV_MvdUnicast +============== +*/ +void SV_MvdUnicast( int clientNum, mvd_ops_t op ) { + int bits; + + if( sv.mvdpaused >= PAUSED_FRAMES ) { + return; + } + + bits = ( msg_write.cursize >> 8 ) & 7; + SZ_WriteByte( &sv.multicast, op | ( bits << SVCMD_BITS ) ); + SZ_WriteByte( &sv.multicast, msg_write.cursize & 255 ); + SZ_WriteByte( &sv.multicast, clientNum ); + SZ_Write( &sv.multicast, msg_write.data, msg_write.cursize ); +} + +/* +============== +SV_MvdConfigstring +============== +*/ +void SV_MvdConfigstring( int index, const char *string ) { + if( sv.mvdpaused >= PAUSED_FRAMES ) { + Q_SetBit( sv.dirty_configstrings, index ); + return; + } + SZ_WriteByte( &sv.multicast, mvd_configstring ); + SZ_WriteShort( &sv.multicast, index ); + SZ_WriteString( &sv.multicast, string ); +} + +/* +============== +SV_MvdRecStop + +Stops server local MVD recording. +============== +*/ +void SV_MvdRecStop( void ) { + int length; + + if( !sv.mvdrecording ) { + return; + } + + // write demo EOF marker + length = 0; + FS_Write( &length, 2, sv.demofile ); + + FS_FCloseFile( sv.demofile ); + sv.demofile = 0; + + sv.mvdrecording = qfalse; +} + +/* +============== +MVD_Record_f + +Begins server MVD recording. +Every entity, every playerinfo and every message will be recorded. +============== +*/ +static void MVD_Record_f( void ) { + char buffer[MAX_QPATH]; + char *name; + fileHandle_t demofile; + uint32 magic; + + if( sv.state != ss_game ) { + if( sv.state == ss_broadcast ) { + MVD_StreamedRecord_f(); + } else { + Com_Printf( "Must be running a game server to record.\n" ); + } + return; + } + + if( Cmd_Argc() != 2 ) { + Com_Printf( "Usage: %s [/]<filename>\n", Cmd_Argv( 0 ) ); + return; + } + + if( !sv_mvd_enable->integer ) { + Com_Printf( "MVD recording disabled on this server.\n" ); + return; + } + + if( sv.mvdrecording ) { + Com_Printf( "Already recording a local MVD.\n" ); + return; + } + + // + // open the demo file + // + name = Cmd_Argv( 1 ); + if( name[0] == '/' ) { + Q_strncpyz( buffer, name + 1, sizeof( buffer ) ); + } else { + Com_sprintf( buffer, sizeof( buffer ), "demos/%s", name ); + COM_DefaultExtension( buffer, ".mvd2", sizeof( buffer ) ); + } + + FS_FOpenFile( buffer, &demofile, FS_MODE_WRITE ); + if( !demofile ) { + Com_EPrintf( "Couldn't open %s for writing\n", buffer ); + return; + } + + if( !SV_MvdCreateDummy() ) { + Com_EPrintf( "Unable to create dummy MVD client\n" ); + return; + } + + sv.demofile = demofile; + sv.mvdrecording = qtrue; + + magic = MVD_MAGIC; + FS_Write( &magic, 4, sv.demofile ); + + SV_MvdEmitGamestate(); + FS_Write( msg_write.data, msg_write.cursize, sv.demofile ); + SZ_Clear( &msg_write ); + + Com_Printf( "Recording local MVD to %s\n", buffer ); +} + + +/* +============== +MVD_Stop_f + +Ends server MVD recording +============== +*/ +static void MVD_Stop_f( void ) { + if( sv.state == ss_broadcast ) { + MVD_StreamedStop_f(); + return; + } + if( !sv.mvdrecording ) { + Com_Printf( "Not recording a local MVD.\n" ); + return; + } + + Com_Printf( "Local MVD recording completed.\n" ); + SV_MvdRecStop(); +} + +static void MVD_Stuff_f( void ) { + if( svs.mvdummy ) { + Cbuf_AddTextEx( &dummy_buffer, Cmd_RawArgs() ); + } else { + Com_Printf( "Can't %s, dummy MVD client not active\n", Cmd_Argv( 0 ) ); + } +} + +static const cmdreg_t c_svmvd[] = { + { "mvdrecord", MVD_Record_f, MVD_Play_g }, + { "mvdstop", MVD_Stop_f }, + { "mvdstuff", MVD_Stuff_f }, + + { NULL } +}; + +void SV_MvdRegister( void ) { + sv_mvd_enable = Cvar_Get( "sv_mvd_enable", "0", CVAR_LATCH ); + sv_mvd_auth = Cvar_Get( "sv_mvd_auth", "", CVAR_PRIVATE ); + sv_mvd_wait = Cvar_Get( "sv_mvd_wait", "0", 0 ); + sv_mvd_max_size = Cvar_Get( "sv_mvd_max_size", "0", 0 ); + sv_mvd_max_duration = Cvar_Get( "sv_mvd_max_duration", "0", 0 ); + sv_mvd_noblend = Cvar_Get( "sv_mvd_noblend", "0", CVAR_LATCH ); + sv_mvd_nogun = Cvar_Get( "sv_mvd_nogun", "1", CVAR_LATCH ); + + dummy_buffer.text = dummy_buffer_text; + dummy_buffer.maxsize = sizeof( dummy_buffer_text ); + dummy_buffer.exec = SV_DummyExecuteString; + + Cmd_Register( c_svmvd ); +} + |