YGGverse
/
xash3d-fwgs
mirror of https://github.com/YGGverse/xash3d-fwgs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

filesystem: implement directory entries caching, to avoid excessive directory listing syscalls to emulate case-insensitive filesystems 

* simplify game directory initialization code
pull/2/head
Alibek Omarov 2 years ago
parent
e1ea3387ee
commit
3393e2d95c
6 changed files with 439 additions and 220 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 329
      filesystem/dir.c
  2. 245
      filesystem/filesystem.c
  3. 21
      filesystem/filesystem_internal.h
  4. 19
      filesystem/pak.c
  5. 10
      filesystem/wad.c
  6. 17
      filesystem/zip.c

329
filesystem/dir.c
Unescape View File

@ -1,5 +1,5 @@
/* /*
dir.c - directory operations dir.c - caseinsensitive directory operations
Copyright (C) 2022 Alibek Omarov, Velaron Copyright (C) 2022 Alibek Omarov, Velaron
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
@ -27,9 +27,309 @@ GNU General Public License for more details.
#include "xash3d_mathlib.h" #include "xash3d_mathlib.h"
#include "common/com_strings.h" #include "common/com_strings.h"
static void FS_Close_DIR( searchpath_t *search ) enum
{
DIRENTRY_EMPTY_DIRECTORY = 0, // don't care if it's not directory or it's empty
DIRENTRY_NOT_SCANNED = -1,
DIRENTRY_CASEINSENSITIVE = -2, // directory is already caseinsensitive, just copy whatever is left
};
typedef struct dir_s
{
string name;
int numentries;
struct dir_s *entries; // sorted
} dir_t;
static int FS_SortDir( const void *_a, const void *_b )
{
const dir_t *a = _a;
const dir_t *b = _b;
return Q_stricmp( a->name, b->name );
}
static void FS_FreeDirEntries( dir_t *dir )
{
if( dir->entries )
{
int i;
for( i = 0; i < dir->numentries; i++ )
FS_FreeDirEntries( &dir->entries[i] );
dir->entries = NULL;
}
dir->numentries = DIRENTRY_NOT_SCANNED;
}
static void FS_InitDirEntries( dir_t *dir, const stringlist_t *list )
{
int i;
if( !list->numstrings )
{
dir->numentries = DIRENTRY_EMPTY_DIRECTORY;
dir->entries = NULL;
return;
}
dir->numentries = list->numstrings;
dir->entries = Mem_Malloc( fs_mempool, sizeof( dir_t ) * dir->numentries );
for( i = 0; i < list->numstrings; i++ )
{
dir_t *entry = &dir->entries[i];
Q_strncpy( entry->name, list->strings[i], sizeof( entry->name ));
entry->numentries = DIRENTRY_NOT_SCANNED;
entry->entries = NULL;
}
qsort( dir->entries, dir->numentries, sizeof( dir->entries[0] ), FS_SortDir );
}
static void FS_PopulateDirEntries( dir_t *dir, const char *path )
{
#if XASH_WIN32 // Windows is always case insensitive
dir->numentries = DIRENTRY_CASEINSENSITIVE;
dir->entries = NULL;
#else
stringlist_t list;
if( !FS_SysFolderExists( path ))
{
dir->numentries = DIRENTRY_EMPTY_DIRECTORY;
dir->entries = NULL;
return;
}
stringlistinit( &list );
listdirectory( &list, path, false );
FS_InitDirEntries( dir, &list );
stringlistfreecontents( &list );
#endif
}
static int FS_FindDirEntry( dir_t *dir, const char *name )
{
int left, right;
if( dir->numentries < 0 )
return -1;
// look for the file (binary search)
left = 0;
right = dir->numentries - 1;
while( left <= right )
{
int middle = (left + right) / 2;
int diff;
diff = Q_stricmp( dir->entries[middle].name, name );
// found it
if( !diff )
return middle;
// if we're too far in the list
if( diff > 0 )
right = middle - 1;
else left = middle + 1;
}
return -1;
}
static void FS_MergeDirEntries( dir_t *dir, const stringlist_t *list )
{
int i;
dir_t temp;
FS_InitDirEntries( &temp, list );
// copy all entries that has the same name and has subentries
for( i = 0; i < dir->numentries; i++ )
{
int j;
// don't care about directories without subentries
if( dir->entries == NULL )
continue;
// try to find this directory in new tree
j = FS_FindDirEntry( &temp, dir->entries[i].name );
// not found, free memory
if( j < 0 )
{
FS_FreeDirEntries( &dir->entries[i] );
continue;
}
// found directory, move all entries
temp.entries[j].numentries = dir->entries[j].numentries;
temp.entries[j].entries = dir->entries[j].entries;
}
// now we can free old tree and replace it with temporary
Mem_Free( dir->entries );
dir->numentries = temp.numentries;
dir->entries = temp.entries;
}
static int FS_MaybeUpdateDirEntries( dir_t *dir, const char *path, const char *entryname )
{
stringlist_t list;
qboolean update = false;
int idx;
stringlistinit( &list );
listdirectory( &list, path, false );
// find the reason to update entries list
if( list.numstrings != dir->numentries )
{
// small optimization to not search string in the list
// and directly go updating entries
update = true;
}
else
{
for( idx = 0; idx < list.numstrings; idx++ )
{
if( !Q_stricmp( list.strings[idx], entryname ))
{
update = true;
break;
}
}
}
if( !update )
{
stringlistfreecontents( &list );
return -1;
}
FS_MergeDirEntries( dir, &list );
stringlistfreecontents( &list );
return FS_FindDirEntry( dir, entryname );
}
qboolean FS_FixFileCase( dir_t *dir, const char *path, char *dst, size_t len, qboolean createpath )
{ {
const char *prev = path;
const char *next = Q_strchrnul( prev, PATH_SEPARATOR );
size_t i = Q_strlen( dst ); // dst is expected to have searchpath filename
while( true )
{
char entryname[MAX_SYSPATH];
int ret;
// this subdirectory is case insensitive, just slam everything that's left
if( dir->numentries == DIRENTRY_CASEINSENSITIVE )
{
i += Q_strncpy( &dst[i], prev, len - i );
if( i >= len )
{
Con_Printf( "%s: overflow while searching %s (caseinsensitive entry)\n", __FUNCTION__, path );
return false;
}
}
// populate cache if needed
if( dir->numentries == DIRENTRY_NOT_SCANNED )
FS_PopulateDirEntries( dir, dst );
// get our entry name
Q_strncpy( entryname, prev, next - prev + 1 );
ret = FS_FindDirEntry( dir, entryname );
// didn't found, but does it exists in FS?
if( ret < 0 )
{
ret = FS_MaybeUpdateDirEntries( dir, dst, entryname );
if( ret < 0 )
{
// if we're creating files or folders, we don't care if path doesn't exist
// so copy everything that's left and exit without an error
if( createpath )
{
i += Q_strncpy( &dst[i], prev, len - i );
if( i >= len )
{
Con_Printf( "%s: overflow while searching %s (create path)\n", __FUNCTION__, path );
return false;
}
return true;
}
return false;
}
}
dir = &dir->entries[ret];
ret = Q_strncpy( &dst[i], dir->name, len - i );
// file not found, rescan...
if( !FS_SysFileOrFolderExists( dst ))
{
// strip failed part
dst[i] = 0;
ret = FS_MaybeUpdateDirEntries( dir, dst, entryname );
// file not found, exit... =/
if( ret < 0 )
{
// if we're creating files or folders, we don't care if path doesn't exist
// so copy everything that's left and exit without an error
if( createpath )
{
i += Q_strncpy( &dst[i], prev, len - i );
if( i >= len )
{
Con_Printf( "%s: overflow while searching %s (create path 2)\n", __FUNCTION__, path );
return false;
}
return true;
}
return false;
}
dir = &dir->entries[ret];
ret = Q_strncpy( &dst[i], dir->name, len - i );
}
i += ret;
if( i >= len ) // overflow!
{
Con_Printf( "%s: overflow while searching %s (appending fixed file name)\n", __FUNCTION__, path );
return false;
}
// end of string, found file, return
if( next[0] == '\0' )
break;
// move pointer one character forward, find next path split character
prev = next + 1;
next = Q_strchrnul( prev, PATH_SEPARATOR );
i += Q_strncpy( &dst[i], PATH_SEPARATOR_STR, len - i );
if( i >= len ) // overflow!
{
Con_Printf( "%s: overflow while searching %s (path separator)\n", __FUNCTION__, path );
return false;
}
}
return true;
}
static void FS_Close_DIR( searchpath_t *search )
{
FS_FreeDirEntries( search->dir );
Mem_Free( search->dir );
} }
static void FS_PrintInfo_DIR( searchpath_t *search, char *dst, size_t size ) static void FS_PrintInfo_DIR( searchpath_t *search, char *dst, size_t size )
@ -37,14 +337,21 @@ static void FS_PrintInfo_DIR( searchpath_t *search, char *dst, size_t size )
Q_strncpy( dst, search->filename, size ); Q_strncpy( dst, search->filename, size );
} }
static int FS_FindFile_DIR( searchpath_t *search, const char *path ) static int FS_FindFile_DIR( searchpath_t *search, const char *path, char *fixedname, size_t len )
{ {
char netpath[MAX_SYSPATH]; char netpath[MAX_SYSPATH];
Q_snprintf( netpath, sizeof( netpath ), "%s%s", search->filename, path ); Q_strncpy( netpath, search->filename, sizeof( netpath ));
if( !FS_FixFileCase( search->dir, path, netpath, sizeof( netpath ), false ))
return -1;
if( FS_SysFileExists( netpath, !( search->flags & FS_CUSTOM_PATH ) ) ) if( FS_SysFileExists( netpath, !FBitSet( search->flags, FS_CUSTOM_PATH )))
{
// return fixed case file name only local for that searchpath
if( fixedname )
Q_strncpy( fixedname, netpath + Q_strlen( search->filename ), len );
return 0; return 0;
}
return -1; return -1;
} }
@ -100,6 +407,7 @@ static void FS_Search_DIR( searchpath_t *search, stringlist_t *list, const char
static int FS_FileTime_DIR( searchpath_t *search, const char *filename ) static int FS_FileTime_DIR( searchpath_t *search, const char *filename )
{ {
int time;
char path[MAX_SYSPATH]; char path[MAX_SYSPATH];
Q_snprintf( path, sizeof( path ), "%s%s", search->filename, filename ); Q_snprintf( path, sizeof( path ), "%s%s", search->filename, filename );
@ -127,9 +435,14 @@ void FS_InitDirectorySearchpath( searchpath_t *search, const char *path, int fla
search->pfnFileTime = FS_FileTime_DIR; search->pfnFileTime = FS_FileTime_DIR;
search->pfnFindFile = FS_FindFile_DIR; search->pfnFindFile = FS_FindFile_DIR;
search->pfnSearch = FS_Search_DIR; search->pfnSearch = FS_Search_DIR;
// create cache root
search->dir = Mem_Malloc( fs_mempool, sizeof( dir_t ));
search->dir->name[0] = 0; // root has no filename, unused
FS_PopulateDirEntries( search->dir, path );
} }
qboolean FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int flags ) searchpath_t *FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int flags )
{ {
searchpath_t *search; searchpath_t *search;
@ -139,7 +452,7 @@ qboolean FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int fla
{ {
if( already_loaded ) if( already_loaded )
*already_loaded = true; *already_loaded = true;
return true; return search;
} }
} }
@ -154,5 +467,5 @@ qboolean FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int fla
Con_Printf( "Adding directory: %s\n", path ); Con_Printf( "Adding directory: %s\n", path );
return true; return search;
} }

245
filesystem/filesystem.c
Unescape View File

@ -51,8 +51,8 @@ searchpath_t *fs_searchpaths = NULL; // chain
char fs_rodir[MAX_SYSPATH]; char fs_rodir[MAX_SYSPATH];
char fs_rootdir[MAX_SYSPATH]; char fs_rootdir[MAX_SYSPATH];
char fs_writedir[MAX_SYSPATH]; // path that game allows to overwrite, delete and rename files (and create new of course) char fs_writedir[MAX_SYSPATH]; // path that game allows to overwrite, delete and rename files (and create new of course)
searchpath_t *fs_writepath;
static searchpath_t fs_directpath; // static direct path
static char fs_basedir[MAX_SYSPATH]; // base game directory static char fs_basedir[MAX_SYSPATH]; // base game directory
static char fs_gamedir[MAX_SYSPATH]; // game current directory static char fs_gamedir[MAX_SYSPATH]; // game current directory
#if !XASH_WIN32 #if !XASH_WIN32
@ -160,7 +160,7 @@ void stringlistappend( stringlist_t *list, char *text )
list->numstrings++; list->numstrings++;
} }
static void stringlistsort( stringlist_t *list ) void stringlistsort( stringlist_t *list )
{ {
char *temp; char *temp;
int i, j; int i, j;
@ -243,109 +243,6 @@ OTHER PRIVATE FUNCTIONS
============================================================================= =============================================================================
*/ */
/*
==================
FS_FixFileCase
emulate WIN32 FS behaviour when opening local file
==================
*/
const char *FS_FixFileCase( const char *path )
{
#if defined __DOS__ & !defined __WATCOM_LFN__
// not fix, but convert to 8.3 CAPS and rotate slashes
// it is still recommended to package game data
static char out[PATH_MAX];
int i = 0;
int last = 0;
while(*path)
{
char c = *path++;
if(c == '/') c = '\\';
else c = toupper(c);
out[i++] = c;
if(c == '\\' || c == '.')
{
if( i - last > 8 )
{
char *l = &out[last];
l[6] = '~';
l[7] = '1';
l[8] = c;
i = last + 9;
}
last = i;
}
}
out[i] = 0;
return out;
#elif !XASH_WIN32 && !XASH_IOS // assume case insensitive
DIR *dir;
struct dirent *entry;
char dirpath[PATH_MAX], *filename;
static char fixedpath[PATH_MAX];
if( !fs_caseinsensitive )
return path;
if( path[0] != '/' )
Q_snprintf( dirpath, sizeof( dirpath ), "./%s", path );
else Q_strncpy( dirpath, path, PATH_MAX );
filename = Q_strrchr( dirpath, '/' );
if( filename )
*filename++ = '\0';
else
{
filename = (char*)path;
Q_strcpy( dirpath, ".");
}
/* android has too slow directory scanning,
so drop out some not useful cases */
if( filename - dirpath > 4 )
{
char *point;
// too many wad textures
if( !Q_stricmp( filename - 5, ".wad") )
return path;
point = Q_strchr( filename, '.' );
if( point )
{
if( !Q_strcmp( point, ".mip") || !Q_strcmp( point, ".dds" ) || !Q_strcmp( point, ".ent" ) )
return path;
if( filename[0] == '{' )
return path;
}
}
//Con_Reportf( "FS_FixFileCase: %s\n", path );
if( !( dir = opendir( dirpath ) ) )
return path;
while( ( entry = readdir( dir ) ) )
{
if( Q_stricmp( entry->d_name, filename ) )
continue;
Q_snprintf( fixedpath, sizeof( fixedpath ), "%s/%s", dirpath, entry->d_name );
//Con_Reportf( "FS_FixFileCase: %s %s %s\n", dirpath, filename, entry->d_name );
path = fixedpath;
break;
}
closedir( dir );
#endif
return path;
}
#if XASH_WIN32 #if XASH_WIN32
/* /*
==================== ====================
@ -397,7 +294,7 @@ static qboolean FS_AddArchive_Fullpath( const char *file, qboolean *already_load
{ {
const char *ext = COM_FileExtension( file ); const char *ext = COM_FileExtension( file );
if( !Q_stricmp( ext, "pk3" ) ) if( !Q_stricmp( ext, "pk3" ))
return FS_AddZip_Fullpath( file, already_loaded, flags ); return FS_AddZip_Fullpath( file, already_loaded, flags );
else if ( !Q_stricmp( ext, "pak" )) else if ( !Q_stricmp( ext, "pak" ))
return FS_AddPak_Fullpath( file, already_loaded, flags ); return FS_AddPak_Fullpath( file, already_loaded, flags );
@ -418,11 +315,9 @@ void FS_AddGameDirectory( const char *dir, uint flags )
{ {
stringlist_t list; stringlist_t list;
searchpath_t *search; searchpath_t *search;
string fullpath; char fullpath[MAX_SYSPATH];
int i; int i;
if( !FBitSet( flags, FS_NOWRITE_PATH ))
Q_strncpy( fs_writedir, dir, sizeof( fs_writedir ));
stringlistinit( &list ); stringlistinit( &list );
listdirectory( &list, dir, false ); listdirectory( &list, dir, false );
stringlistsort( &list ); stringlistsort( &list );
@ -430,41 +325,36 @@ void FS_AddGameDirectory( const char *dir, uint flags )
// add any PAK package in the directory // add any PAK package in the directory
for( i = 0; i < list.numstrings; i++ ) for( i = 0; i < list.numstrings; i++ )
{ {
if( !Q_stricmp( COM_FileExtension( list.strings[i] ), "pak" )) const char *ext = COM_FileExtension( list.strings[i] );
if( !Q_stricmp( ext, "pak" ))
{ {
Q_sprintf( fullpath, "%s%s", dir, list.strings[i] ); Q_snprintf( fullpath, sizeof( fullpath ), "%s%s", dir, list.strings[i] );
FS_AddPak_Fullpath( fullpath, NULL, flags ); FS_AddPak_Fullpath( fullpath, NULL, flags );
} }
} else if( !Q_stricmp( ext, "pk3" ))
// add any Zip package in the directory
for( i = 0; i < list.numstrings; i++ )
{
if( !Q_stricmp( COM_FileExtension( list.strings[i] ), "pk3" ) )
{ {
Q_sprintf( fullpath, "%s%s", dir, list.strings[i] ); Q_snprintf( fullpath, sizeof( fullpath ), "%s%s", dir, list.strings[i] );
FS_AddZip_Fullpath( fullpath, NULL, flags ); FS_AddZip_Fullpath( fullpath, NULL, flags );
} }
} else if( !Q_stricmp( ext, "wad" ))
FS_AllowDirectPaths( true );
// add any WAD package in the directory
for( i = 0; i < list.numstrings; i++ )
{
if( !Q_stricmp( COM_FileExtension( list.strings[i] ), "wad" ))
{ {
Q_sprintf( fullpath, "%s%s", dir, list.strings[i] ); FS_AllowDirectPaths( true );
Q_snprintf( fullpath, sizeof( fullpath ), "%s%s", dir, list.strings[i] );
FS_AddWad_Fullpath( fullpath, NULL, flags ); FS_AddWad_Fullpath( fullpath, NULL, flags );
FS_AllowDirectPaths( false );
} }
} }
stringlistfreecontents( &list ); stringlistfreecontents( &list );
FS_AllowDirectPaths( false );
// add the directory to the search path // add the directory to the search path
// (unpacked files have the priority over packed files) // (unpacked files have the priority over packed files)
FS_AddDir_Fullpath( dir, NULL, flags ); search = FS_AddDir_Fullpath( dir, NULL, flags );
if( !FBitSet( flags, FS_NOWRITE_PATH ))
{
Q_strncpy( fs_writedir, dir, sizeof( fs_writedir ));
fs_writepath = search;
}
} }
/* /*
@ -929,7 +819,7 @@ void FS_ParseGenericGameInfo( gameinfo_t *GameInfo, const char *buf, const qbool
} }
// make sure what gamedir is really exist // make sure what gamedir is really exist
if( !FS_SysFolderExists( va( "%s"PATH_SPLITTER"%s", fs_rootdir, GameInfo->falldir ))) if( !FS_SysFolderExists( va( "%s" PATH_SEPARATOR_STR "%s", fs_rootdir, GameInfo->falldir )))
GameInfo->falldir[0] = '\0'; GameInfo->falldir[0] = '\0';
} }
@ -1302,7 +1192,7 @@ static qboolean FS_FindLibrary( const char *dllname, qboolean directpath, fs_dll
COM_DefaultExtension( dllInfo->shortPath, "."OS_LIB_EXT ); // apply ext if forget COM_DefaultExtension( dllInfo->shortPath, "."OS_LIB_EXT ); // apply ext if forget
search = FS_FindFile( dllInfo->shortPath, &index, false ); search = FS_FindFile( dllInfo->shortPath, &index, NULL, 0, false );
if( !search && !directpath ) if( !search && !directpath )
{ {
@ -1310,7 +1200,7 @@ static qboolean FS_FindLibrary( const char *dllname, qboolean directpath, fs_dll
// trying check also 'bin' folder for indirect paths // trying check also 'bin' folder for indirect paths
Q_strncpy( dllInfo->shortPath, dllname, sizeof( dllInfo->shortPath )); Q_strncpy( dllInfo->shortPath, dllname, sizeof( dllInfo->shortPath ));
search = FS_FindFile( dllInfo->shortPath, &index, false ); search = FS_FindFile( dllInfo->shortPath, &index, NULL, 0, false );
if( !search ) return false; // unable to find if( !search ) return false; // unable to find
} }
@ -1433,8 +1323,11 @@ qboolean FS_InitStdio( qboolean caseinsensitive, const char *rootdir, const char
for( i = 0; i < dirs.numstrings; i++ ) for( i = 0; i < dirs.numstrings; i++ )
{ {
char *roPath = va( "%s" PATH_SPLITTER "%s" PATH_SPLITTER, fs_rodir, dirs.strings[i] ); char roPath[MAX_SYSPATH];
char *rwPath = va( "%s" PATH_SPLITTER "%s" PATH_SPLITTER, fs_rootdir, dirs.strings[i] ); char rwPath[MAX_SYSPATH];
Q_snprintf( roPath, sizeof( roPath ), "%s" PATH_SEPARATOR_STR "%s" PATH_SEPARATOR_STR, fs_rodir, dirs.strings[i] );
Q_snprintf( rwPath, sizeof( rwPath ), "%s" PATH_SEPARATOR_STR "%s" PATH_SEPARATOR_STR, fs_rootdir, dirs.strings[i] );
// check if it's a directory // check if it's a directory
if( !FS_SysFolderExists( roPath )) if( !FS_SysFolderExists( roPath ))
@ -1468,6 +1361,8 @@ qboolean FS_InitStdio( qboolean caseinsensitive, const char *rootdir, const char
} }
// build list of game directories here // build list of game directories here
if( COM_CheckStringEmpty( fs_rodir ))
FS_AddGameDirectory( va( "%s/", fs_rodir ), FS_STATIC_PATH|FS_NOWRITE_PATH );
FS_AddGameDirectory( "./", FS_STATIC_PATH ); FS_AddGameDirectory( "./", FS_STATIC_PATH );
for( i = 0; i < dirs.numstrings; i++ ) for( i = 0; i < dirs.numstrings; i++ )
@ -1620,14 +1515,6 @@ file_t *FS_SysOpen( const char *filepath, const char *mode )
#if !XASH_WIN32 #if !XASH_WIN32
if( file->handle < 0 ) if( file->handle < 0 )
{
const char *ffilepath = FS_FixFileCase( filepath );
if( ffilepath != filepath )
file->handle = open( ffilepath, mod|opt, 0666 );
if( file->handle >= 0 )
FS_BackupFileName( file, ffilepath, mod|opt );
}
else
FS_BackupFileName( file, filepath, mod|opt ); FS_BackupFileName( file, filepath, mod|opt );
#endif #endif
@ -1717,14 +1604,6 @@ qboolean FS_SysFileExists( const char *path, qboolean caseinsensitive )
ret = stat( path, &buf ); ret = stat( path, &buf );
// speedup custom path search
if( caseinsensitive && ( ret < 0 ) )
{
const char *fpath = FS_FixFileCase( path );
if( fpath != path )
ret = stat( fpath, &buf );
}
if( ret < 0 ) if( ret < 0 )
return false; return false;
@ -1777,6 +1656,26 @@ qboolean FS_SysFolderExists( const char *path )
#endif #endif
} }
/*
==============
FS_SysFileOrFolderExists
Check if filesystem entry exists at all, don't mind the type
==============
*/
qboolean FS_SysFileOrFolderExists( const char *path )
{
#if XASH_WIN32
return GetFileAttributes( path ) != -1;
#elif XASH_POSIX
struct stat buf;
return stat( path, &buf ) >= 0;
#else
#error
#endif
}
/* /*
==================== ====================
FS_FindFile FS_FindFile
@ -1787,7 +1686,7 @@ Return the searchpath where the file was found (or NULL)
and the file index in the package if relevant and the file index in the package if relevant
==================== ====================
*/ */
searchpath_t *FS_FindFile( const char *name, int *index, qboolean gamedironly ) searchpath_t *FS_FindFile( const char *name, int *index, char *fixedname, size_t len, qboolean gamedironly )
{ {
searchpath_t *search; searchpath_t *search;
@ -1799,7 +1698,7 @@ searchpath_t *FS_FindFile( const char *name, int *index, qboolean gamedironly )
if( gamedironly & !FBitSet( search->flags, FS_GAMEDIRONLY_SEARCH_FLAGS )) if( gamedironly & !FBitSet( search->flags, FS_GAMEDIRONLY_SEARCH_FLAGS ))
continue; continue;
pack_ind = search->pfnFindFile( search, name ); pack_ind = search->pfnFindFile( search, name, fixedname, len );
if( pack_ind >= 0 ) if( pack_ind >= 0 )
{ {
if( index ) *index = pack_ind; if( index ) *index = pack_ind;
@ -1811,14 +1710,25 @@ searchpath_t *FS_FindFile( const char *name, int *index, qboolean gamedironly )
{ {
char netpath[MAX_SYSPATH], dirpath[MAX_SYSPATH]; char netpath[MAX_SYSPATH], dirpath[MAX_SYSPATH];
Q_snprintf( dirpath, sizeof( dirpath ), "%s" PATH_SPLITTER, fs_rootdir ); Q_snprintf( dirpath, sizeof( dirpath ), "%s" PATH_SEPARATOR_STR, fs_rootdir );
Q_snprintf( netpath, sizeof( netpath ), "%s%s", dirpath, name ); Q_snprintf( netpath, sizeof( netpath ), "%s%s", dirpath, name );
if( FS_SysFileExists( netpath, true )) if( FS_SysFileExists( netpath, true ))
{ {
static searchpath_t fs_directpath;
// clear old dir cache
if( fs_directpath.pfnClose )
fs_directpath.pfnClose( &fs_directpath );
// just copy the name, we don't do case sensitivity fix there
if( fixedname )
{
Q_strncpy( fixedname, name, len );
}
FS_InitDirectorySearchpath( &fs_directpath, dirpath, 0 ); FS_InitDirectorySearchpath( &fs_directpath, dirpath, 0 );
if( index != NULL ) if( index != NULL )
*index = -1; *index = 0;
return &fs_directpath; return &fs_directpath;
} }
} }
@ -1840,15 +1750,16 @@ Look for a file in the search paths and open it in read-only mode
file_t *FS_OpenReadFile( const char *filename, const char *mode, qboolean gamedironly ) file_t *FS_OpenReadFile( const char *filename, const char *mode, qboolean gamedironly )
{ {
searchpath_t *search; searchpath_t *search;
char netpath[MAX_SYSPATH];
int pack_ind; int pack_ind;
search = FS_FindFile( filename, &pack_ind, gamedironly ); search = FS_FindFile( filename, &pack_ind, netpath, sizeof( netpath ), gamedironly );
// not found? // not found?
if( search == NULL ) if( search == NULL )
return NULL; return NULL;
return search->pfnOpenFile( search, filename, mode, pack_ind ); return search->pfnOpenFile( search, netpath, mode, pack_ind );
} }
/* /*
@ -1884,7 +1795,7 @@ file_t *FS_Open( const char *filepath, const char *mode, qboolean gamedironly )
// open the file on disk directly // open the file on disk directly
Q_sprintf( real_path, "%s/%s", fs_writedir, filepath ); Q_sprintf( real_path, "%s/%s", fs_writedir, filepath );
FS_CreatePath( real_path );// Create directories up to the file FS_CreatePath( real_path ); // Create directories up to the file
return FS_SysOpen( real_path, mode ); return FS_SysOpen( real_path, mode );
} }
@ -2450,9 +2361,7 @@ Look for a file in the packages and in the filesystem
*/ */
int GAME_EXPORT FS_FileExists( const char *filename, int gamedironly ) int GAME_EXPORT FS_FileExists( const char *filename, int gamedironly )
{ {
if( FS_FindFile( filename, NULL, gamedironly )) return FS_FindFile( filename, NULL, NULL, 0, gamedironly ) != NULL;
return true;
return false;
} }
/* /*
@ -2465,15 +2374,16 @@ return NULL for file in pack
*/ */
const char *FS_GetDiskPath( const char *name, qboolean gamedironly ) const char *FS_GetDiskPath( const char *name, qboolean gamedironly )
{ {
static char temp[MAX_SYSPATH];
searchpath_t *search; searchpath_t *search;
search = FS_FindFile( name, NULL, gamedironly ); search = FS_FindFile( name, NULL, temp, sizeof( temp ), gamedironly );
if( search ) if( search )
{ {
if( search->type != SEARCHPATH_PLAIN ) // file in pack or wad if( search->type != SEARCHPATH_PLAIN ) // file in pack or wad
return NULL; return NULL;
return va( "%s%s", search->filename, name ); return temp;
} }
return NULL; return NULL;
@ -2527,12 +2437,13 @@ return time of creation file in seconds
int FS_FileTime( const char *filename, qboolean gamedironly ) int FS_FileTime( const char *filename, qboolean gamedironly )
{ {
searchpath_t *search; searchpath_t *search;
char netpath[MAX_SYSPATH];
int pack_ind; int pack_ind;
search = FS_FindFile( filename, &pack_ind, gamedironly ); search = FS_FindFile( filename, &pack_ind, netpath, sizeof( netpath ), gamedironly );
if( !search ) return -1; // doesn't exist if( !search ) return -1; // doesn't exist
return search->pfnFileTime( search, filename ); return search->pfnFileTime( search, netpath );
} }
/* /*
@ -2550,6 +2461,10 @@ qboolean FS_Rename( const char *oldname, const char *newname )
if( !oldname || !newname || !*oldname || !*newname ) if( !oldname || !newname || !*oldname || !*newname )
return false; return false;
// no work done
if( !Q_stricmp( oldname, newname ))
return true;
Q_snprintf( oldpath, sizeof( oldpath ), "%s%s", fs_writedir, oldname ); Q_snprintf( oldpath, sizeof( oldpath ), "%s%s", fs_writedir, oldname );
Q_snprintf( newpath, sizeof( newpath ), "%s%s", fs_writedir, newname ); Q_snprintf( newpath, sizeof( newpath ), "%s%s", fs_writedir, newname );

21
filesystem/filesystem_internal.h
Unescape View File

@ -24,6 +24,7 @@ extern "C"
{ {
#endif #endif
typedef struct dir_s dir_t;
typedef struct zip_s zip_t; typedef struct zip_s zip_t;
typedef struct pack_s pack_t; typedef struct pack_s pack_t;
typedef struct wfile_s wfile_t; typedef struct wfile_s wfile_t;
@ -72,6 +73,7 @@ typedef struct searchpath_s
union union
{ {
dir_t *dir;
pack_t *pack; pack_t *pack;
wfile_t *wad; wfile_t *wad;
zip_t *zip; zip_t *zip;
@ -83,7 +85,7 @@ typedef struct searchpath_s
void (*pfnClose)( struct searchpath_s *search ); void (*pfnClose)( struct searchpath_s *search );
file_t *(*pfnOpenFile)( struct searchpath_s *search, const char *filename, const char *mode, int pack_ind ); file_t *(*pfnOpenFile)( struct searchpath_s *search, const char *filename, const char *mode, int pack_ind );
int (*pfnFileTime)( struct searchpath_s *search, const char *filename ); int (*pfnFileTime)( struct searchpath_s *search, const char *filename );
int (*pfnFindFile)( struct searchpath_s *search, const char *path ); int (*pfnFindFile)( struct searchpath_s *search, const char *path, char *fixedname, size_t len );
void (*pfnSearch)( struct searchpath_s *search, stringlist_t *list, const char *pattern, int caseinsensitive ); void (*pfnSearch)( struct searchpath_s *search, stringlist_t *list, const char *pattern, int caseinsensitive );
} searchpath_t; } searchpath_t;
@ -157,6 +159,13 @@ qboolean FS_WriteFile( const char *filename, const void *data, fs_offset_t len )
qboolean CRC32_File( dword *crcvalue, const char *filename ); qboolean CRC32_File( dword *crcvalue, const char *filename );
qboolean MD5_HashFile( byte digest[16], const char *pszFileName, uint seed[4] ); qboolean MD5_HashFile( byte digest[16], const char *pszFileName, uint seed[4] );
// stringlist ops
void stringlistinit( stringlist_t *list );
void stringlistfreecontents( stringlist_t *list );
void stringlistappend( stringlist_t *list, char *text );
void stringlistsort( stringlist_t *list );
void listdirectory( stringlist_t *list, const char *path, qboolean lowercase );
// filesystem ops // filesystem ops
int FS_FileExists( const char *filename, int gamedironly ); int FS_FileExists( const char *filename, int gamedironly );
int FS_FileTime( const char *filename, qboolean gamedironly ); int FS_FileTime( const char *filename, qboolean gamedironly );
@ -165,19 +174,15 @@ qboolean FS_Rename( const char *oldname, const char *newname );
qboolean FS_Delete( const char *path ); qboolean FS_Delete( const char *path );
qboolean FS_SysFileExists( const char *path, qboolean casesensitive ); qboolean FS_SysFileExists( const char *path, qboolean casesensitive );
const char *FS_GetDiskPath( const char *name, qboolean gamedironly ); const char *FS_GetDiskPath( const char *name, qboolean gamedironly );
void stringlistinit( stringlist_t *list );
void stringlistfreecontents( stringlist_t *list );
void stringlistappend( stringlist_t *list, char *text );
void listdirectory( stringlist_t *list, const char *path, qboolean lowercase );
void FS_CreatePath( char *path ); void FS_CreatePath( char *path );
qboolean FS_SysFolderExists( const char *path ); qboolean FS_SysFolderExists( const char *path );
qboolean FS_SysFileOrFolderExists( const char *path );
file_t *FS_OpenReadFile( const char *filename, const char *mode, qboolean gamedironly ); file_t *FS_OpenReadFile( const char *filename, const char *mode, qboolean gamedironly );
int FS_SysFileTime( const char *filename ); int FS_SysFileTime( const char *filename );
file_t *FS_OpenHandle( const char *syspath, int handle, fs_offset_t offset, fs_offset_t len ); file_t *FS_OpenHandle( const char *syspath, int handle, fs_offset_t offset, fs_offset_t len );
file_t *FS_SysOpen( const char *filepath, const char *mode ); file_t *FS_SysOpen( const char *filepath, const char *mode );
const char *FS_FixFileCase( const char *path ); searchpath_t *FS_FindFile( const char *name, int *index, char *fixedname, size_t len, qboolean gamedironly );
searchpath_t *FS_FindFile( const char *name, int *index, qboolean gamedironly );
// //
// pak.c // pak.c
@ -206,7 +211,7 @@ qboolean FS_AddZip_Fullpath( const char *zipfile, qboolean *already_loaded, int
// //
// dir.c // dir.c
// //
qboolean FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int flags ); searchpath_t *FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int flags );
void FS_InitDirectorySearchpath( searchpath_t *search, const char *path, int flags ); void FS_InitDirectorySearchpath( searchpath_t *search, const char *path, int flags );
#ifdef __cplusplus #ifdef __cplusplus

19
filesystem/pak.c
Unescape View File

@ -104,15 +104,6 @@ static pack_t *FS_LoadPackPAK( const char *packfile, int *error )
packhandle = open( packfile, O_RDONLY|O_BINARY ); packhandle = open( packfile, O_RDONLY|O_BINARY );
#if !XASH_WIN32
if( packhandle < 0 )
{
const char *fpackfile = FS_FixFileCase( packfile );
if( fpackfile != packfile )
packhandle = open( fpackfile, O_RDONLY|O_BINARY );
}
#endif
if( packhandle < 0 ) if( packhandle < 0 )
{ {
Con_Reportf( "%s couldn't open: %s\n", packfile, strerror( errno )); Con_Reportf( "%s couldn't open: %s\n", packfile, strerror( errno ));
@ -210,7 +201,7 @@ FS_FindFile_PAK
=========== ===========
*/ */
static int FS_FindFile_PAK( searchpath_t *search, const char *path ) static int FS_FindFile_PAK( searchpath_t *search, const char *path, char *fixedname, size_t len )
{ {
int left, right, middle; int left, right, middle;
@ -227,6 +218,8 @@ static int FS_FindFile_PAK( searchpath_t *search, const char *path )
// Found it // Found it
if( !diff ) if( !diff )
{ {
if( fixedname )
Q_strncpy( fixedname, search->pack->files[middle].name, len );
return middle; return middle;
} }
@ -359,8 +352,6 @@ qboolean FS_AddPak_Fullpath( const char *pakfile, qboolean *already_loaded, int
if( pak ) if( pak )
{ {
string fullpath;
search = (searchpath_t *)Mem_Calloc( fs_mempool, sizeof( searchpath_t )); search = (searchpath_t *)Mem_Calloc( fs_mempool, sizeof( searchpath_t ));
Q_strncpy( search->filename, pakfile, sizeof( search->filename )); Q_strncpy( search->filename, pakfile, sizeof( search->filename ));
search->pack = pak; search->pack = pak;
@ -384,7 +375,9 @@ qboolean FS_AddPak_Fullpath( const char *pakfile, qboolean *already_loaded, int
{ {
if( !Q_stricmp( COM_FileExtension( pak->files[i].name ), "wad" )) if( !Q_stricmp( COM_FileExtension( pak->files[i].name ), "wad" ))
{ {
Q_snprintf( fullpath, MAX_STRING, "%s/%s", pakfile, pak->files[i].name ); char fullpath[MAX_SYSPATH];
Q_snprintf( fullpath, sizeof( fullpath ), "%s/%s", pakfile, pak->files[i].name );
FS_AddWad_Fullpath( fullpath, NULL, flags ); FS_AddWad_Fullpath( fullpath, NULL, flags );
} }
} }

10
filesystem/wad.c
Unescape View File

@ -299,10 +299,6 @@ static wfile_t *W_Open( const char *filename, int *error )
wad->handle = FS_Open( basename, "rb", false ); wad->handle = FS_Open( basename, "rb", false );
// HACKHACK: try to open WAD by full path for RoDir, when searchpaths are not ready
if( COM_CheckStringEmpty( fs_rodir ) && fs_ext_path && wad->handle == NULL )
wad->handle = FS_SysOpen( filename, "rb" );
if( wad->handle == NULL ) if( wad->handle == NULL )
{ {
Con_Reportf( S_ERROR "W_Open: couldn't open %s\n", filename ); Con_Reportf( S_ERROR "W_Open: couldn't open %s\n", filename );
@ -430,7 +426,7 @@ FS_FindFile_WAD
=========== ===========
*/ */
static int FS_FindFile_WAD( searchpath_t *search, const char *path ) static int FS_FindFile_WAD( searchpath_t *search, const char *path, char *fixedname, size_t len )
{ {
dlumpinfo_t *lump; dlumpinfo_t *lump;
signed char type = W_TypeFromExt( path ); signed char type = W_TypeFromExt( path );
@ -469,6 +465,8 @@ static int FS_FindFile_WAD( searchpath_t *search, const char *path )
if( lump ) if( lump )
{ {
if( fixedname )
Q_strncpy( fixedname, lump->name, len );
return lump - search->wad->lumps; return lump - search->wad->lumps;
} }
@ -677,7 +675,7 @@ byte *FS_LoadWADFile( const char *path, fs_offset_t *lumpsizeptr, qboolean gamed
searchpath_t *search; searchpath_t *search;
int index; int index;
search = FS_FindFile( path, &index, gamedironly ); search = FS_FindFile( path, &index, NULL, 0, gamedironly );
if( search && search->type == SEARCHPATH_WAD ) if( search && search->type == SEARCHPATH_WAD )
return W_ReadLump( search->wad, &search->wad->lumps[index], lumpsizeptr ); return W_ReadLump( search->wad, &search->wad->lumps[index], lumpsizeptr );
return NULL; return NULL;

17
filesystem/zip.c
Unescape View File

@ -202,15 +202,6 @@ static zip_t *FS_LoadZip( const char *zipfile, int *error )
zip->handle = open( zipfile, O_RDONLY|O_BINARY ); zip->handle = open( zipfile, O_RDONLY|O_BINARY );
#if !XASH_WIN32
if( zip->handle < 0 )
{
const char *fzipfile = FS_FixFileCase( zipfile );
if( fzipfile != zipfile )
zip->handle = open( fzipfile, O_RDONLY|O_BINARY );
}
#endif
if( zip->handle < 0 ) if( zip->handle < 0 )
{ {
Con_Reportf( S_ERROR "%s couldn't open\n", zipfile ); Con_Reportf( S_ERROR "%s couldn't open\n", zipfile );
@ -439,7 +430,7 @@ byte *FS_LoadZIPFile( const char *path, fs_offset_t *sizeptr, qboolean gamediron
if( sizeptr ) *sizeptr = 0; if( sizeptr ) *sizeptr = 0;
search = FS_FindFile( path, &index, gamedironly ); search = FS_FindFile( path, &index, NULL, 0, gamedironly );
if( !search || search->type != SEARCHPATH_ZIP ) if( !search || search->type != SEARCHPATH_ZIP )
return NULL; return NULL;
@ -593,7 +584,7 @@ FS_FindFile_ZIP
=========== ===========
*/ */
int FS_FindFile_ZIP( searchpath_t *search, const char *path ) int FS_FindFile_ZIP( searchpath_t *search, const char *path, char *fixedname, size_t len )
{ {
int left, right, middle; int left, right, middle;
@ -609,7 +600,11 @@ int FS_FindFile_ZIP( searchpath_t *search, const char *path )
// Found it // Found it
if( !diff ) if( !diff )
{
if( fixedname )
Q_strncpy( fixedname, search->zip->files[middle].name, len );
return middle; return middle;
}
// if we're too far in the list // if we're too far in the list
if( diff > 0 ) if( diff > 0 )

Write Preview
Loading…
Cancel
Save