Xash3D FWGS engine.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

510 lines
12 KiB

/*
dir.c - caseinsensitive directory operations
Copyright (C) 2022 Alibek Omarov, Velaron
Copyright (C) 2023 Xash3D FWGS contributors
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "build.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stddef.h>
#if XASH_POSIX
#include <unistd.h>
#if !XASH_PSVITA
#include <sys/ioctl.h>
#endif
#endif
#if XASH_LINUX
#include <linux/fs.h>
#ifndef FS_CASEFOLD_FL // for compatibility with older distros
#define FS_CASEFOLD_FL 0x40000000
#endif // FS_CASEFOLD_FL
#endif // XASH_LINUX
#include "port.h"
#include "filesystem_internal.h"
#include "crtlib.h"
#include "xash3d_mathlib.h"
#include "common/com_strings.h"
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 qboolean Platform_GetDirectoryCaseSensitivity( const char *dir )
{
#if XASH_WIN32 || XASH_PSVITA || XASH_NSWITCH
return false;
#elif XASH_LINUX && defined( FS_IOC_GETFLAGS )
int flags = 0;
int fd;
fd = open( dir, O_RDONLY | O_NONBLOCK );
if( fd < 0 )
return true;
if( ioctl( fd, FS_IOC_GETFLAGS, &flags ) < 0 )
return true;
close( fd );
return !FBitSet( flags, FS_CASEFOLD_FL );
#else
return true;
#endif
}
static int FS_SortDirEntries( 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;
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_SortDirEntries );
}
static void FS_PopulateDirEntries( dir_t *dir, const char *path )
{
stringlist_t list;
if( !FS_SysFolderExists( path ))
{
dir->numentries = DIRENTRY_EMPTY_DIRECTORY;
dir->entries = NULL;
return;
}
if( !Platform_GetDirectoryCaseSensitivity( path ))
{
dir->numentries = DIRENTRY_CASEINSENSITIVE;
dir->entries = NULL;
return;
}
stringlistinit( &list );
listdirectory( &list, path );
if( !list.numstrings )
{
dir->numentries = DIRENTRY_EMPTY_DIRECTORY;
dir->entries = NULL;
}
else
{
FS_InitDirEntries( dir, &list );
}
stringlistfreecontents( &list );
}
static int FS_FindDirEntry( dir_t *dir, const char *name )
{
int left, right;
// 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;
// glorified realloc for sorted dir entries
// make new array and copy old entries with same name and subentries
// everything else get freed
FS_InitDirEntries( &temp, list );
for( i = 0; i < dir->numentries; i++ )
{
dir_t *oldentry = &dir->entries[i];
dir_t *newentry;
int j;
// don't care about directories without subentries
if( oldentry->entries == NULL )
continue;
// try to find this directory in new tree
j = FS_FindDirEntry( &temp, oldentry->name );
// not found, free memory
if( j < 0 )
{
FS_FreeDirEntries( oldentry );
continue;
}
// found directory, move all entries
newentry = &temp.entries[j];
newentry->numentries = oldentry->numentries;
newentry->entries = oldentry->entries;
}
// now we can free old tree and replace it with temporary
// do not add null check there! If we hit it, it's probably a logic error!
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;
int ret;
stringlistinit( &list );
listdirectory( &list, path );
if( list.numstrings == 0 ) // empty directory
{
FS_FreeDirEntries( dir );
dir->numentries = DIRENTRY_EMPTY_DIRECTORY;
ret = -1;
}
else if( dir->numentries <= DIRENTRY_EMPTY_DIRECTORY ) // not initialized or was empty
{
FS_InitDirEntries( dir, &list );
ret = FS_FindDirEntry( dir, entryname );
}
else if( list.numstrings != dir->numentries ) // quick update
{
FS_MergeDirEntries( dir, &list );
ret = FS_FindDirEntry( dir, entryname );
}
else
{
// do heavy compare if directory now have an entry we need
int i;
for( i = 0; i < list.numstrings; i++ )
{
if( !Q_stricmp( list.strings[i], entryname ))
break;
}
if( i != list.numstrings )
{
FS_MergeDirEntries( dir, &list );
ret = FS_FindDirEntry( dir, entryname );
}
else ret = -1;
}
stringlistfreecontents( &list );
return ret;
}
static inline qboolean FS_AppendToPath( char *dst, size_t *pi, const size_t len, const char *src, const char *path, const char *err )
{
size_t i = *pi;
i += Q_strncpy( &dst[i], src, len - i );
*pi = i;
if( i >= len )
{
Con_Printf( S_ERROR "FS_FixFileCase: overflow while searching %s (%s)\n", path, err );
return false;
}
return true;
}
qboolean FS_FixFileCase( dir_t *dir, const char *path, char *dst, const size_t len, qboolean createpath )
{
const char *prev;
const char *next;
size_t i = 0;
if( !FS_AppendToPath( dst, &i, len, dir->name, path, "init" ))
return false;
for( prev = path, next = Q_strchrnul( prev, '/' );
;
prev = next + 1, next = Q_strchrnul( prev, '/' ))
{
qboolean uptodate = false; // do not run second scan if we're just updated our directory list
size_t temp;
char entryname[MAX_SYSPATH];
int ret;
if( dir->numentries == DIRENTRY_NOT_SCANNED )
{
// read directory first time
FS_PopulateDirEntries( dir, dst );
uptodate = true;
}
// this subdirectory is case insensitive, just slam everything that's left
if( dir->numentries == DIRENTRY_CASEINSENSITIVE )
{
if( !FS_AppendToPath( dst, &i, len, prev, path, "caseinsensitive entry" ))
return false;
// check file existense
return createpath ? true : FS_SysFileOrFolderExists( dst );
}
// get our entry name
Q_strncpy( entryname, prev, next - prev + 1 );
// didn't found, but does it exists in FS?
if(( ret = FS_FindDirEntry( dir, entryname )) < 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( uptodate || ( ret = FS_MaybeUpdateDirEntries( dir, dst, entryname )) < 0 )
return createpath ? FS_AppendToPath( dst, &i, len, prev, path, "create path" ) : false;
uptodate = true;
}
dir = &dir->entries[ret];
temp = i;
if( !FS_AppendToPath( dst, &temp, len, dir->name, path, "case fix" ))
return false;
if( !uptodate && !FS_SysFileOrFolderExists( dst )) // file not found, rescan...
{
dst[i] = 0; // strip failed part
// 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(( ret = FS_MaybeUpdateDirEntries( dir, dst, entryname )) < 0 )
return createpath ? FS_AppendToPath( dst, &i, len, prev, path, "create path rescan" ) : false;
dir = &dir->entries[ret];
if( !FS_AppendToPath( dst, &temp, len, dir->name, path, "case fix rescan" ))
return false;
}
i = temp;
// end of string, found file, return
if( next[0] == '\0' || ( next[0] == '/' && next[1] == '\0' ))
break;
if( !FS_AppendToPath( dst, &i, len, "/", path, "path separator" ))
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 )
{
Q_strncpy( dst, search->filename, size );
}
static int FS_FindFile_DIR( searchpath_t *search, const char *path, char *fixedname, size_t len )
{
char netpath[MAX_SYSPATH];
if( !FS_FixFileCase( search->dir, path, netpath, sizeof( netpath ), false ))
return -1;
if( FS_SysFileExists( netpath ))
{
// return fixed case file name only local for that searchpath
if( fixedname )
Q_strncpy( fixedname, netpath + Q_strlen( search->filename ), len );
return 0;
}
return -1;
}
static void FS_Search_DIR( searchpath_t *search, stringlist_t *list, const char *pattern, int caseinsensitive )
{
string netpath, temp;
stringlist_t dirlist;
const char *slash, *backslash, *colon, *separator;
int basepathlength, dirlistindex, resultlistindex;
char *basepath;
slash = Q_strrchr( pattern, '/' );
backslash = Q_strrchr( pattern, '\\' );
colon = Q_strrchr( pattern, ':' );
separator = Q_max( slash, backslash );
separator = Q_max( separator, colon );
basepathlength = separator ? (separator + 1 - pattern) : 0;
basepath = Mem_Calloc( fs_mempool, basepathlength + 1 );
if( basepathlength ) memcpy( basepath, pattern, basepathlength );
basepath[basepathlength] = '\0';
if( !FS_FixFileCase( search->dir, basepath, netpath, sizeof( netpath ), false ))
{
Mem_Free( basepath );
return;
}
stringlistinit( &dirlist );
listdirectory( &dirlist, netpath );
Q_strncpy( temp, basepath, sizeof( temp ));
for( dirlistindex = 0; dirlistindex < dirlist.numstrings; dirlistindex++ )
{
Q_strncpy( &temp[basepathlength], dirlist.strings[dirlistindex], sizeof( temp ) - basepathlength );
if( matchpattern( temp, (char *)pattern, true ) )
{
for( resultlistindex = 0; resultlistindex < list->numstrings; resultlistindex++ )
{
if( !Q_strcmp( list->strings[resultlistindex], temp ) )
break;
}
if( resultlistindex == list->numstrings )
stringlistappend( list, temp );
}
}
stringlistfreecontents( &dirlist );
Mem_Free( basepath );
}
static int FS_FileTime_DIR( searchpath_t *search, const char *filename )
{
int time;
char path[MAX_SYSPATH];
Q_snprintf( path, sizeof( path ), "%s%s", search->filename, filename );
return FS_SysFileTime( path );
}
static file_t *FS_OpenFile_DIR( searchpath_t *search, const char *filename, const char *mode, int pack_ind )
{
char path[MAX_SYSPATH];
Q_snprintf( path, sizeof( path ), "%s%s", search->filename, filename );
return FS_SysOpen( path, mode );
}
void FS_InitDirectorySearchpath( searchpath_t *search, const char *path, int flags )
{
memset( search, 0, sizeof( searchpath_t ));
Q_strncpy( search->filename, path, sizeof( search->filename ));
search->type = SEARCHPATH_PLAIN;
search->flags = flags;
search->pfnPrintInfo = FS_PrintInfo_DIR;
search->pfnClose = FS_Close_DIR;
search->pfnOpenFile = FS_OpenFile_DIR;
search->pfnFileTime = FS_FileTime_DIR;
search->pfnFindFile = FS_FindFile_DIR;
search->pfnSearch = FS_Search_DIR;
// create cache root
search->dir = Mem_Malloc( fs_mempool, sizeof( dir_t ));
Q_strncpy( search->dir->name, search->filename, sizeof( search->dir->name ));
FS_PopulateDirEntries( search->dir, path );
}
searchpath_t *FS_AddDir_Fullpath( const char *path, qboolean *already_loaded, int flags )
{
searchpath_t *search;
for( search = fs_searchpaths; search; search = search->next )
{
if( search->type == SEARCHPATH_PLAIN && !Q_stricmp( search->filename, path ))
{
if( already_loaded )
*already_loaded = true;
return search;
}
}
if( already_loaded )
*already_loaded = false;
search = (searchpath_t *)Mem_Calloc( fs_mempool, sizeof( searchpath_t ));
FS_InitDirectorySearchpath( search, path, flags );
search->next = fs_searchpaths;
fs_searchpaths = search;
Con_Printf( "Adding directory: %s\n", path );
return search;
}