/* <9a1a9> ../engine/sv_log.c:162 */
void Log_Open(void)
{
time_t ltime;
struct tm *today;
char szFileBase[MAX_PATH];
char szTestFile[MAX_PATH];
int i;
FileHandle_t fp;
char *temp;
if (!g_psvs.log.active || (sv_log_onefile.value != 0.0f && g_psvs.log.file))
return;
if (mp_logfile.value == 0.0f)
Con_Printf("Server logging data to console.\n");
else
{
Log_Close();
time(<ime);
today = localtime(<ime);
temp = Cvar_VariableString("logsdir");
if (!temp || Q_strlen(temp) <= 0 || Q_strstr(temp, ":") || Q_strstr(temp, ".."))
Q_snprintf(szFileBase, sizeof(szFileBase), "logs/L%02i%02i", today->tm_mon + 1, today->tm_mday);
else Q_snprintf(szFileBase, sizeof(szFileBase), "%s/L%02i%02i", temp, today->tm_mon + 1, today->tm_mday);
for (i = 0; i < 1000; i++)
{
Q_snprintf(szTestFile, sizeof(szTestFile), "%s%03i.log", szFileBase, i);
COM_FixSlashes(szTestFile);
COM_CreatePath(szTestFile);
fp = FS_OpenPathID(szTestFile, "r", "GAMECONFIG");
if (!fp)
{
COM_CreatePath(szTestFile);
fp = FS_OpenPathID(szTestFile, "wt", "GAMECONFIG");
if (fp)
{
g_psvs.log.file = (void *)fp;
Con_Printf("Server logging data to file %s\n", szTestFile);
Log_Printf("Log file started (file \"%s\") (game \"%s\") (version \"%i/%s/%d\")\n", szTestFile, Info_ValueForKey(Info_Serverinfo(), "*gamedir"), PROTOCOL_VERSION, gpszVersionString, build_number());
}
return;
}
FS_Close(fp);
}
Con_Printf("Unable to open logfiles under %s\nLogging disabled\n", szFileBase);
g_psvs.log.active = FALSE;
}
}
void Movie_Start_f (void)
{
char name[MAX_OSPATH], path[256]; //qb: jqavi was MAX_FILELENGTH
int i;
if (Cmd_Argc() != 2) //qb: autogenerate file name if none is given.
{
Q_strcpy(name,"qbs8_000.avi"); //qb: screenshots dir
for (i=0 ; i<=999 ; i++)
{
name[5] = i/100 + '0';
name[6] = (i/10)%10 + '0';
name[7] = i%10 + '0';
sprintf (path, "%s/%s/%s", com_gamedir, "screenshots", name);
if (Sys_FileTime(path) == -1)
break; // file doesn't exist
}
if (i==1000)
{
Con_Printf ("Movie_Start_f: Too many AVI files in directory.\n");
return;
}
}
else
{
Q_strncpyz (name, Cmd_Argv(1), sizeof(name));
COM_ForceExtension (name, ".avi");
}
hack_ctr = capture_hack.value;
Q_snprintfz (path, sizeof(path), "%s/%s/%s", com_gamedir, "screenshots", name);
if (!(moviefile = fopen(path, "wb")))
{
COM_CreatePath (path);
if (!(moviefile = fopen(path, "wb")))
{
Con_Printf ("ERROR: Couldn't open %s\n", name);
return;
}
}
movie_is_capturing = Capture_Open (path);
if (movie_is_capturing)
Con_DPrintf("Capturing video %s\n", path); //qb: is printed on the vid, so only in debug mode.
else
Con_Printf("Movie_Start_f: Movie capture open failed.\n");
}
/* <2a33c> ../engine/hashpak.c:1401 */
void HPAK_Extract_f(void)
{
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
char name[MAX_PATH];
char type[32];
FileHandle_t fp;
int nIndex;
byte *pData;
int nDataSize;
FileHandle_t fpOutput;
char szFileOut[MAX_PATH];
if (cmd_source != src_command)
return;
HPAK_FlushHostQueue();
if (Cmd_Argc() != 3)
{
Con_Printf("Usage: hpkextract hpkname [all | single index]\n");
return;
}
if (Q_stricmp(Cmd_Argv(2),"all") != 0)
{
nIndex = Q_atoi(Cmd_Argv(2));
#ifdef REHLDS_FIXES
Q_snprintf(name, sizeof(name), "%s", Cmd_Argv(1));
#else
Q_snprintf(name, 256, "%s", Cmd_Argv(1));
#endif // REHLDS_FIXES
if (nIndex != -1)
Con_Printf("Extracting lump %i from %s\n", nIndex, name);
}
else
{
nIndex = -1;
Q_snprintf(name, ARRAYSIZE(name), "%s", Cmd_Argv(1));
#ifdef REHLDS_FIXES
name[ARRAYSIZE(name) - 1] = 0;
#endif // REHLDS_FIXES
COM_DefaultExtension(name, HASHPAK_EXTENSION);
Con_Printf("Extracting all lumps from %s.\n", name);
}
fp = FS_Open(name, "rb");
if (!fp)
{
Con_Printf("ERROR: couldn't open %s.\n", name);
return;
}
FS_Read(&header, sizeof(hash_pack_header_t), 1, fp);
if (Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp)))
{
Con_Printf("%s is not an HPAK file\n", name);
FS_Close(fp);
return;
}
if (header.version != HASHPAK_VERSION)
{
Con_Printf("hpkextract: version mismatch\n");
FS_Close(fp);
return;
}
FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&directory.nEntries, 4, 1, fp);
if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES)
{
Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", directory.nEntries);
FS_Close(fp);
return;
}
Con_Printf("# of Entries: %i\n", directory.nEntries);
Con_Printf("# Type Size FileName : MD5 Hash\n");
directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries);
FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp);
for (int nCurrent = 0; nCurrent < directory.nEntries; nCurrent++)
{
entry = &directory.p_rgEntries[nCurrent];
if (nIndex == -1 || nIndex == nCurrent)
{
COM_FileBase(entry->resource.szFileName, szFileOut);
switch (entry->resource.type)
{
case t_sound:
Q_strcpy(type, "sound");
break;
case t_skin:
Q_strcpy(type, "skin");
break;
case t_model:
Q_strcpy(type, "model");
break;
case t_decal:
Q_strcpy(type, "decal");
break;
case t_generic:
Q_strcpy(type, "generic");
break;
case t_eventscript:
Q_strcpy(type, "event");
break;
default:
Q_strcpy(type, "?");
break;
}
Con_Printf("Extracting %i: %10s %.2fK %s\n", nCurrent, type, entry->resource.nDownloadSize / 1024.0f, szFileOut);
nDataSize = entry->nFileLength;
if (nDataSize < 1 || (unsigned int)nDataSize >= MAX_FILE_SIZE)
Con_Printf("Unable to extract data, size invalid: %s\n", nDataSize);
else
{
pData = (byte *)Mem_Malloc(nDataSize + 1);
Q_memset(pData, 0, nDataSize);
FS_Seek(fp, entry->nOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(pData, nDataSize, 1, fp);
Q_snprintf(szFileOut, sizeof(szFileOut), "hpklmps\\lmp%04i.wad", nCurrent);
COM_FixSlashes(szFileOut);
COM_CreatePath(szFileOut);
fpOutput = FS_Open(szFileOut, "wb");
if (fpOutput)
{
FS_Write(pData, nDataSize, 1, fpOutput);
FS_Close(fpOutput);
}
else Con_Printf("Error creating lump file %s\n", szFileOut);
if (pData)
Mem_Free(pData);
}
}
}
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
}
/*
===============
SV_SaveGame_f
===============
*/
void SV_SaveGame_f (void)
{
char name[256];
FILE *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH+1];
if (Cmd_Argc() != 2) {
Com_Printf ("save <savename> : save a game\n");
return;
}
if (strstr(Cmd_Argv(1), "..")) {
Com_Printf ("Relative pathnames are not allowed.\n");
return;
}
if (sv.state != ss_active) {
Com_Printf ("Not playing a local game.\n");
return;
}
if (CL_IntermissionRunning()) {
Com_Printf ("Can't save in intermission.\n");
return;
}
if (deathmatch.value != 0 || coop.value != 0 || maxclients.value != 1) {
Com_Printf ("Can't save multiplayer games.\n");
return;
}
for (i = 1; i < MAX_CLIENTS; i++) {
if (svs.clients[i].state == cs_spawned)
{
Com_Printf ("Can't save multiplayer games.\n");
return;
}
}
if (svs.clients[0].state != cs_spawned) {
Com_Printf ("Can't save, client #0 not spawned.\n");
return;
}
sprintf (name, "%s/save/%s", com_gamedir, Cmd_Argv(1));
COM_DefaultExtension (name, ".sav");
Com_Printf ("Saving game to %s...\n", name);
COM_CreatePath (name);
f = fopen (name, "w");
if (!f)
{
Com_Printf ("ERROR: couldn't open.\n");
return;
}
fprintf (f, "%i\n", SAVEGAME_VERSION);
SV_SavegameComment (comment);
fprintf (f, "%s\n", comment);
for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
fprintf (f, "%f\n", svs.clients->spawn_parms[i]);
fprintf (f, "%d\n", current_skill);
fprintf (f, "%s\n", sv.mapname);
fprintf (f, "%f\n",sv.time);
// write the light styles
for (i = 0; i < MAX_LIGHTSTYLES; i++)
{
if (sv.lightstyles[i])
fprintf (f, "%s\n", sv.lightstyles[i]);
else
fprintf (f,"m\n");
}
ED_WriteGlobals (f);
for (i=0 ; i<sv.num_edicts ; i++)
{
ED_Write (f, EDICT_NUM(i));
fflush (f);
}
fclose (f);
Com_Printf ("done.\n");
}
//--------------------------------------------------------------------------------------------------------------
void DownloadCache::PersistToDisk( const RequestContext *rc )
{
if ( !m_cache )
return;
if ( rc && rc->data && rc->nBytesTotal )
{
char gamePath[MAX_PATH];
if ( rc->bIsBZ2 )
{
Q_StripExtension( rc->gamePath, gamePath, sizeof( gamePath ) );
}
else
{
Q_strncpy( gamePath, rc->gamePath, sizeof( gamePath ) );
}
if ( !g_pFileSystem->FileExists( gamePath ) )
{
// Create the subdirs
char * tmpDir = CloneString( gamePath );
COM_CreatePath( tmpDir );
delete[] tmpDir;
bool success = false;
if ( rc->bIsBZ2 )
{
success = DecompressBZipToDisk( gamePath, rc->gamePath, reinterpret_cast< char * >(rc->data), rc->nBytesTotal );
}
else
{
FileHandle_t fp = g_pFileSystem->Open( gamePath, "wb" );
if ( fp )
{
g_pFileSystem->Write( rc->data, rc->nBytesTotal, fp );
g_pFileSystem->Close( fp );
success = true;
}
}
if ( success )
{
// write succeeded. remove any old data from the cache.
char cachePath[_MAX_PATH];
GetCacheFilename( rc, cachePath );
if ( cachePath[0] )
{
g_pFileSystem->RemoveFile( cachePath, NULL );
}
BuildKeyNames( rc->gamePath );
KeyValues *kv = m_cache->FindKey( m_cachefileKey, false );
if ( kv )
{
m_cache->RemoveSubKey( kv );
}
kv = m_cache->FindKey( m_timestampKey, false );
if ( kv )
{
m_cache->RemoveSubKey( kv );
}
}
}
}
m_cache->SaveToFile( g_pFileSystem, CacheFilename, NULL );
}
/**
* Takes a data stream compressed with bzip2, and writes it out to disk, uncompresses it, and deletes the
* compressed version.
*/
static bool DecompressBZipToDisk( const char *outFilename, const char *srcFilename, char *data, int bytesTotal )
{
if ( g_pFileSystem->FileExists( outFilename ) || !data || bytesTotal < 1 )
{
return false;
}
// Create the subdirs
char * tmpDir = CloneString( outFilename );
COM_CreatePath( tmpDir );
delete[] tmpDir;
// open the file for writing
char fullSrcPath[MAX_PATH];
Q_MakeAbsolutePath( fullSrcPath, sizeof( fullSrcPath ), srcFilename, com_gamedir );
if ( !g_pFileSystem->FileExists( fullSrcPath ) )
{
// Write out the .bz2 file, for simplest decompression
FileHandle_t ifp = g_pFileSystem->Open( fullSrcPath, "wb" );
if ( !ifp )
{
return false;
}
int bytesWritten = g_pFileSystem->Write( data, bytesTotal, ifp );
g_pFileSystem->Close( ifp );
if ( bytesWritten != bytesTotal )
{
// couldn't write out all of the .bz2 file
g_pFileSystem->RemoveFile( srcFilename );
return false;
}
}
// Prepare the uncompressed filehandle
FileHandle_t ofp = g_pFileSystem->Open( outFilename, "wb" );
if ( !ofp )
{
g_pFileSystem->RemoveFile( srcFilename );
return false;
}
// And decompress!
const int OutBufSize = 65536;
char buf[ OutBufSize ];
BZFILE *bzfp = BZ2_bzopen( fullSrcPath, "rb" );
while ( 1 )
{
int bytesRead = BZ2_bzread( bzfp, buf, OutBufSize );
if ( bytesRead < 0 )
{
break; // error out
}
if ( bytesRead > 0 )
{
int bytesWritten = g_pFileSystem->Write( buf, bytesRead, ofp );
if ( bytesWritten != bytesRead )
{
break; // error out
}
}
else
{
g_pFileSystem->Close( ofp );
BZ2_bzclose( bzfp );
g_pFileSystem->RemoveFile( srcFilename );
return true;
}
}
// We failed somewhere, so clean up and exit
g_pFileSystem->Close( ofp );
BZ2_bzclose( bzfp );
g_pFileSystem->RemoveFile( srcFilename );
g_pFileSystem->RemoveFile( outFilename );
return false;
}
