b380421e42
Clarify the 'too many alternate clients' messages. Gamepad movement should respond to +speed. favour fte's nq protocols over dp ones when both are supported by the client, to boost compat with qss. try to generate proper utf-8 filenames from player/team names when recording mvds, instead of bad char encodings. Fix loading saved games with splitscreen enabled. pr_dumpplatform can now optionally filter symbols via some specific external files, adding deprecated tags for any symbol not also supported by DP and QSS. Rework CSQC globals to use macros, to ensure completeness and consistency. rework sv_csqcdebug to use special svcs. This should make it more robust. Fix some scary warnings when vid_reloading the vulkan renderer. Fix a possible segfault from opengl+rtlights. Mousewheel will now interact better with engine menus. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5757 fc73d0e0-1445-4013-8a0c-d673dee63da5
3200 lines
79 KiB
C
3200 lines
79 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
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 included (GNU.txt) 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.
|
|
|
|
*/
|
|
|
|
#include "quakedef.h"
|
|
#ifdef MVD_RECORDING
|
|
#ifndef CLIENTONLY
|
|
|
|
#include "winquake.h"
|
|
#include "fs.h"
|
|
|
|
#include "netinc.h"
|
|
|
|
void SV_MVDStop_f (void);
|
|
|
|
#define demo_size_padding 0x1000
|
|
|
|
static void QDECL SV_DemoDir_Callback(struct cvar_s *var, char *oldvalue);
|
|
|
|
cvar_t sv_demoAutoRecord = CVARAD("sv_demoAutoRecord", "0", "cl_autodemo", "If set, automatically record demos.\n-1: record on client connection only.\n1+: record once there's this many active players on the server (or if connected to a remote server).");
|
|
cvar_t sv_demoUseCache = CVARD("sv_demoUseCache", "", "If set, demo data will be flushed only periodically");
|
|
cvar_t sv_demoCacheSize = CVAR("sv_demoCacheSize", "0x80000"); //half a meg
|
|
cvar_t sv_demoMaxDirSize = CVARD("sv_demoMaxDirSize", "100mb", "Maximum allowed serverside storage space for mvds. set to blank to remove the limit. New demos cannot be recorded once this size is reached."); //so ktpro autorecords.
|
|
cvar_t sv_demoMaxDirCount = CVARD("sv_demoMaxDirCount", "500", "Maximum allowed serverside mvds to record. Set to 0 to remove the limit. New demos cannot be recorded once this many demos have already been recorded."); //so ktpro autorecords.
|
|
cvar_t sv_demoMaxDirAge = CVARD("sv_demoMaxDirAge", "0", "Maximum allowed age for demos, any older demos will be deleted when sv_demoClearOld is set (this doesn't prevent recording new demos).");
|
|
cvar_t sv_demoClearOld = CVARD("sv_demoClearOld", "0", "Automatically delete demos to keep the demos count reasonable.");
|
|
cvar_t sv_demoDir = CVARC("sv_demoDir", "demos", SV_DemoDir_Callback);
|
|
cvar_t sv_demoDirAlt = CVARCD("sv_demoDirAlt", "", SV_DemoDir_Callback, "Provides a fallback directory name for demo downloads, for when sv_demoDir doesn't contain the requested demo.");
|
|
cvar_t sv_demofps = CVAR("sv_demofps", "30");
|
|
cvar_t sv_demoPings = CVARD("sv_demoPings", "10", "Interval between ping updates in mvds");
|
|
cvar_t sv_demoMaxSize = CVARD("sv_demoMaxSize", "", "Demos will be truncated to be no larger than this size.");
|
|
cvar_t sv_demoExtraNames = CVAR("sv_demoExtraNames", "");
|
|
cvar_t sv_demoExtensions = CVARD("sv_demoExtensions", "1", "Enables protocol extensions within MVDs. This will cause older/non-fte clients to error upon playback.\n0: off.\n1: all extensions.\n2: extensions also supported by a certain other engine.");
|
|
cvar_t sv_demoAutoCompress = CVARD("sv_demoAutoCompress", "", "Specifies whether to compress demos as they're recorded.\n0 = no compression.\n1 = gzip compression.");
|
|
cvar_t sv_demo_write_csqc = CVARD("sv_demo_write_csqc", "", "Writes a copy of the csprogs into recorded demos. This ensures that the demo can be played back despite future gamecode changes.");
|
|
|
|
cvar_t qtv_password = CVAR( "qtv_password", "");
|
|
cvar_t qtv_maxstreams = CVARAFD( "qtv_maxstreams", "0",
|
|
"mvd_maxstreams", 0, "This is the maximum number of QTV clients/proxies that may be directly connected to the server. If empty then there is no limit. 0 disallows any streaming.");
|
|
|
|
cvar_t sv_demoAutoPrefix = CVAR("sv_demoAutoPrefix", "auto_");
|
|
cvar_t sv_demoPrefix = CVAR("sv_demoPrefix", "");
|
|
cvar_t sv_demoSuffix = CVAR("sv_demoSuffix", "");
|
|
cvar_t sv_demotxt = CVAR("sv_demotxt", "1");
|
|
|
|
void SV_WriteMVDMessage (sizebuf_t *msg, int type, int to, float time);
|
|
void SV_WriteRecordMVDMessage (sizebuf_t *msg);
|
|
#ifdef TCPCONNECT
|
|
void tobase64(unsigned char *out, int outlen, unsigned char *in, int inlen);
|
|
#endif
|
|
|
|
|
|
static struct
|
|
{ //tracks the previously recorded demos, so we don't have to content with dates and filesystem ordering and stuff.
|
|
#define DEMOLOG_LENGTH 16
|
|
unsigned int sequence; //incremented
|
|
struct
|
|
{
|
|
char filename[MAX_QPATH];
|
|
} log[DEMOLOG_LENGTH];
|
|
} demolog;
|
|
|
|
demo_t demo;
|
|
static float demo_prevtime;
|
|
//static dbuffer_t *demobuffer;
|
|
//static int header = (char *)&((header_t*)0)->data - (char *)NULL;
|
|
static sizebuf_t demomsg;
|
|
int demomsgtype;
|
|
int demomsgto;
|
|
static char demomsgbuf[MAX_OVERALLMSGLEN];
|
|
|
|
static void SV_MVD_Stopped(void);
|
|
|
|
static mvddest_t *singledest; //used when a stream is starting up so redundant data doesn't get dumped into other streams
|
|
static struct reversedest_s
|
|
{
|
|
struct reversedest_s *next;
|
|
qtvpendingstate_t info;
|
|
vfsfile_t *stream;
|
|
char inbuffer[2048];
|
|
int inbuffersize;
|
|
double timeout;
|
|
} *reversedest; //used when a reverse stream is starting up
|
|
|
|
static mvddest_t *SV_MVD_InitStream(vfsfile_t *stream, const char *info);
|
|
qboolean SV_MVD_Record (mvddest_t *dest);
|
|
char *SV_MVDName2Txt(char *name);
|
|
extern cvar_t qtv_password;
|
|
|
|
//does not unlink.
|
|
static void DestClose(mvddest_t *d, enum mvdclosereason_e reason)
|
|
{
|
|
if (d->desttype == DEST_THREADEDFILE)
|
|
{
|
|
while(d->flushing == true)
|
|
COM_WorkerPartialSync(d, &d->flushing, true);
|
|
}
|
|
|
|
if (d->cache)
|
|
BZ_Free(d->cache);
|
|
if (d->file)
|
|
{
|
|
VFS_CLOSE(d->file);
|
|
if (d->desttype != DEST_STREAM)
|
|
FS_FlushFSHashWritten(d->filename);
|
|
}
|
|
|
|
if (d->desttype != DEST_STREAM)
|
|
{
|
|
if (reason == MVD_CLOSE_CANCEL)
|
|
{
|
|
FS_Remove(d->filename, FS_GAMEONLY);
|
|
|
|
FS_Remove(SV_MVDName2Txt(d->filename), FS_GAMEONLY);
|
|
|
|
//SV_BroadcastPrintf (PRINT_CHAT, "Server recording canceled, demo removed\n");
|
|
}
|
|
else
|
|
{
|
|
char buf[512];
|
|
Q_strncpyz(demolog.log[demolog.sequence%DEMOLOG_LENGTH].filename, d->simplename, sizeof(demolog.log[demolog.sequence%DEMOLOG_LENGTH].filename));
|
|
demolog.sequence++;
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server recording complete\n^[/download %s^]\n", COM_QuotedString(va("demos/%s",d->simplename), buf, sizeof(buf), false));
|
|
}
|
|
}
|
|
|
|
Z_Free(d);
|
|
}
|
|
|
|
static void MVD_FlushDest_Flushed(void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
mvddest_t *d = ctx;
|
|
d->flushing = false;
|
|
}
|
|
static void MVD_FlushDest_Worker(void *ctx, void *data, size_t datasize, size_t b)
|
|
{
|
|
mvddest_t *d = ctx;
|
|
int len = VFS_WRITE(d->file, data, datasize);
|
|
VFS_FLUSH(d->file);
|
|
|
|
if (len != datasize)
|
|
d->error = true;
|
|
|
|
d->altcache = data;
|
|
COM_AddWork(WG_MAIN, MVD_FlushDest_Flushed, d, NULL, 0, 0);
|
|
}
|
|
|
|
void DestFlush(qboolean compleate)
|
|
{
|
|
int len;
|
|
mvddest_t *d, *t;
|
|
|
|
if (compleate)
|
|
{
|
|
//make sure everything is flushed.
|
|
MVDWrite_Begin(255, -1, 0);
|
|
}
|
|
|
|
if (!demo.dest)
|
|
return;
|
|
while (demo.dest->error)
|
|
{
|
|
d = demo.dest;
|
|
demo.dest = d->nextdest;
|
|
|
|
DestClose(d, MVD_CLOSE_FSERROR);
|
|
|
|
if (!demo.dest)
|
|
{
|
|
SV_MVDStop(MVD_CLOSE_DISCONNECTED, false);
|
|
return;
|
|
}
|
|
}
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
switch(d->desttype)
|
|
{
|
|
case DEST_FILE:
|
|
VFS_FLUSH (d->file);
|
|
break;
|
|
case DEST_BUFFEREDFILE:
|
|
if (d->cacheused+demo_size_padding > d->maxcachesize || compleate)
|
|
{
|
|
len = VFS_WRITE(d->file, d->cache, d->cacheused);
|
|
if (len < d->cacheused)
|
|
d->error = true;
|
|
VFS_FLUSH(d->file);
|
|
|
|
d->cacheused = 0;
|
|
}
|
|
break;
|
|
case DEST_THREADEDFILE:
|
|
if (d->cacheused+demo_size_padding > d->maxcachesize || compleate)
|
|
{
|
|
void *data = d->cache;
|
|
while(d->flushing == true)
|
|
COM_WorkerPartialSync(d, &d->flushing, true);
|
|
d->cache = d->altcache;
|
|
d->altcache = NULL;
|
|
d->flushing = true;
|
|
COM_AddWork(WG_LOADER, MVD_FlushDest_Worker, d, data, d->cacheused, 0);
|
|
d->cacheused = 0;
|
|
}
|
|
break;
|
|
|
|
case DEST_STREAM:
|
|
if (d->cacheused && !d->error)
|
|
{
|
|
len = VFS_WRITE(d->file, d->cache, d->cacheused);
|
|
if (len < 0) //client died
|
|
d->error = true;
|
|
else if (len > 0) //we put some data through
|
|
{ //move up the buffer
|
|
d->cacheused -= len;
|
|
memmove(d->cache, d->cache+len, d->cacheused);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DEST_NONE:
|
|
Sys_Error("DestFlush encoundered bad dest.");
|
|
}
|
|
|
|
if (sv_demoMaxSize.value && d->totalsize > sv_demoMaxSize.value*1024)
|
|
d->error = 2; //abort, but don't kill it.
|
|
|
|
while (d->nextdest && d->nextdest->error)
|
|
{
|
|
t = d->nextdest;
|
|
d->nextdest = t->nextdest;
|
|
|
|
DestClose(t, MVD_CLOSE_FSERROR);
|
|
}
|
|
}
|
|
}
|
|
|
|
enum qtvstatus_e
|
|
{
|
|
QTV_ERROR = -1, //corrupt/bad request that should be dropped.
|
|
QTV_RETRY = 0, //still handshaking.
|
|
QTV_ACCEPT = 1 //stream is now owned by the qtv code
|
|
};
|
|
int SV_MVD_GotQTVRequest(vfsfile_t *clientstream, char *headerstart, char *headerend, qtvpendingstate_t *p)
|
|
{
|
|
char *e;
|
|
|
|
qboolean server = false;
|
|
char *start, *lineend;
|
|
int versiontouse = 0;
|
|
int raw = 0;
|
|
char password[256] = "";
|
|
char userinfo[1024];
|
|
enum {
|
|
//MUST BE ORDERED HIGHEST-PRIORITY-LAST
|
|
QTVAM_NONE,
|
|
QTVAM_PLAIN,
|
|
#ifdef TCPCONNECT
|
|
// QTVAM_CCITT, //16bit = ddos it
|
|
QTVAM_MD4, //fucked
|
|
// QTVAM_MD5, //fucked, no hash implemented
|
|
QTVAM_SHA1, //fucked too nowadays
|
|
// QTVAM_SHA2_256, //no hash implemented
|
|
// QTVAM_SHA2_512, //no hash implemented
|
|
#endif
|
|
} authmethod = QTVAM_NONE;
|
|
|
|
start = headerstart;
|
|
|
|
lineend = strchr(start, '\n');
|
|
if (!lineend)
|
|
return QTV_ERROR;
|
|
|
|
*lineend = '\0';
|
|
COM_ParseToken(start, NULL);
|
|
start = lineend+1;
|
|
if (strcmp(com_token, "QTV"))
|
|
{ //it's an error if it's not qtv.
|
|
if (!strcmp(com_token, "QTVSV"))
|
|
server = true;
|
|
else
|
|
return QTV_ERROR;
|
|
}
|
|
|
|
if (server != p->isreverse)
|
|
{ //just a small check
|
|
return QTV_ERROR;
|
|
}
|
|
|
|
*userinfo = 0;
|
|
for(;;)
|
|
{
|
|
lineend = strchr(start, '\n');
|
|
if (!lineend)
|
|
break;
|
|
*lineend = '\0';
|
|
start = COM_ParseToken(start, NULL);
|
|
if (start && *start == ':')
|
|
{
|
|
//VERSION: a list of the different qtv protocols supported. Multiple versions can be specified. The first is assumed to be the prefered version.
|
|
//RAW: if non-zero, send only a raw mvd with no additional markup anywhere (for telnet use). Doesn't work with challenge-based auth, so will only be accepted when proxy passwords are not required.
|
|
//AUTH: specifies an auth method, the exact specs varies based on the method
|
|
// PLAIN: the password is sent as a PASSWORD line
|
|
// MD4: the server responds with an "AUTH: MD4\n" line as well as a "CHALLENGE: somerandomchallengestring\n" line, the client sends a new 'initial' request with CHALLENGE: MD4\nRESPONSE: hexbasedmd4checksumhere\n"
|
|
// MD5: same as md4
|
|
// CCITT: same as md4, but using the CRC stuff common to all quake engines.
|
|
// if the supported/allowed auth methods don't match, the connection is silently dropped.
|
|
//SOURCE: which stream to play from, DEFAULT is special. Without qualifiers, it's assumed to be a tcp address.
|
|
//COMPRESSION: Suggests a compression method (multiple are allowed). You'll get a COMPRESSION response, and compression will begin with the binary data.
|
|
|
|
start = start+1;
|
|
while(*start == ' ' || *start == '\t')
|
|
start++;
|
|
Con_DPrintf("qtv, got (%s) (%s)\n", com_token, start);
|
|
if (!strcmp(com_token, "VERSION"))
|
|
{
|
|
start = COM_ParseToken(start, NULL);
|
|
if (atoi(com_token) == 1)
|
|
versiontouse = 1;
|
|
}
|
|
else if (!strcmp(com_token, "RAW"))
|
|
{
|
|
start = COM_ParseToken(start, NULL);
|
|
raw = atoi(com_token);
|
|
}
|
|
else if (!strcmp(com_token, "PASSWORD"))
|
|
{
|
|
start = COM_ParseToken(start, NULL);
|
|
Q_strncpyz(password, com_token, sizeof(password));
|
|
}
|
|
else if (!strcmp(com_token, "AUTH"))
|
|
{
|
|
int thisauth;
|
|
start = COM_ParseToken(start, NULL);
|
|
if (!strcmp(com_token, "NONE"))
|
|
thisauth = QTVAM_NONE;
|
|
else if (!strcmp(com_token, "PLAIN"))
|
|
thisauth = QTVAM_PLAIN;
|
|
#ifdef TCPCONNECT
|
|
// else if (!strcmp(com_token, "CCIT"))
|
|
// thisauth = QTVAM_CCITT;
|
|
else if (!strcmp(com_token, "MD4"))
|
|
thisauth = QTVAM_MD4;
|
|
// else if (!strcmp(com_token, "MD5"))
|
|
// thisauth = QTVAM_MD5;
|
|
else if (!strcmp(com_token, "SHA1"))
|
|
thisauth = QTVAM_SHA1;
|
|
#endif
|
|
else
|
|
{
|
|
thisauth = QTVAM_NONE;
|
|
Con_DPrintf("qtv: received unrecognised auth method (%s)\n", com_token);
|
|
}
|
|
|
|
if (authmethod < thisauth)
|
|
authmethod = thisauth;
|
|
}
|
|
else if (!strcmp(com_token, "SOURCE"))
|
|
{
|
|
//servers don't support source, and ignore it.
|
|
//source is only useful for qtv proxy servers.
|
|
}
|
|
else if (!strcmp(com_token, "COMPRESSION"))
|
|
{
|
|
//compression not supported yet
|
|
}
|
|
else if (!strcmp(com_token, "QTV_EZQUAKE_EXT"))
|
|
{
|
|
//if we were treating this as a regular client over tcp (qizmo...)
|
|
}
|
|
else if (!strcmp(com_token, "USERINFO"))
|
|
{
|
|
//if we were treating this as a regular client over tcp (qizmo...)
|
|
start = COM_ParseTokenOut(start, NULL, userinfo, sizeof(userinfo), &com_tokentype);
|
|
}
|
|
else
|
|
{
|
|
//not recognised.
|
|
}
|
|
}
|
|
start = lineend+1;
|
|
}
|
|
|
|
/*len = (headerend - headerstart)+2;
|
|
p->insize -= len;
|
|
memmove(p->inbuffer, p->inbuffer + len, p->insize);
|
|
p->inbuffer[p->insize] = 0;
|
|
*/
|
|
|
|
e = NULL;
|
|
if (p->hasauthed)
|
|
{
|
|
}
|
|
else if (p->isreverse)
|
|
p->hasauthed = true; //reverse connections do not need to auth.
|
|
else if (!*qtv_password.string)
|
|
p->hasauthed = true; //no password, no need to auth.
|
|
else if (*password)
|
|
{
|
|
if (!*p->challenge && authmethod>QTVAM_PLAIN)
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: Challenge wasn't given...\n\n");
|
|
else switch (authmethod)
|
|
{
|
|
case QTVAM_NONE:
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: You need to provide a password.\n\n");
|
|
break;
|
|
case QTVAM_PLAIN:
|
|
p->hasauthed = !strcmp(qtv_password.string, password);
|
|
break;
|
|
#ifdef TCPCONNECT
|
|
/*case QTVAM_CCITT:
|
|
{
|
|
unsigned short ushort_result;
|
|
QCRC_Init(&ushort_result);
|
|
QCRC_AddBlock(&ushort_result, p->challenge, strlen(p->challenge));
|
|
QCRC_AddBlock(&ushort_result, qtv_password.string, strlen(qtv_password.string));
|
|
p->hasauthed = (ushort_result == strtoul(password, NULL, 0));
|
|
}
|
|
break;*/
|
|
case QTVAM_MD4:
|
|
{
|
|
char hash[512];
|
|
int md4sum[4];
|
|
|
|
Q_snprintfz(hash, sizeof(hash), "%s%s", p->challenge, qtv_password.string);
|
|
Com_BlockFullChecksum (hash, strlen(hash), (unsigned char*)md4sum);
|
|
Q_snprintfz(hash, sizeof(hash), "%X%X%X%X", md4sum[0], md4sum[1], md4sum[2], md4sum[3]);
|
|
p->hasauthed = !strcmp(password, hash);
|
|
}
|
|
break;
|
|
case QTVAM_SHA1:
|
|
{
|
|
char hash[512];
|
|
int digest[5];
|
|
|
|
Q_snprintfz(hash, sizeof(hash), "%s%s", p->challenge, qtv_password.string);
|
|
CalcHash(&hash_sha1, (char*)digest, sizeof(digest), hash, strlen(hash));
|
|
Q_snprintfz(hash, sizeof(hash), "%08X%08X%08X%08X%08X", digest[0], digest[1], digest[2], digest[3], digest[4]);
|
|
p->hasauthed = !strcmp(password, hash);
|
|
}
|
|
break;
|
|
// case QTVAM_MD5:
|
|
#endif
|
|
default:
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: server bug detected.\n\n");
|
|
break;
|
|
}
|
|
if (!p->hasauthed && !e)
|
|
{
|
|
if (raw)
|
|
e = "";
|
|
else
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: Bad password.\n\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//no password, and not automagically authed
|
|
switch (authmethod)
|
|
{
|
|
case QTVAM_NONE:
|
|
if (raw)
|
|
e = "";
|
|
else
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: You need to provide a common auth method.\n\n");
|
|
break;
|
|
case QTVAM_PLAIN:
|
|
p->hasauthed = !strcmp(qtv_password.string, password);
|
|
break;
|
|
#ifdef TCPCONNECT
|
|
/*case QTVAM_CCITT:
|
|
e = ("QTVSV 1\n"
|
|
"AUTH: CCITT\n"
|
|
"CHALLENGE: ");
|
|
goto hashedpassword;*/
|
|
case QTVAM_MD4:
|
|
e = ("QTVSV 1\n"
|
|
"AUTH: MD4\n"
|
|
"CHALLENGE: ");
|
|
goto hashedpassword;
|
|
/*case QTVAM_MD5:
|
|
e = ("QTVSV 1\n"
|
|
"AUTH: MD5\n"
|
|
"CHALLENGE: ");
|
|
goto hashedpassword;*/
|
|
case QTVAM_SHA1:
|
|
e = ("QTVSV 1\n"
|
|
"AUTH: SHA1\n"
|
|
"CHALLENGE: ");
|
|
goto hashedpassword;
|
|
hashedpassword:
|
|
{
|
|
char tmp[32];
|
|
Sys_RandomBytes(tmp, sizeof(tmp));
|
|
tobase64(p->challenge, sizeof(p->challenge), tmp, sizeof(tmp));
|
|
}
|
|
|
|
VFS_WRITE(clientstream, e, strlen(e));
|
|
VFS_WRITE(clientstream, p->challenge, strlen(p->challenge));
|
|
e = "\n\n";
|
|
VFS_WRITE(clientstream, e, strlen(e));
|
|
return QTV_RETRY;
|
|
#endif
|
|
default:
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: server bug detected.\n\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (*qtv_maxstreams.string && !p->isreverse)
|
|
{
|
|
int count = 0;
|
|
mvddest_t *dest;
|
|
for (dest = demo.dest; dest; dest = dest->nextdest)
|
|
{
|
|
if (dest->desttype == DEST_STREAM)
|
|
count++;
|
|
}
|
|
|
|
if (count >= qtv_maxstreams.value) //sorry
|
|
{
|
|
if (!qtv_maxstreams.value)
|
|
e = "QTVSV 1\nTERROR: QTV streaming from this server is blocked by qtv_maxstreams.\n\n";
|
|
else
|
|
e = "QTVSV 1\nTERROR: This server enforces a limit on the number of proxies connected at any one time. Please try again later.\n\n";
|
|
}
|
|
}
|
|
|
|
if (e)
|
|
{
|
|
}
|
|
else if (!versiontouse)
|
|
{
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: Incompatible version (valid version is v1)\n\n");
|
|
}
|
|
else if (raw)
|
|
{
|
|
if (p->hasauthed == true)
|
|
{
|
|
if (!SV_MVD_Record(SV_MVD_InitStream(clientstream, userinfo)))
|
|
return QTV_ERROR;
|
|
return QTV_ACCEPT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (p->hasauthed == true)
|
|
{
|
|
mvddest_t *dst;
|
|
e = ("QTVSV 1\n"
|
|
"BEGIN\n"
|
|
"\n");
|
|
VFS_WRITE(clientstream, e, strlen(e));
|
|
e = NULL;
|
|
dst = SV_MVD_InitStream(clientstream, userinfo);
|
|
dst->droponmapchange = p->isreverse;
|
|
if (!SV_MVD_Record(dst))
|
|
return QTV_ERROR;
|
|
return QTV_ACCEPT;
|
|
}
|
|
else
|
|
{
|
|
e = ("QTVSV 1\n"
|
|
"PERROR: You need to provide a password.\n\n");
|
|
}
|
|
}
|
|
|
|
if (e && !raw) //don't write any error messages to raw requests. that would confuse stuff.
|
|
VFS_WRITE(clientstream, e, strlen(e));
|
|
return QTV_ERROR;
|
|
}
|
|
|
|
static int DestCloseAllFlush(enum mvdclosereason_e reason, qboolean mvdonly)
|
|
{
|
|
int numclosed = 0;
|
|
mvddest_t *d, **prev, *next;
|
|
DestFlush(true); //make sure it's all written.
|
|
|
|
prev = &demo.dest;
|
|
d = demo.dest;
|
|
while(d)
|
|
{
|
|
next = d->nextdest;
|
|
if (!mvdonly || d->droponmapchange)
|
|
{
|
|
*prev = d->nextdest;
|
|
DestClose(d, reason);
|
|
numclosed++;
|
|
}
|
|
else
|
|
prev = &d->nextdest;
|
|
|
|
d = next;
|
|
}
|
|
|
|
return numclosed;
|
|
}
|
|
|
|
|
|
static int DemoWriteDest(void *data, int len, mvddest_t *d)
|
|
{
|
|
if (d->error)
|
|
return 0;
|
|
d->totalsize += len;
|
|
switch(d->desttype)
|
|
{
|
|
case DEST_FILE:
|
|
VFS_WRITE(d->file, data, len);
|
|
break;
|
|
case DEST_BUFFEREDFILE: //these write to a cache, which is flushed later
|
|
case DEST_THREADEDFILE:
|
|
case DEST_STREAM:
|
|
if (d->cacheused+len > d->maxcachesize)
|
|
{
|
|
d->error = true;
|
|
return 0;
|
|
}
|
|
memcpy(d->cache+d->cacheused, data, len);
|
|
d->cacheused += len;
|
|
break;
|
|
default:
|
|
case DEST_NONE:
|
|
Sys_Error("DemoWriteDest encoundered bad dest.");
|
|
}
|
|
return len;
|
|
}
|
|
|
|
static int DemoWrite(void *data, int len) //broadcast to all proxies/mvds
|
|
{
|
|
mvddest_t *d;
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (singledest && singledest != d)
|
|
continue;
|
|
DemoWriteDest(data, len, d);
|
|
}
|
|
return len;
|
|
}
|
|
|
|
void DemoWriteQTVTimePad(int msecs) //broadcast to all proxies
|
|
{
|
|
mvddest_t *d;
|
|
unsigned char buffer[6];
|
|
while (msecs > 0)
|
|
{
|
|
//duration
|
|
if (msecs > 255)
|
|
buffer[0] = 255;
|
|
else
|
|
buffer[0] = msecs;
|
|
msecs -= buffer[0];
|
|
//message type
|
|
buffer[1] = dem_read;
|
|
//length
|
|
buffer[2] = 0;
|
|
buffer[3] = 0;
|
|
buffer[4] = 0;
|
|
buffer[5] = 0;
|
|
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype == DEST_STREAM)
|
|
{
|
|
DemoWriteDest(buffer, sizeof(buffer), d);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// returns the file size
|
|
// return -1 if file is not present
|
|
// the file should be in BINARY mode for stupid OSs that care
|
|
#define MAX_MVD_NAME 64
|
|
|
|
typedef struct
|
|
{
|
|
char name[MAX_MVD_NAME];
|
|
qofs_t size;
|
|
time_t mtime;
|
|
searchpathfuncs_t *path;
|
|
} file_t;
|
|
|
|
typedef struct
|
|
{
|
|
file_t *files;
|
|
qofs_t size;
|
|
int numfiles;
|
|
int numdirs;
|
|
|
|
int maxfiles;
|
|
} dir_t;
|
|
|
|
#define SORT_NO 0
|
|
#define SORT_BY_DATE 1
|
|
|
|
static int QDECL Sys_listdirFound(const char *fname, qofs_t fsize, time_t mtime, void *uptr, searchpathfuncs_t *spath)
|
|
{
|
|
file_t *f;
|
|
dir_t *dir = uptr;
|
|
fname = COM_SkipPath(fname);
|
|
if (!*fname)
|
|
{
|
|
dir->numdirs++;
|
|
return true;
|
|
}
|
|
if (dir->numfiles == dir->maxfiles)
|
|
{
|
|
int nc = dir->numfiles + 256;
|
|
file_t *n = realloc(dir->files, nc*sizeof(*dir->files));
|
|
if (!n)
|
|
return false;
|
|
dir->files = n;
|
|
dir->maxfiles = nc;
|
|
}
|
|
f = &dir->files[dir->numfiles++];
|
|
Q_strncpyz(f->name, fname, sizeof(f->name));
|
|
f->size = fsize;
|
|
f->mtime = mtime;
|
|
f->path = spath;
|
|
dir->size += fsize;
|
|
|
|
return true;
|
|
}
|
|
|
|
static int QDECL Sys_listdir_Sort(const void *va, const void *vb)
|
|
{
|
|
const file_t *fa = va;
|
|
const file_t *fb = vb;
|
|
|
|
if (fa->mtime == fb->mtime)
|
|
return 0;
|
|
if (fa->mtime >= fb->mtime)
|
|
return 1;
|
|
return -1;
|
|
}
|
|
|
|
static dir_t *Sys_listdemos (char *path, int ispublic, qboolean usesorting)
|
|
{
|
|
const char *exts[] = {
|
|
".mvd", ".mvd.gz",
|
|
".qwz", ".qwz.gz",
|
|
#ifdef NQPROT
|
|
".dem", ".dem.gz",
|
|
#endif
|
|
#if defined(Q2SERVER) || defined(Q2CLIENT)
|
|
".dm2", ".dm2.gz"
|
|
#endif
|
|
};
|
|
char searchterm[MAX_QPATH];
|
|
size_t i;
|
|
|
|
dir_t *dir = malloc(sizeof(*dir));
|
|
memset(dir, 0, sizeof(*dir));
|
|
dir->files = NULL;
|
|
dir->maxfiles = 0;
|
|
|
|
for (i = 0; i < (ispublic?2:countof(exts)); i++)
|
|
{
|
|
Q_strncpyz(searchterm, va("%s/*%s", path, exts[i]), sizeof(searchterm));
|
|
COM_EnumerateFiles(searchterm, Sys_listdirFound, dir);
|
|
}
|
|
|
|
if (usesorting)
|
|
qsort(dir->files, dir->numfiles, sizeof(*dir->files), Sys_listdir_Sort);
|
|
|
|
return dir;
|
|
}
|
|
static void Sys_freedir(dir_t *dir)
|
|
{
|
|
if (dir)
|
|
free(dir->files);
|
|
free(dir);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// only one .. is allowed (so we can get to the same dir as the quake exe)
|
|
static void QDECL SV_DemoDir_Callback(struct cvar_s *var, char *oldvalue)
|
|
{
|
|
char *value;
|
|
|
|
value = var->string;
|
|
if (!value[0] || value[0] == '/' || (value[0] == '\\' && value[1] == '\\'))
|
|
{
|
|
Cvar_ForceSet(var, var->enginevalue);
|
|
return;
|
|
}
|
|
if (value[0] == '.' && value[1] == '.')
|
|
value += 2;
|
|
if (strstr(value,".."))
|
|
{
|
|
Cvar_ForceSet(var, var->enginevalue);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void SV_MVDPings (void)
|
|
{
|
|
sizebuf_t *msg;
|
|
client_t *client;
|
|
int j;
|
|
|
|
for (j = 0, client = svs.clients; j < demo.recorder.max_net_clients && j < svs.allocated_client_slots; j++, client++)
|
|
{
|
|
if (client->state != cs_spawned)
|
|
continue;
|
|
|
|
msg = MVDWrite_Begin (dem_all, 0, 7);
|
|
MSG_WriteByte(msg, svc_updateping);
|
|
MSG_WriteByte(msg, j);
|
|
MSG_WriteShort(msg, SV_CalcPing(client, false));
|
|
MSG_WriteByte(msg, svc_updatepl);
|
|
MSG_WriteByte (msg, j);
|
|
MSG_WriteByte (msg, client->lossage);
|
|
}
|
|
}
|
|
void SV_MVD_FullClientUpdate(sizebuf_t *msg, client_t *player)
|
|
{
|
|
char info[EXTENDED_INFO_STRING];
|
|
qboolean dosizes;
|
|
|
|
if (!sv.mvdrecording)
|
|
return;
|
|
|
|
dosizes = !msg;
|
|
|
|
if (dosizes)
|
|
msg = MVDWrite_Begin (dem_all, 0, 4);
|
|
MSG_WriteByte (msg, svc_updatefrags);
|
|
MSG_WriteByte (msg, player - svs.clients);
|
|
MSG_WriteShort (msg, player->old_frags);
|
|
|
|
if (dosizes)
|
|
msg = MVDWrite_Begin (dem_all, 0, 4);
|
|
MSG_WriteByte (msg, svc_updateping);
|
|
MSG_WriteByte (msg, player - svs.clients);
|
|
MSG_WriteShort (msg, SV_CalcPing(player, false)&0xffff);
|
|
|
|
if (dosizes)
|
|
msg = MVDWrite_Begin (dem_all, 0, 3);
|
|
MSG_WriteByte (msg, svc_updatepl);
|
|
MSG_WriteByte (msg, player - svs.clients);
|
|
MSG_WriteByte (msg, player->lossage);
|
|
|
|
if (dosizes)
|
|
msg = MVDWrite_Begin (dem_all, 0, 6);
|
|
MSG_WriteByte (msg, svc_updateentertime);
|
|
MSG_WriteByte (msg, player - svs.clients);
|
|
MSG_WriteFloat (msg, realtime - player->connection_started);
|
|
|
|
InfoBuf_ToString(&player->userinfo, info, sizeof(info), basicuserinfos, privateuserinfos, NULL, &demo.recorder.infosync, player);
|
|
|
|
if (dosizes)
|
|
msg = MVDWrite_Begin (dem_all, 0, 7 + strlen(info));
|
|
MSG_WriteByte (msg, svc_updateuserinfo);
|
|
MSG_WriteByte (msg, player - svs.clients);
|
|
MSG_WriteLong (msg, player->userid);
|
|
MSG_WriteString (msg, info);
|
|
}
|
|
|
|
sizebuf_t *MVDWrite_Begin(qbyte type, int to, int size)
|
|
{
|
|
if (demomsg.cursize && (demomsgtype != type || demomsgto != to || demomsg.cursize+size > sizeof(demomsgbuf)))
|
|
{
|
|
SV_WriteMVDMessage(&demomsg, demomsgtype, demomsgto, demo_prevtime);
|
|
demomsg.cursize = 0;
|
|
}
|
|
|
|
demomsgtype = type;
|
|
demomsgto = to;
|
|
|
|
demomsg.maxsize = demomsg.cursize+size;
|
|
demomsg.data = demomsgbuf;
|
|
demomsg.prim = demo.recorder.netchan.netprim;
|
|
return &demomsg;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_WriteMVDMessage
|
|
|
|
Dumps the current net message, along with framing
|
|
====================
|
|
*/
|
|
void SV_WriteMVDMessage (sizebuf_t *msg, int type, int to, float time)
|
|
{
|
|
int len, i, msec;
|
|
qbyte c;
|
|
|
|
if (!sv.mvdrecording)
|
|
return;
|
|
|
|
if (msg->overflowed)
|
|
{
|
|
msg->overflowed = false;
|
|
Con_Printf("SV_WriteMVDMessage: message overflowed\n");
|
|
return;
|
|
}
|
|
|
|
msec = (time - demo_prevtime)*1000;
|
|
if (abs(msec) > 1000)
|
|
{
|
|
//catastoptic slip. debugging? reset any sync
|
|
msec = 1;
|
|
demo_prevtime = time;
|
|
}
|
|
else if (msec > 0)
|
|
{ //if there was any progress, make sure we write msecs >0
|
|
if (msec > 255)
|
|
msec = 255;
|
|
if (msec < 1)
|
|
msec = 1;
|
|
demo_prevtime += msec*0.001;
|
|
}
|
|
else
|
|
msec = 0;
|
|
|
|
c = msec;
|
|
DemoWrite(&c, sizeof(c));
|
|
|
|
if (demo.lasttype != type || demo.lastto != to)
|
|
{
|
|
demo.lasttype = type;
|
|
demo.lastto = to;
|
|
switch (demo.lasttype)
|
|
{
|
|
case dem_all:
|
|
c = dem_all;
|
|
DemoWrite (&c, sizeof(c));
|
|
break;
|
|
case dem_multiple:
|
|
c = dem_multiple;
|
|
DemoWrite (&c, sizeof(c));
|
|
|
|
i = LittleLong(demo.lastto);
|
|
DemoWrite (&i, sizeof(i));
|
|
break;
|
|
case dem_single:
|
|
case dem_stats:
|
|
c = demo.lasttype + (demo.lastto << 3);
|
|
DemoWrite (&c, sizeof(c));
|
|
break;
|
|
default:
|
|
SV_MVDStop_f ();
|
|
Con_Printf("bad demo message type:%d", type);
|
|
return;
|
|
}
|
|
} else {
|
|
c = dem_read;
|
|
DemoWrite (&c, sizeof(c));
|
|
}
|
|
|
|
|
|
len = LittleLong (msg->cursize);
|
|
DemoWrite (&len, 4);
|
|
DemoWrite (msg->data, msg->cursize);
|
|
|
|
DestFlush(false);
|
|
}
|
|
|
|
//if you use ClientReliable to write to demo.recorder's message buffer (for code reuse) call this function to ensure its flushed.
|
|
void SV_MVD_WriteReliables(qboolean writebroadcasts)
|
|
{
|
|
int i;
|
|
|
|
if (writebroadcasts)
|
|
{
|
|
//chuck in the broadcast reliables
|
|
if (sv.reliable_datagram.cursize)
|
|
{
|
|
ClientReliableCheckBlock(&demo.recorder, sv.reliable_datagram.cursize);
|
|
ClientReliableWrite_SZ(&demo.recorder, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
|
|
}
|
|
//and the broadcast unreliables. everything is reliables when it comes to mvds
|
|
if (sv.datagram.cursize)
|
|
{
|
|
ClientReliableCheckBlock(&demo.recorder, sv.datagram.cursize);
|
|
ClientReliableWrite_SZ(&demo.recorder, sv.datagram.data, sv.datagram.cursize);
|
|
}
|
|
}
|
|
|
|
if (demo.recorder.netchan.message.cursize)
|
|
{
|
|
SV_WriteMVDMessage(&demo.recorder.netchan.message, dem_all, 0, demo_prevtime);
|
|
demo.recorder.netchan.message.cursize = 0;
|
|
}
|
|
for (i = 0; i < demo.recorder.num_backbuf; i++)
|
|
{
|
|
demo.recorder.backbuf.data = demo.recorder.backbuf_data[i];
|
|
demo.recorder.backbuf.cursize = demo.recorder.backbuf_size[i];
|
|
if (demo.recorder.backbuf.cursize)
|
|
SV_WriteMVDMessage(&demo.recorder.backbuf, dem_all, 0, demo_prevtime);
|
|
demo.recorder.backbuf_size[i] = 0;
|
|
}
|
|
demo.recorder.num_backbuf = 0;
|
|
demo.recorder.backbuf.cursize = 0;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_MVDWritePackets
|
|
|
|
Interpolates to get exact players position for current frame
|
|
and writes packets to the disk/memory
|
|
====================
|
|
*/
|
|
|
|
float adjustangle(float current, float ideal, float fraction)
|
|
{
|
|
float move;
|
|
|
|
move = ideal - current;
|
|
if (ideal > current)
|
|
{
|
|
|
|
if (move >= 180)
|
|
move = move - 360;
|
|
}
|
|
else
|
|
{
|
|
if (move <= -180)
|
|
move = move + 360;
|
|
}
|
|
|
|
move *= fraction;
|
|
|
|
return (current + move);
|
|
}
|
|
|
|
qboolean SV_MVDWritePackets (int num)
|
|
{
|
|
demo_frame_t *frame, *nextframe;
|
|
demo_client_t *cl, *nextcl = NULL;
|
|
int i, j, flags;
|
|
qboolean valid;
|
|
double time, playertime, nexttime;
|
|
float f;
|
|
vec3_t origin, angles;
|
|
sizebuf_t msg;
|
|
qbyte msg_buf[MAX_QWMSGLEN];
|
|
demoinfo_t *demoinfo;
|
|
|
|
if (!sv.mvdrecording)
|
|
return false;
|
|
if (demo.recorder.fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
return false;
|
|
|
|
//flush any intermediate data
|
|
MVDWrite_Begin(255, -1, 0);
|
|
|
|
msg.allowoverflow = true; //fixme
|
|
msg.overflowed = false;
|
|
msg.prim = svs.netprim;
|
|
msg.data = msg_buf;
|
|
msg.maxsize = sizeof(msg_buf);
|
|
|
|
if (num > demo.parsecount - demo.lastwritten + 1)
|
|
num = demo.parsecount - demo.lastwritten + 1;
|
|
|
|
// 'num' frames to write
|
|
for ( ; num; num--, demo.lastwritten++)
|
|
{
|
|
frame = &demo.frames[demo.lastwritten&DEMO_FRAMES_MASK];
|
|
time = frame->time;
|
|
nextframe = frame;
|
|
msg.cursize = 0;
|
|
|
|
// find two frames
|
|
// one before the exact time (time - msec) and one after,
|
|
// then we can interpolte exact position for current frame
|
|
for (i = 0, cl = frame->clients, demoinfo = demo.info; i < demo.recorder.max_net_clients ; i++, cl++, demoinfo++)
|
|
{
|
|
if (cl->parsecount != demo.lastwritten)
|
|
continue; // not valid
|
|
|
|
nexttime = playertime = time - cl->sec;
|
|
|
|
for (j = demo.lastwritten+1, valid = false; nexttime < time && j < demo.parsecount; j++)
|
|
{
|
|
nextframe = &demo.frames[j&DEMO_FRAMES_MASK];
|
|
nextcl = &nextframe->clients[i];
|
|
|
|
if (nextcl->parsecount != j)
|
|
break; // disconnected?
|
|
if (nextcl->fixangle)
|
|
break; // respawned, or walked into teleport, do not interpolate!
|
|
if (!(nextcl->flags & DF_DEAD) && (cl->flags & DF_DEAD))
|
|
break; // respawned, do not interpolate
|
|
|
|
nexttime = nextframe->time - nextcl->sec;
|
|
|
|
if (nexttime >= time)
|
|
{
|
|
// good, found what we were looking for
|
|
valid = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (valid)
|
|
{
|
|
f = (time - nexttime)/(nexttime - playertime);
|
|
for (j=0;j<3;j++) {
|
|
angles[j] = adjustangle(cl->info.angles[j], nextcl->info.angles[j],1.0+f);
|
|
origin[j] = nextcl->info.origin[j] + f*(nextcl->info.origin[j]-cl->info.origin[j]);
|
|
}
|
|
} else {
|
|
VectorCopy(cl->info.origin, origin);
|
|
VectorCopy(cl->info.angles, angles);
|
|
}
|
|
|
|
// now write it to buf
|
|
flags = cl->flags; //df_dead/df_gib
|
|
|
|
if (demo.playerreset[i])
|
|
{
|
|
demo.playerreset[i] = false;
|
|
flags |= DF_RESET;
|
|
}
|
|
|
|
if (cl->fixangle)
|
|
{
|
|
demo.fixangletime[i] = cl->cmdtime;
|
|
}
|
|
|
|
for (j=0; j < 3; j++)
|
|
if (origin[j] != demoinfo->origin[i])
|
|
flags |= DF_ORIGINX << j;
|
|
|
|
if (cl->fixangle || demo.fixangletime[i] != cl->cmdtime)
|
|
{
|
|
for (j=0; j < 3; j++)
|
|
if (angles[j] != demoinfo->angles[j])
|
|
flags |= DF_ANGLEX << j;
|
|
}
|
|
|
|
if (cl->info.model != demoinfo->model)
|
|
flags |= DF_MODEL;
|
|
if (cl->info.effects != demoinfo->effects)
|
|
flags |= DF_EFFECTS;
|
|
if (cl->info.skinnum != demoinfo->skinnum)
|
|
flags |= DF_SKINNUM;
|
|
if (cl->info.weaponframe != demoinfo->weaponframe)
|
|
flags |= DF_WEAPONFRAME;
|
|
|
|
MSG_WriteByte (&msg, svc_playerinfo);
|
|
MSG_WriteByte (&msg, i);
|
|
MSG_WriteShort (&msg, flags);
|
|
|
|
MSG_WriteByte (&msg, cl->frame);
|
|
|
|
for (j=0 ; j<3 ; j++)
|
|
if (flags & (DF_ORIGINX << j))
|
|
MSG_WriteCoord (&msg, origin[j]);
|
|
|
|
for (j=0 ; j<3 ; j++)
|
|
if (flags & (DF_ANGLEX << j))
|
|
MSG_WriteAngle16 (&msg, angles[j]);
|
|
|
|
|
|
if (flags & DF_MODEL)
|
|
MSG_WriteByte (&msg, cl->info.model);
|
|
|
|
if (flags & DF_SKINNUM)
|
|
MSG_WriteByte (&msg, cl->info.skinnum);
|
|
|
|
if (flags & DF_EFFECTS)
|
|
MSG_WriteByte (&msg, cl->info.effects & 0xff);
|
|
|
|
if (flags & DF_WEAPONFRAME)
|
|
MSG_WriteByte (&msg, cl->info.weaponframe);
|
|
|
|
VectorCopy(cl->info.origin, demoinfo->origin);
|
|
VectorCopy(cl->info.angles, demoinfo->angles);
|
|
demoinfo->skinnum = cl->info.skinnum;
|
|
demoinfo->effects = cl->info.effects;
|
|
demoinfo->weaponframe = cl->info.weaponframe;
|
|
demoinfo->model = cl->info.model;
|
|
}
|
|
|
|
if (msg.cursize)
|
|
SV_WriteMVDMessage(&msg, dem_all, 0, (float)time);
|
|
|
|
/* The above functions can set this variable to false, but that's a really bad thing. Let's try to fix it. */
|
|
if (!sv.mvdrecording)
|
|
return false;
|
|
}
|
|
|
|
if (demo.lastwritten > demo.parsecount)
|
|
demo.lastwritten = demo.parsecount;
|
|
|
|
return true;
|
|
}
|
|
|
|
void MVD_Init (void)
|
|
{
|
|
#define MVDVARGROUP "Server MVD cvars"
|
|
|
|
Cvar_Register (&sv_demofps, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoPings, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoUseCache, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoCacheSize, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoMaxSize, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoMaxDirSize, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoMaxDirCount, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoMaxDirAge, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoClearOld, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoDir, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoDirAlt, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoPrefix, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoSuffix, MVDVARGROUP);
|
|
Cvar_Register (&sv_demotxt, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoExtraNames, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoExtensions, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoAutoCompress,MVDVARGROUP);
|
|
Cvar_Register (&sv_demoAutoRecord, MVDVARGROUP);
|
|
Cvar_Register (&sv_demoAutoPrefix, MVDVARGROUP);
|
|
Cvar_Register (&sv_demo_write_csqc,MVDVARGROUP);
|
|
}
|
|
|
|
static char *SV_PrintTeams(void)
|
|
{
|
|
char *teams[MAX_CLIENTS];
|
|
// char *p;
|
|
int i, j, numcl = 0, numt = 0;
|
|
client_t *clients[MAX_CLIENTS];
|
|
char buf[2048] = {0};
|
|
extern cvar_t teamplay;
|
|
// extern char chartbl2[];
|
|
|
|
// count teams and players
|
|
for (i=0; i < sv.allocated_client_slots; i++)
|
|
{
|
|
if (svs.clients[i].state != cs_spawned)
|
|
continue;
|
|
if (svs.clients[i].spectator)
|
|
continue;
|
|
|
|
clients[numcl++] = &svs.clients[i];
|
|
for (j = 0; j < numt; j++)
|
|
if (!strcmp(InfoBuf_ValueForKey(&svs.clients[i].userinfo, "team"), teams[j]))
|
|
break;
|
|
if (j != numt)
|
|
continue;
|
|
|
|
teams[numt++] = InfoBuf_ValueForKey(&svs.clients[i].userinfo, "team");
|
|
}
|
|
|
|
// create output
|
|
|
|
if (numcl == 2) // duel
|
|
{
|
|
snprintf(buf, sizeof(buf), "team1 %s\nteam2 %s\n", clients[0]->name, clients[1]->name);
|
|
}
|
|
else if (!teamplay.value) // ffa
|
|
{
|
|
snprintf(buf, sizeof(buf), "players:\n");
|
|
for (i = 0; i < numcl; i++)
|
|
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s\n", clients[i]->name);
|
|
}
|
|
else
|
|
{ // teamplay
|
|
for (j = 0; j < numt; j++)
|
|
{
|
|
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "team %s:\n", teams[j]);
|
|
for (i = 0; i < numcl; i++)
|
|
if (!strcmp(InfoBuf_ValueForKey(&clients[i]->userinfo, "team"), teams[j]))
|
|
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s\n", clients[i]->name);
|
|
}
|
|
}
|
|
|
|
if (!numcl)
|
|
return "\n";
|
|
// for (p = buf; *p; p++) *p = chartbl2[(qbyte)*p];
|
|
return va("%s",buf);
|
|
}
|
|
|
|
|
|
mvddest_t *SV_FindRecordFile(char *match, mvddest_t ***link_out)
|
|
{
|
|
mvddest_t **link, *f;
|
|
for (link = &demo.dest; *link; link = &(*link)->nextdest)
|
|
{
|
|
f = *link;
|
|
if (f->desttype == DEST_FILE || f->desttype == DEST_BUFFEREDFILE || f->desttype == DEST_THREADEDFILE)
|
|
{
|
|
if (!match || !strcmp(match, f->simplename))
|
|
{
|
|
if (link_out)
|
|
*link_out = link;
|
|
return f;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_InitRecord
|
|
====================
|
|
*/
|
|
|
|
mvddest_t *SV_MVD_InitRecordFile (char *name)
|
|
{
|
|
char *s, *txtname;
|
|
mvddest_t *dst;
|
|
vfsfile_t *file;
|
|
|
|
if (strlen(name) >= countof(dst->filename))
|
|
{
|
|
Con_Printf ("ERROR: couldn't open \"%s\". Too long.\n", name);
|
|
return NULL;
|
|
}
|
|
|
|
file = FS_OpenVFS (name, "wb", FS_GAMEONLY);
|
|
if (!file)
|
|
{
|
|
Con_Printf ("ERROR: couldn't open \"%s\"\n", name);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef AVAIL_GZDEC
|
|
if (!Q_strcasecmp(".gz", COM_GetFileExtension(name, NULL)))
|
|
file = FS_GZ_WriteFilter(file, true, true);
|
|
#endif
|
|
|
|
dst = Z_Malloc(sizeof(mvddest_t));
|
|
strcpy(dst->filename, name);
|
|
|
|
#ifdef LOADERTHREAD
|
|
if (!*sv_demoUseCache.string)
|
|
dst->desttype = DEST_THREADEDFILE;
|
|
else
|
|
#endif
|
|
if (sv_demoUseCache.value <= 0)
|
|
dst->desttype = DEST_FILE;
|
|
else
|
|
dst->desttype = DEST_BUFFEREDFILE;
|
|
|
|
if (dst->desttype == DEST_FILE)
|
|
{
|
|
dst->desttype = DEST_FILE;
|
|
dst->file = file;
|
|
dst->maxcachesize = 0;
|
|
}
|
|
else
|
|
{ //cached or threaded
|
|
dst->file = file;
|
|
if (sv_demoCacheSize.ival < 0x8000)
|
|
dst->maxcachesize = 0x8000;
|
|
else
|
|
dst->maxcachesize = sv_demoCacheSize.ival;
|
|
dst->cache = BZ_Malloc(dst->maxcachesize);
|
|
if (dst->desttype == DEST_THREADEDFILE)
|
|
dst->altcache = BZ_Malloc(dst->maxcachesize);
|
|
else
|
|
dst->altcache = NULL;
|
|
}
|
|
dst->droponmapchange = true;
|
|
|
|
s = name + strlen(name);
|
|
while (*s != '/') s--;
|
|
Q_strncpyz(dst->simplename, s+1, sizeof(dst->simplename));
|
|
|
|
switch(dst->desttype)
|
|
{
|
|
default:
|
|
case DEST_NONE:
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n", "ERROR", name);
|
|
break;
|
|
case DEST_STREAM:
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n", "ERROR: STREAM", name);
|
|
break;
|
|
case DEST_BUFFEREDFILE:
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n", "memory", name);
|
|
break;
|
|
case DEST_THREADEDFILE:
|
|
//SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n", "worker thread", name);
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording:\n%s\n", name);
|
|
break;
|
|
case DEST_FILE:
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server starts recording (%s):\n%s\n", "disk", name);
|
|
break;
|
|
}
|
|
|
|
txtname = SV_MVDName2Txt(name);
|
|
if (sv_demotxt.value)
|
|
{
|
|
vfsfile_t *f;
|
|
|
|
if (sv_demotxt.value == 2)
|
|
{
|
|
//this is a special mode for mods that want to write it instead (done via the sv_demoinfoadd command).
|
|
f = FS_OpenVFS (txtname, "wt", FS_GAMEONLY);
|
|
if (f)
|
|
VFS_CLOSE(f);
|
|
}
|
|
else
|
|
{
|
|
f = FS_OpenVFS (txtname, "wt", FS_GAMEONLY);
|
|
if (f != NULL)
|
|
{
|
|
char buf[2000];
|
|
date_t date;
|
|
|
|
COM_TimeOfDay(&date);
|
|
|
|
snprintf(buf, sizeof(buf), "date %s\nmap %s\nteamplay %d\ndeathmatch %d\ntimelimit %d\n%s",date.str, svs.name, (int)teamplay.value, (int)deathmatch.value, (int)timelimit.value, SV_PrintTeams());
|
|
VFS_WRITE(f, buf, strlen(buf));
|
|
VFS_FLUSH(f);
|
|
VFS_CLOSE(f);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FS_Remove(txtname, FS_GAMEONLY);
|
|
FS_FlushFSHashRemoved(txtname);
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
char *SV_Demo_CurrentOutput(void)
|
|
{
|
|
mvddest_t *d;
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype == DEST_FILE || d->desttype == DEST_BUFFEREDFILE || d->desttype == DEST_THREADEDFILE)
|
|
return d->simplename;
|
|
}
|
|
return "";
|
|
}
|
|
void SV_Demo_PrintOutputs(void)
|
|
{
|
|
mvddest_t *d;
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype == DEST_FILE || d->desttype == DEST_BUFFEREDFILE || d->desttype == DEST_THREADEDFILE)
|
|
Con_Printf("recording : %s\n", d->simplename);
|
|
else if (d->desttype == DEST_STREAM)
|
|
Con_Printf("streaming : %s\n", d->simplename);
|
|
}
|
|
}
|
|
|
|
static mvddest_t *SV_MVD_InitStream(vfsfile_t *stream, const char *info)
|
|
{
|
|
mvddest_t *dst;
|
|
|
|
for (dst = demo.dest; dst; dst = dst->nextdest)
|
|
{
|
|
if (dst->desttype == DEST_STREAM)
|
|
break;
|
|
}
|
|
if (!dst)
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Smile, you're on QTV!\n");
|
|
|
|
dst = Z_Malloc(sizeof(mvddest_t));
|
|
|
|
dst->desttype = DEST_STREAM;
|
|
dst->file = stream;
|
|
dst->maxcachesize = 0x8000; //is this too small?
|
|
dst->cache = BZ_Malloc(dst->maxcachesize);
|
|
dst->droponmapchange = false;
|
|
*dst->filename = 0;
|
|
*dst->simplename = 0;
|
|
|
|
if (info)
|
|
{
|
|
char *s = Info_ValueForKey(info, "name");
|
|
Q_strncpyz(dst->simplename, s, sizeof(dst->simplename));
|
|
|
|
s = Info_ValueForKey(info, "streamid");
|
|
Q_strncpyz(dst->filename, s, sizeof(dst->filename));
|
|
s = Info_ValueForKey(info, "address");
|
|
if (*dst->filename && *s)
|
|
Q_strncatz(dst->filename, "@", sizeof(dst->filename));
|
|
Q_strncatz(dst->filename, s, sizeof(dst->filename));
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_Stop
|
|
|
|
stop recording a demo
|
|
====================
|
|
*/
|
|
void SV_MVDStop (enum mvdclosereason_e reason, qboolean mvdonly)
|
|
{
|
|
sizebuf_t *msg;
|
|
if (!sv.mvdrecording)
|
|
{
|
|
Con_Printf ("Not recording a demo.\n");
|
|
return;
|
|
}
|
|
|
|
if (reason == MVD_CLOSE_CANCEL || reason == MVD_CLOSE_DISCONNECTED)
|
|
{
|
|
DestCloseAllFlush(reason, mvdonly);
|
|
// stop and remove
|
|
|
|
if (!demo.dest)
|
|
SV_MVD_Stopped();
|
|
|
|
if (reason == MVD_CLOSE_DISCONNECTED)
|
|
SV_BroadcastPrintf (PRINT_CHAT, "QTV disconnected\n");
|
|
else
|
|
SV_BroadcastPrintf (PRINT_CHAT, "Server recording canceled, demo removed\n");
|
|
|
|
Cvar_ForceSet(Cvar_Get("serverdemo", "", CVAR_NOSET, ""), "");
|
|
|
|
return;
|
|
}
|
|
|
|
// write a disconnect message to the demo file
|
|
msg = MVDWrite_Begin(dem_all, 0, 2+strlen("EndOfDemo"));
|
|
MSG_WriteByte (msg, svc_disconnect);
|
|
MSG_WriteString (msg, "EndOfDemo");
|
|
|
|
SV_MVDWritePackets(demo.parsecount - demo.lastwritten + 1);
|
|
// finish up
|
|
|
|
DestCloseAllFlush(reason, mvdonly);
|
|
|
|
if (!demo.dest) //might still be streaming qtv.
|
|
SV_MVD_Stopped();
|
|
|
|
Cvar_ForceSet(Cvar_Get("serverdemo", "", CVAR_NOSET, ""), "");
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_Stop_f
|
|
====================
|
|
*/
|
|
void SV_MVDStop_f (void)
|
|
{
|
|
SV_MVDStop(MVD_CLOSE_STOPPED, true);
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_Cancel_f
|
|
|
|
Stops recording, and removes the demo
|
|
====================
|
|
*/
|
|
void SV_MVD_Cancel_f (void)
|
|
{
|
|
SV_MVDStop(MVD_CLOSE_CANCEL, true);
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_WriteMVDMessage
|
|
|
|
Dumps the current net message, prefixed by the length and view angles
|
|
====================
|
|
*/
|
|
|
|
void SV_WriteRecordMVDMessage (sizebuf_t *msg)
|
|
{
|
|
int len;
|
|
qbyte c;
|
|
|
|
if (!sv.mvdrecording)
|
|
return;
|
|
|
|
if (!msg->cursize)
|
|
return;
|
|
|
|
c = 0;
|
|
DemoWrite (&c, sizeof(c));
|
|
|
|
c = dem_read;
|
|
DemoWrite (&c, sizeof(c));
|
|
|
|
len = LittleLong (msg->cursize);
|
|
DemoWrite (&len, 4);
|
|
|
|
DemoWrite (msg->data, msg->cursize);
|
|
|
|
DestFlush(false);
|
|
}
|
|
|
|
void SV_WriteSetMVDMessage (void)
|
|
{
|
|
int len;
|
|
qbyte c;
|
|
|
|
//Con_Printf("write: %ld bytes, %4.4f\n", msg->cursize, realtime);
|
|
|
|
if (!sv.mvdrecording)
|
|
return;
|
|
|
|
c = 0;
|
|
DemoWrite (&c, sizeof(c));
|
|
|
|
c = dem_set;
|
|
DemoWrite (&c, sizeof(c));
|
|
|
|
|
|
len = LittleLong(0);
|
|
DemoWrite (&len, 4);
|
|
len = LittleLong(0);
|
|
DemoWrite (&len, 4);
|
|
|
|
DestFlush(false);
|
|
}
|
|
|
|
void SV_MVD_SendInitialGamestate(mvddest_t *dest);
|
|
qboolean SV_MVD_Record (mvddest_t *dest)
|
|
{
|
|
static int destid;
|
|
if (!dest)
|
|
return false;
|
|
|
|
dest->id = ++destid; //give each stream a unique id, for no real reason other than for other people to track it via SVC_Status(|32).
|
|
|
|
SV_MVD_WriteReliables(false);
|
|
DestFlush(true);
|
|
|
|
if (!sv.mvdrecording)
|
|
{
|
|
memset(&demo, 0, sizeof(demo));
|
|
demo.recorder.protocol = SCP_QUAKEWORLD;
|
|
demo.recorder.netchan.netprim = sv.datagram.prim;
|
|
|
|
demo.datagram.maxsize = sizeof(demo.datagram_data);
|
|
demo.datagram.data = demo.datagram_data;
|
|
demo.datagram.prim = demo.recorder.netchan.netprim;
|
|
|
|
if (sv_demoExtensions.ival == 2 || !*sv_demoExtensions.string)
|
|
{ /*more limited subset supported by ezquake, but not fuhquake/fodquake. sorry.*/
|
|
demo.recorder.fteprotocolextensions = /*PEXT_CHUNKEDDOWNLOADS|*/PEXT_256PACKETENTITIES|/*PEXT_FLOATCOORDS|*/PEXT_MODELDBL|PEXT_ENTITYDBL|PEXT_ENTITYDBL2|PEXT_SPAWNSTATIC2;
|
|
// demo.recorder.fteprotocolextensions |= PEXT_HLBSP; /*ezquake DOES have this, but it is pointless and should have been in some feature mask rather than protocol extensions*/
|
|
// demo.recorder.fteprotocolextensions |= PEXT_ACCURATETIMINGS; /*ezquake does not support this any more*/
|
|
// demo.recorder.fteprotocolextensions |= PEXT_TRANS; /*ezquake has no support for .alpha*/
|
|
demo.recorder.fteprotocolextensions2 = PEXT2_VOICECHAT;
|
|
demo.recorder.zquake_extensions = Z_EXT_PM_TYPE | Z_EXT_PM_TYPE_NEW | Z_EXT_VIEWHEIGHT | Z_EXT_SERVERTIME | Z_EXT_PITCHLIMITS | Z_EXT_JOIN_OBSERVE | Z_EXT_VWEP;
|
|
}
|
|
else if (sv_demoExtensions.ival)
|
|
{ /*everything*/
|
|
extern cvar_t pext_replacementdeltas;
|
|
demo.recorder.fteprotocolextensions = PEXT_CSQC | PEXT_COLOURMOD | PEXT_DPFLAGS | PEXT_CUSTOMTEMPEFFECTS | PEXT_ENTITYDBL | PEXT_ENTITYDBL2 | PEXT_FATNESS | PEXT_HEXEN2 | PEXT_HULLSIZE | PEXT_LIGHTSTYLECOL | PEXT_MODELDBL | PEXT_SCALE | PEXT_SETATTACHMENT | PEXT_SETVIEW | PEXT_SOUNDDBL | PEXT_SPAWNSTATIC2 | PEXT_TRANS;
|
|
#ifdef PEXT_VIEW2
|
|
demo.recorder.fteprotocolextensions |= PEXT_VIEW2;
|
|
#endif
|
|
demo.recorder.fteprotocolextensions2 = PEXT2_VOICECHAT | PEXT2_SETANGLEDELTA | /*PEXT2_PRYDONCURSOR |*/ (pext_replacementdeltas.ival?PEXT2_REPLACEMENTDELTAS:0);
|
|
/*enable these, because we might as well (stat ones are always useful)*/
|
|
demo.recorder.zquake_extensions = Z_EXT_PM_TYPE | Z_EXT_PM_TYPE_NEW | Z_EXT_VIEWHEIGHT | Z_EXT_SERVERTIME | Z_EXT_PITCHLIMITS | Z_EXT_JOIN_OBSERVE | Z_EXT_VWEP;
|
|
|
|
// if (demo.recorder.fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS) //replacementdeltas makes a number of earlier extensions obsolete...
|
|
// demo.recorder.fteprotocolextensions &= ~(PEXT_COLOURMOD|PEXT_DPFLAGS|PEXT_ENTITYDBL|PEXT_ENTITYDBL2|PEXT_FATNESS|PEXT_HEXEN2|PEXT_HULLSIZE|PEXT_MODELDBL|PEXT_SCALE|PEXT_SETATTACHMENT|PEXT_SOUNDDBL|PEXT_SPAWNSTATIC2|PEXT_TRANS);
|
|
}
|
|
else
|
|
{
|
|
demo.recorder.fteprotocolextensions = 0;
|
|
demo.recorder.fteprotocolextensions2 = 0;
|
|
demo.recorder.zquake_extensions = Z_EXT_PM_TYPE | Z_EXT_PM_TYPE_NEW | Z_EXT_VIEWHEIGHT | Z_EXT_SERVERTIME | Z_EXT_PITCHLIMITS | Z_EXT_JOIN_OBSERVE | Z_EXT_VWEP;
|
|
}
|
|
|
|
//pointless extensions that are redundant with mvds
|
|
demo.recorder.fteprotocolextensions &= ~PEXT_ACCURATETIMINGS | PEXT_CHUNKEDDOWNLOADS;
|
|
demo.recorder.fteprotocolextensions &= ~PEXT1_HIDEPROTOCOLS;
|
|
}
|
|
// else
|
|
// SV_WriteRecordMVDMessage(&buf, dem_read);
|
|
|
|
dest->nextdest = demo.dest;
|
|
demo.dest = dest;
|
|
|
|
Cvar_ForceSet(Cvar_Get("serverdemo", "", CVAR_NOSET, ""), SV_Demo_CurrentOutput());
|
|
|
|
SV_ClientProtocolExtensionsChanged(&demo.recorder);
|
|
|
|
SV_MVD_SendInitialGamestate(dest);
|
|
return true;
|
|
}
|
|
|
|
static void SV_MVD_Stopped(void)
|
|
{ //all recording has stopped. clean up any demo.recorder state
|
|
if (demo.recorder.frameunion.frames)
|
|
{
|
|
Z_Free(demo.recorder.frameunion.frames);
|
|
demo.recorder.frameunion.frames = NULL;
|
|
}
|
|
sv.mvdrecording = false;
|
|
memset(&demo, 0, sizeof(demo));
|
|
}
|
|
|
|
void SV_EnableClientsCSQC(void);
|
|
void SV_MVD_SendInitialGamestate(mvddest_t *dest)
|
|
{
|
|
sizebuf_t buf;
|
|
char buf_data[MAX_QWMSGLEN];
|
|
int i, j;
|
|
// int n;
|
|
// const char *s;
|
|
|
|
client_t *player;
|
|
char *gamedir;
|
|
|
|
if (!demo.dest)
|
|
return;
|
|
|
|
SV_MVD_WriteReliables(false);
|
|
|
|
sv.mvdrecording = true;
|
|
demo.resetdeltas = true;
|
|
|
|
host_client = &demo.recorder;
|
|
if (demo.recorder.fteprotocolextensions & PEXT_CSQC)
|
|
SV_EnableClientsCSQC();
|
|
|
|
|
|
demo.pingtime = demo.time = sv.time;
|
|
|
|
|
|
singledest = dest;
|
|
|
|
/*-------------------------------------------------*/
|
|
|
|
// serverdata
|
|
// send the info about the new client to all connected clients
|
|
memset(&buf, 0, sizeof(buf));
|
|
buf.data = buf_data;
|
|
buf.maxsize = sizeof(buf_data);
|
|
buf.prim = svs.netprim;
|
|
|
|
// send the serverdata
|
|
|
|
gamedir = InfoBuf_ValueForKey (&svs.info, "*gamedir");
|
|
if (!gamedir[0])
|
|
gamedir = FS_GetGamedir(true);
|
|
|
|
//generate some meta info so the file can be identified later
|
|
{
|
|
char timestr[64];
|
|
time_t t;
|
|
MSG_WriteByte (&buf, svc_stufftext);
|
|
MSG_WriteString(&buf, va("//protocolname %s\n", com_protocolname.string)); //so that the game is known when playing back, to deal with games that conventionally have entirely separate installations.
|
|
|
|
MSG_WriteByte (&buf, svc_stufftext);
|
|
t = time(NULL);
|
|
strftime(timestr, sizeof(timestr), "%Y-%m-%dT%H:%M:%SZ", gmtime(&t));
|
|
MSG_WriteString(&buf, va("//recorddate %s\n", timestr)); //in order to avoid needing to depend upon file times that get destroyed in many different ways.
|
|
}
|
|
|
|
MSG_WriteByte (&buf, svc_serverdata);
|
|
|
|
//fix up extensions to match sv_bigcoords correctly. sorry for old clients not working.
|
|
if (buf.prim.coordtype == COORDTYPE_FLOAT_32)
|
|
demo.recorder.fteprotocolextensions |= PEXT_FLOATCOORDS;
|
|
else
|
|
demo.recorder.fteprotocolextensions &= ~PEXT_FLOATCOORDS;
|
|
|
|
if (demo.recorder.fteprotocolextensions)
|
|
{
|
|
MSG_WriteLong(&buf, PROTOCOL_VERSION_FTE1);
|
|
MSG_WriteLong(&buf, demo.recorder.fteprotocolextensions);
|
|
}
|
|
if (demo.recorder.fteprotocolextensions2)
|
|
{
|
|
MSG_WriteLong(&buf, PROTOCOL_VERSION_FTE2);
|
|
MSG_WriteLong(&buf, demo.recorder.fteprotocolextensions2);
|
|
}
|
|
MSG_WriteLong (&buf, PROTOCOL_VERSION_QW);
|
|
MSG_WriteLong (&buf, svs.spawncount);
|
|
MSG_WriteString (&buf, gamedir);
|
|
|
|
if (demo.recorder.fteprotocolextensions2 & PEXT2_MAXPLAYERS)
|
|
MSG_WriteByte(&buf, demo.recorder.max_net_ents);
|
|
|
|
MSG_WriteFloat (&buf, sv.time);
|
|
|
|
// send full levelname
|
|
MSG_WriteString (&buf, sv.mapname);
|
|
|
|
// send the movevars
|
|
MSG_WriteFloat(&buf, movevars.gravity);
|
|
MSG_WriteFloat(&buf, movevars.stopspeed);
|
|
MSG_WriteFloat(&buf, movevars.maxspeed);
|
|
MSG_WriteFloat(&buf, movevars.spectatormaxspeed);
|
|
MSG_WriteFloat(&buf, movevars.accelerate);
|
|
MSG_WriteFloat(&buf, movevars.airaccelerate);
|
|
MSG_WriteFloat(&buf, movevars.wateraccelerate);
|
|
MSG_WriteFloat(&buf, movevars.friction);
|
|
MSG_WriteFloat(&buf, movevars.waterfriction);
|
|
MSG_WriteFloat(&buf, movevars.entgravity);
|
|
|
|
SV_WriteRecordMVDMessage (&buf);
|
|
SZ_Clear (&buf);
|
|
|
|
demo.recorder.prespawn_stage = PRESPAWN_SERVERINFO;
|
|
demo.recorder.prespawn_idx = 0;
|
|
demo.recorder.netchan.message = buf;
|
|
while (demo.recorder.prespawn_stage != PRESPAWN_COMPLETED)
|
|
{
|
|
if (demo.recorder.prespawn_stage == PRESPAWN_MAPCHECK)
|
|
{
|
|
demo.recorder.prespawn_stage++;//client won't reply, so don't wait.
|
|
demo.recorder.prespawn_idx = 0;
|
|
}
|
|
demo.recorder.prespawn_allow_soundlist = true; //normally set for the server to wait for ack. we don't want to wait.
|
|
demo.recorder.prespawn_allow_modellist = true; //normally set for the server to wait for ack. we don't want to wait.
|
|
|
|
SV_SendClientPrespawnInfo(&demo.recorder);
|
|
SV_MVD_WriteReliables(false);
|
|
}
|
|
memset(&demo.recorder.netchan.message, 0, sizeof(demo.recorder.netchan.message));
|
|
|
|
// send current status of all other players
|
|
|
|
for (i = 0; i < demo.recorder.max_net_clients && i < svs.allocated_client_slots; i++)
|
|
{
|
|
player = &svs.clients[i];
|
|
|
|
SV_MVD_FullClientUpdate(&buf, player);
|
|
|
|
if (buf.cursize > MAX_QWMSGLEN/2)
|
|
{
|
|
//flush backbuffer
|
|
SV_WriteRecordMVDMessage (&buf);
|
|
SZ_Clear (&buf);
|
|
}
|
|
}
|
|
|
|
// send all current light styles
|
|
for (i=0 ; i<sv.maxlightstyles || i < MAX_STANDARDLIGHTSTYLES; i++)
|
|
SV_SendLightstyle(&demo.recorder, &buf, i, true);
|
|
|
|
//invalidate stats+players somehow
|
|
for (i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
for (j = 0; j < MAX_CL_STATS; j++)
|
|
{
|
|
demo.statsi[i][j] = 0x7fffffff;
|
|
demo.statsf[i][j] = -0x7fffffff;
|
|
}
|
|
demo.playerreset[i] = true;
|
|
}
|
|
|
|
// get the client to check and download skins
|
|
// when that is completed, a begin command will be issued
|
|
MSG_WriteByte (&buf, svc_stufftext);
|
|
MSG_WriteString (&buf, "skins\n");
|
|
|
|
SV_WriteRecordMVDMessage (&buf);
|
|
SV_MVD_WriteReliables(false);
|
|
SV_WriteSetMVDMessage();
|
|
|
|
singledest = NULL;
|
|
}
|
|
|
|
//double-underscores will get merged together.
|
|
const char *SV_GenCleanTable(void)
|
|
{
|
|
static char tab[256];
|
|
static int tabbuilt = -1;
|
|
int mode = com_parseutf8.ival>0;
|
|
int i;
|
|
|
|
if (tabbuilt == mode)
|
|
return tab;
|
|
|
|
//identity
|
|
for(i = 0; i < 32; i++)
|
|
tab[i] = '_'; //unprintables.
|
|
for( ; i < 128; i++)
|
|
tab[i] = i;
|
|
|
|
//cheesy way around NUL.mvd etc filenames.
|
|
for(i = 'A'; i <= 'Z'; i++)
|
|
tab[i] = i + ('a'-'A');
|
|
|
|
//these chars are reserved by windows, so its generally best to not use them, even on loonix
|
|
tab['<'] = '[';
|
|
tab['>'] = ']';
|
|
tab['|'] = '_';
|
|
tab[':'] = '_';
|
|
tab['*'] = '_';
|
|
tab['?'] = '_';
|
|
tab['\\']= '_';
|
|
tab['/'] = '_';
|
|
tab['\"']= '_';
|
|
//some extra ones to make unix scripts nicer.
|
|
tab['&'] = '_';
|
|
tab['~'] = '_';
|
|
tab['`'] = '_';
|
|
tab[','] = '_';
|
|
tab[' '] = '_'; //don't use spaces, it means files need quotes, and then stuff bugs out.
|
|
tab['.'] = '_'; //many windows programs can't properly deal with multiple dots
|
|
|
|
if (mode)
|
|
{
|
|
//high chars are regular utf-8. yay
|
|
for(i = 128; i < 256; i++)
|
|
tab[i] = i;
|
|
}
|
|
else
|
|
{
|
|
//second row contains coloured numbers for the hud
|
|
tab[16] = '[';
|
|
tab[17] = ']';
|
|
for(i = 0; i < 10; i++)
|
|
tab[18+i] = '0'+i;
|
|
tab[28] = '_'; //'.'
|
|
tab[29] = //line breaks
|
|
tab[30] =
|
|
tab[31] = '_';
|
|
|
|
//high chars
|
|
|
|
//the first 16 chars of the high range are actually different.
|
|
tab[128] = '_'; //scrollbars
|
|
tab[129] = '_';
|
|
tab[130] = '_';
|
|
tab[130] = '_';
|
|
for(i = 132; i < 128+16; i++)
|
|
tab[18+i] = '_'; //LEDs mostly
|
|
|
|
//but the rest of the table is just recoloured.
|
|
for(i = 128+16; i < 256; i++)
|
|
tab[i] = tab[i&127];
|
|
}
|
|
return tab;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_CleanName
|
|
|
|
Cleans the demo name, removes restricted chars, makes name lowercase
|
|
====================
|
|
*/
|
|
|
|
char *SV_CleanName (unsigned char *name)
|
|
{
|
|
static char text[1024];
|
|
char *out = text;
|
|
const char *chartbl = SV_GenCleanTable();
|
|
|
|
*out = chartbl[*name++];
|
|
|
|
while (*name && out - text < sizeof(text))
|
|
if (*out == '_' && chartbl[*name] == '_')
|
|
name++;
|
|
else *++out = chartbl[*name++];
|
|
|
|
*++out = 0;
|
|
|
|
|
|
out = text;
|
|
while (*out == '.')
|
|
out++; //leading dots (which could be caused by all sorts of things) are bad. boo hidden files.
|
|
return out;
|
|
}
|
|
|
|
//figure out the actual size limit. this is somewhat approximate anyway.
|
|
qofs_t MVD_DemoMaxDirSize(void)
|
|
{
|
|
char *e;
|
|
double maxdirsize = strtod(sv_demoMaxDirSize.string, &e);
|
|
if (*e == ' ' || *e == '\t')
|
|
e++;
|
|
//that will be trailed by g[b], m[b], k[b], or b
|
|
if (*e == 'b' || *e == 'B')
|
|
return maxdirsize;
|
|
else if (*e == 'k' || *e == 'K')
|
|
return maxdirsize * 1024;
|
|
else if (*e == 'm' || *e == 'M')
|
|
return maxdirsize * 1024*1024;
|
|
else if (*e == 'g' || *e == 'G')
|
|
return maxdirsize * 1024*1024*1024;
|
|
else
|
|
return maxdirsize * 1024; //assume kb.
|
|
}
|
|
//returns if there's enough disk space to record another demo.
|
|
qboolean MVD_CheckSpace(qboolean broadcastwarnings)
|
|
{
|
|
dir_t *dir;
|
|
|
|
qofs_t maxdirsize = MVD_DemoMaxDirSize();
|
|
if (maxdirsize > 0 || sv_demoMaxDirCount.ival > 0 || sv_demoMaxDirAge.ival > 0)
|
|
{
|
|
dir = Sys_listdemos(sv_demoDir.string, false, SORT_BY_DATE);
|
|
if (sv_demoClearOld.ival && *sv_demoDir.string)
|
|
{
|
|
time_t removebeforetime = time(NULL) - sv_demoMaxDirAge.value*60*60*24;
|
|
while (dir->numfiles && (
|
|
(maxdirsize>0 && dir->size > maxdirsize) ||
|
|
(sv_demoMaxDirCount.ival>0 && dir->numfiles >= sv_demoMaxDirCount.ival) ||
|
|
(sv_demoMaxDirAge.ival && dir->files[dir->numfiles-1].mtime && dir->files[dir->numfiles-1].mtime - removebeforetime < 0)))
|
|
{
|
|
file_t *f = &dir->files[dir->numfiles-1]; //this is the file we want to kill.
|
|
if (!f->path || !f->path->RemoveFile)
|
|
{ //erm, can't remove it...
|
|
dir->size -= f->size;
|
|
dir->numfiles--;
|
|
continue;
|
|
}
|
|
if (f->path->RemoveFile(f->path, f->name))
|
|
{ //okay, looks like we managed to kill it.
|
|
Con_Printf(CON_WARNING"Removed demo \"%s\"\n", f->name);
|
|
dir->size -= f->size;
|
|
dir->numfiles--;
|
|
|
|
//Try to take the .txt too.
|
|
f->path->RemoveFile(f->path, SV_MVDName2Txt(f->name));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dir->numfiles && sv_demoMaxDirCount.ival>0 && dir->numfiles >= sv_demoMaxDirCount.ival)
|
|
{
|
|
if (broadcastwarnings)
|
|
SV_BroadcastPrintf(PRINT_MEDIUM, CON_WARNING"insufficient directory space, increase server's sv_demoMaxDirCount\n");
|
|
else
|
|
Con_Printf(CON_WARNING"insufficient demo space, increase sv_demoMaxDirCount\n");
|
|
Sys_freedir(dir);
|
|
return false;
|
|
}
|
|
if (dir->numfiles && maxdirsize>0 && dir->size > maxdirsize)
|
|
{
|
|
if (broadcastwarnings)
|
|
SV_BroadcastPrintf(PRINT_MEDIUM, CON_WARNING"insufficient directory space, increase server's sv_demoMaxDirSize\n");
|
|
else
|
|
Con_Printf(CON_WARNING"insufficient demo space, increase sv_demoMaxDirSize\n");
|
|
Sys_freedir(dir);
|
|
return false;
|
|
}
|
|
|
|
Sys_freedir(dir);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_Record_f
|
|
|
|
record <demoname>
|
|
====================
|
|
*/
|
|
void SV_MVD_Record_f (void)
|
|
{
|
|
int c;
|
|
char name[MAX_OSPATH+MAX_MVD_NAME];
|
|
char newname[MAX_MVD_NAME];
|
|
|
|
c = Cmd_Argc();
|
|
if (c != 2)
|
|
{
|
|
Con_Printf ("mvdrecord <demoname>\n");
|
|
return;
|
|
}
|
|
|
|
if (sv.state != ss_active){
|
|
Con_Printf ("Not active yet.\n");
|
|
return;
|
|
}
|
|
|
|
if (!MVD_CheckSpace(Cmd_FromGamecode()))
|
|
return;
|
|
|
|
Q_strncpyz(newname, va("%s%s", sv_demoPrefix.string, SV_CleanName(Cmd_Argv(1))),
|
|
sizeof(newname) - strlen(sv_demoSuffix.string) - 5);
|
|
Q_strncatz(newname, sv_demoSuffix.string, MAX_MVD_NAME);
|
|
|
|
snprintf (name, MAX_OSPATH+MAX_MVD_NAME, "%s/%s", sv_demoDir.string, newname);
|
|
|
|
|
|
COM_StripExtension(name, name, sizeof(name));
|
|
#ifdef AVAIL_GZDEC
|
|
if (sv_demoAutoCompress.ival == 1)
|
|
COM_DefaultExtension(name, ".mvd.gz", sizeof(name));
|
|
else
|
|
#endif
|
|
COM_DefaultExtension(name, ".mvd", sizeof(name));
|
|
FS_CreatePath (name, FS_GAMEONLY);
|
|
|
|
//
|
|
// open the demo file and start recording
|
|
//
|
|
SV_MVD_Record (SV_MVD_InitRecordFile(name));
|
|
}
|
|
|
|
//called when a connecting player becomes active.
|
|
void SV_MVD_AutoRecord (void)
|
|
{
|
|
//not enabled (for the server) anyway.
|
|
if (sv_demoAutoRecord.ival <= 0)
|
|
return;
|
|
|
|
//don't record multiple...
|
|
if (sv.mvdrecording)
|
|
return;
|
|
|
|
//only do it if we're underneath our quotas.
|
|
if (!MVD_CheckSpace(true))
|
|
return;
|
|
|
|
if (sv_demoAutoRecord.ival > 0)
|
|
{
|
|
int playercount = 0, i;
|
|
for (i = 0; i < svs.allocated_client_slots; i++)
|
|
{
|
|
if (svs.clients[i].state >= cs_spawned)
|
|
playercount++;
|
|
}
|
|
if (playercount >= sv_demoAutoRecord.ival)
|
|
{ //okay, we've reached our player count, its time to start recording now.
|
|
char name[MAX_OSPATH];
|
|
char timestamp[64];
|
|
time_t tm = time(NULL);
|
|
strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", localtime(&tm));
|
|
Q_snprintfz(name, sizeof(name), "%s/%s%s_%s", sv_demoDir.string, sv_demoAutoPrefix.string, svs.name, timestamp);
|
|
#ifdef AVAIL_GZDEC
|
|
if (sv_demoAutoCompress.ival == 1 || !*sv_demoAutoCompress.string) //default is to gzip.
|
|
Q_strncatz(name, ".mvd.gz", sizeof(name));
|
|
else
|
|
#endif
|
|
Q_strncatz(name, ".mvd", sizeof(name));
|
|
FS_CreatePath (name, FS_GAMEONLY);
|
|
|
|
SV_MVD_Record (SV_MVD_InitRecordFile(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SV_MVD_CheckReverse(void)
|
|
{
|
|
struct reversedest_s *rd, **link;
|
|
enum qtvstatus_e s;
|
|
int len;
|
|
for (link = &reversedest; *link; link = &rd->next)
|
|
{
|
|
rd = *link;
|
|
if (realtime > rd->timeout)
|
|
len = -1;
|
|
else
|
|
len = VFS_READ(rd->stream, rd->inbuffer+rd->inbuffersize, sizeof(rd->inbuffer)-1-rd->inbuffersize);
|
|
if (len < 0)
|
|
s = QTV_ERROR;
|
|
else if (!len)
|
|
continue; //keep waiting...
|
|
else
|
|
{
|
|
rd->inbuffersize += len;
|
|
rd->inbuffer[rd->inbuffersize] = 0;
|
|
if (rd->inbuffersize >= 3 && strncmp(rd->inbuffer, "QTV", 3))
|
|
s = QTV_ERROR; //not qtv server...
|
|
else
|
|
{
|
|
char *e = strstr(rd->inbuffer, "\n\n");
|
|
if (e)
|
|
s = SV_MVD_GotQTVRequest(rd->stream, rd->inbuffer, rd->inbuffer+rd->inbuffersize, &rd->info);
|
|
else
|
|
continue; //not nuff data yet
|
|
}
|
|
}
|
|
switch(s)
|
|
{
|
|
case QTV_RETRY: //need to parse new stuff.
|
|
continue;
|
|
case QTV_ACCEPT:
|
|
rd->stream = NULL;
|
|
//fallthrough
|
|
case QTV_ERROR:
|
|
if (rd->stream)
|
|
VFS_CLOSE(rd->stream);
|
|
*link = rd->next;
|
|
Z_Free(rd);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SV_MVD_QTVReverse_f (void)
|
|
{
|
|
#if 1//ndef HAVE_TCP
|
|
// Con_Printf ("%s is not supported in this build\n", Cmd_Argv(0));
|
|
|
|
const char *ip = Cmd_Argv(1);
|
|
vfsfile_t *f;
|
|
const char *msg = "QTV\n"
|
|
"VERSION: 1\n"
|
|
"REVERSE\n"
|
|
"\n";
|
|
struct reversedest_s *rd;
|
|
if (sv.state<ss_loading)
|
|
return;
|
|
|
|
f = FS_OpenTCP(ip, 27599, false);
|
|
if (!f)
|
|
return;
|
|
|
|
VFS_WRITE(f, msg, strlen(msg));
|
|
|
|
rd = Z_Malloc(sizeof(*rd));
|
|
rd->stream = f;
|
|
rd->info.isreverse = true;
|
|
rd->timeout = realtime + 10;
|
|
reversedest = rd;
|
|
#else
|
|
char *ip;
|
|
if (sv.state != ss_active)
|
|
{
|
|
Con_Printf ("Server is not running\n");
|
|
return;
|
|
}
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_Printf ("%s ip:port\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
ip = Cmd_Argv(1);
|
|
|
|
|
|
|
|
{
|
|
char *data;
|
|
int sock;
|
|
|
|
struct sockaddr_qstorage remote;
|
|
// int fromlen;
|
|
|
|
int adrfam;
|
|
int adrsz;
|
|
unsigned int nonblocking = true;
|
|
|
|
|
|
if (!NET_StringToSockaddr(ip, 0, &remote, &adrfam, &adrsz))
|
|
{
|
|
Con_Printf ("qtvreverse: failed to resolve address\n");
|
|
return;
|
|
}
|
|
|
|
if ((sock = socket (adrfam, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
|
|
{
|
|
Con_Printf ("qtvreverse: socket: %s\n", strerror(neterrno()));
|
|
return;
|
|
}
|
|
if (connect(sock, (void*)&remote, adrsz) == INVALID_SOCKET)
|
|
{
|
|
closesocket(sock);
|
|
Con_Printf ("qtvreverse: connect: %s\n", strerror(neterrno()));
|
|
return;
|
|
}
|
|
|
|
if (ioctlsocket (sock, FIONBIO, (u_long *)&nonblocking) == INVALID_SOCKET)
|
|
{
|
|
closesocket(sock);
|
|
Con_Printf ("qtvreverse: ioctl FIONBIO: %s\n", strerror(neterrno()));
|
|
return;
|
|
}
|
|
|
|
data = "QTV\n"
|
|
"REVERSE\n"
|
|
"\n";
|
|
if (send(sock, data, strlen(data), 0) == INVALID_SOCKET)
|
|
{
|
|
closesocket(sock);
|
|
Con_Printf ("qtvreverse: send: %s\n", strerror(neterrno()));
|
|
return;
|
|
}
|
|
|
|
|
|
SV_MVD_InitPendingStream(sock, ip)->isreverse = true;
|
|
}
|
|
|
|
//SV_MVD_Record (dest);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
====================
|
|
SV_EasyRecord_f
|
|
|
|
easyrecord [demoname]
|
|
====================
|
|
*/
|
|
|
|
int Dem_CountPlayers (void)
|
|
{
|
|
int i, count;
|
|
|
|
count = 0;
|
|
for (i = 0; i < sv.allocated_client_slots ; i++)
|
|
{
|
|
if (svs.clients[i].name[0] && !svs.clients[i].spectator)
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
char *Dem_Team(int num)
|
|
{
|
|
int i;
|
|
static char *lastteam[2];
|
|
qboolean first = true;
|
|
client_t *client;
|
|
static int index = 0;
|
|
|
|
index = 1 - index;
|
|
|
|
for (i = 0, client = svs.clients; num && i < sv.allocated_client_slots; i++, client++)
|
|
{
|
|
if (!client->name[0] || client->spectator)
|
|
continue;
|
|
|
|
if (first || strcmp(lastteam[index], InfoBuf_ValueForKey(&client->userinfo, "team")))
|
|
{
|
|
first = false;
|
|
num--;
|
|
lastteam[index] = InfoBuf_ValueForKey(&client->userinfo, "team");
|
|
}
|
|
}
|
|
|
|
if (num)
|
|
return "";
|
|
|
|
return lastteam[index];
|
|
}
|
|
|
|
char *Dem_PlayerName(int num)
|
|
{
|
|
int i;
|
|
client_t *client;
|
|
|
|
for (i = 0, client = svs.clients; i < sv.allocated_client_slots; i++, client++)
|
|
{
|
|
if (!client->name[0] || client->spectator)
|
|
continue;
|
|
|
|
if (!--num)
|
|
return client->name;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
// -> scream
|
|
char *Dem_PlayerNameTeam(char *t)
|
|
{
|
|
int i;
|
|
client_t *client;
|
|
static char n[1024];
|
|
int sep;
|
|
|
|
n[0] = 0;
|
|
|
|
sep = 0;
|
|
|
|
for (i = 0, client = svs.clients; i < sv.allocated_client_slots; i++, client++)
|
|
{
|
|
if (!client->name[0] || client->spectator)
|
|
continue;
|
|
|
|
if (strcmp(t, InfoBuf_ValueForKey(&client->userinfo, "team"))==0)
|
|
{
|
|
if (sep >= 1)
|
|
Q_strncatz (n, "_", sizeof(n));
|
|
// snprintf (n, sizeof(n), "%s_", n);
|
|
Q_strncatz (n, client->name, sizeof(n));
|
|
// snprintf (n, sizeof(n),"%s%s", n, client->name);
|
|
sep++;
|
|
}
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
int Dem_CountTeamPlayers (char *t)
|
|
{
|
|
int i, count;
|
|
|
|
count = 0;
|
|
for (i = 0; i < sv.allocated_client_slots ; i++)
|
|
{
|
|
if (svs.clients[i].name[0] && !svs.clients[i].spectator)
|
|
if (strcmp(InfoBuf_ValueForKey(&svs.clients[i].userinfo, "team"), t)==0)
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
//takes a quake-mark-up string (subject to com_parseutf and ^ etc) and spits out a usable utf-8 name
|
|
//in and out may overlap.
|
|
static char *FS_UTF8FromQuakeFilename(const char *in, qboolean dequake, qboolean keepmarkup, qboolean blockdirsep, char *out, size_t outsize)
|
|
{
|
|
conchar_t cline[8192], *c;
|
|
char *outend = out+outsize-1; //-1 for our null
|
|
unsigned int charflags, codepoint;
|
|
|
|
COM_ParseFunString(CON_WHITEMASK, in, cline, sizeof(cline), keepmarkup);
|
|
for (c = cline; *c; )
|
|
{
|
|
c = Font_Decode(c, &charflags, &codepoint);
|
|
if (charflags & CON_HIDDEN)
|
|
continue;
|
|
if (dequake)
|
|
codepoint = COM_DeQuake(codepoint);
|
|
|
|
if (codepoint == '/' && blockdirsep) codepoint = '-'; //spreading across multiple dirs is just awkward
|
|
else if (codepoint < ' ' ) codepoint = '-'; //C0 chars are all kinds of problematic
|
|
else if (codepoint == '\\') codepoint = '-'; //windows sucks. or string escapes do.
|
|
else if (codepoint == ':' ) codepoint = '-'; //drives, or Alternative Data Streams (read: often hidden)
|
|
else if (codepoint == '\"') codepoint = '-'; //erk! escapes necessitate escapes...
|
|
else if (codepoint == '<' ) codepoint = '-'; //pipe stuff sucks
|
|
else if (codepoint == '>' ) codepoint = '-'; //pipe stuff sucks
|
|
else if (codepoint == '|' ) codepoint = '-'; //pipe stuff sucks
|
|
else if (codepoint == '?' ) codepoint = '-'; //wildcards complicate things
|
|
else if (codepoint == '*' ) codepoint = '-'; //wildcards complicate things
|
|
|
|
out += utf8_encode(out, codepoint, outend-out);
|
|
}
|
|
*out = 0;
|
|
return out;
|
|
}
|
|
// <-
|
|
|
|
void SV_MVDEasyRecord_f (void)
|
|
{
|
|
int c;
|
|
char name[1024];
|
|
char name2[MAX_OSPATH*7]; // scream
|
|
//char name2[MAX_OSPATH*2];
|
|
int i;
|
|
vfsfile_t *f;
|
|
|
|
c = Cmd_Argc();
|
|
if (c > 2)
|
|
{
|
|
Con_Printf ("easyrecord [demoname]\n");
|
|
return;
|
|
}
|
|
|
|
if (sv.state < ss_active)
|
|
{
|
|
Con_Printf("Server isn't running or is still loading\n");
|
|
return;
|
|
}
|
|
|
|
if (!MVD_CheckSpace(Cmd_FromGamecode()))
|
|
return;
|
|
|
|
if (c == 2)
|
|
{
|
|
Q_strncpyz (name, Cmd_Argv(1), sizeof(name));
|
|
FS_UTF8FromQuakeFilename(name, true, false, false, name, sizeof(name));
|
|
}
|
|
else
|
|
{
|
|
i = Dem_CountPlayers();
|
|
/*if (!deathmatch.ival)
|
|
{
|
|
if (coop.ival || i>1)
|
|
snprintf (name, sizeof(name), "coop_%s_%d(%d)", sv.name, skill.ival, i);
|
|
else
|
|
snprintf (name, sizeof(name), "sp_%s_%d_%s", sv.name, skill.ival, Dem_PlayerName(0));
|
|
}
|
|
else*/ if (teamplay.value >= 1 && i > 2)
|
|
{
|
|
// Teamplay
|
|
snprintf (name, sizeof(name), "%don%d_", Dem_CountTeamPlayers(Dem_Team(1)), Dem_CountTeamPlayers(Dem_Team(2)));
|
|
if (sv_demoExtraNames.value > 0)
|
|
{
|
|
Q_strncatz (name, va("[%s]_%s_vs_[%s]_%s_%s",
|
|
Dem_Team(1), Dem_PlayerNameTeam(Dem_Team(1)),
|
|
Dem_Team(2), Dem_PlayerNameTeam(Dem_Team(2)),
|
|
svs.name), sizeof(name));
|
|
} else
|
|
Q_strncatz (name, va("%s_vs_%s_%s", Dem_Team(1), Dem_Team(2), svs.name), sizeof(name));
|
|
} else {
|
|
if (i == 2) {
|
|
// Duel
|
|
snprintf (name, sizeof(name), "duel_%s_vs_%s_%s",
|
|
Dem_PlayerName(1),
|
|
Dem_PlayerName(2),
|
|
svs.name);
|
|
} else {
|
|
// FFA
|
|
snprintf (name, sizeof(name), "ffa_%s(%d)", svs.name, i);
|
|
}
|
|
}
|
|
|
|
//convert to utf-8, so its readable on most systems (we convert utf-8 to utf-16 for windows, while linux tends to just use utf-8 in the first place)
|
|
FS_UTF8FromQuakeFilename(name, true, false, true, name, sizeof(name));
|
|
}
|
|
|
|
// <-
|
|
|
|
// Make sure the filename doesn't contain illegal characters
|
|
Q_strncpyz(name, va("%s%s", sv_demoPrefix.string, SV_CleanName(name)),
|
|
MAX_MVD_NAME - strlen(sv_demoSuffix.string) - 7);
|
|
Q_strncatz(name, sv_demoSuffix.string, sizeof(name));
|
|
Q_strncpyz(name, va("%s/%s", sv_demoDir.string, name), sizeof(name));
|
|
// find a filename that doesn't exist yet
|
|
Q_strncpyz(name2, name, sizeof(name2));
|
|
// COM_StripExtension(name2, name2);
|
|
FS_CreatePath (name2, FS_GAMEONLY);
|
|
Q_strncatz(name2, ".mvd", sizeof(name2));
|
|
if ((f = FS_OpenVFS(name2, "rb", FS_GAMEONLY)) == 0)
|
|
f = FS_OpenVFS(va("%s.gz", name2), "rb", FS_GAMEONLY);
|
|
|
|
if (f)
|
|
{
|
|
i = 1;
|
|
do {
|
|
VFS_CLOSE (f);
|
|
snprintf(name2, sizeof(name2), "%s_%02i", name, i);
|
|
// COM_StripExtension(name2, name2);
|
|
Q_strncatz(name2, ".mvd", sizeof(name2));
|
|
if ((f = FS_OpenVFS (name2, "rb", FS_GAMEONLY)) == 0)
|
|
f = FS_OpenVFS(va("%s.gz", name2), "rb", FS_GAMEONLY);
|
|
i++;
|
|
} while (f);
|
|
}
|
|
|
|
#ifdef AVAIL_GZDEC
|
|
if (sv_demoAutoCompress.ival == 1)
|
|
Q_strncatz(name2, ".gz", sizeof(name2));
|
|
#endif
|
|
SV_MVD_Record (SV_MVD_InitRecordFile(name2));
|
|
}
|
|
|
|
//console command for servers/admins
|
|
void SV_MVDList_f (void)
|
|
{
|
|
mvddest_t *d;
|
|
dir_t *dir;
|
|
file_t *list;
|
|
float f;
|
|
int i,j,show;
|
|
qofs_t maxdirsize = MVD_DemoMaxDirSize();
|
|
|
|
Con_Printf("content of %s/*.mvd\n", sv_demoDir.string);
|
|
dir = Sys_listdemos(sv_demoDir.string, true, SORT_BY_DATE);
|
|
list = dir->files;
|
|
if (!dir->numfiles)
|
|
{
|
|
Con_Printf("no demos\n");
|
|
}
|
|
|
|
for (i = 1; i <= dir->numfiles; i++, list++)
|
|
{
|
|
for (j = 1; j < Cmd_Argc(); j++)
|
|
if (strstr(list->name, Cmd_Argv(j)) == NULL)
|
|
break;
|
|
show = Cmd_Argc() == j;
|
|
|
|
if (show)
|
|
{
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype != DEST_STREAM && !strcmp(list->name, d->simplename))
|
|
Con_Printf("*%d: ^[^7%s\\demo\\%s/%s^] %uk\n", i, list->name, sv_demoDir.string, list->name, (unsigned int)(d->totalsize/1024));
|
|
}
|
|
if (!d)
|
|
Con_Printf("%d: ^[^7%s\\demo\\%s/%s^] %uk\n", i, list->name, sv_demoDir.string, list->name, (unsigned int)(list->size/1024));
|
|
}
|
|
}
|
|
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
dir->size += d->totalsize;
|
|
|
|
Con_Printf("\ndirectory size: %.1fMB\n",(float)dir->size/(1024*1024));
|
|
if (maxdirsize)
|
|
{
|
|
f = (maxdirsize - dir->size)/(1024*1024);
|
|
if ( f < 0)
|
|
f = 0;
|
|
Con_Printf("space available: %.1fMB\n", f);
|
|
}
|
|
|
|
Sys_freedir(dir);
|
|
}
|
|
|
|
//console command used to print to connected clients (we're acting as a dedicated server)
|
|
void SV_UserCmdMVDList_f (void)
|
|
{
|
|
mvddest_t *d;
|
|
dir_t *dir;
|
|
file_t *list;
|
|
float f;
|
|
int i,j,show;
|
|
qofs_t maxdirsize = MVD_DemoMaxDirSize();
|
|
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "available demos:\n");
|
|
dir = Sys_listdemos(sv_demoDir.string, true, SORT_BY_DATE);
|
|
list = dir->files;
|
|
if (!dir->numfiles)
|
|
{
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "no demos\n");
|
|
}
|
|
|
|
for (i = 1; i <= dir->numfiles; i++, list++)
|
|
{
|
|
for (j = 1; j < Cmd_Argc(); j++)
|
|
if (strstr(list->name, Cmd_Argv(j)) == NULL)
|
|
break;
|
|
show = Cmd_Argc() == j;
|
|
|
|
if (show)
|
|
{
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype != DEST_STREAM && !strcmp(list->name, d->simplename))
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "*%d: %s %dk\n", i, list->name, d->totalsize/1024);
|
|
}
|
|
if (!d)
|
|
{
|
|
if (host_client->fteprotocolextensions2 & PEXT_CSQC) //its a hack to use csqc this way, but oh well, but other clients don't want the gibberish.
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "%d: ^[%s\\type\\/download demos/%s^] %dk\n", i, list->name, list->name, (unsigned int)(list->size/1024));
|
|
else
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "%d: %s %dk\n", i, list->name, (unsigned int)(list->size/1024));
|
|
}
|
|
}
|
|
|
|
if (host_client->num_backbuf >= MAX_BACK_BUFFERS/2)
|
|
{
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "*MORE*\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
dir->size += d->totalsize;
|
|
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "\ndirectory size: %.1fMB\n",(float)dir->size/(1024*1024));
|
|
if (maxdirsize)
|
|
{
|
|
f = (maxdirsize - dir->size)/(1024*1024);
|
|
if ( f < 0)
|
|
f = 0;
|
|
SV_ClientPrintf(host_client, PRINT_HIGH, "space available: %.1fMB\n", f);
|
|
}
|
|
|
|
Sys_freedir(dir);
|
|
}
|
|
|
|
void SV_UserCmdMVDList_HTML (vfsfile_t *pipe)
|
|
{
|
|
//#define EMBEDGAME
|
|
mvddest_t *d;
|
|
dir_t *dir;
|
|
file_t *list;
|
|
float f;
|
|
int i;
|
|
qofs_t maxdirsize = MVD_DemoMaxDirSize();
|
|
|
|
VFS_PRINTF(pipe,
|
|
"<html>"
|
|
"<head>"
|
|
"<title>%s - %s</title>"
|
|
"<meta charset='UTF-8'>"
|
|
"<style>"
|
|
".mydiv { width: 20%%; height: 100%%; padding: 0px; margin: 0px; border: 0px solclass #aaaaaa; float:left; }"
|
|
".game { width: 80%%; height: 100%%; padding: 0px; margin: 0px; border: 0px solclass #aaaaaa; float:left; }"
|
|
"</style>"
|
|
#ifdef EMBEDGAME
|
|
"<script>"
|
|
"function playdemo(demo)"
|
|
"{"
|
|
"demo = window.location.origin+'/demos/'+demo;"
|
|
"thegame.postMessage({cmd:'playdemo',url:demo}, '*');"
|
|
"}"
|
|
"</script>"
|
|
#endif
|
|
"</head>"
|
|
"<body>"
|
|
"<div class='mydiv'>\n"
|
|
, fs_manifest->formalname, hostname.string);
|
|
|
|
VFS_PRINTF(pipe, "available demos:<br/>\n");
|
|
dir = Sys_listdemos(sv_demoDir.string, true, SORT_BY_DATE);
|
|
list = dir->files;
|
|
if (!dir->numfiles)
|
|
{
|
|
VFS_PRINTF(pipe, "no demos<br/>\n");
|
|
}
|
|
|
|
for (i = 1; i <= dir->numfiles; i++, list++)
|
|
{
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
{
|
|
if (d->desttype != DEST_STREAM && !strcmp(list->name, d->simplename))
|
|
VFS_PRINTF(pipe, "*%d: %s %dk<br/>\n", i, list->name, d->totalsize/1024);
|
|
}
|
|
if (!d)
|
|
{
|
|
char datetime[64];
|
|
strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S", localtime(&list->mtime));
|
|
#ifdef EMBEDGAME
|
|
VFS_PRINTF(pipe, "%d: <a href='/demos/%s'>%s</a> %uk <a href='javascript:void(0)' onclick='playdemo(\"%s\")'>play</a> %s<br/>\n", i, list->name, list->name, (unsigned int)(list->size/1024), list->name, datetime);
|
|
#else
|
|
VFS_PRINTF(pipe, "%d: <a href='/demos/%s'>%s</a> %uk %s<br/>\n", i, list->name, list->name, (unsigned int)(list->size/1024), datetime);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
for (d = demo.dest; d; d = d->nextdest)
|
|
dir->size += d->totalsize;
|
|
|
|
VFS_PRINTF(pipe, "<br/>\ndirectory size: %.1fMB<br/>\n",(float)dir->size/(1024*1024));
|
|
if (maxdirsize)
|
|
{
|
|
f = (maxdirsize - dir->size)/(1024*1024);
|
|
if ( f < 0)
|
|
f = 0;
|
|
VFS_PRINTF(pipe, "space available: %.1fMB<br/>\n", f);
|
|
}
|
|
|
|
VFS_PRINTF(pipe,
|
|
"</div>"
|
|
#ifdef EMBEDGAME
|
|
"<div class='game'>"
|
|
"<iframe name='thegame'" //the name of the game is... thegame!
|
|
" src='"ENGINEWEBSITE"/quake' allowfullscreen=true"
|
|
" frameborder='0' scrolling='no' marginheight='0' marginwidth='0' width='100%%' height='100%%'"
|
|
" onerror=\"alert('Failed to load engine')\">"
|
|
"</iframe>"
|
|
"</div>"
|
|
#endif
|
|
"</body>\n"
|
|
"</html>\n");
|
|
|
|
Sys_freedir(dir);
|
|
}
|
|
|
|
const char *SV_MVDLastNum(unsigned int num)
|
|
{
|
|
if (!num || num > DEMOLOG_LENGTH)
|
|
return NULL;
|
|
num = demolog.sequence - num;
|
|
return demolog.log[num % DEMOLOG_LENGTH].filename;
|
|
}
|
|
char *SV_MVDNum(char *buffer, int bufferlen, int num) //lame number->name lookup according to a list generated at an arbitrary time
|
|
{
|
|
file_t *list;
|
|
dir_t *dir;
|
|
|
|
dir = Sys_listdemos(sv_demoDir.string, true, SORT_BY_DATE);
|
|
list = dir->files;
|
|
|
|
if (num < 0)
|
|
num = dir->numfiles + num;
|
|
if (num > dir->numfiles || num <= 0)
|
|
{
|
|
Sys_freedir(dir);
|
|
return NULL;
|
|
}
|
|
num--;
|
|
|
|
list += num;
|
|
|
|
Q_strncpyz(buffer, list->name, bufferlen);
|
|
Sys_freedir(dir);
|
|
return buffer;
|
|
}
|
|
|
|
char *SV_MVDName2Txt(char *name)
|
|
{
|
|
char s[MAX_OSPATH];
|
|
const char *ext;
|
|
|
|
if (!name)
|
|
return NULL;
|
|
|
|
Q_strncpyz(s, name, MAX_OSPATH);
|
|
|
|
ext = COM_GetFileExtension(s, NULL);
|
|
if (!Q_strcasecmp(ext, ".gz"))
|
|
ext = COM_GetFileExtension(s, ext);
|
|
else if (!Q_strcasecmp(ext, ".xz"))
|
|
ext = COM_GetFileExtension(s, ext);
|
|
if (!ext || !*ext) //if there's no extension on there, then make sure we're pointing to the end of the string.
|
|
ext = s+strlen(s);
|
|
if (ext > s+sizeof(s)-4) //make sure we don't overflow the buffer by truncating the base/path, ensuring that we don't write some other type of file.
|
|
ext = s+sizeof(s)-4; //should probably make this an error case and abort instead.
|
|
strcpy((char*)ext, ".txt");
|
|
|
|
return va("%s", s);
|
|
}
|
|
|
|
char *SV_MVDTxTNum(char *buffer, int bufferlen, int num)
|
|
{
|
|
return SV_MVDName2Txt(SV_MVDNum(buffer, bufferlen, num));
|
|
}
|
|
|
|
void SV_MVDRemove_f (void)
|
|
{
|
|
char name[MAX_MVD_NAME], *ptr;
|
|
char path[MAX_OSPATH];
|
|
int i;
|
|
mvddest_t *active;
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_Printf("%s <demoname> - removes the demo\nrmdemo *<token> - removes demo with <token> in the name\nrmdemo * - removes all demos\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
ptr = Cmd_Argv(1);
|
|
if (*ptr == '*')
|
|
{
|
|
dir_t *dir;
|
|
file_t *list;
|
|
|
|
// remove all demos with specified token
|
|
ptr++;
|
|
|
|
dir = Sys_listdemos(sv_demoDir.string, true, SORT_BY_DATE);
|
|
list = dir->files;
|
|
for (i = 0;i < dir->numfiles; list++)
|
|
{
|
|
if (strstr(list->name, ptr))
|
|
{
|
|
mvddest_t *active = SV_FindRecordFile(list->name, NULL);
|
|
if (active)
|
|
SV_MVDStop_f();
|
|
|
|
// stop recording first;
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, list->name);
|
|
if (FS_Remove(path, FS_GAMEONLY))
|
|
{
|
|
Con_Printf("removing %s...\n", list->name);
|
|
i++;
|
|
}
|
|
|
|
FS_Remove(SV_MVDName2Txt(path), FS_GAMEONLY);
|
|
}
|
|
}
|
|
Sys_freedir(dir);
|
|
|
|
if (i)
|
|
{
|
|
Con_Printf("%d demos removed\n", i);
|
|
}
|
|
else
|
|
{
|
|
Con_Printf("no matching found\n");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
Q_strncpyz(name, Cmd_Argv(1), MAX_MVD_NAME);
|
|
COM_DefaultExtension(name, ".mvd", sizeof(name));
|
|
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, name);
|
|
|
|
active = SV_FindRecordFile(name, NULL);
|
|
if (active)
|
|
SV_MVDStop_f();
|
|
|
|
if (FS_Remove(path, FS_GAMEONLY))
|
|
{
|
|
Con_Printf("demo %s successfully removed\n", name);
|
|
}
|
|
else
|
|
Con_Printf("unable to remove demo %s\n", name);
|
|
|
|
FS_Remove(SV_MVDName2Txt(path), FS_GAMEONLY);
|
|
}
|
|
|
|
void SV_MVDRemoveNum_f (void)
|
|
{
|
|
int num;
|
|
char namebuf[MAX_QPATH];
|
|
char *val, *name;
|
|
char path[MAX_OSPATH];
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_Printf("%s <#>\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
val = Cmd_Argv(1);
|
|
if ((num = atoi(val)) == 0 && val[0] != '0')
|
|
{
|
|
Con_Printf("%s <#>\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
name = SV_MVDNum(namebuf, sizeof(namebuf), num);
|
|
|
|
if (name != NULL)
|
|
{
|
|
mvddest_t *active = SV_FindRecordFile(name, NULL);
|
|
if (active)
|
|
SV_MVDStop_f();
|
|
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, name);
|
|
if (FS_Remove(path, FS_GAMEONLY))
|
|
{
|
|
Con_Printf("demo %s succesfully removed\n", name);
|
|
}
|
|
else
|
|
Con_Printf("unable to remove demo %s\n", name);
|
|
|
|
FS_Remove(SV_MVDName2Txt(path), FS_GAMEONLY);
|
|
}
|
|
else
|
|
Con_Printf("invalid demo num\n");
|
|
}
|
|
|
|
void SV_MVDInfoAdd_f (void)
|
|
{
|
|
char namebuf[MAX_QPATH];
|
|
char *name, *args, path[MAX_OSPATH];
|
|
vfsfile_t *f;
|
|
|
|
//** is a special hack for ktx
|
|
if (Cmd_Argc() < 3) {
|
|
Con_Printf("%s <demonum> <info string>\n<demonum> = * for currently recorded demo\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(Cmd_Argv(1), "*") || !strcmp(Cmd_Argv(1), "**"))
|
|
{
|
|
mvddest_t *active = SV_FindRecordFile(NULL, NULL);
|
|
if (!active)
|
|
{
|
|
Con_Printf("Not recording demo!\n");
|
|
return;
|
|
}
|
|
|
|
Q_strncpyz(path, SV_MVDName2Txt(active->filename), sizeof(path));
|
|
}
|
|
else
|
|
{
|
|
name = SV_MVDTxTNum(namebuf, sizeof(namebuf), atoi(Cmd_Argv(1)));
|
|
|
|
if (!name)
|
|
{
|
|
Con_Printf("invalid demo num\n");
|
|
return;
|
|
}
|
|
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, name);
|
|
}
|
|
|
|
if ((f = FS_OpenVFS(path, "ab", FS_GAMEONLY)) == NULL)
|
|
{
|
|
Con_Printf("%s: failed to open \"%s\"\n", Cmd_Argv(0), path);
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(Cmd_Argv(1), "**"))
|
|
{
|
|
size_t fsize;
|
|
args = FS_LoadMallocFile(Cmd_Argv(2), &fsize);
|
|
if (args)
|
|
{
|
|
VFS_WRITE(f, args, fsize);
|
|
FS_FreeFile(args);
|
|
}
|
|
else
|
|
Con_Printf("%s: failed to open input file\n", Cmd_Argv(0));
|
|
}
|
|
else
|
|
{
|
|
// skip demonum
|
|
args = Cmd_Args();
|
|
while (*args > 32) args++;
|
|
while (*args && *args <= 32) args++;
|
|
|
|
VFS_WRITE(f, args, strlen(args));
|
|
VFS_WRITE(f, "\n", 1);
|
|
}
|
|
VFS_FLUSH(f);
|
|
VFS_CLOSE(f);
|
|
}
|
|
|
|
void SV_MVDInfoRemove_f (void)
|
|
{
|
|
char namebuf[MAX_QPATH];
|
|
char *name, path[MAX_OSPATH];
|
|
|
|
if (Cmd_Argc() < 2)
|
|
{
|
|
Con_Printf("%s <demonum>\n<demonum> = * for currently recorded demo\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(Cmd_Argv(1), "*"))
|
|
{
|
|
mvddest_t *active = SV_FindRecordFile(NULL, NULL);
|
|
if (!active)
|
|
{
|
|
Con_Printf("Not recording demo!\n");
|
|
return;
|
|
}
|
|
|
|
snprintf(path, MAX_OSPATH, "%s", SV_MVDName2Txt(active->filename));
|
|
}
|
|
else
|
|
{
|
|
name = SV_MVDTxTNum(namebuf, sizeof(namebuf), atoi(Cmd_Argv(1)));
|
|
|
|
if (!name)
|
|
{
|
|
Con_Printf("invalid demo num\n");
|
|
return;
|
|
}
|
|
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, name);
|
|
}
|
|
|
|
if (FS_Remove(path, FS_GAMEONLY))
|
|
{
|
|
FS_FlushFSHashRemoved(path);
|
|
Con_Printf("file removed\n");
|
|
}
|
|
else
|
|
Con_Printf("failed to remove the file\n");
|
|
|
|
}
|
|
|
|
void SV_MVDInfo_f (void)
|
|
{
|
|
int len;
|
|
char buf[64];
|
|
vfsfile_t *f = NULL;
|
|
char *name, path[MAX_OSPATH];
|
|
|
|
if (Cmd_Argc() < 2)
|
|
{
|
|
Con_Printf("%s <demonum>\n<demonum> = * for currently recorded demo\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
if (!strcmp(Cmd_Argv(1), "*"))
|
|
{
|
|
mvddest_t *active = SV_FindRecordFile(NULL, NULL);
|
|
if (!active)
|
|
{
|
|
Con_Printf("Not recording demo!\n");
|
|
return;
|
|
}
|
|
|
|
Q_strncpyz(path, SV_MVDName2Txt(active->filename), sizeof(path));
|
|
}
|
|
else
|
|
{
|
|
name = SV_MVDTxTNum(buf, sizeof(buf), atoi(Cmd_Argv(1)));
|
|
|
|
if (!name)
|
|
{
|
|
Con_Printf("invalid demo num\n");
|
|
return;
|
|
}
|
|
|
|
snprintf(path, MAX_OSPATH, "%s/%s", sv_demoDir.string, name);
|
|
}
|
|
|
|
if ((f = FS_OpenVFS(path, "rt", FS_GAMEONLY)) == NULL)
|
|
{
|
|
Con_Printf("(empty)\n");
|
|
return;
|
|
}
|
|
|
|
for(;;)
|
|
{
|
|
len = VFS_READ (f, buf, sizeof(buf)-1);
|
|
if (len < 0)
|
|
break;
|
|
buf[len] = 0;
|
|
Con_Printf("%s", buf);
|
|
}
|
|
|
|
VFS_CLOSE(f);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
void SV_MVDPlayNum_f(void)
|
|
{
|
|
char namebuf[MAX_QPATH];
|
|
char *name;
|
|
int num;
|
|
char *val;
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_Printf("%s <#>\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
val = Cmd_Argv(1);
|
|
if ((num = atoi(val)) == 0 && val[0] != '0')
|
|
{
|
|
Con_Printf("%s <#>\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
name = SV_MVDNum(namebuf, sizeof(namebuf), atoi(val));
|
|
|
|
if (name)
|
|
Cbuf_AddText(va("mvdplay %s\n", name), Cmd_ExecLevel);
|
|
else
|
|
Con_Printf("invalid demo num\n");
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void SV_MVDInit(void)
|
|
{
|
|
MVD_Init();
|
|
|
|
//names that conflict with the client and thus only exist in dedicated servers (and thus shouldn't be used by mods that want mvds).
|
|
#ifdef SERVERONLY
|
|
Cmd_AddCommand ("record", SV_MVD_Record_f);
|
|
Cmd_AddCommand ("stop", SV_MVDStop_f); //client version should still work for mvds too.
|
|
#endif
|
|
//these don't currently conflict, but hey...
|
|
Cmd_AddCommand ("cancel", SV_MVD_Cancel_f);
|
|
Cmd_AddCommand ("easyrecord", SV_MVDEasyRecord_f);
|
|
Cmd_AddCommand ("demolist", SV_MVDList_f);
|
|
Cmd_AddCommand ("rmdemo", SV_MVDRemove_f);
|
|
Cmd_AddCommand ("rmdemonum", SV_MVDRemoveNum_f);
|
|
|
|
//serverside only names that won't conflict (matching mvdsv)
|
|
Cmd_AddCommand ("sv_demorecord", SV_MVD_Record_f);
|
|
Cmd_AddCommand ("sv_demostop", SV_MVDStop_f);
|
|
Cmd_AddCommand ("sv_democancel", SV_MVD_Cancel_f);
|
|
Cmd_AddCommand ("sv_demoeasyrecord",SV_MVDEasyRecord_f);
|
|
Cmd_AddCommand ("sv_demolist", SV_MVDList_f);
|
|
Cmd_AddCommand ("sv_demoremove", SV_MVDRemove_f);
|
|
Cmd_AddCommand ("sv_demonumremove", SV_MVDRemoveNum_f);
|
|
|
|
//old fte names to avoid conflicts.
|
|
Cmd_AddCommand ("mvdrecord", SV_MVD_Record_f);
|
|
Cmd_AddCommand ("mvdstop", SV_MVDStop_f);
|
|
Cmd_AddCommand ("mvdcancel", SV_MVD_Cancel_f);
|
|
Cmd_AddCommand ("mvdlist", SV_MVDList_f);
|
|
#ifdef SERVER_DEMO_PLAYBACK
|
|
Cmd_AddCommand ("mvdplaynum", SV_MVDPlayNum_f);
|
|
#endif
|
|
|
|
Cmd_AddCommand ("sv_demoinfoadd", SV_MVDInfoAdd_f);
|
|
Cmd_AddCommand ("sv_demoinforemove",SV_MVDInfoRemove_f);
|
|
Cmd_AddCommand ("sv_demoinfo", SV_MVDInfo_f);
|
|
|
|
Cmd_AddCommand ("qtvreverse", SV_MVD_QTVReverse_f);
|
|
Cvar_Register(&qtv_maxstreams, "MVD Streaming");
|
|
Cvar_Register(&qtv_password, "MVD Streaming");
|
|
}
|
|
|
|
#endif
|
|
#endif
|