nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-23 12:22:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/server/sv_mvd.c
Spoike 4c2066601a Support connecting subnodes to servers over tcp (instead of depending on fork). 
Fixed up the -netquake / -spasm / -fitz args slightly, should actually be usable now.
sv_mintic 0 is now treated as 0.013 when using nqplayerphysics, to try to make it smoother for nq clients.
Preparing for astc's volume formats. Mostly for completeness, I was bored. Disabled for now because nothing supports them anyway.
Fix broken mousewheel in SDL2 builds.
Fix configs not getting loaded following initial downloads in the web port/etc.
Make the near-cloud layer of q1 scrolling sky fully opaque by default (like vanilla).
Sky fog now ignores depth, treating it as an infinite distance.
Fix turbs not responding to fog.
r_fullbright no longer needs vid_reload to take effect (and more efficient now).
Tweaked the audio code to use an format enum instead of byte width, just with the same values still, primarily to clean up loaders that deal with S32 vs F32, or U8 vs S8.
Added a cvar to control whether to use threads for the qcgc. Still disabled by default but no longer requires engine recompiles to enable!



git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5683 fc73d0e0-1445-4013-8a0c-d673dee63da5
2020-04-29 10:43:22 +00:00

3166 lines
78 KiB
C
Raw Blame History

/*
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;
}
// <-
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)
{
char *c;
Q_strncpyz (name, Cmd_Argv(1), sizeof(name));
while((c = strchr(name, ':')))
*c = '-';
}
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);
}
}
}
// <-
// 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
Reference in a new issue View git blame Copy permalink