# include <direct.h>
# include <io.h>
# include <shlobj.h>
+# include <sys/stat.h>
+# include <share.h>
#else
# include <pwd.h>
# include <sys/stat.h>
#endif
#include "quakedef.h"
+#include "thread.h"
#include "fs.h"
#include "wad.h"
# define lseek _lseeki64
#endif
-#if _MSC_VER >= 1400
// suppress deprecated warnings
-# include <sys/stat.h>
-# include <share.h>
+#if _MSC_VER >= 1400
# define read _read
# define write _write
# define close _close
*/
mempool_t *fs_mempool;
+void *fs_mutex = NULL;
searchpath_t *fs_searchpaths = NULL;
const char *const fs_checkgamedir_missing = "missing";
static dllhandle_t shfolder_dll = NULL;
const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
-#define qREFKNOWNFOLDERID GUID
+#define qREFKNOWNFOLDERID const GUID *
#define qKF_FLAG_CREATE 0x8000
#define qKF_FLAG_NO_ALIAS 0x1000
static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
static dllfunction_t shell32funcs[] =
{
- {"SHGetKnownFolderPathA", (void **) &qSHGetKnownFolderPath},
+ {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
{NULL, NULL}
};
static const char* shell32dllnames [] =
Unload the Zlib DLL
====================
*/
-void PK3_CloseLibrary (void)
+static void PK3_CloseLibrary (void)
{
#ifndef LINK_TO_ZLIB
Sys_UnloadLibrary (&zlib_dll);
Try to load the Zlib DLL
====================
*/
-qboolean PK3_OpenLibrary (void)
+static qboolean PK3_OpenLibrary (void)
{
#ifdef LINK_TO_ZLIB
return true;
Extract the end of the central directory from a PK3 package
====================
*/
-qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
+static qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
{
fs_offset_t filesize, maxsize;
unsigned char *buffer, *ptr;
Extract the file list from a PK3 file
====================
*/
-int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
+static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
{
unsigned char *central_dir, *ptr;
unsigned int ind;
Create a package entry associated with a PK3 file
====================
*/
-pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
+static pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
{
pk3_endOfCentralDir_t eocd;
pack_t *pack;
Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
return pack;
}
-pack_t *FS_LoadPackPK3 (const char *packfile)
+static pack_t *FS_LoadPackPK3 (const char *packfile)
{
int packhandle;
-#if _MSC_VER >= 1400
- _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
-#else
- packhandle = open (packfile, O_RDONLY | O_BINARY);
-#endif
+ packhandle = FS_SysOpenFD (packfile, "rb", false);
if (packhandle < 0)
return NULL;
return FS_LoadPackPK3FromFD(packfile, packhandle, false);
Find where the true file data offset is
====================
*/
-qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
+static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
{
unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
fs_offset_t count;
============
*/
-void FS_Path_f (void)
+static void FS_Path_f (void)
{
searchpath_t *s;
*Loads the header and directory, adding the files at the beginning
*of the list so they override previous pack files.
*/
-pack_t *FS_LoadPackPAK (const char *packfile)
+static pack_t *FS_LoadPackPAK (const char *packfile)
{
dpackheader_t header;
int i, numpackfiles;
pack_t *pack;
dpackfile_t *info;
-#if _MSC_VER >= 1400
- _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
-#else
- packhandle = open (packfile, O_RDONLY | O_BINARY);
-#endif
+ packhandle = FS_SysOpenFD(packfile, "rb", false);
if (packhandle < 0)
return NULL;
if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
Create a package entry associated with a directory file
====================
*/
-pack_t *FS_LoadPackVirtual (const char *dirname)
+static pack_t *FS_LoadPackVirtual (const char *dirname)
{
pack_t *pack;
pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
then loads and adds pak1.pak pak2.pak ...
================
*/
-void FS_AddGameDirectory (const char *dir)
+static void FS_AddGameDirectory (const char *dir)
{
int i;
stringlist_t list;
stringlistinit(&list);
listdirectory(&list, "", dir);
- stringlistsort(&list);
+ stringlistsort(&list, false);
// add any PAK package in the directory
for (i = 0;i < list.numstrings;i++)
FS_AddGameHierarchy
================
*/
-void FS_AddGameHierarchy (const char *dir)
+static void FS_AddGameHierarchy (const char *dir)
{
+ char vabuf[1024];
// Add the common game directory
- FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
+ FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
if (*fs_userdir)
- FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
+ FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
}
FS_ClearSearchPath
================
*/
-void FS_ClearSearchPath (void)
+static void FS_ClearSearchPath (void)
{
// unload all packs and directory information, close all pack files
// (if a qfile is still reading a pack it won't be harmed because it used
qboolean fs_modified = false;
qboolean reset = false;
char gamedirbuf[MAX_INPUTLINE];
+ char vabuf[1024];
if (fs_searchpaths)
reset = true;
// gamedirname1 (typically id1)
FS_AddGameHierarchy (gamedirname1);
// update the com_modname (used for server info)
- strlcpy(com_modname, gamedirname1, sizeof(com_modname));
+ if (gamedirname2 && gamedirname2[0])
+ strlcpy(com_modname, gamedirname2, sizeof(com_modname));
+ else
+ strlcpy(com_modname, gamedirname1, sizeof(com_modname));
// add the game-specific path, if any
// (only used for mission packs and the like, which should set fs_modified)
- if (gamedirname2)
+ if (gamedirname2 && gamedirname2[0])
{
fs_modified = true;
FS_AddGameHierarchy (gamedirname2);
// update the com_modname (used server info)
strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
if(i)
- strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
+ strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
else
strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
}
// If "-condebug" is in the command line, remove the previous log file
if (COM_CheckParm ("-condebug") != 0)
- unlink (va("%s/qconsole.log", fs_gamedir));
+ unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
// look for the pop.lmp file and set registered to true if it is found
if (FS_FileExists("gfx/pop.lmp"))
W_UnloadAll();
}
-void FS_Rescan_f(void)
+static void FS_Rescan_f(void)
{
FS_Rescan();
}
FS_ChangeGameDirs
================
*/
-extern void Host_SaveConfig (void);
-extern void Host_LoadConfig_f (void);
extern qboolean vid_opened;
-extern void VID_Stop(void);
qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
{
int i;
FS_GameDir_f
================
*/
-void FS_GameDir_f (void)
+static void FS_GameDir_f (void)
{
int i;
int numgamedirs;
FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
}
-static const char *FS_SysCheckGameDir(const char *gamedir)
+static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
{
- static char buf[8192];
qboolean success;
qfile_t *f;
stringlist_t list;
fs_offset_t n;
+ char vabuf[1024];
stringlistinit(&list);
listdirectory(&list, gamedir, "");
if(success)
{
- f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
+ f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
if(f)
{
- n = FS_Read (f, buf, sizeof(buf) - 1);
+ n = FS_Read (f, buf, buflength - 1);
if(n >= 0)
buf[n] = 0;
else
const char *FS_CheckGameDir(const char *gamedir)
{
const char *ret;
+ char buf[8192];
+ char vabuf[1024];
if (FS_CheckNastyPath(gamedir, true))
return NULL;
- ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
if(ret)
{
if(!*ret)
{
// get description from basedir
- ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
if(ret)
return ret;
return "";
return ret;
}
- ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+ ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
if(ret)
return ret;
stringlist_t list, list2;
int i, j;
const char *info;
+ char vabuf[1024];
fs_all_gamedirs_count = 0;
if(fs_all_gamedirs)
Mem_Free(fs_all_gamedirs);
stringlistinit(&list);
- listdirectory(&list, va("%s/", fs_basedir), "");
- listdirectory(&list, va("%s/", fs_userdir), "");
- stringlistsort(&list);
+ listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
+ listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
+ stringlistsort(&list, false);
stringlistinit(&list2);
for(i = 0; i < list.numstrings; ++i)
}
}
+/*
+#ifdef WIN32
+#pragma comment(lib, "shell32.lib")
+#include <ShlObj.h>
+#endif
+*/
+
/*
================
FS_Init_SelfPack
}
}
-int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
+static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
{
#if defined(__IPHONEOS__)
if (userdirmode == USERDIRMODE_HOME)
wchar_t *savedgamesdirw;
char savedgamesdir[MAX_OSPATH];
int fd;
-
+ char vabuf[1024];
+
userdir[0] = 0;
switch(userdirmode)
{
{
savedgamesdir[0] = 0;
qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
- if (qSHGetKnownFolderPath(qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+/*
+#ifdef __cplusplus
+ if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+#else
+ if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
+#endif
+*/
+ if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
{
memset(savedgamesdir, 0, sizeof(savedgamesdir));
#if _MSC_VER >= 1400
#else
int fd;
char *homedir;
+ char vabuf[1024];
userdir[0] = 0;
switch(userdirmode)
{
}
#endif
+
+#ifdef WIN32
+ // historical behavior...
+ if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
+ return 0; // don't bother checking if the basedir folder is writable, it's annoying... unless it is Quake on Windows where NOHOME is the default preferred and we have to check for an error case
+#endif
+
// see if we can write to this path (note: won't create path)
-#if _MSC_VER >= 1400
- _sopen_s(&fd, va("%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
+#ifdef WIN32
+ // no access() here, we must try to open the file for appending
+ fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
+ if(fd >= 0)
+ close(fd);
#else
- fd = open (va("%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
+ // on Unix, we don't need to ACTUALLY attempt to open the file
+ if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
+ fd = 1;
+ else
+ fd = 0;
#endif
if(fd >= 0)
{
- close(fd);
return 1; // good choice - the path exists and is writable
}
else
- return 0; // probably good - failed to write but maybe we need to create path
+ {
+ if (userdirmode == USERDIRMODE_NOHOME)
+ return -1; // path usually already exists, we lack permissions
+ else
+ return 0; // probably good - failed to write but maybe we need to create path
+ }
}
/*
#ifdef DP_FS_BASEDIR
strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
#elif defined(MACOSX)
- // FIXME: is there a better way to find the directory outside the .app?
- // FIXME: check if game data is inside .app bundle
+ // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
if (strstr(com_argv[0], ".app/"))
{
char *split;
split = strstr(fs_basedir, ".app/");
if (split)
{
- while (split > fs_basedir && *split != '/')
- split--;
- *split = 0;
+ struct stat statresult;
+ char vabuf[1024];
+ // truncate to just after the .app/
+ split[5] = 0;
+ // see if gamedir exists in Resources
+ if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
+ {
+ // found gamedir inside Resources, use it
+ strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
+ }
+ else
+ {
+ // no gamedir found in Resources, gamedir is probably
+ // outside the .app, remove .app part of path
+ while (split > fs_basedir && *split != '/')
+ split--;
+ *split = 0;
+ }
}
}
#endif
// generate the searchpath
FS_Rescan();
+
+ if (Thread_HasThreads())
+ fs_mutex = Thread_CreateMutex();
}
void FS_Init_Commands(void)
// by the OS anyway)
FS_ClearSearchPath();
Mem_FreePool (&fs_mempool);
+ PK3_CloseLibrary ();
#ifdef WIN32
Sys_UnloadLibrary (&shfolder_dll);
Sys_UnloadLibrary (&shell32_dll);
Sys_UnloadLibrary (&ole32_dll);
#endif
+
+ if (fs_mutex)
+ Thread_DestroyMutex(fs_mutex);
}
int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
{
- int handle;
+ int handle = -1;
int mod, opt;
unsigned int ind;
+ qboolean dolock = false;
// Parse the mode string
switch (mode[0])
case 'b':
opt |= O_BINARY;
break;
+ case 'l':
+ dolock = true;
+ break;
default:
Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
filepath, mode, mode[ind]);
if (nonblocking)
opt |= O_NONBLOCK;
-#if _MSC_VER >= 1400
- _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#ifdef WIN32
+# if _MSC_VER >= 1400
+ _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
+# else
+ handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
+# endif
#else
handle = open (filepath, mod | opt, 0666);
+ if(handle >= 0 && dolock)
+ {
+ struct flock l;
+ l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
+ l.l_whence = SEEK_SET;
+ l.l_start = 0;
+ l.l_len = 0;
+ if(fcntl(handle, F_SETLK, &l) == -1)
+ {
+ close(handle);
+ handle = -1;
+ }
+ }
#endif
+
return handle;
}
Open a packed file using its package file descriptor
===========
*/
-qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
+static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
{
packfile_t *pfile;
int dup_handle;
Look for a file in the search paths and open it in read-only mode
===========
*/
-qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
+static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
{
searchpath_t *search;
int pack_ind;
*/
qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
{
+ qfile_t *result = NULL;
if (FS_CheckNastyPath(filepath, false))
{
Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
return NULL;
}
- return FS_OpenReadFile (filepath, quiet, false, 16);
+ if (fs_mutex) Thread_LockMutex(fs_mutex);
+ result = FS_OpenReadFile (filepath, quiet, false, 16);
+ if (fs_mutex) Thread_UnlockMutex(fs_mutex);
+ return result;
}
if (resultlist.numstrings)
{
- stringlistsort(&resultlist);
+ stringlistsort(&resultlist, true);
numfiles = resultlist.numstrings;
numchars = 0;
for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
}
extern int con_linewidth;
-int FS_ListDirectory(const char *pattern, int oneperline)
+static int FS_ListDirectory(const char *pattern, int oneperline)
{
int numfiles;
int numcolumns;
static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
{
const char *pattern;
- if (Cmd_Argc() > 3)
+ if (Cmd_Argc() >= 3)
{
Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
return;