/*
=================
UI_LoadGame_GetGameList
=================
*/
static void UI_LoadGame_GetGameList( void )
{
char comment[256];
char **filenames;
int i, numFiles;
filenames = FS_SEARCH( "save/*.sav", &numFiles, TRUE );
// sort the saves in reverse order (oldest past at the end)
qsort( filenames, numFiles, sizeof( char* ), (cmpfunc)COM_CompareSaves );
for ( i = 0; i < numFiles; i++ )
{
if( i >= UI_MAXGAMES ) break;
if( !GET_SAVE_COMMENT( filenames[i], comment ))
{
if( strlen( comment ))
{
// get name string even if not found - SV_GetComment can be mark saves
// as <CORRUPTED> <OLD VERSION> etc
StringConcat( uiLoadGame.saveDescription[i], uiEmptyString, TIME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], comment, NAME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], uiEmptyString, NAME_LENGTH );
uiLoadGame.saveDescriptionPtr[i] = uiLoadGame.saveDescription[i];
COM_FileBase( filenames[i], uiLoadGame.delName[i] );
}
else uiLoadGame.saveDescriptionPtr[i] = NULL;
continue;
}
// strip path, leave only filename (empty slots doesn't have savename)
COM_FileBase( filenames[i], uiLoadGame.saveName[i] );
COM_FileBase( filenames[i], uiLoadGame.delName[i] );
// fill save desc
StringConcat( uiLoadGame.saveDescription[i], comment + CS_SIZE, TIME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], " ", TIME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], comment + CS_SIZE + CS_TIME, TIME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], uiEmptyString, TIME_LENGTH ); // fill remaining entries
StringConcat( uiLoadGame.saveDescription[i], comment, NAME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], uiEmptyString, NAME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], comment + CS_SIZE + (CS_TIME * 2), GAMETIME_LENGTH );
StringConcat( uiLoadGame.saveDescription[i], uiEmptyString, GAMETIME_LENGTH );
uiLoadGame.saveDescriptionPtr[i] = uiLoadGame.saveDescription[i];
}
for ( ; i < UI_MAXGAMES; i++ )
uiLoadGame.saveDescriptionPtr[i] = NULL;
uiLoadGame.savesList.itemNames = (const char **)uiLoadGame.saveDescriptionPtr;
if ( strlen( uiLoadGame.saveName[0] ) == 0 )
uiLoadGame.load.generic.flags |= QMF_GRAYED;
else uiLoadGame.load.generic.flags &= ~QMF_GRAYED;
if ( strlen( uiLoadGame.delName[0] ) == 0 )
uiLoadGame.remove.generic.flags |= QMF_GRAYED;
else uiLoadGame.remove.generic.flags &= ~QMF_GRAYED;
}
/*
=================
UI_PlayDemo_GetDemoList
=================
*/
static void UI_PlayDemo_GetDemoList( void )
{
char comment[256];
char **filenames;
int i, numFiles;
filenames = FS_SEARCH( "demos/*.dem", &numFiles, TRUE );
for( i = 0; i < numFiles; i++ )
{
if( i >= UI_MAXGAMES ) break;
if( !GET_DEMO_COMMENT( filenames[i], comment ))
{
if( strlen( comment ))
{
// get name string even if not found - CL_GetComment can be mark demos
// as <CORRUPTED> <OLD VERSION> etc
StringConcat( uiPlayDemo.demoDescription[i], uiEmptyString, TITLE_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], comment, MAPNAME_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], uiEmptyString, MAXCLIENTS_LENGTH );
uiPlayDemo.demoDescriptionPtr[i] = uiPlayDemo.demoDescription[i];
COM_FileBase( filenames[i], uiPlayDemo.delName[i] );
}
else uiPlayDemo.demoDescriptionPtr[i] = NULL;
continue;
}
// strip path, leave only filename (empty slots doesn't have savename)
COM_FileBase( filenames[i], uiPlayDemo.demoName[i] );
COM_FileBase( filenames[i], uiPlayDemo.delName[i] );
// fill demo desc
StringConcat( uiPlayDemo.demoDescription[i], comment + CS_SIZE, TITLE_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], uiEmptyString, TITLE_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], comment, MAPNAME_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], uiEmptyString, MAPNAME_LENGTH ); // fill remaining entries
StringConcat( uiPlayDemo.demoDescription[i], comment + CS_SIZE * 2, MAXCLIENTS_LENGTH );
StringConcat( uiPlayDemo.demoDescription[i], uiEmptyString, MAXCLIENTS_LENGTH );
uiPlayDemo.demoDescriptionPtr[i] = uiPlayDemo.demoDescription[i];
}
for ( ; i < UI_MAXGAMES; i++ )
uiPlayDemo.demoDescriptionPtr[i] = NULL;
uiPlayDemo.demosList.itemNames = (const char **)uiPlayDemo.demoDescriptionPtr;
if( strlen( uiPlayDemo.demoName[0] ) == 0 )
uiPlayDemo.play.generic.flags |= QMF_GRAYED;
else uiPlayDemo.play.generic.flags &= ~QMF_GRAYED;
if( strlen( uiPlayDemo.delName[0] ) == 0 || !stricmp( gpGlobals->demoname, uiPlayDemo.delName[uiPlayDemo.demosList.curItem] ))
uiPlayDemo.remove.generic.flags |= QMF_GRAYED;
else uiPlayDemo.remove.generic.flags &= ~QMF_GRAYED;
}
/*
* ML_Update
*/
bool ML_Update( void )
{
int i, len, total, newpaks;
size_t size;
char *map, *maps, *filename;
newpaks = FS_Rescan();
if( !newpaks )
return false;
total = FS_GetFileListExt( "maps", ".bsp", NULL, &size, 0, 0 );
if( size )
{
maps = ( char* )Mem_TempMalloc( size );
FS_GetFileList( "maps", ".bsp", maps, size, 0, 0 );
for( i = 0, len = 0; i < total; i++ )
{
map = maps + len;
len += strlen( map ) + 1;
filename = ( char * )COM_FileBase( map );
COM_StripExtension( filename );
// don't check for existance of each file itself, as we've just got the fresh list
if( !ML_FilenameExistsExt( filename, true ) )
ML_AddMap( filename, MLIST_UNKNOWN_MAPNAME );
}
Mem_TempFree( maps );
}
return true;
}
/*
=================
UI_PlayerSetup_FindModels
=================
*/
static void UI_PlayerSetup_FindModels( void )
{
char name[256], path[256];
char **filenames;
int i, numFiles;
uiPlayerSetup.num_models = 0;
// Get file list
filenames = FS_SEARCH( "models/player/*", &numFiles, TRUE );
if( !numFiles ) filenames = FS_SEARCH( "models/player/*", &numFiles, FALSE );
#if 1
// add default singleplayer model
strcpy( uiPlayerSetup.models[uiPlayerSetup.num_models], "player" );
uiPlayerSetup.num_models++;
#endif
// build the model list
for( i = 0; i < numFiles; i++ )
{
COM_FileBase( filenames[i], name );
sprintf( path, "models/player/%s/%s.mdl", name, name );
if( !FILE_EXISTS( path )) continue;
strcpy( uiPlayerSetup.models[uiPlayerSetup.num_models], name );
uiPlayerSetup.num_models++;
}
}
/*
* CL_DownloadStatus_f
*/
void CL_DownloadStatus_f( void )
{
if( !cls.download.requestname )
{
Com_Printf( "No download active\n" );
return;
}
if( !cls.download.name )
{
Com_Printf( "%s: Requesting\n", COM_FileBase( cls.download.requestname ) );
return;
}
Com_Printf( "%s: %s download %3.2f%c done\n", COM_FileBase( cls.download.name ),
( cls.download.web ? "Web" : "Server" ), cls.download.percent * 100.0f, '%' );
}
/* <2ae8e> ../engine/hashpak.c:1599 */
NOXREF char *HPAK_GetItem(int item)
{
NOXREFCHECK;
int nCurrent;
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
static char name[MAX_PATH];
char szFileName[MAX_PATH];
FileHandle_t fp;
HPAK_FlushHostQueue();
Q_snprintf(name, ARRAYSIZE(name), "%s", "custom");
COM_DefaultExtension(name, HASHPAK_EXTENSION);
fp = FS_Open(name, "rb");
if (!fp)
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("HPAK_List: 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 "";
}
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);
nCurrent = directory.nEntries - 1;
if (nCurrent > item)
nCurrent = item;
entry = &directory.p_rgEntries[nCurrent];
COM_FileBase(entry->resource.szFileName, szFileName);
Q_snprintf(name, sizeof(name), "!MD5%s", MD5_Print(entry->resource.rgucMD5_hash));
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
return name;
}
/*
* CL_DownloadRequest
*
* Request file download
* return qfalse if couldn't request it for some reason
* Files with .pk3 or .pak extension have to have gamedir attached
* Other files must not have gamedir
*/
qboolean CL_DownloadRequest( const char *filename, qboolean requestpak )
{
if( cls.download.requestname )
{
Com_Printf( "Can't download: %s. Download already in progress.\n", filename );
return qfalse;
}
if( !COM_ValidateRelativeFilename( filename ) )
{
Com_Printf( "Can't download: %s. Invalid filename.\n", filename );
return qfalse;
}
if( FS_CheckPakExtension( filename ) )
{
if( FS_FOpenBaseFile( filename, NULL, FS_READ ) != -1 )
{
Com_Printf( "Can't download: %s. File already exists.\n", filename );
return qfalse;
}
if( !Q_strnicmp( COM_FileBase( filename ), "modules", strlen( "modules" ) ) )
{
if( !CL_CanDownloadModules() )
return qfalse;
}
}
else
{
if( FS_FOpenFile( filename, NULL, FS_READ ) != -1 )
{
Com_Printf( "Can't download: %s. File already exists.\n", filename );
return qfalse;
}
}
if( cls.socket->type == SOCKET_LOOPBACK )
{
Com_DPrintf( "Can't download: %s. Loopback server.\n", filename );
return qfalse;
}
Com_Printf( "Asking to download: %s\n", filename );
cls.download.requestpak = requestpak;
cls.download.requestname = Mem_ZoneMalloc( sizeof( char ) * ( strlen( filename ) + 1 ) );
Q_strncpyz( cls.download.requestname, filename, sizeof( char ) * ( strlen( filename ) + 1 ) );
cls.download.timeout = Sys_Milliseconds() + 5000;
CL_AddReliableCommand( va( "download %i \"%s\"", requestpak, filename ) );
return qtrue;
}
/*
* SV_ReloadPureList
*/
static void SV_ReloadPureList( void ) {
char **paks;
int i, numpaks;
Com_FreePureList( &svs.purelist );
// game modules
if( sv_pure_forcemodulepk3->string[0] ) {
if( Q_strnicmp( COM_FileBase( sv_pure_forcemodulepk3->string ), "modules", strlen( "modules" ) ) ||
!FS_IsPakValid( sv_pure_forcemodulepk3->string, NULL ) ) {
Com_Printf( "Warning: Invalid value for sv_pure_forcemodulepk3, disabling\n" );
Cvar_ForceSet( "sv_pure_forcemodulepk3", "" );
} else {
SV_AddPurePak( sv_pure_forcemodulepk3->string );
}
}
if( !sv_pure_forcemodulepk3->string[0] ) {
char *libname;
int libname_size;
libname_size = strlen( LIB_PREFIX ) + 5 + strlen( ARCH ) + strlen( LIB_SUFFIX ) + 1;
libname = Mem_TempMalloc( libname_size );
Q_snprintfz( libname, libname_size, LIB_PREFIX "game_" ARCH LIB_SUFFIX );
if( !FS_PakNameForFile( libname ) ) {
if( sv_pure->integer ) {
Com_Printf( "Warning: Game module not in pk3, disabling pure mode\n" );
Com_Printf( "sv_pure_forcemodulepk3 can be used to force the pure system to use a different module\n" );
Cvar_ForceSet( "sv_pure", "0" );
}
} else {
SV_AddPureFile( libname );
}
Mem_TempFree( libname );
libname = NULL;
}
// *pure.(pk3|pak)
paks = NULL;
numpaks = FS_GetExplicitPurePakList( &paks );
if( numpaks ) {
for( i = 0; i < numpaks; i++ ) {
SV_AddPurePak( paks[i] );
Mem_ZoneFree( paks[i] );
}
Mem_ZoneFree( paks );
}
}
/*
=================
HUD_IsGame
=================
*/
int HUD_IsGame( const char *game )
{
const char *gamedir;
char gd[ 1024 ];
gamedir = gEngfuncs.pfnGetGameDirectory();
if ( gamedir && gamedir[0] )
{
COM_FileBase( gamedir, gd );
if ( !stricmp( gd, game ) )
return 1;
}
return 0;
}
/*
==================
Mod_LoadModel
Loads a model into the cache
==================
*/
model_t *Mod_LoadModel (model_t *mod, qboolean crash)
{
// void *d;
unsigned *buf;
byte stackbuf[1024]; // avoid dirtying the cache heap
if (!mod->needload)
{
if (mod->type == mod_alias)
{
// d = Cache_Check (&mod->cache);
// if (d)
// return mod;
;
}
else
return mod; // not cached at all
}
//
// load the file
//
buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf));
if (!buf)
{
if (crash)
SV_Error ("Mod_NumForName: %s not found", mod->name);
return NULL;
}
//
// allocate a new model
//
COM_FileBase (mod->name, loadname);
loadmodel = mod;
//
// fill it in
//
// call the apropriate loader
mod->needload = false;
Mod_LoadBrushModel (mod, buf);
return mod;
}
/*
* Sys_FS_FindNext
*/
const char *Sys_FS_FindNext( unsigned musthave, unsigned canhave )
{
struct dirent64 *d;
assert( fdir );
assert( findbase && findpattern );
if( !fdir )
return NULL;
while( ( d = readdir64( fdir ) ) != NULL )
{
if( !CompareAttributes( d, findbase, musthave, canhave ) )
continue;
if( fdots > 0 )
{
// . and .. never match
const char *base = COM_FileBase( d->d_name );
if( !strcmp( base, "." ) || !strcmp( base, ".." ) )
{
fdots--;
continue;
}
}
if( !*findpattern || Com_GlobMatch( findpattern, d->d_name, 0 ) )
{
const char *dname = d->d_name;
size_t dname_len = strlen( dname );
size_t size = sizeof( char ) * ( findbase_size + dname_len + 1 + 1 );
if( findpath_size < size )
{
if( findpath )
Mem_TempFree( findpath );
findpath_size = size * 2; // extra size to reduce reallocs
findpath = Mem_TempMalloc( findpath_size );
}
Q_snprintfz( findpath, findpath_size, "%s/%s%s", findbase, dname,
dname[dname_len-1] != '/' && FS_DirentIsDir( d, findbase ) ? "/" : "" );
if( CompareAttributesForPath( d, findpath, musthave, canhave ) )
return findpath;
}
}
return NULL;
}
std::string StreamCache::CacheFileForUrl( const std::string url, bool noCache )
{
unsigned int hashkey;
std::string fileName;
// compute hash key for the URL and convert to hex
hashkey = md5_digest32( ( const qbyte * )url.c_str(), url.size() );
std::stringstream outstream;
outstream << std::hex << hashkey; // to hex
// strip path and query string from the target file name
fileName = std::string( COM_FileBase( url.c_str() ) );
std::string::size_type delim = fileName.find( '?' );
if( delim != fileName.npos ) {
fileName = fileName.substr( 0, delim );
}
std::string cacheName = std::string( WSW_UI_STREAMCACHE_DIR ) + "/" + outstream.str() +
(noCache ? "_0" : "_1") + "_" + fileName;
std::transform(cacheName.begin(), cacheName.end(), cacheName.begin(), ::tolower);
// link exists?
std::string linkName = cacheName + LINK_EXTENSION;
int filenum, length;
length = trap::FS_FOpenFile( linkName.c_str(), &filenum, FS_READ );
if( length >= 0 ) {
if( length > 0 ) {
char *buf = new char[length+1];
trap::FS_Read( buf, length, filenum );
buf[length] = '\0';
cacheName = buf;
delete[] buf;
}
trap::FS_FCloseFile( filenum );
}
return cacheName;
}
/*
==================
Mod_LoadModel
Loads a model into the cache
==================
*/
static model_t *Mod_LoadModel (model_t *mod, qboolean crash)
{
unsigned int *buf;
if (mod->needload == NL_PRESENT)
return mod;
//
// load the file
//
buf = (unsigned int *)FS_LoadTempFile (mod->name);
if (!buf)
{
if (crash)
SV_Error ("%s: %s not found", __thisfunc__, mod->name);
return NULL;
}
//
// allocate a new model
//
COM_FileBase (mod->name, loadname, sizeof(loadname));
loadmodel = mod;
//
// fill it in
//
// call the apropriate loader
mod->needload = NL_PRESENT;
Mod_LoadBrushModel (mod, buf);
return mod;
}
/*
* CL_DownloadRequest
*
* Request file download
* return false if couldn't request it for some reason
* Files with .pk3 or .pak extension have to have gamedir attached
* Other files must not have gamedir
*/
bool CL_DownloadRequest( const char *filename, bool requestpak )
{
if( cls.download.requestname )
{
Com_Printf( "Can't download: %s. Download already in progress.\n", filename );
return false;
}
if( !COM_ValidateRelativeFilename( filename ) )
{
Com_Printf( "Can't download: %s. Invalid filename.\n", filename );
return false;
}
if( FS_CheckPakExtension( filename ) )
{
if( FS_PakFileExists( filename ) )
{
Com_Printf( "Can't download: %s. File already exists.\n", filename );
return false;
}
if( !Q_strnicmp( COM_FileBase( filename ), "modules", strlen( "modules" ) ) )
{
if( !CL_CanDownloadModules() )
return false;
}
}
else
{
if( FS_FOpenFile( filename, NULL, FS_READ ) != -1 )
{
Com_Printf( "Can't download: %s. File already exists.\n", filename );
return false;
}
if( !requestpak ) {
const char *extension;
// only allow demo downloads
extension = COM_FileExtension( filename );
if( !extension || Q_stricmp( extension, APP_DEMO_EXTENSION_STR ) )
{
Com_Printf( "Can't download, got arbitrary file type: %s\n", filename );
return false;
}
}
}
if( cls.socket->type == SOCKET_LOOPBACK )
{
Com_DPrintf( "Can't download: %s. Loopback server.\n", filename );
return false;
}
Com_Printf( "Asking to download: %s\n", filename );
cls.download.requestpak = requestpak;
cls.download.requestname = Mem_ZoneMalloc( sizeof( char ) * ( strlen( filename ) + 1 ) );
Q_strncpyz( cls.download.requestname, filename, sizeof( char ) * ( strlen( filename ) + 1 ) );
cls.download.timeout = Sys_Milliseconds() + 5000;
CL_AddReliableCommand( va( "download %i \"%s\"", requestpak, filename ) );
return true;
}
/*
* Sys_Library_GetFullName
*/
const char *Sys_Library_GetFullName( const char *name )
{
static char tempname[PATH_MAX];
Q_snprintfz( tempname, sizeof( tempname ), "/data/data/%s/lib/%s", sys_android_packageName, COM_FileBase( name ) );
return tempname;
}
/* <2a3cb> ../engine/hashpak.c:1235 */
void HPAK_Validate_f(void)
{
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
char name[MAX_PATH];
char szFileName[MAX_PATH];
char type[32];
FileHandle_t fp;
byte *pData;
int nDataSize;
byte md5[16];
MD5Context_t ctx;
if (cmd_source != src_command)
return;
HPAK_FlushHostQueue();
if (Cmd_Argc() != 2)
{
Con_Printf("Usage: hpkval hpkname\n");
return;
}
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("Validating %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("hpkval: 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];
COM_FileBase(entry->resource.szFileName, szFileName);
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("%i: %10s %.2fK %s: ", nCurrent + 1, type, entry->resource.nDownloadSize / 1024.0f, szFileName);
nDataSize = entry->nFileLength;
if (nDataSize < 1 || (unsigned int)nDataSize >= MAX_FILE_SIZE)
Con_Printf("Unable to MD5 hash data, size invalid: %i\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_memset(&ctx, 0, sizeof(MD5Context_t));
MD5Init(&ctx);
MD5Update(&ctx, pData, nDataSize);
MD5Final(md5, &ctx);
if (Q_memcmp(entry->resource.rgucMD5_hash, md5, sizeof(md5)) == 0)
Con_Printf(" OK\n");
else
{
Con_Printf(" MISMATCHED\n");
Con_Printf("--------------------\n");
Con_Printf(" File : %s\n", MD5_Print(entry->resource.rgucMD5_hash));
Con_Printf(" Actual: %s\n", MD5_Print(md5));
Con_Printf("--------------------\n");
}
if (pData)
Mem_Free(pData);
}
}
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
}
/* <2a644> ../engine/hashpak.c:945 */
void HPAK_List_f(void)
{
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
char name[MAX_PATH];
char szFileName[MAX_PATH];
char type[32];
FileHandle_t fp;
if (cmd_source != src_command)
return;
HPAK_FlushHostQueue();
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("Contents for %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("HPAK_List: 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];
COM_FileBase(entry->resource.szFileName, szFileName);
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("%i: %10s %.2fK %s\n : %s\n", nCurrent + 1, type, entry->resource.nDownloadSize / 1024.0f, szFileName, MD5_Print(entry->resource.rgucMD5_hash));
}
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
}
/* <2afb5> ../engine/hashpak.c:1728 */
void HPAK_ValidatePak(char *fullpakname)
{
hash_pack_header_t header;
hash_pack_directory_t directory;
hash_pack_entry_t *entry;
char szFileName[MAX_PATH];
FileHandle_t fp;
byte *pData;
byte md5[16];
MD5Context_t ctx;
HPAK_FlushHostQueue();
fp = FS_Open(fullpakname, "rb");
if (!fp)
return;
FS_Read(&header, sizeof(hash_pack_header_t), 1, fp);
if (header.version != HASHPAK_VERSION || Q_strncmp(header.szFileStamp, "HPAK", sizeof(header.szFileStamp)) != 0)
{
Con_Printf("%s is not a PAK file, deleting\n", fullpakname);
FS_Close(fp);
FS_RemoveFile(fullpakname, 0);
return;
}
FS_Seek(fp, header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&directory, 4, 1, fp);
if (directory.nEntries < 1 || (unsigned int)directory.nEntries > MAX_FILE_ENTRIES)
{
Con_Printf("ERROR: HPAK %s had bogus # of directory entries: %i, deleting\n", fullpakname, directory.nEntries);
FS_Close(fp);
FS_RemoveFile(fullpakname, 0);
return;
}
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];
COM_FileBase(entry->resource.szFileName, szFileName);
if ((unsigned int)entry->nFileLength >= MAX_FILE_SIZE)
{
Con_Printf("Mismatched data in HPAK file %s, deleting\n", fullpakname);
Con_Printf("Unable to MD5 hash data lump %i, size invalid: %i\n", nCurrent + 1, entry->nFileLength);
FS_Close(fp);
FS_RemoveFile(fullpakname, 0);
Mem_Free(directory.p_rgEntries);
return;
}
pData = (byte *)Mem_Malloc(entry->nFileLength + 1);
Q_memset(pData, 0, entry->nFileLength);
FS_Seek(fp, entry->nOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(pData, entry->nFileLength, 1, fp);
Q_memset(&ctx, 0, sizeof(MD5Context_t));
MD5Init(&ctx);
MD5Update(&ctx, pData, entry->nFileLength);
MD5Final(md5, &ctx);
if (pData)
Mem_Free(pData);
if (Q_memcmp(entry->resource.rgucMD5_hash, md5, sizeof(md5)) != 0)
{
Con_Printf("Mismatched data in HPAK file %s, deleting\n", fullpakname);
FS_Close(fp);
FS_RemoveFile(fullpakname, 0);
Mem_Free(directory.p_rgEntries);
return;
}
}
FS_Close(fp);
Mem_Free(directory.p_rgEntries);
}
/* <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);
}
/*
=================
UI_TouchOptions_Callback
=================
*/
static void UI_TouchOptions_Callback( void *self, int event )
{
menuCommon_s *item = (menuCommon_s *)self;
switch( item->id )
{
case ID_ENABLE:
case ID_GRID:
case ID_IGNORE_MOUSE:
if( event == QM_PRESSED )
((menuCheckBox_s *)self)->focusPic = UI_CHECKBOX_PRESSED;
else ((menuCheckBox_s *)self)->focusPic = UI_CHECKBOX_FOCUS;
break;
}
if( event == QM_CHANGED )
{
// Update cvars based on controls
UI_TouchOptions_SetConfig();
if( item->id == ID_PROFILELIST )
{
char curprofile[256];
int isCurrent;
COM_FileBase( CVAR_GET_STRING( "touch_config_file" ), curprofile );
isCurrent = !strcmp( curprofile, uiTouchOptions.profileDesc[ uiTouchOptions.profiles.curItem ]);
// Scrolllist changed, update availiable options
uiTouchOptions.remove.generic.flags |= QMF_GRAYED;
if( ( uiTouchOptions.profiles.curItem > uiTouchOptions.firstProfile ) && !isCurrent )
uiTouchOptions.remove.generic.flags &= ~QMF_GRAYED;
uiTouchOptions.apply.generic.flags &= ~QMF_GRAYED;
if( uiTouchOptions.profiles.curItem == 0 || uiTouchOptions.profiles.curItem == uiTouchOptions.firstProfile -1 )
uiTouchOptions.profiles.curItem ++;
if( isCurrent )
uiTouchOptions.apply.generic.flags |= QMF_GRAYED;
}
return;
}
if( event != QM_ACTIVATED )
return;
switch( item->id )
{
case ID_DONE:
UI_TouchOptions_SetConfig();
UI_PopMenu();
break;
case ID_RESET:
uiTouchOptions.save.generic.flags |= QMF_INACTIVE;
uiTouchOptions.remove.generic.flags |= QMF_INACTIVE;
uiTouchOptions.enable.generic.flags |= QMF_INACTIVE;
uiTouchOptions.profiles.generic.flags |= QMF_INACTIVE;
uiTouchOptions.moveX.generic.flags |= QMF_INACTIVE;
uiTouchOptions.moveY.generic.flags |= QMF_INACTIVE;
uiTouchOptions.lookX.generic.flags |= QMF_INACTIVE;
uiTouchOptions.lookY.generic.flags |= QMF_INACTIVE;
uiTouchOptions.reset.generic.flags |= QMF_INACTIVE;
uiTouchOptions.profilename.generic.flags |= QMF_INACTIVE;
uiTouchOptions.done.generic.flags |= QMF_INACTIVE;
uiTouchOptions.msgBox.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.promptMessage.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.no.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.yes.generic.flags &= ~QMF_HIDDEN;
strcpy( uiTouchOptions.dialogText, "Reset all buttons?" );
uiTouchOptions.dialogAction = UI_ResetButtons;
break;
case ID_DELETE:
uiTouchOptions.save.generic.flags |= QMF_INACTIVE;
uiTouchOptions.remove.generic.flags |= QMF_INACTIVE;
uiTouchOptions.enable.generic.flags |= QMF_INACTIVE;
uiTouchOptions.profiles.generic.flags |= QMF_INACTIVE;
uiTouchOptions.moveX.generic.flags |= QMF_INACTIVE;
uiTouchOptions.moveY.generic.flags |= QMF_INACTIVE;
uiTouchOptions.lookX.generic.flags |= QMF_INACTIVE;
uiTouchOptions.lookY.generic.flags |= QMF_INACTIVE;
uiTouchOptions.reset.generic.flags |= QMF_INACTIVE;
uiTouchOptions.profilename.generic.flags |= QMF_INACTIVE;
uiTouchOptions.done.generic.flags |= QMF_INACTIVE;
uiTouchOptions.msgBox.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.promptMessage.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.no.generic.flags &= ~QMF_HIDDEN;
uiTouchOptions.yes.generic.flags &= ~QMF_HIDDEN;
strcpy( uiTouchOptions.dialogText, "Delete selected profile?" );
uiTouchOptions.dialogAction = UI_DeleteProfile;
break;
case ID_YES:
if( uiTouchOptions.dialogAction )
uiTouchOptions.dialogAction();
case ID_NO:
uiTouchOptions.save.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.remove.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.enable.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.profiles.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.moveX.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.moveY.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.lookX.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.lookY.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.reset.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.profilename.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.done.generic.flags &= ~QMF_INACTIVE;
uiTouchOptions.msgBox.generic.flags |= QMF_HIDDEN;
uiTouchOptions.promptMessage.generic.flags |= QMF_HIDDEN;
uiTouchOptions.no.generic.flags |= QMF_HIDDEN;
uiTouchOptions.yes.generic.flags |= QMF_HIDDEN;
break;
case ID_SAVE:
{
char name[256];
if( uiTouchOptions.profilename.buffer[0] )
{
snprintf( name, 256, "touch_profiles/%s.cfg", uiTouchOptions.profilename.buffer );
CVAR_SET_STRING("touch_config_file", name );
}
CLIENT_COMMAND( 1, "touch_writeconfig\n" );
}
UI_TouchOptions_GetProfileList();
uiTouchOptions.profilename.buffer[0] = 0;
uiTouchOptions.profilename.cursor = uiTouchOptions.profilename.scroll = 0;
break;
case ID_APPLY:
{
int i = uiTouchOptions.profiles.curItem;
// preset selected
if( i > 0 && i < uiTouchOptions.firstProfile - 1 )
{
char command[256];
char *curconfig = CVAR_GET_STRING( "touch_config_file" );
snprintf( command, 256, "exec \"touch_presets/%s\"\n", uiTouchOptions.profileDesc[ i ] );
CLIENT_COMMAND( 1, command );
while( FILE_EXISTS( curconfig ) )
{
char copystring[256];
char filebase[256];
COM_FileBase( curconfig, filebase );
if( snprintf( copystring, 256, "touch_profiles/%s (new).cfg", filebase ) > 255 )
break;
CVAR_SET_STRING( "touch_config_file", copystring );
curconfig = CVAR_GET_STRING( "touch_config_file" );
}
}
else if( i == uiTouchOptions.firstProfile )
CLIENT_COMMAND( 1,"exec touch.cfg\n" );
else if( i > uiTouchOptions.firstProfile )
{
char command[256];
snprintf( command, 256, "exec \"touch_profiles/%s\"\n", uiTouchOptions.profileDesc[ i ] );
CLIENT_COMMAND( 1, command );
}
// try save config
CLIENT_COMMAND( 1, "touch_writeconfig\n" );
// check if it failed ant reset profile to default if it is
if( !FILE_EXISTS( CVAR_GET_STRING( "touch_config_file" ) ))
{
CVAR_SET_STRING( "touch_config_file", "touch.cfg" );
uiTouchOptions.profiles.curItem = uiTouchOptions.firstProfile;
}
UI_TouchOptions_GetProfileList();
UI_TouchOptions_GetConfig();
}
}
}
/* <ee234> ../engine/sv_steam3.cpp:375 */
void CSteam3Server::Activate()
{
bool bLanOnly;
int argSteamPort;
EServerMode eSMode;
int gamePort;
char gamedir[MAX_PATH];
int usSteamPort;
uint32 unIP;
if (m_bLoggedOn)
{
bLanOnly = sv_lan.value != 0.0;
if (this->m_bLanOnly != bLanOnly)
{
m_bLanOnly = bLanOnly;
m_bWantToBeSecure = !COM_CheckParm("-insecure") && !bLanOnly;
}
}
else
{
m_bLoggedOn = 1;
unIP = 0;
usSteamPort = 26900;
argSteamPort = COM_CheckParm("-sport");
if (argSteamPort > 0)
usSteamPort = atoi(com_argv[argSteamPort + 1]);
eSMode = eServerModeAuthenticationAndSecure;
if (net_local_adr.type == NA_IP)
unIP = ntohl(*(u_long *)&net_local_adr.ip[0]);
m_bLanOnly = sv_lan.value > 0.0;
m_bWantToBeSecure = !COM_CheckParm("-insecure") && !m_bLanOnly;
COM_FileBase(com_gamedir, gamedir);
if (!m_bWantToBeSecure)
eSMode = eServerModeAuthentication;
if (m_bLanOnly)
eSMode = eServerModeNoAuthentication;
gamePort = (int)iphostport.value;
if (gamePort == 0)
gamePort = (int)hostport.value;
int nAppId = GetGameAppID();
if (nAppId > 0 && g_pcls.state == ca_dedicated)
{
FILE* f = fopen("steam_appid.txt", "w+");
if (f)
{
fprintf(f, "%d\n", nAppId);
fclose(f);
}
}
if (!CRehldsPlatformHolder::get()->SteamGameServer_Init(unIP, usSteamPort, gamePort, 0xFFFFu, eSMode, gpszVersionString))
Sys_Error("Unable to initialize Steam.");
CRehldsPlatformHolder::get()->SteamGameServer()->SetProduct(gpszProductString);
CRehldsPlatformHolder::get()->SteamGameServer()->SetModDir(gamedir);
CRehldsPlatformHolder::get()->SteamGameServer()->SetDedicatedServer(g_pcls.state == ca_dedicated);
CRehldsPlatformHolder::get()->SteamGameServer()->SetGameDescription(gEntityInterface.pfnGetGameDescription());
CRehldsPlatformHolder::get()->SteamGameServer()->LogOnAnonymous();
m_bLogOnResult = false;
if (COM_CheckParm("-nomaster"))
{
Con_Printf("Master server communication disabled.\n");
gfNoMasterServer = TRUE;
}
else
{
if (!gfNoMasterServer && g_psvs.maxclients > 1)
{
CRehldsPlatformHolder::get()->SteamGameServer()->EnableHeartbeats(true);
double fMasterHeartbeatTimeout = 200.0;
if (!Q_strcmp(gamedir, "dmc"))
fMasterHeartbeatTimeout = 150.0;
if (!Q_strcmp(gamedir, "tfc"))
fMasterHeartbeatTimeout = 400.0;
if (!Q_strcmp(gamedir, "cstrike"))
fMasterHeartbeatTimeout = 400.0;
CRehldsPlatformHolder::get()->SteamGameServer()->SetHeartbeatInterval((int)fMasterHeartbeatTimeout);
CSteam3Server::NotifyOfLevelChange(true);
}
}
}
}
/*
* CL_InitDownload_f
*
* Hanldles server's initdownload message, starts web or server download if possible
*/
static void CL_InitDownload_f( void )
{
const char *filename;
const char *url;
int size, alloc_size;
unsigned checksum;
qboolean allow_localhttpdownload;
download_list_t *dl;
// ignore download commands coming from demo files
if( cls.demo.playing )
return;
// read the data
filename = Cmd_Argv( 1 );
size = atoi( Cmd_Argv( 2 ) );
checksum = strtoul( Cmd_Argv( 3 ), NULL, 10 );
allow_localhttpdownload = ( atoi( Cmd_Argv( 4 ) ) != 0 ) && cls.httpbaseurl != NULL;
url = Cmd_Argv( 5 );
if( !cls.download.requestname )
{
Com_Printf( "Got init download message without request\n" );
return;
}
if( cls.download.filenum || cls.download.web )
{
Com_Printf( "Got init download message while already downloading\n" );
return;
}
if( size == -1 )
{
// means that download was refused
Com_Printf( "Server refused download request: %s\n", url ); // if it's refused, url field holds the reason
CL_DownloadDone();
return;
}
if( size <= 0 )
{
Com_Printf( "Server gave invalid size, not downloading\n" );
CL_DownloadDone();
return;
}
if( checksum == 0 )
{
Com_Printf( "Server didn't provide checksum, not downloading\n" );
CL_DownloadDone();
return;
}
if( !COM_ValidateRelativeFilename( filename ) )
{
Com_Printf( "Not downloading, invalid filename: %s\n", filename );
CL_DownloadDone();
return;
}
if( FS_CheckPakExtension( filename ) && !cls.download.requestpak )
{
Com_Printf( "Got a pak file when requesting normal one, not downloading\n" );
CL_DownloadDone();
return;
}
if( !FS_CheckPakExtension( filename ) && cls.download.requestpak )
{
Com_Printf( "Got a non pak file when requesting pak, not downloading\n" );
CL_DownloadDone();
return;
}
if( !strchr( filename, '/' ) )
{
Com_Printf( "Refusing to download file with no gamedir: %s\n", filename );
CL_DownloadDone();
return;
}
// check that it is in game or basegame dir
if( strlen( filename ) < strlen( FS_GameDirectory() )+1 ||
strncmp( filename, FS_GameDirectory(), strlen( FS_GameDirectory() ) ) ||
filename[strlen( FS_GameDirectory() )] != '/' )
{
if( strlen( filename ) < strlen( FS_BaseGameDirectory() )+1 ||
strncmp( filename, FS_BaseGameDirectory(), strlen( FS_BaseGameDirectory() ) ) ||
filename[strlen( FS_BaseGameDirectory() )] != '/' )
{
Com_Printf( "Can't download, invalid game directory: %s\n", filename );
CL_DownloadDone();
return;
}
}
if( FS_CheckPakExtension( filename ) )
{
if( strchr( strchr( filename, '/' ) + 1, '/' ) )
{
Com_Printf( "Refusing to download pack file to subdirectory: %s\n", filename );
CL_DownloadDone();
return;
}
if( !Q_strnicmp( COM_FileBase( filename ), "modules", strlen( "modules" ) ) )
{
if( !CL_CanDownloadModules() )
{
CL_DownloadDone();
return;
}
}
if( FS_FOpenBaseFile( filename, NULL, FS_READ ) != -1 )
{
Com_Printf( "Can't download, file already exists: %s\n", filename );
CL_DownloadDone();
return;
}
}
else
{
if( strcmp( cls.download.requestname, strchr( filename, '/' ) + 1 ) )
{
Com_Printf( "Can't download, got different file than requested: %s\n", filename );
CL_DownloadDone();
return;
}
}
if( cls.download.requestnext )
{
dl = cls.download.list;
while( dl != NULL )
{
if( !Q_stricmp( dl->filename, filename ) )
{
Com_Printf( "Skipping, already tried downloading: %s\n", filename );
CL_DownloadDone();
return;
}
dl = dl->next;
}
}
cls.download.name = ZoneCopyString( filename );
alloc_size = strlen( filename ) + strlen( ".tmp" ) + 1;
cls.download.tempname = Mem_ZoneMalloc( alloc_size );
Q_snprintfz( cls.download.tempname, alloc_size, "%s.tmp", filename );
cls.download.web = qfalse;
cls.download.cancelled = qfalse;
cls.download.disconnect = qfalse;
cls.download.size = size;
cls.download.checksum = checksum;
cls.download.percent = 0;
cls.download.timeout = 0;
cls.download.retries = 0;
cls.download.timestart = Sys_Milliseconds();
cls.download.offset = 0;
cls.download.baseoffset = 0;
cls.download.pending_reconnect = qfalse;
Cvar_ForceSet( "cl_download_name", COM_FileBase( cls.download.name ) );
Cvar_ForceSet( "cl_download_percent", "0" );
if( cls.download.requestnext )
{
dl = Mem_ZoneMalloc( sizeof( download_list_t ) );
dl->filename = ZoneCopyString( cls.download.name );
dl->next = cls.download.list;
cls.download.list = dl;
}
if( cl_downloads_from_web->integer && allow_localhttpdownload && url && url[0] != 0 ) {
cls.download.web = qtrue;
Com_Printf( "Web download: %s from %s%s\n", cls.download.tempname, cls.httpbaseurl, url );
}
else if( cl_downloads_from_web->integer && url && url[0] != 0 ) {
cls.download.web = qtrue;
Com_Printf( "Web download: %s from %s\n", cls.download.tempname, url );
}
else {
Com_Printf( "Server download: %s\n", cls.download.tempname );
}
cls.download.baseoffset = cls.download.offset = FS_FOpenBaseFile( cls.download.tempname, &cls.download.filenum, FS_APPEND );
if( !cls.download.filenum )
{
Com_Printf( "Can't download, couldn't open %s for writing\n", cls.download.tempname );
Mem_ZoneFree( cls.download.name );
cls.download.name = NULL;
Mem_ZoneFree( cls.download.tempname );
cls.download.tempname = NULL;
cls.download.filenum = 0;
cls.download.offset = 0;
cls.download.size = 0;
CL_DownloadDone();
return;
}
if( cls.download.web ) {
char *referer, *fullurl;
const char *headers[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
alloc_size = strlen( APP_URI_SCHEME ) + strlen( NET_AddressToString( &cls.serveraddress ) ) + 1;
referer = Mem_ZoneMalloc( alloc_size );
Q_snprintfz( referer, alloc_size, APP_URI_SCHEME "%s", NET_AddressToString( &cls.serveraddress ) );
Q_strlwr( referer );
if( allow_localhttpdownload ) {
alloc_size = strlen( cls.httpbaseurl ) + 1 + strlen( url ) + 1;
fullurl = Mem_ZoneMalloc( alloc_size );
Q_snprintfz( fullurl, alloc_size, "%s/%s", cls.httpbaseurl, url );
}
else {
size_t url_len = strlen( url );
alloc_size = url_len + 1 + strlen( filename ) * 3 + 1;
fullurl = Mem_ZoneMalloc( alloc_size );
Q_snprintfz( fullurl, alloc_size, "%s/", url );
Q_urlencode_unsafechars( filename, fullurl + url_len + 1, alloc_size - url_len - 1 );
}
headers[0] = "Referer";
headers[1] = referer;
CL_AddSessionHttpRequestHeaders( fullurl, &headers[2] );
CL_AsyncStreamRequest( fullurl, headers, cl_downloads_from_web_timeout->integer / 100, cls.download.offset,
CL_WebDownloadReadCb, CL_WebDownloadDoneCb, NULL, NULL, qfalse );
Mem_ZoneFree( fullurl );
Mem_ZoneFree( referer );
return;
}
// have to use Sys_Milliseconds because cls.realtime might be old from Web_Get
cls.download.timeout = Sys_Milliseconds() + 3000;
cls.download.retries = 0;
CL_AddReliableCommand( va( "nextdl \"%s\" %i", cls.download.name, cls.download.offset ) );
}
/*
=================
UI_RecDemo_GetDemoList
=================
*/
static void UI_RecDemo_GetDemoList( void )
{
char comment[256];
char **filenames;
int i = 0, j, numFiles;
filenames = FS_SEARCH( "demos/*.dem", &numFiles, TRUE );
if ( CL_IsActive () && !gpGlobals->demorecording && !gpGlobals->demoplayback )
{
char maxClients[32];
sprintf( maxClients, "%i", gpGlobals->maxClients );
// create new entry for current save game
strncpy( uiRecDemo.demoName[i], "new", CS_SIZE );
StringConcat( uiRecDemo.demoDescription[i], gpGlobals->maptitle, TITLE_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, TITLE_LENGTH ); // fill remaining entries
StringConcat( uiRecDemo.demoDescription[i], "New Demo", MAPNAME_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, MAPNAME_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], maxClients, MAXCLIENTS_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, MAXCLIENTS_LENGTH );
uiRecDemo.demoDescriptionPtr[i] = uiRecDemo.demoDescription[i];
i++;
}
for( j = 0; j < numFiles; i++, j++ )
{
if( i >= UI_MAXGAMES ) break;
if( !GET_DEMO_COMMENT( filenames[j], comment ))
{
if( strlen( comment ))
{
// get name string even if not found - C:_GetComment can be mark demos
// as <CORRUPTED> <OLD VERSION> etc
// get name string even if not found - SV_GetComment can be mark saves
// as <CORRUPTED> <OLD VERSION> etc
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, TITLE_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], comment, MAPNAME_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, MAXCLIENTS_LENGTH );
uiRecDemo.demoDescriptionPtr[i] = uiRecDemo.demoDescription[i];
COM_FileBase( filenames[j], uiRecDemo.demoName[i] );
COM_FileBase( filenames[j], uiRecDemo.delName[i] );
}
else uiRecDemo.demoDescriptionPtr[i] = NULL;
continue;
}
// strip path, leave only filename (empty slots doesn't have demoname)
COM_FileBase( filenames[j], uiRecDemo.demoName[i] );
COM_FileBase( filenames[j], uiRecDemo.delName[i] );
// fill demo desc
StringConcat( uiRecDemo.demoDescription[i], comment + CS_SIZE, TITLE_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, TITLE_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], comment, MAPNAME_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, MAPNAME_LENGTH ); // fill remaining entries
StringConcat( uiRecDemo.demoDescription[i], comment + CS_SIZE * 2, MAXCLIENTS_LENGTH );
StringConcat( uiRecDemo.demoDescription[i], uiEmptyString, MAXCLIENTS_LENGTH );
uiRecDemo.demoDescriptionPtr[i] = uiRecDemo.demoDescription[i];
}
for ( ; i < UI_MAXGAMES; i++ )
uiRecDemo.demoDescriptionPtr[i] = NULL;
uiRecDemo.demosList.itemNames = (const char **)uiRecDemo.demoDescriptionPtr;
if( strlen( uiRecDemo.demoName[0] ) == 0 || !CL_IsActive () || gpGlobals->demoplayback )
uiRecDemo.record.generic.flags |= QMF_GRAYED;
else uiRecDemo.record.generic.flags &= ~QMF_GRAYED;
if( strlen( uiRecDemo.delName[0] ) == 0 || !stricmp( gpGlobals->demoname, uiRecDemo.delName[uiRecDemo.demosList.curItem] ))
uiRecDemo.remove.generic.flags |= QMF_GRAYED;
else uiRecDemo.remove.generic.flags &= ~QMF_GRAYED;
}
/*
==================
Mod_LoadModel
Loads a model into the cache
==================
*/
model_t *Mod_LoadModel (model_t *mod, qboolean crash)
{
unsigned *buf;
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Deferring allocation. Stack in this device is pretty small:
//byte stackbuf[1024]; // avoid dirtying the cache heap
byte* stackbuf; // avoid dirtying the cache heap
// <<< FIX
if (mod->type == mod_alias)
{
if (Cache_Check (&mod->cache))
{
mod->needload = NL_PRESENT;
return mod;
}
}
else
{
if (mod->needload == NL_PRESENT)
return mod;
}
//
// because the world is so huge, load it one piece at a time
//
//
// load the file
//
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Allocating for previous fixes (and, this time, expanding the allocated size), in big stack:
stackbuf = Sys_BigStackAlloc(4096 * sizeof(byte), "Mod_LoadModel");
// <<< FIX
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Adjusting for previous fix:
//buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf));
buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, 4096);
// <<< FIX
if (!buf)
{
if (crash)
Sys_Error ("Mod_NumForName: %s not found", mod->name);
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Deallocating from previous fixes:
Sys_BigStackFree(4096 * sizeof(byte), "Mod_LoadModel");
// <<< FIX
return NULL;
}
//
// allocate a new model
//
COM_FileBase (mod->name, loadname);
loadmodel = mod;
//
// fill it in
//
// call the apropriate loader
mod->needload = NL_PRESENT;
switch (LittleLong(*(unsigned *)buf))
{
case IDPOLYHEADER:
Mod_LoadAliasModel (mod, buf);
break;
case IDSPRITEHEADER:
Mod_LoadSpriteModel (mod, buf);
break;
default:
Mod_LoadBrushModel (mod, buf);
break;
}
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Deallocating from previous fixes:
Sys_BigStackFree(4096 * sizeof(byte), "Mod_LoadModel");
// <<< FIX
return mod;
}
/*
* TV_Upstream_ParseConfigstringCommand_f
*/
static void TV_Upstream_HandleConfigstring( upstream_t *upstream, int index, const char *val )
{
char hostname[MAX_CONFIGSTRING_CHARS];
msg_t msg;
qbyte msgbuf[MAX_MSGLEN];
if( !val || !val[0] )
return;
if( index < 0 || index >= MAX_CONFIGSTRINGS )
TV_Upstream_Error( upstream, "configstring > MAX_CONFIGSTRINGS" );
Q_strncpyz( upstream->configstrings[index], val, sizeof( upstream->configstrings[index] ) );
if( index == CS_AUTORECORDSTATE )
{
// don't do a thing until we receive a "precache" command
if( upstream->precacheDone )
TV_Upstream_AutoRecordAction( upstream, upstream->configstrings[CS_AUTORECORDSTATE] );
return;
}
if( index != CS_HOSTNAME )
return;
if( !upstream->demo.playing )
{
TV_Upstream_SetName( upstream, val );
return;
}
// demos often come with generic hostnames, attempt to workaround that
if( !Q_stricmp( val, APPLICATION " server" ) )
{
char *temp;
size_t temp_size;
const char *filebase;
filebase = COM_FileBase( upstream->demo.filename );
temp_size = strlen( filebase ) + strlen( APP_DEMO_EXTENSION_STR ) + 1;
temp = Mem_TempMalloc( temp_size );
Q_strncpyz( temp, filebase, temp_size );
COM_ReplaceExtension( temp, APP_DEMO_EXTENSION_STR, temp_size );
if( Com_GlobMatch( "*_auto[0-9][0-9][0-9][0-9]" APP_DEMO_EXTENSION_STR, temp, qfalse )
|| Com_GlobMatch( "*_mvd" APP_DEMO_EXTENSION_STR, temp, qfalse ) )
temp[strrchr( temp, '_' ) - temp] = '\0';
else
COM_StripExtension( temp );
Q_strncpyz( hostname, va( S_COLOR_ORANGE "R: " S_COLOR_WHITE "%s", temp ), sizeof( hostname ) );
Mem_TempFree( temp );
}
else
{
Q_strncpyz( hostname, va( S_COLOR_ORANGE "R: " S_COLOR_WHITE "%s", val ), sizeof( hostname ) );
}
TV_Upstream_SetName( upstream, hostname );
// override CS_HOSTNAME in next packet
MSG_Init( &msg, msgbuf, sizeof( msgbuf ) );
MSG_WriteByte( &msg, svc_servercs );
MSG_WriteString( &msg, va( "cs %i \"%s\"", CS_HOSTNAME, hostname ) );
TV_Upstream_SavePacket( upstream, &msg, 0 );
}
/*
==================
Mod_LoadModel
Loads a model into the cache
==================
*/
model_t *Mod_LoadModel (model_t *mod, qboolean crash)
{
void *d;
unsigned *buf;
byte stackbuf[1024]; // avoid dirtying the cache heap
if (!mod->needload)
{
if (mod->type == mod_alias)
{
d = Cache_Check (&mod->cache);
if (d)
return mod;
}
else
return mod; // not cached at all
}
//
// because the world is so huge, load it one piece at a time
//
if (!crash)
{
}
//
// load the file
//
buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf));
if (!buf)
{
if (crash)
Sys_Error ("Mod_NumForName: %s not found", mod->name);
return NULL;
}
//
// allocate a new model
//
COM_FileBase (mod->name, loadname);
loadmodel = mod;
//
// fill it in
//
// call the apropriate loader
mod->needload = false;
switch (LittleLong(*(unsigned *)buf))
{
case IDPOLYHEADER:
Mod_LoadAliasModel (mod, buf);
break;
case IDSPRITEHEADER:
Mod_LoadSpriteModel (mod, buf);
break;
default:
Mod_LoadBrushModel (mod, buf);
break;
}
return mod;
}
static void UI_TouchOptions_GetProfileList( void )
{
char **filenames;
int i = 0, numFiles, j = 0;
char *curprofile;
strncpy( uiTouchOptions.profileDesc[i], "Presets:", CS_SIZE );
uiTouchOptions.profileDescPtr[i] = uiTouchOptions.profileDesc[i];
i++;
filenames = FS_SEARCH( "touch_presets/*.cfg", &numFiles, TRUE );
for ( ; j < numFiles; i++, j++ )
{
if( i >= UI_MAXGAMES ) break;
// strip path, leave only filename (empty slots doesn't have savename)
COM_FileBase( filenames[j], uiTouchOptions.profileDesc[i] );
uiTouchOptions.profileDescPtr[i] = uiTouchOptions.profileDesc[i];
}
// Overwrite "Presets:" line if there is no presets
if( i == 1 )
i = 0;
filenames = FS_SEARCH( "touch_profiles/*.cfg", &numFiles, TRUE );
j = 0;
curprofile = CVAR_GET_STRING("touch_config_file");
strncpy( uiTouchOptions.profileDesc[i], "Profiles:", CS_SIZE );
uiTouchOptions.profileDescPtr[i] = uiTouchOptions.profileDesc[i];
i++;
strncpy( uiTouchOptions.profileDesc[i], "default", CS_SIZE );
uiTouchOptions.profileDescPtr[i] = uiTouchOptions.profileDesc[i];
uiTouchOptions.profiles.highlight = i;
uiTouchOptions.firstProfile = i;
i++;
for ( ; j < numFiles; i++, j++ )
{
if( i >= UI_MAXGAMES ) break;
COM_FileBase( filenames[j], uiTouchOptions.profileDesc[i] );
uiTouchOptions.profileDescPtr[i] = uiTouchOptions.profileDesc[i];
if( !strcmp( filenames[j], curprofile ) )
uiTouchOptions.profiles.highlight = i;
}
uiTouchOptions.profiles.numItems = i;
uiTouchOptions.remove.generic.flags |= QMF_GRAYED;
uiTouchOptions.apply.generic.flags |= QMF_GRAYED;
if( uiTouchOptions.profiles.generic.charHeight )
{
uiTouchOptions.profiles.numRows = (uiTouchOptions.profiles.generic.height2 / uiTouchOptions.profiles.generic.charHeight) - 2;
if( uiTouchOptions.profiles.numRows > uiTouchOptions.profiles.numItems )
uiTouchOptions.profiles.numRows = i;
}
for ( ; i < UI_MAXGAMES; i++ )
uiTouchOptions.profileDescPtr[i] = NULL;
uiTouchOptions.profiles.curItem = uiTouchOptions.profiles.highlight;
uiTouchOptions.profiles.itemNames = (const char **)uiTouchOptions.profileDescPtr;
}
