4 Copyright (C) 2003-2006 Mathieu Olivier
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 See the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to:
20 Free Software Foundation, Inc.
21 59 Temple Place - Suite 330
22 Boston, MA 02111-1307, USA
32 # include <sys/stat.h>
36 # include <sys/stat.h>
43 // include SDL for IPHONEOS code
56 // Win32 requires us to add O_BINARY, but the other OSes don't have it
61 // In case the system doesn't support the O_NONBLOCK flag
66 // largefile support for Win32
69 # define lseek _lseeki64
72 // suppress deprecated warnings
77 # define unlink _unlink
83 typedef SDL_RWops *filedesc_t;
84 # define FILEDESC_INVALID NULL
85 # define FILEDESC_ISVALID(fd) ((fd) != NULL)
86 # define FILEDESC_READ(fd,buf,count) ((fs_offset_t)SDL_RWread(fd, buf, 1, count))
87 # define FILEDESC_WRITE(fd,buf,count) ((fs_offset_t)SDL_RWwrite(fd, buf, 1, count))
88 # define FILEDESC_CLOSE SDL_RWclose
89 # define FILEDESC_SEEK SDL_RWseek
90 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
91 filedesc_t new_fd = SDL_RWFromFile(filename, "rb");
92 if (SDL_RWseek(new_fd, SDL_RWseek(fd, 0, RW_SEEK_CUR), RW_SEEK_SET) < 0) {
98 # define unlink(name) Con_DPrintf("Sorry, no unlink support when trying to unlink %s.\n", (name))
100 typedef int filedesc_t;
101 # define FILEDESC_INVALID -1
102 # define FILEDESC_ISVALID(fd) ((fd) != -1)
103 # define FILEDESC_READ read
104 # define FILEDESC_WRITE write
105 # define FILEDESC_CLOSE close
106 # define FILEDESC_SEEK lseek
107 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
113 /* This code seems to have originally been written with the assumption that
114 * read(..., n) returns n on success. This is not the case (refer to
115 * <https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html>).
123 Read exactly length bytes from fd into buf. If end of file is reached,
124 the number of bytes read is returned. If an error occurred, that error
125 is returned. Note that if an error is returned, any previously read
129 static fs_offset_t ReadAll(const filedesc_t fd, void *const buf, const size_t length)
131 char *const p = (char *)buf;
135 const fs_offset_t result = FILEDESC_READ(fd, p + cursor, length - cursor);
136 if (result < 0) // Error
138 if (result == 0) // EOF
141 } while (cursor < length);
149 Write exactly length bytes to fd from buf.
150 If an error occurred, that error is returned.
153 static fs_offset_t WriteAll(const filedesc_t fd, const void *const buf, const size_t length)
155 const char *const p = (const char *)buf;
159 const fs_offset_t result = FILEDESC_WRITE(fd, p + cursor, length - cursor);
160 if (result < 0) // Error
163 } while (cursor < length);
168 #define FILEDESC_READ ReadAll
169 #undef FILEDESC_WRITE
170 #define FILEDESC_WRITE WriteAll
172 /** \page fs File System
174 All of Quake's data access is through a hierarchical file system, the contents
175 of the file system can be transparently merged from several sources.
177 The "base directory" is the path to the directory holding the quake.exe and
178 all game directories. The sys_* files pass this to host_init in
179 quakeparms_t->basedir. This can be overridden with the "-basedir" command
180 line parm to allow code debugging in a different directory. The base
181 directory is only used during filesystem initialization.
183 The "game directory" is the first tree on the search path and directory that
184 all generated files (savegames, screenshots, demos, config files) will be
185 saved to. This can be overridden with the "-game" command line parameter.
186 If multiple "-game <gamedir>" args are passed the last one is the "primary"
187 and files will be saved there, the rest are read-only.
193 =============================================================================
197 =============================================================================
200 // Magic numbers of a ZIP file (big-endian format)
201 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
202 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
203 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
205 // Other constants for ZIP files
206 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
207 #define ZIP_END_CDIR_SIZE 22
208 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
209 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
214 #define qz_inflate inflate
215 #define qz_inflateEnd inflateEnd
216 #define qz_inflateInit2_ inflateInit2_
217 #define qz_inflateReset inflateReset
218 #define qz_deflateInit2_ deflateInit2_
219 #define qz_deflateEnd deflateEnd
220 #define qz_deflate deflate
221 #define Z_MEMLEVEL_DEFAULT 8
224 // Zlib constants (from zlib.h)
225 #define Z_SYNC_FLUSH 2
228 #define Z_STREAM_END 1
229 #define Z_STREAM_ERROR (-2)
230 #define Z_DATA_ERROR (-3)
231 #define Z_MEM_ERROR (-4)
232 #define Z_BUF_ERROR (-5)
233 #define ZLIB_VERSION "1.2.3"
237 #define Z_MEMLEVEL_DEFAULT 8
240 #define Z_DEFAULT_COMPRESSION (-1)
242 #define Z_SYNC_FLUSH 2
243 #define Z_FULL_FLUSH 3
246 // Uncomment the following line if the zlib DLL you have still uses
247 // the 1.1.x series calling convention on Win32 (WINAPI)
248 //#define ZLIB_USES_WINAPI
252 =============================================================================
256 =============================================================================
259 /*! Zlib stream (from zlib.h)
260 * \warning: some pointers we don't use directly have
261 * been cast to "void*" for a matter of simplicity
265 unsigned char *next_in; ///< next input byte
266 unsigned int avail_in; ///< number of bytes available at next_in
267 unsigned long total_in; ///< total nb of input bytes read so far
269 unsigned char *next_out; ///< next output byte should be put there
270 unsigned int avail_out; ///< remaining free space at next_out
271 unsigned long total_out; ///< total nb of bytes output so far
273 char *msg; ///< last error message, NULL if no error
274 void *state; ///< not visible by applications
276 void *zalloc; ///< used to allocate the internal state
277 void *zfree; ///< used to free the internal state
278 void *opaque; ///< private data object passed to zalloc and zfree
280 int data_type; ///< best guess about the data type: ascii or binary
281 unsigned long adler; ///< adler32 value of the uncompressed data
282 unsigned long reserved; ///< reserved for future use
287 /// inside a package (PAK or PK3)
288 #define QFILE_FLAG_PACKED (1 << 0)
289 /// file is compressed using the deflate algorithm (PK3 only)
290 #define QFILE_FLAG_DEFLATED (1 << 1)
291 /// file is actually already loaded data
292 #define QFILE_FLAG_DATA (1 << 2)
293 /// real file will be removed on close
294 #define QFILE_FLAG_REMOVE (1 << 3)
296 #define FILE_BUFF_SIZE 2048
300 size_t comp_length; ///< length of the compressed file
301 size_t in_ind, in_len; ///< input buffer current index and length
302 size_t in_position; ///< position in the compressed file
303 unsigned char input [FILE_BUFF_SIZE];
309 filedesc_t handle; ///< file descriptor
310 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
311 fs_offset_t position; ///< current position in the file
312 fs_offset_t offset; ///< offset into the package (0 if external file)
313 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
316 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
317 unsigned char buff [FILE_BUFF_SIZE];
319 ztoolkit_t* ztk; ///< For zipped files.
321 const unsigned char *data; ///< For data files.
323 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
327 // ------ PK3 files on disk ------ //
329 // You can get the complete ZIP format description from PKWARE website
331 typedef struct pk3_endOfCentralDir_s
333 unsigned int signature;
334 unsigned short disknum;
335 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
336 unsigned short localentries; ///< number of entries in the central directory on this disk
337 unsigned short nbentries; ///< total number of entries in the central directory on this disk
338 unsigned int cdir_size; ///< size of the central directory
339 unsigned int cdir_offset; ///< with respect to the starting disk number
340 unsigned short comment_size;
341 fs_offset_t prepended_garbage;
342 } pk3_endOfCentralDir_t;
345 // ------ PAK files on disk ------ //
346 typedef struct dpackfile_s
349 int filepos, filelen;
352 typedef struct dpackheader_s
360 /*! \name Packages in memory
363 /// the offset in packfile_t is the true contents offset
364 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
365 /// file compressed using the deflate algorithm
366 #define PACKFILE_FLAG_DEFLATED (1 << 1)
367 /// file is a symbolic link
368 #define PACKFILE_FLAG_SYMLINK (1 << 2)
370 typedef struct packfile_s
372 char name [MAX_QPATH];
375 fs_offset_t packsize; ///< size in the package
376 fs_offset_t realsize; ///< real file size (uncompressed)
379 typedef struct pack_s
381 char filename [MAX_OSPATH];
382 char shortname [MAX_QPATH];
384 qbool ignorecase; ///< PK3 ignores case
392 /// Search paths for files (including packages)
393 typedef struct searchpath_s
395 // only one of filename / pack will be used
396 char filename[MAX_OSPATH];
398 struct searchpath_s *next;
403 =============================================================================
407 =============================================================================
410 void FS_Dir_f(cmd_state_t *cmd);
411 void FS_Ls_f(cmd_state_t *cmd);
412 void FS_Which_f(cmd_state_t *cmd);
414 static searchpath_t *FS_FindFile (const char *name, int *index, const char **canonicalname, qbool quiet);
415 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
416 fs_offset_t offset, fs_offset_t packsize,
417 fs_offset_t realsize, int flags);
421 =============================================================================
425 =============================================================================
428 mempool_t *fs_mempool;
429 void *fs_mutex = NULL;
431 searchpath_t *fs_searchpaths = NULL;
432 const char *const fs_checkgamedir_missing = "missing";
434 #define MAX_FILES_IN_PACK 65536
436 char fs_userdir[MAX_OSPATH];
437 char fs_gamedir[MAX_OSPATH];
438 char fs_basedir[MAX_OSPATH];
439 static pack_t *fs_selfpack = NULL;
441 // list of active game directories (empty if not running a mod)
442 int fs_numgamedirs = 0;
443 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
445 // list of all gamedirs with modinfo.txt
446 gamedir_t *fs_all_gamedirs = NULL;
447 int fs_all_gamedirs_count = 0;
449 cvar_t scr_screenshot_name = {CF_CLIENT | CF_PERSISTENT, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
450 cvar_t fs_empty_files_in_pack_mark_deletions = {CF_CLIENT | CF_SERVER, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
451 cvar_t fs_unload_dlcache = {CF_CLIENT, "fs_unload_dlcache", "1", "if enabled, unload dlcache's loaded pak/pk3 files when changing server and/or map WARNING: disabling unloading can cause servers to override assets of other servers, \"memory leaking\" by dlcache assets never unloading and many more issues"};
452 cvar_t cvar_fs_gamedir = {CF_CLIENT | CF_SERVER | CF_READONLY | CF_PERSISTENT, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
456 =============================================================================
458 PRIVATE FUNCTIONS - PK3 HANDLING
460 =============================================================================
464 // Functions exported from zlib
465 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
466 # define ZEXPORT WINAPI
471 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
472 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
473 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
474 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
475 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
476 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
477 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
480 #define qz_inflateInit2(strm, windowBits) \
481 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
482 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
483 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
486 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
488 static dllfunction_t zlibfuncs[] =
490 {"inflate", (void **) &qz_inflate},
491 {"inflateEnd", (void **) &qz_inflateEnd},
492 {"inflateInit2_", (void **) &qz_inflateInit2_},
493 {"inflateReset", (void **) &qz_inflateReset},
494 {"deflateInit2_", (void **) &qz_deflateInit2_},
495 {"deflateEnd", (void **) &qz_deflateEnd},
496 {"deflate", (void **) &qz_deflate},
500 /// Handle for Zlib DLL
501 static dllhandle_t zlib_dll = NULL;
505 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
506 static dllfunction_t shfolderfuncs[] =
508 {"SHGetFolderPathW", (void **) &qSHGetFolderPath},
511 static const char* shfolderdllnames [] =
513 "shfolder.dll", // IE 4, or Win NT and higher
516 static dllhandle_t shfolder_dll = NULL;
518 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
519 #define qREFKNOWNFOLDERID const GUID *
520 #define qKF_FLAG_CREATE 0x8000
521 #define qKF_FLAG_NO_ALIAS 0x1000
522 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
523 static dllfunction_t shell32funcs[] =
525 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
528 static const char* shell32dllnames [] =
530 "shell32.dll", // Vista and higher
533 static dllhandle_t shell32_dll = NULL;
535 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
536 static void (WINAPI *qCoUninitialize)(void);
537 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
538 static dllfunction_t ole32funcs[] =
540 {"CoInitializeEx", (void **) &qCoInitializeEx},
541 {"CoUninitialize", (void **) &qCoUninitialize},
542 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
545 static const char* ole32dllnames [] =
547 "ole32.dll", // 2000 and higher
550 static dllhandle_t ole32_dll = NULL;
560 static void PK3_CloseLibrary (void)
563 Sys_FreeLibrary (&zlib_dll);
572 Try to load the Zlib DLL
575 static qbool PK3_OpenLibrary (void)
580 const char* dllnames [] =
583 # ifdef ZLIB_USES_WINAPI
589 #elif defined(MACOSX)
603 return Sys_LoadDependency (dllnames, &zlib_dll, zlibfuncs);
611 See if zlib is available
614 qbool FS_HasZlib(void)
619 PK3_OpenLibrary(); // to be safe
620 return (zlib_dll != 0);
626 PK3_GetEndOfCentralDir
628 Extract the end of the central directory from a PK3 package
631 static qbool PK3_GetEndOfCentralDir (const char *packfile, filedesc_t packhandle, pk3_endOfCentralDir_t *eocd)
633 fs_offset_t filesize, maxsize;
634 unsigned char *buffer, *ptr;
637 // Get the package size
638 filesize = FILEDESC_SEEK (packhandle, 0, SEEK_END);
639 if (filesize < ZIP_END_CDIR_SIZE)
642 // Load the end of the file in memory
643 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
646 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
647 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
648 FILEDESC_SEEK (packhandle, filesize - maxsize, SEEK_SET);
649 if (FILEDESC_READ (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
655 // Look for the end of central dir signature around the end of the file
656 maxsize -= ZIP_END_CDIR_SIZE;
657 ptr = &buffer[maxsize];
659 while (BuffBigLong (ptr) != ZIP_END_HEADER)
671 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
672 eocd->signature = LittleLong (eocd->signature);
673 eocd->disknum = LittleShort (eocd->disknum);
674 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
675 eocd->localentries = LittleShort (eocd->localentries);
676 eocd->nbentries = LittleShort (eocd->nbentries);
677 eocd->cdir_size = LittleLong (eocd->cdir_size);
678 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
679 eocd->comment_size = LittleShort (eocd->comment_size);
680 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
681 eocd->cdir_offset += eocd->prepended_garbage;
686 eocd->cdir_size > filesize ||
687 eocd->cdir_offset >= filesize ||
688 eocd->cdir_offset + eocd->cdir_size > filesize
691 // Obviously invalid central directory.
703 Extract the file list from a PK3 file
706 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
708 unsigned char *central_dir, *ptr;
710 fs_offset_t remaining;
712 // Load the central directory in memory
713 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
714 if (FILEDESC_SEEK (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
716 Mem_Free (central_dir);
719 if(FILEDESC_READ (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
721 Mem_Free (central_dir);
725 // Extract the files properties
726 // The parsing is done "by hand" because some fields have variable sizes and
727 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
728 remaining = eocd->cdir_size;
731 for (ind = 0; ind < eocd->nbentries; ind++)
733 fs_offset_t namesize, count;
735 // Checking the remaining size
736 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
738 Mem_Free (central_dir);
741 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
744 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
746 Mem_Free (central_dir);
750 namesize = (unsigned short)BuffLittleShort (&ptr[28]); // filename length
752 // Check encryption, compression, and attributes
753 // 1st uint8 : general purpose bit flag
754 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
756 // LadyHavoc: bit 3 would be a problem if we were scanning the archive
757 // but is not a problem in the central directory where the values are
760 // bit 3 seems to always be set by the standard Mac OSX zip maker
762 // 2nd uint8 : external file attributes
763 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
764 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
766 // Still enough bytes for the name?
767 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
769 Mem_Free (central_dir);
773 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
774 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
776 char filename [sizeof (pack->files[0].name)];
777 fs_offset_t offset, packsize, realsize;
780 // Extract the name (strip it if necessary)
781 namesize = min(namesize, (int)sizeof (filename) - 1);
782 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
783 filename[namesize] = '\0';
785 if (BuffLittleShort (&ptr[10]))
786 flags = PACKFILE_FLAG_DEFLATED;
789 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
790 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
791 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
793 switch(ptr[5]) // C_VERSION_MADE_BY_1
798 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
799 // can't use S_ISLNK here, as this has to compile on non-UNIX too
800 flags |= PACKFILE_FLAG_SYMLINK;
804 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
808 // Skip the name, additionnal field, and comment
809 // 1er uint16 : extra field length
810 // 2eme uint16 : file comment length
811 count = namesize + (unsigned short)BuffLittleShort (&ptr[30]) + (unsigned short)BuffLittleShort (&ptr[32]);
812 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
816 // If the package is empty, central_dir is NULL here
817 if (central_dir != NULL)
818 Mem_Free (central_dir);
819 return pack->numfiles;
827 Create a package entry associated with a PK3 file
830 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, filedesc_t packhandle, qbool silent)
832 pk3_endOfCentralDir_t eocd;
836 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
839 Con_Printf ("%s is not a PK3 file\n", packfile);
840 FILEDESC_CLOSE(packhandle);
844 // Multi-volume ZIP archives are NOT allowed
845 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
847 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
848 FILEDESC_CLOSE(packhandle);
852 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
853 // since eocd.nbentries is an unsigned 16 bits integer
854 #if MAX_FILES_IN_PACK < 65535
855 if (eocd.nbentries > MAX_FILES_IN_PACK)
857 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
858 FILEDESC_CLOSE(packhandle);
863 // Create a package structure in memory
864 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
865 pack->ignorecase = true; // PK3 ignores case
866 dp_strlcpy (pack->filename, packfile, sizeof (pack->filename));
867 pack->handle = packhandle;
868 pack->numfiles = eocd.nbentries;
869 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
871 real_nb_files = PK3_BuildFileList (pack, &eocd);
872 if (real_nb_files < 0)
874 Con_Printf ("%s is not a valid PK3 file\n", packfile);
875 FILEDESC_CLOSE(pack->handle);
880 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
884 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qbool nonblocking);
885 static pack_t *FS_LoadPackPK3 (const char *packfile)
887 filedesc_t packhandle;
888 packhandle = FS_SysOpenFiledesc (packfile, "rb", false);
889 if (!FILEDESC_ISVALID(packhandle))
891 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
897 PK3_GetTrueFileOffset
899 Find where the true file data offset is
902 static qbool PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
904 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
908 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
911 // Load the local file description
912 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
914 Con_Printf ("Can't seek in package %s\n", pack->filename);
917 count = FILEDESC_READ (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
918 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
920 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
924 // Skip name and extra field
925 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
927 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
933 =============================================================================
935 OTHER PRIVATE FUNCTIONS
937 =============================================================================
945 Add a file to the list of files contained into a package
948 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
949 fs_offset_t offset, fs_offset_t packsize,
950 fs_offset_t realsize, int flags)
952 int (*strcmp_funct) (const char* str1, const char* str2);
953 int left, right, middle;
956 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
958 // Look for the slot we should put that file into (binary search)
960 right = pack->numfiles - 1;
961 while (left <= right)
965 middle = (left + right) / 2;
966 diff = strcmp_funct (pack->files[middle].name, name);
968 // If we found the file, there's a problem
970 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
972 // If we're too far in the list
979 // We have to move the right of the list by one slot to free the one we need
980 pfile = &pack->files[left];
981 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
984 dp_strlcpy (pfile->name, name, sizeof (pfile->name));
985 pfile->offset = offset;
986 pfile->packsize = packsize;
987 pfile->realsize = realsize;
988 pfile->flags = flags;
995 static inline int wstrlen(wchar *wstr)
998 while (wstr[len] != 0 && len < WSTRBUF)
1002 #define widen(str, wstr) fromwtf8(str, strlen(str), wstr, WSTRBUF)
1003 #define narrow(wstr, str) towtf8(wstr, wstrlen(wstr), str, WSTRBUF)
1006 static void FS_mkdir (const char *path)
1009 wchar pathw[WSTRBUF] = {0};
1011 if(Sys_CheckParm("-readonly"))
1016 if (_wmkdir (pathw) == -1)
1018 if (mkdir (path, 0777) == -1)
1021 // No logging for this. The only caller is FS_CreatePath (which
1022 // calls it in ways that will intentionally produce EEXIST),
1023 // and its own callers always use the directory afterwards and
1024 // thus will detect failure that way.
1032 Only used for FS_OpenRealFile.
1035 void FS_CreatePath (char *path)
1039 for (ofs = path+1 ; *ofs ; ofs++)
1041 if (*ofs == '/' || *ofs == '\\')
1043 // create the directory
1059 static void FS_Path_f(cmd_state_t *cmd)
1063 Con_Print("Current search path:\n");
1064 for (s=fs_searchpaths ; s ; s=s->next)
1069 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
1071 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1074 Con_Printf("%s\n", s->filename);
1084 /*! Takes an explicit (not game tree related) path to a pak file.
1085 *Loads the header and directory, adding the files at the beginning
1086 *of the list so they override previous pack files.
1088 static pack_t *FS_LoadPackPAK (const char *packfile)
1090 dpackheader_t header;
1091 int i, numpackfiles;
1092 filedesc_t packhandle;
1096 packhandle = FS_SysOpenFiledesc(packfile, "rb", false);
1097 if (!FILEDESC_ISVALID(packhandle))
1099 if(FILEDESC_READ (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
1101 Con_Printf ("%s is not a packfile\n", packfile);
1102 FILEDESC_CLOSE(packhandle);
1105 if (memcmp(header.id, "PACK", 4))
1107 Con_Printf ("%s is not a packfile\n", packfile);
1108 FILEDESC_CLOSE(packhandle);
1111 header.dirofs = LittleLong (header.dirofs);
1112 header.dirlen = LittleLong (header.dirlen);
1114 if (header.dirlen % sizeof(dpackfile_t))
1116 Con_Printf ("%s has an invalid directory size\n", packfile);
1117 FILEDESC_CLOSE(packhandle);
1121 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1123 if (numpackfiles < 0 || numpackfiles > MAX_FILES_IN_PACK)
1125 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
1126 FILEDESC_CLOSE(packhandle);
1130 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1131 FILEDESC_SEEK (packhandle, header.dirofs, SEEK_SET);
1132 if(header.dirlen != FILEDESC_READ (packhandle, (void *)info, header.dirlen))
1134 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1136 FILEDESC_CLOSE(packhandle);
1140 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1141 pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
1142 dp_strlcpy (pack->filename, packfile, sizeof (pack->filename));
1143 pack->handle = packhandle;
1145 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1147 // parse the directory
1148 for (i = 0;i < numpackfiles;i++)
1150 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1151 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1153 // Ensure a zero terminated file name (required by format).
1154 info[i].name[sizeof(info[i].name) - 1] = 0;
1156 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1161 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1166 ====================
1169 Create a package entry associated with a directory file
1170 ====================
1172 static pack_t *FS_LoadPackVirtual (const char *dirname)
1175 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1177 pack->ignorecase = false;
1178 dp_strlcpy (pack->filename, dirname, sizeof(pack->filename));
1179 pack->handle = FILEDESC_INVALID;
1180 pack->numfiles = -1;
1182 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1191 /*! Adds the given pack to the search path.
1192 * The pack type is autodetected by the file extension.
1194 * Returns true if the file was successfully added to the
1195 * search path or if it was already included.
1197 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1198 * plain directories.
1201 static qbool FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qbool *already_loaded, qbool keep_plain_dirs, qbool dlcache)
1203 searchpath_t *search;
1205 const char *ext = FS_FileExtension(pakfile);
1208 for(search = fs_searchpaths; search; search = search->next)
1210 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1213 *already_loaded = true;
1214 return true; // already loaded
1219 *already_loaded = false;
1221 if(!strcasecmp(ext, "pk3dir") || !strcasecmp(ext, "dpkdir"))
1222 pak = FS_LoadPackVirtual (pakfile);
1223 else if(!strcasecmp(ext, "pak"))
1224 pak = FS_LoadPackPAK (pakfile);
1225 else if(!strcasecmp(ext, "pk3") || !strcasecmp(ext, "dpk"))
1226 pak = FS_LoadPackPK3 (pakfile);
1227 else if(!strcasecmp(ext, "obb")) // android apk expansion
1228 pak = FS_LoadPackPK3 (pakfile);
1230 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1234 dp_strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1236 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1239 // find the first item whose next one is a pack or NULL
1240 searchpath_t *insertion_point = 0;
1241 if(fs_searchpaths && !fs_searchpaths->pack)
1243 insertion_point = fs_searchpaths;
1246 if(!insertion_point->next)
1248 if(insertion_point->next->pack)
1250 insertion_point = insertion_point->next;
1253 // If insertion_point is NULL, this means that either there is no
1254 // item in the list yet, or that the very first item is a pack. In
1255 // that case, we want to insert at the beginning...
1256 if(!insertion_point)
1258 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1259 search->next = fs_searchpaths;
1260 fs_searchpaths = search;
1263 // otherwise we want to append directly after insertion_point.
1265 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1266 search->next = insertion_point->next;
1267 insertion_point->next = search;
1272 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1273 search->next = fs_searchpaths;
1274 fs_searchpaths = search;
1277 search->pack->dlcache = dlcache;
1280 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1281 // if shortname ends with "pk3dir" or "dpkdir", strip that suffix to make it just "pk3" or "dpk"
1282 // same goes for the name inside the pack structure
1283 l = strlen(pak->shortname);
1285 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir") || !strcasecmp(pak->shortname + l - 7, ".dpkdir"))
1286 pak->shortname[l - 3] = 0;
1287 l = strlen(pak->filename);
1289 if(!strcasecmp(pak->filename + l - 7, ".pk3dir") || !strcasecmp(pak->filename + l - 7, ".dpkdir"))
1290 pak->filename[l - 3] = 0;
1296 Con_Printf(CON_ERROR "unable to load pak \"%s\"\n", pakfile);
1307 /*! Adds the given pack to the search path and searches for it in the game path.
1308 * The pack type is autodetected by the file extension.
1310 * Returns true if the file was successfully added to the
1311 * search path or if it was already included.
1313 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1314 * plain directories.
1316 qbool FS_AddPack(const char *pakfile, qbool *already_loaded, qbool keep_plain_dirs, qbool dlcache)
1318 char fullpath[MAX_OSPATH];
1320 searchpath_t *search;
1323 *already_loaded = false;
1325 // then find the real name...
1326 search = FS_FindFile(pakfile, &index, NULL, true);
1327 if(!search || search->pack)
1329 Con_Printf("could not find pak \"%s\"\n", pakfile);
1333 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1335 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs, dlcache);
1343 Sets fs_gamedir, adds the directory to the head of the path,
1344 then loads and adds pak1.pak pak2.pak ...
1347 static void FS_AddGameDirectory (const char *dir)
1351 searchpath_t *search;
1353 dp_strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1355 stringlistinit(&list);
1356 listdirectory(&list, "", dir);
1357 stringlistsort(&list, false);
1359 // add any PAK package in the directory
1360 for (i = 0;i < list.numstrings;i++)
1362 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1364 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false, false);
1368 // add any PK3 package in the directory
1369 for (i = 0;i < list.numstrings;i++)
1371 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir")
1372 || !strcasecmp(FS_FileExtension(list.strings[i]), "dpk") || !strcasecmp(FS_FileExtension(list.strings[i]), "dpkdir"))
1374 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false, false);
1378 stringlistfreecontents(&list);
1380 // Add the directory to the search path
1381 // (unpacked files have the priority over packed files)
1382 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1383 dp_strlcpy (search->filename, dir, sizeof (search->filename));
1384 search->next = fs_searchpaths;
1385 fs_searchpaths = search;
1394 static void FS_AddGameHierarchy (const char *dir)
1397 // Add the common game directory
1398 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1401 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1410 const char *FS_FileExtension (const char *in)
1412 const char *separator, *backslash, *colon, *dot;
1414 dot = strrchr(in, '.');
1418 separator = strrchr(in, '/');
1419 backslash = strrchr(in, '\\');
1420 if (!separator || separator < backslash)
1421 separator = backslash;
1422 colon = strrchr(in, ':');
1423 if (!separator || separator < colon)
1426 if (separator && (dot < separator))
1438 const char *FS_FileWithoutPath (const char *in)
1440 const char *separator, *backslash, *colon;
1442 separator = strrchr(in, '/');
1443 backslash = strrchr(in, '\\');
1444 if (!separator || separator < backslash)
1445 separator = backslash;
1446 colon = strrchr(in, ':');
1447 if (!separator || separator < colon)
1449 return separator ? separator + 1 : in;
1458 static void FS_ClearSearchPath (void)
1460 // unload all packs and directory information, close all pack files
1461 // (if a qfile is still reading a pack it won't be harmed because it used
1462 // dup() to get its own handle already)
1463 while (fs_searchpaths)
1465 searchpath_t *search = fs_searchpaths;
1466 fs_searchpaths = search->next;
1467 if (search->pack && search->pack != fs_selfpack)
1469 if(!search->pack->vpack)
1472 FILEDESC_CLOSE(search->pack->handle);
1473 // free any memory associated with it
1474 if (search->pack->files)
1475 Mem_Free(search->pack->files);
1477 Mem_Free(search->pack);
1485 FS_UnloadPacks_dlcache
1487 Like FS_ClearSearchPath() but unloads only the packs loaded from dlcache
1488 so we don't need to use a full FS_Rescan() to prevent
1489 content from the previous server and/or map from interfering with the next
1492 void FS_UnloadPacks_dlcache(void)
1494 searchpath_t *search = fs_searchpaths, *searchprev = fs_searchpaths, *searchnext;
1496 if (!fs_unload_dlcache.integer)
1501 searchnext = search->next;
1502 if (search->pack && search->pack->dlcache)
1504 Con_DPrintf("Unloading pack: %s\n", search->pack->shortname);
1506 // remove it from the search path list
1507 if (search == fs_searchpaths)
1508 fs_searchpaths = search->next;
1510 searchprev->next = search->next;
1513 FILEDESC_CLOSE(search->pack->handle);
1514 // free any memory associated with it
1515 if (search->pack->files)
1516 Mem_Free(search->pack->files);
1517 Mem_Free(search->pack);
1521 searchprev = search;
1522 search = searchnext;
1526 static void FS_AddSelfPack(void)
1530 searchpath_t *search;
1531 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1532 search->next = fs_searchpaths;
1533 search->pack = fs_selfpack;
1534 fs_searchpaths = search;
1544 void FS_Rescan (void)
1547 qbool fs_modified = false;
1548 qbool reset = false;
1549 char gamedirbuf[MAX_INPUTLINE];
1554 FS_ClearSearchPath();
1556 // automatically activate gamemode for the gamedirs specified
1558 COM_ChangeGameTypeForGameDirs();
1560 // add the game-specific paths
1561 // gamedirname1 (typically id1)
1562 FS_AddGameHierarchy (gamedirname1);
1563 // update the com_modname (used for server info)
1564 if (gamedirname2 && gamedirname2[0])
1565 dp_strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1567 dp_strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1569 // add the game-specific path, if any
1570 // (only used for mission packs and the like, which should set fs_modified)
1571 if (gamedirname2 && gamedirname2[0])
1574 FS_AddGameHierarchy (gamedirname2);
1578 // Adds basedir/gamedir as an override game
1579 // LadyHavoc: now supports multiple -game directories
1580 // set the com_modname (reported in server info)
1582 for (i = 0;i < fs_numgamedirs;i++)
1585 FS_AddGameHierarchy (fs_gamedirs[i]);
1586 // update the com_modname (used server info)
1587 dp_strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1589 dp_strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1591 dp_strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1593 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1595 // add back the selfpack as new first item
1598 if (cls.state != ca_dedicated)
1600 // set the default screenshot name to either the mod name or the
1601 // gamemode screenshot name
1602 if (strcmp(com_modname, gamedirname1))
1603 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1605 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1608 if((i = Sys_CheckParm("-modname")) && i < sys.argc - 1)
1609 dp_strlcpy(com_modname, sys.argv[i+1], sizeof(com_modname));
1611 // If "-condebug" is in the command line, remove the previous log file
1612 if (Sys_CheckParm ("-condebug") != 0)
1613 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1615 // look for the pop.lmp file and set registered to true if it is found
1616 if (FS_FileExists("gfx/pop.lmp"))
1617 Cvar_SetValueQuick(®istered, 1);
1623 if (!registered.integer)
1626 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1628 Con_Print("Playing shareware version.\n");
1631 Con_Print("Playing registered version.\n");
1633 case GAME_STEELSTORM:
1634 if (registered.integer)
1635 Con_Print("Playing registered version.\n");
1637 Con_Print("Playing shareware version.\n");
1643 // unload all wads so that future queries will return the new data
1647 static void FS_Rescan_f(cmd_state_t *cmd)
1657 extern qbool vid_opened;
1658 qbool FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qbool complain, qbool failmissing)
1663 if (fs_numgamedirs == numgamedirs)
1665 for (i = 0;i < numgamedirs;i++)
1666 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1668 if (i == numgamedirs)
1669 return true; // already using this set of gamedirs, do nothing
1672 if (numgamedirs > MAX_GAMEDIRS)
1675 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1676 return false; // too many gamedirs
1679 for (i = 0;i < numgamedirs;i++)
1681 // if string is nasty, reject it
1682 p = FS_CheckGameDir(gamedirs[i]);
1686 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1687 return false; // nasty gamedirs
1689 if(p == fs_checkgamedir_missing && failmissing)
1692 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1693 return false; // missing gamedirs
1697 Host_SaveConfig(CONFIGFILENAME);
1699 fs_numgamedirs = numgamedirs;
1700 for (i = 0;i < fs_numgamedirs;i++)
1701 dp_strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1703 // reinitialize filesystem to detect the new paks
1706 if (cls.demoplayback)
1712 // unload all sounds so they will be reloaded from the new files as needed
1713 S_UnloadAllSounds_f(cmd_local);
1715 // reset everything that can be and reload configs
1716 Cbuf_InsertText(cmd_local, "\nloadconfig\n");
1726 static void FS_GameDir_f(cmd_state_t *cmd)
1730 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1732 if (Cmd_Argc(cmd) < 2)
1734 Con_Printf("gamedirs active:");
1735 for (i = 0;i < fs_numgamedirs;i++)
1736 Con_Printf(" %s", fs_gamedirs[i]);
1741 numgamedirs = Cmd_Argc(cmd) - 1;
1742 if (numgamedirs > MAX_GAMEDIRS)
1744 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1748 for (i = 0;i < numgamedirs;i++)
1749 dp_strlcpy(gamedirs[i], Cmd_Argv(cmd, i+1), sizeof(gamedirs[i]));
1751 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1753 // actually, changing during game would work fine, but would be stupid
1754 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1758 // halt demo playback to close the file
1761 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1764 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1772 stringlistinit(&list);
1773 listdirectory(&list, gamedir, "");
1774 success = list.numstrings > 0;
1775 stringlistfreecontents(&list);
1779 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1782 n = FS_Read (f, buf, buflength - 1);
1802 const char *FS_CheckGameDir(const char *gamedir)
1805 static char buf[8192];
1808 if (FS_CheckNastyPath(gamedir, true))
1811 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1816 // get description from basedir
1817 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1825 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1829 return fs_checkgamedir_missing;
1832 static void FS_ListGameDirs(void)
1834 stringlist_t list, list2;
1839 fs_all_gamedirs_count = 0;
1841 Mem_Free(fs_all_gamedirs);
1843 stringlistinit(&list);
1844 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1845 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1846 stringlistsort(&list, false);
1848 stringlistinit(&list2);
1849 for(i = 0; i < list.numstrings; ++i)
1852 if(!strcmp(list.strings[i-1], list.strings[i]))
1854 info = FS_CheckGameDir(list.strings[i]);
1857 if(info == fs_checkgamedir_missing)
1861 stringlistappend(&list2, list.strings[i]);
1863 stringlistfreecontents(&list);
1865 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1866 for(i = 0; i < list2.numstrings; ++i)
1868 info = FS_CheckGameDir(list2.strings[i]);
1869 // all this cannot happen any more, but better be safe than sorry
1872 if(info == fs_checkgamedir_missing)
1876 dp_strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1877 dp_strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1878 ++fs_all_gamedirs_count;
1884 #pragma comment(lib, "shell32.lib")
1889 static void COM_InsertFlags(const char *buf) {
1892 const char **new_argv;
1894 int args_left = 256;
1895 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*sys.argv) * (sys.argc + args_left + 2));
1897 new_argv[0] = "dummy"; // Can't really happen.
1899 new_argv[0] = sys.argv[0];
1902 while(COM_ParseToken_Console(&p))
1904 size_t sz = strlen(com_token) + 1; // shut up clang
1907 q = (char *)Mem_Alloc(fs_mempool, sz);
1908 dp_strlcpy(q, com_token, sz);
1912 // Now: i <= args_left + 1.
1915 memcpy((char *)(&new_argv[i]), &sys.argv[1], sizeof(*sys.argv) * (sys.argc - 1));
1918 // Now: i <= args_left + (sys.argc || 1).
1920 sys.argv = new_argv;
1924 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1926 #if defined(__IPHONEOS__)
1927 if (userdirmode == USERDIRMODE_HOME)
1929 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1930 // fs_userdir stores configurations to the Documents folder of the app
1931 dp_strlcpy(userdir, "../Documents/", MAX_OSPATH);
1936 #elif defined(WIN32)
1937 char homedir[WSTRBUF];
1939 #if _MSC_VER >= 1400
1942 wchar_t mydocsdirw[WSTRBUF];
1943 char mydocsdir[WSTRBUF];
1944 wchar_t *savedgamesdirw;
1945 char savedgamesdir[WSTRBUF] = {0};
1954 case USERDIRMODE_NOHOME:
1955 dp_strlcpy(userdir, fs_basedir, userdirsize);
1957 case USERDIRMODE_MYGAMES:
1959 Sys_LoadDependency(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1961 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdirw) == S_OK)
1963 narrow(mydocsdirw, mydocsdir);
1964 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1967 #if _MSC_VER >= 1400
1968 _wdupenv_s(&homedirw, &homedirwlen, L"USERPROFILE");
1969 narrow(homedirw, homedir);
1972 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1977 homedirw = _wgetenv(L"USERPROFILE");
1978 narrow(homedirw, homedir);
1981 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1986 case USERDIRMODE_SAVEDGAMES:
1988 Sys_LoadDependency(shell32dllnames, &shell32_dll, shell32funcs);
1990 Sys_LoadDependency(ole32dllnames, &ole32_dll, ole32funcs);
1991 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1993 savedgamesdir[0] = 0;
1994 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1997 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1999 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
2002 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
2004 narrow(savedgamesdirw, savedgamesdir);
2005 qCoTaskMemFree(savedgamesdirw);
2008 if (savedgamesdir[0])
2010 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
2025 case USERDIRMODE_NOHOME:
2026 dp_strlcpy(userdir, fs_basedir, userdirsize);
2028 case USERDIRMODE_HOME:
2029 homedir = getenv("HOME");
2032 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
2036 case USERDIRMODE_SAVEDGAMES:
2037 homedir = getenv("HOME");
2041 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
2043 // the XDG say some files would need to go in:
2044 // XDG_CONFIG_HOME (or ~/.config/%s/)
2045 // XDG_DATA_HOME (or ~/.local/share/%s/)
2046 // XDG_CACHE_HOME (or ~/.cache/%s/)
2047 // and also search the following global locations if defined:
2048 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
2049 // XDG_DATA_DIRS (normally /usr/share/%s/)
2050 // this would be too complicated...
2060 #if !defined(__IPHONEOS__)
2063 // historical behavior...
2064 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
2065 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
2068 // see if we can write to this path (note: won't create path)
2070 // no access() here, we must try to open the file for appending
2071 fd = FS_SysOpenFiledesc(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
2075 // on Unix, we don't need to ACTUALLY attempt to open the file
2076 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
2083 return 1; // good choice - the path exists and is writable
2087 if (userdirmode == USERDIRMODE_NOHOME)
2088 return -1; // path usually already exists, we lack permissions
2090 return 0; // probably good - failed to write but maybe we need to create path
2095 void FS_Init_Commands(void)
2097 Cvar_RegisterVariable (&scr_screenshot_name);
2098 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2099 Cvar_RegisterVariable (&fs_unload_dlcache);
2100 Cvar_RegisterVariable (&cvar_fs_gamedir);
2102 Cmd_AddCommand(CF_SHARED, "gamedir", FS_GameDir_f, "changes active gamedir list, can take multiple arguments which shouldn't include the base directory, the last gamedir is the \"primary\" and files will be saved there (example usage: gamedir ctf id1)");
2103 Cmd_AddCommand(CF_SHARED, "fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2104 Cmd_AddCommand(CF_SHARED, "path", FS_Path_f, "print searchpath (game directories and archives)");
2105 Cmd_AddCommand(CF_SHARED, "dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2106 Cmd_AddCommand(CF_SHARED, "ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2107 Cmd_AddCommand(CF_SHARED, "which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2110 static void FS_Init_Dir (void)
2120 // Overrides the system supplied base directory (under GAMENAME)
2121 // COMMANDLINEOPTION: Filesystem: -basedir <path> chooses what base directory the game data is in, inside this there should be a data directory for the game (for example id1)
2122 i = Sys_CheckParm ("-basedir");
2123 if (i && i < sys.argc-1)
2125 dp_strlcpy (fs_basedir, sys.argv[i+1], sizeof (fs_basedir));
2126 i = (int)strlen (fs_basedir);
2127 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
2128 fs_basedir[i-1] = 0;
2132 // If the base directory is explicitly defined by the compilation process
2133 #ifdef DP_FS_BASEDIR
2134 dp_strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
2135 #elif defined(__ANDROID__)
2136 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
2137 #elif defined(MACOSX)
2138 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
2139 if (strstr(sys.argv[0], ".app/"))
2142 dp_strlcpy(fs_basedir, sys.argv[0], sizeof(fs_basedir));
2143 split = strstr(fs_basedir, ".app/");
2146 struct stat statresult;
2148 // truncate to just after the .app/
2150 // see if gamedir exists in Resources
2151 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
2153 // found gamedir inside Resources, use it
2154 dp_strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
2158 // no gamedir found in Resources, gamedir is probably
2159 // outside the .app, remove .app part of path
2160 while (split > fs_basedir && *split != '/')
2169 // make sure the appending of a path separator won't create an unterminated string
2170 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
2171 // add a path separator to the end of the basedir if it lacks one
2172 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
2173 dp_strlcat(fs_basedir, "/", sizeof(fs_basedir));
2175 // Add the personal game directory
2176 if((i = Sys_CheckParm("-userdir")) && i < sys.argc - 1)
2177 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", sys.argv[i+1]);
2178 else if (Sys_CheckParm("-nohome"))
2179 *fs_userdir = 0; // user wants roaming installation, no userdir
2182 #ifdef DP_FS_USERDIR
2183 dp_strlcpy(fs_userdir, DP_FS_USERDIR, sizeof(fs_userdir));
2186 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2187 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2188 int userdirstatus[USERDIRMODE_COUNT];
2190 // historical behavior...
2191 if (!strcmp(gamedirname1, "id1"))
2192 preferreduserdirmode = USERDIRMODE_NOHOME;
2194 // check what limitations the user wants to impose
2195 if (Sys_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2196 if (Sys_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2197 if (Sys_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2198 // gather the status of the possible userdirs
2199 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2201 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2202 if (userdirstatus[dirmode] == 1)
2203 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2204 else if (userdirstatus[dirmode] == 0)
2205 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2207 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2209 // some games may prefer writing to basedir, but if write fails we
2210 // have to search for a real userdir...
2211 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2212 preferreduserdirmode = highestuserdirmode;
2213 // check for an existing userdir and continue using it if possible...
2214 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2215 if (userdirstatus[dirmode] == 1)
2217 // if no existing userdir found, make a new one...
2218 if (dirmode == 0 && preferreduserdirmode > 0)
2219 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2220 if (userdirstatus[dirmode] >= 0)
2222 // and finally, we picked one...
2223 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2224 Con_DPrintf("userdir %i is the winner\n", dirmode);
2228 // if userdir equal to basedir, clear it to avoid confusion later
2229 if (!strcmp(fs_basedir, fs_userdir))
2234 p = FS_CheckGameDir(gamedirname1);
2235 if(!p || p == fs_checkgamedir_missing)
2236 Con_Printf(CON_WARN "WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2240 p = FS_CheckGameDir(gamedirname2);
2241 if(!p || p == fs_checkgamedir_missing)
2242 Con_Printf(CON_WARN "WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2246 // Adds basedir/gamedir as an override game
2247 // LadyHavoc: now supports multiple -game directories
2248 for (i = 1;i < sys.argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2252 if (!strcmp (sys.argv[i], "-game") && i < sys.argc-1)
2255 p = FS_CheckGameDir(sys.argv[i]);
2257 Con_Printf("WARNING: Nasty -game name rejected: %s\n", sys.argv[i]);
2258 if(p == fs_checkgamedir_missing)
2259 Con_Printf(CON_WARN "WARNING: -game %s%s/ not found!\n", fs_basedir, sys.argv[i]);
2260 // add the gamedir to the list of active gamedirs
2261 dp_strlcpy (fs_gamedirs[fs_numgamedirs], sys.argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2266 // generate the searchpath
2269 if (Thread_HasThreads())
2270 fs_mutex = Thread_CreateMutex();
2278 void FS_Init_SelfPack (void)
2282 // Load darkplaces.opt from the FS.
2283 if (!Sys_CheckParm("-noopt"))
2285 buf = (char *) FS_SysLoadFile("darkplaces.opt", tempmempool, true, NULL);
2288 COM_InsertFlags(buf);
2294 // Provide the SelfPack.
2295 if (!Sys_CheckParm("-noselfpack") && sys.selffd >= 0)
2297 fs_selfpack = FS_LoadPackPK3FromFD(sys.argv[0], sys.selffd, true);
2301 if (!Sys_CheckParm("-noopt"))
2303 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
2306 COM_InsertFlags(buf);
2323 fs_mempool = Mem_AllocPool("file management", 0, NULL);
2329 // initialize the self-pack (must be before COM_InitGameType as it may add command line options)
2332 // detect gamemode from commandline options or executable name
2343 void FS_Shutdown (void)
2345 // close all pack files and such
2346 // (hopefully there aren't any other open files, but they'll be cleaned up
2347 // by the OS anyway)
2348 FS_ClearSearchPath();
2349 Mem_FreePool (&fs_mempool);
2350 PK3_CloseLibrary ();
2353 Sys_FreeLibrary (&shfolder_dll);
2354 Sys_FreeLibrary (&shell32_dll);
2355 Sys_FreeLibrary (&ole32_dll);
2359 Thread_DestroyMutex(fs_mutex);
2362 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qbool nonblocking)
2364 filedesc_t handle = FILEDESC_INVALID;
2367 qbool dolock = false;
2369 wchar filepathw[WSTRBUF] = {0};
2372 // Parse the mode string
2381 opt = O_CREAT | O_TRUNC;
2385 opt = O_CREAT | O_APPEND;
2388 Con_Printf(CON_ERROR "FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2389 return FILEDESC_INVALID;
2391 for (ind = 1; mode[ind] != '\0'; ind++)
2405 Con_Printf(CON_ERROR "FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2406 filepath, mode, mode[ind]);
2413 if(Sys_CheckParm("-readonly") && mod != O_RDONLY)
2414 return FILEDESC_INVALID;
2418 return FILEDESC_INVALID;
2419 handle = SDL_RWFromFile(filepath, mode);
2422 widen(filepath, filepathw);
2423 # if _MSC_VER >= 1400
2424 _wsopen_s(&handle, filepathw, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2426 handle = _wsopen (filepathw, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2429 handle = open (filepath, mod | opt, 0666);
2430 if(handle >= 0 && dolock)
2433 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2434 l.l_whence = SEEK_SET;
2437 if(fcntl(handle, F_SETLK, &l) == -1)
2439 FILEDESC_CLOSE(handle);
2449 int FS_SysOpenFD(const char *filepath, const char *mode, qbool nonblocking)
2454 return FS_SysOpenFiledesc(filepath, mode, nonblocking);
2459 ====================
2462 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2463 ====================
2465 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qbool nonblocking)
2469 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2471 file->handle = FS_SysOpenFiledesc(filepath, mode, nonblocking);
2472 if (!FILEDESC_ISVALID(file->handle))
2478 file->filename = Mem_strdup(fs_mempool, filepath);
2480 file->real_length = FILEDESC_SEEK (file->handle, 0, SEEK_END);
2482 // For files opened in append mode, we start at the end of the file
2484 file->position = file->real_length;
2486 FILEDESC_SEEK (file->handle, 0, SEEK_SET);
2496 Open a packed file using its package file descriptor
2499 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2502 filedesc_t dup_handle;
2505 pfile = &pack->files[pack_ind];
2507 // If we don't have the true offset, get it now
2508 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2509 if (!PK3_GetTrueFileOffset (pfile, pack))
2512 #ifndef LINK_TO_ZLIB
2513 // No Zlib DLL = no compressed files
2514 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2516 Con_Printf(CON_WARN "WARNING: can't open the compressed file %s\n"
2517 "You need the Zlib DLL to use compressed files\n",
2523 // LadyHavoc: FILEDESC_SEEK affects all duplicates of a handle so we do it before
2524 // the dup() call to avoid having to close the dup_handle on error here
2525 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
2527 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2528 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2532 dup_handle = FILEDESC_DUP (pack->filename, pack->handle);
2533 if (!FILEDESC_ISVALID(dup_handle))
2535 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2539 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2540 memset (file, 0, sizeof (*file));
2541 file->handle = dup_handle;
2542 file->flags = QFILE_FLAG_PACKED;
2543 file->real_length = pfile->realsize;
2544 file->offset = pfile->offset;
2548 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2552 file->flags |= QFILE_FLAG_DEFLATED;
2554 // We need some more variables
2555 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2557 ztk->comp_length = pfile->packsize;
2559 // Initialize zlib stream
2560 ztk->zstream.next_in = ztk->input;
2561 ztk->zstream.avail_in = 0;
2563 /* From Zlib's "unzip.c":
2565 * windowBits is passed < 0 to tell that there is no zlib header.
2566 * Note that in this case inflate *requires* an extra "dummy" byte
2567 * after the compressed stream in order to complete decompression and
2568 * return Z_STREAM_END.
2569 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2570 * size of both compressed and uncompressed data
2572 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2574 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2575 FILEDESC_CLOSE(dup_handle);
2580 ztk->zstream.next_out = file->buff;
2581 ztk->zstream.avail_out = sizeof (file->buff);
2590 ====================
2593 Return true if the path should be rejected due to one of the following:
2594 1: path elements that are non-portable
2595 2: path elements that would allow access to files outside the game directory,
2596 or are just not a good idea for a mod to be using.
2597 ====================
2599 int FS_CheckNastyPath (const char *path, qbool isgamedir)
2601 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2605 // Windows: don't allow \ in filenames (windows-only), period.
2606 // (on Windows \ is a directory separator, but / is also supported)
2607 if (strstr(path, "\\"))
2608 return 1; // non-portable
2610 // Mac: don't allow Mac-only filenames - : is a directory separator
2611 // instead of /, but we rely on / working already, so there's no reason to
2612 // support a Mac-only path
2613 // Amiga and Windows: : tries to go to root of drive
2614 if (strstr(path, ":"))
2615 return 1; // non-portable attempt to go to root of drive
2617 // Amiga: // is parent directory
2618 if (strstr(path, "//"))
2619 return 1; // non-portable attempt to go to parent directory
2621 // all: don't allow going to parent directory (../ or /../)
2622 if (strstr(path, ".."))
2623 return 2; // attempt to go outside the game directory
2625 // Windows and UNIXes: don't allow absolute paths
2627 return 2; // attempt to go outside the game directory
2629 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2630 if (strstr(path, "./"))
2631 return 2; // possible attempt to go outside the game directory
2633 // all: forbid trailing slash on gamedir
2634 if (isgamedir && path[strlen(path)-1] == '/')
2637 // all: forbid leading dot on any filename for any reason
2638 if (strstr(path, "/."))
2639 return 2; // attempt to go outside the game directory
2641 // after all these checks we're pretty sure it's a / separated filename
2642 // and won't do much if any harm
2647 ====================
2650 Sanitize path (replace non-portable characters
2651 with portable ones in-place, etc)
2652 ====================
2654 void FS_SanitizePath(char *path)
2656 for (; *path; path++)
2662 ====================
2665 Look for a file in the packages and in the filesystem
2667 Return the searchpath where the file was found (or NULL)
2668 and the file index in the package if relevant
2669 ====================
2671 static searchpath_t *FS_FindFile (const char *name, int *index, const char **canonicalname, qbool quiet)
2673 searchpath_t *search;
2676 // search through the path, one element at a time
2677 for (search = fs_searchpaths;search;search = search->next)
2679 // is the element a pak file?
2680 if (search->pack && !search->pack->vpack)
2682 int (*strcmp_funct) (const char* str1, const char* str2);
2683 int left, right, middle;
2686 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2688 // Look for the file (binary search)
2690 right = pak->numfiles - 1;
2691 while (left <= right)
2695 middle = (left + right) / 2;
2696 diff = strcmp_funct (pak->files[middle].name, name);
2701 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2703 // yes, but the first one is empty so we treat it as not being there
2704 if (!quiet && developer_extra.integer)
2705 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2710 *canonicalname = NULL;
2714 if (!quiet && developer_extra.integer)
2715 Con_DPrintf("FS_FindFile: %s in %s\n", pak->files[middle].name, pak->filename);
2720 *canonicalname = pak->files[middle].name;
2724 // If we're too far in the list
2733 char netpath[MAX_OSPATH];
2734 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2735 if (FS_SysFileExists (netpath))
2737 if (!quiet && developer_extra.integer)
2738 Con_DPrintf("FS_FindFile: %s\n", netpath);
2743 *canonicalname = name;
2749 if (!quiet && developer_extra.integer)
2750 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2755 *canonicalname = NULL;
2764 Look for a file in the search paths and open it in read-only mode
2767 static qfile_t *FS_OpenReadFile (const char *filename, qbool quiet, qbool nonblocking, int symlinkLevels)
2769 searchpath_t *search;
2772 search = FS_FindFile (filename, &pack_ind, NULL, quiet);
2778 // Found in the filesystem?
2781 // this works with vpacks, so we are fine
2782 char path [MAX_OSPATH];
2783 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2784 return FS_SysOpen (path, "rb", nonblocking);
2787 // So, we found it in a package...
2789 // Is it a PK3 symlink?
2790 // TODO also handle directory symlinks by parsing the whole structure...
2791 // but heck, file symlinks are good enough for now
2792 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2794 if(symlinkLevels <= 0)
2796 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2801 char linkbuf[MAX_QPATH];
2803 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2804 const char *mergeslash;
2809 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2815 // Now combine the paths...
2816 mergeslash = strrchr(filename, '/');
2817 mergestart = linkbuf;
2819 mergeslash = filename;
2820 while(!strncmp(mergestart, "../", 3))
2823 while(mergeslash > filename)
2826 if(*mergeslash == '/')
2830 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2831 if(mergeslash == filename)
2833 // Either mergeslash == filename, then we just replace the name (done below)
2837 // Or, we append the name after mergeslash;
2838 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2839 int spaceNeeded = mergeslash - filename + 1;
2840 int spaceRemoved = mergestart - linkbuf;
2841 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2843 Con_DPrintf("symlink: too long path rejected\n");
2846 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2847 memcpy(linkbuf, filename, spaceNeeded);
2848 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2849 mergestart = linkbuf;
2851 if (!quiet && developer_loading.integer)
2852 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2853 if(FS_CheckNastyPath (mergestart, false))
2855 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2858 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2862 return FS_OpenPackedFile (search->pack, pack_ind);
2867 =============================================================================
2869 MAIN PUBLIC FUNCTIONS
2871 =============================================================================
2875 ====================
2878 Open a file in the userpath. The syntax is the same as fopen
2879 Used for savegame scanning in menu, and all file writing.
2880 ====================
2882 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qbool quiet)
2884 char real_path [MAX_OSPATH];
2886 if (FS_CheckNastyPath(filepath, false))
2888 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2892 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2894 // If the file is opened in "write", "append", or "read/write" mode,
2895 // create directories up to the file.
2896 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2897 FS_CreatePath (real_path);
2898 return FS_SysOpen (real_path, mode, false);
2903 ====================
2906 Open a file. The syntax is the same as fopen
2907 ====================
2909 qfile_t* FS_OpenVirtualFile (const char* filepath, qbool quiet)
2911 qfile_t *result = NULL;
2912 if (FS_CheckNastyPath(filepath, false))
2914 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2918 if (fs_mutex) Thread_LockMutex(fs_mutex);
2919 result = FS_OpenReadFile (filepath, quiet, false, 16);
2920 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2926 ====================
2929 Open a file. The syntax is the same as fopen
2930 ====================
2932 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qbool quiet)
2935 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2936 memset (file, 0, sizeof (*file));
2937 file->flags = QFILE_FLAG_DATA;
2939 file->real_length = size;
2945 ====================
2949 ====================
2951 int FS_Close (qfile_t* file)
2953 if(file->flags & QFILE_FLAG_DATA)
2959 if (FILEDESC_CLOSE (file->handle))
2964 if (file->flags & QFILE_FLAG_REMOVE)
2966 if (remove(file->filename) == -1)
2968 // No need to report this. If removing a just
2969 // written file failed, this most likely means
2970 // someone else deleted it first - which we
2975 Mem_Free((void *) file->filename);
2980 qz_inflateEnd (&file->ztk->zstream);
2981 Mem_Free (file->ztk);
2988 void FS_RemoveOnClose(qfile_t* file)
2990 file->flags |= QFILE_FLAG_REMOVE;
2994 ====================
2997 Write "datasize" bytes into a file
2998 ====================
3000 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
3002 fs_offset_t written = 0;
3004 // If necessary, seek to the exact file position we're supposed to be
3005 if (file->buff_ind != file->buff_len)
3007 if (FILEDESC_SEEK (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
3009 Con_Printf(CON_WARN "WARNING: could not seek in %s.\n", file->filename);
3013 // Purge cached data
3016 // Write the buffer and update the position
3017 // LadyHavoc: to hush a warning about passing size_t to an unsigned int parameter on Win64 we do this as multiple writes if the size would be too big for an integer (we never write that big in one go, but it's a theory)
3018 while (written < (fs_offset_t)datasize)
3020 // figure out how much to write in one chunk
3021 fs_offset_t maxchunk = 1<<30; // 1 GiB
3022 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
3023 int result = (int)FILEDESC_WRITE (file->handle, (const unsigned char *)data + written, chunk);
3024 // if at least some was written, add it to our accumulator
3027 // if the result is not what we expected, consider the write to be incomplete
3028 if (result != chunk)
3031 file->position = FILEDESC_SEEK (file->handle, 0, SEEK_CUR);
3032 if (file->real_length < file->position)
3033 file->real_length = file->position;
3035 // note that this will never be less than 0 even if the write failed
3041 ====================
3044 Read up to "buffersize" bytes from a file
3045 ====================
3047 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
3049 fs_offset_t count, done;
3051 if (buffersize == 0 || !buffer)
3054 // Get rid of the ungetc character
3055 if (file->ungetc != EOF)
3057 ((char*)buffer)[0] = file->ungetc;
3065 if(file->flags & QFILE_FLAG_DATA)
3067 size_t left = file->real_length - file->position;
3068 if(buffersize > left)
3070 memcpy(buffer, file->data + file->position, buffersize);
3071 file->position += buffersize;
3075 // First, we copy as many bytes as we can from "buff"
3076 if (file->buff_ind < file->buff_len)
3078 count = file->buff_len - file->buff_ind;
3079 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
3081 memcpy (buffer, &file->buff[file->buff_ind], count);
3082 file->buff_ind += count;
3084 buffersize -= count;
3085 if (buffersize == 0)
3089 // NOTE: at this point, the read buffer is always empty
3091 // If the file isn't compressed
3092 if (! (file->flags & QFILE_FLAG_DEFLATED))
3096 // We must take care to not read after the end of the file
3097 count = file->real_length - file->position;
3099 // If we have a lot of data to get, put them directly into "buffer"
3100 if (buffersize > sizeof (file->buff) / 2)
3102 if (count > (fs_offset_t)buffersize)
3103 count = (fs_offset_t)buffersize;
3104 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
3106 // Seek failed. When reading from a pipe, and
3107 // the caller never called FS_Seek, this still
3108 // works fine. So no reporting this error.
3110 nb = FILEDESC_READ (file->handle, &((unsigned char*)buffer)[done], count);
3114 file->position += nb;
3116 // Purge cached data
3122 if (count > (fs_offset_t)sizeof (file->buff))
3123 count = (fs_offset_t)sizeof (file->buff);
3124 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
3126 // Seek failed. When reading from a pipe, and
3127 // the caller never called FS_Seek, this still
3128 // works fine. So no reporting this error.
3130 nb = FILEDESC_READ (file->handle, file->buff, count);
3133 file->buff_len = nb;
3134 file->position += nb;
3136 // Copy the requested data in "buffer" (as much as we can)
3137 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
3138 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
3139 file->buff_ind = count;
3147 // If the file is compressed, it's more complicated...
3148 // We cycle through a few operations until we have read enough data
3149 while (buffersize > 0)
3151 ztoolkit_t *ztk = file->ztk;
3154 // NOTE: at this point, the read buffer is always empty
3156 // If "input" is also empty, we need to refill it
3157 if (ztk->in_ind == ztk->in_len)
3159 // If we are at the end of the file
3160 if (file->position == file->real_length)
3163 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
3164 if (count > (fs_offset_t)sizeof (ztk->input))
3165 count = (fs_offset_t)sizeof (ztk->input);
3166 FILEDESC_SEEK (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
3167 if (FILEDESC_READ (file->handle, ztk->input, count) != count)
3169 Con_Printf ("FS_Read: unexpected end of file\n");
3174 ztk->in_len = count;
3175 ztk->in_position += count;
3178 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
3179 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
3181 // Now that we are sure we have compressed data available, we need to determine
3182 // if it's better to inflate it in "file->buff" or directly in "buffer"
3184 // Inflate the data in "file->buff"
3185 if (buffersize < sizeof (file->buff) / 2)
3187 ztk->zstream.next_out = file->buff;
3188 ztk->zstream.avail_out = sizeof (file->buff);
3189 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3190 if (error != Z_OK && error != Z_STREAM_END)
3192 Con_Printf ("FS_Read: Can't inflate file\n");
3195 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3197 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
3198 file->position += file->buff_len;
3200 // Copy the requested data in "buffer" (as much as we can)
3201 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
3202 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
3203 file->buff_ind = count;
3206 // Else, we inflate directly in "buffer"
3209 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
3210 ztk->zstream.avail_out = (unsigned int)buffersize;
3211 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3212 if (error != Z_OK && error != Z_STREAM_END)
3214 Con_Printf ("FS_Read: Can't inflate file\n");
3217 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3219 // How much data did it inflate?
3220 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
3221 file->position += count;
3223 // Purge cached data
3228 buffersize -= count;
3236 ====================
3239 Print a string into a file
3240 ====================
3242 int FS_Print (qfile_t* file, const char *msg)
3244 return (int)FS_Write (file, msg, strlen (msg));
3248 ====================
3251 Print a string into a file
3252 ====================
3254 int FS_Printf(qfile_t* file, const char* format, ...)
3259 va_start (args, format);
3260 result = FS_VPrintf (file, format, args);
3268 ====================
3271 Print a string into a file
3272 ====================
3274 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3277 fs_offset_t buff_size = MAX_INPUTLINE;
3282 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3283 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3284 if (len >= 0 && len < buff_size)
3286 Mem_Free (tempbuff);
3290 len = FILEDESC_WRITE (file->handle, tempbuff, len);
3291 Mem_Free (tempbuff);
3298 ====================
3301 Get the next character of a file
3302 ====================
3304 int FS_Getc (qfile_t* file)
3308 if (FS_Read (file, &c, 1) != 1)
3316 ====================
3319 Put a character back into the read buffer (only supports one character!)
3320 ====================
3322 int FS_UnGetc (qfile_t* file, unsigned char c)
3324 // If there's already a character waiting to be read
3325 if (file->ungetc != EOF)
3334 ====================
3337 Move the position index in a file
3338 ====================
3340 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3343 unsigned char* buffer;
3344 fs_offset_t buffersize;
3346 // Compute the file offset
3350 offset += file->position - file->buff_len + file->buff_ind;
3357 offset += file->real_length;
3363 if (offset < 0 || offset > file->real_length)
3366 if(file->flags & QFILE_FLAG_DATA)
3368 file->position = offset;
3372 // If we have the data in our read buffer, we don't need to actually seek
3373 if (file->position - file->buff_len <= offset && offset <= file->position)
3375 file->buff_ind = offset + file->buff_len - file->position;
3379 // Purge cached data
3382 // Unpacked or uncompressed files can seek directly
3383 if (! (file->flags & QFILE_FLAG_DEFLATED))
3385 if (FILEDESC_SEEK (file->handle, file->offset + offset, SEEK_SET) == -1)
3387 file->position = offset;
3391 // Seeking in compressed files is more a hack than anything else,
3392 // but we need to support it, so here we go.
3395 // If we have to go back in the file, we need to restart from the beginning
3396 if (offset <= file->position)
3400 ztk->in_position = 0;
3402 if (FILEDESC_SEEK (file->handle, file->offset, SEEK_SET) == -1)
3403 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3405 // Reset the Zlib stream
3406 ztk->zstream.next_in = ztk->input;
3407 ztk->zstream.avail_in = 0;
3408 qz_inflateReset (&ztk->zstream);
3411 // We need a big buffer to force inflating into it directly
3412 buffersize = 2 * sizeof (file->buff);
3413 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3415 // Skip all data until we reach the requested offset
3416 while (offset > (file->position - file->buff_len + file->buff_ind))
3418 fs_offset_t diff = offset - (file->position - file->buff_len + file->buff_ind);
3419 fs_offset_t count, len;
3421 count = (diff > buffersize) ? buffersize : diff;
3422 len = FS_Read (file, buffer, count);
3436 ====================
3439 Give the current position in a file
3440 ====================
3442 fs_offset_t FS_Tell (qfile_t* file)
3444 return file->position - file->buff_len + file->buff_ind;
3449 ====================
3452 Give the total size of a file
3453 ====================
3455 fs_offset_t FS_FileSize (qfile_t* file)
3457 return file->real_length;
3462 ====================
3465 Erases any buffered input or output data
3466 ====================
3468 void FS_Purge (qfile_t* file)
3478 FS_LoadAndCloseQFile
3480 Loads full content of a qfile_t and closes it.
3481 Always appends a 0 byte.
3484 static unsigned char *FS_LoadAndCloseQFile (qfile_t *file, const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3486 unsigned char *buf = NULL;
3487 fs_offset_t filesize = 0;
3491 filesize = file->real_length;
3494 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3499 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3500 buf[filesize] = '\0';
3501 FS_Read (file, buf, filesize);
3503 if (developer_loadfile.integer)
3504 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3507 if (filesizepointer)
3508 *filesizepointer = filesize;
3517 Filename are relative to the quake directory.
3518 Always appends a 0 byte.
3521 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3523 qfile_t *file = FS_OpenVirtualFile(path, quiet);
3524 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3532 Filename are OS paths.
3533 Always appends a 0 byte.
3536 unsigned char *FS_SysLoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3538 qfile_t *file = FS_SysOpen(path, "rb", false);
3539 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3547 The filename will be prefixed by the current game directory
3550 qbool FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3554 fs_offset_t lentotal;
3556 file = FS_OpenRealFile(filename, "wb", false);
3559 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3564 for(i = 0; i < count; ++i)
3566 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3567 for(i = 0; i < count; ++i)
3568 FS_Write (file, data[i], len[i]);
3573 qbool FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3575 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3580 =============================================================================
3582 OTHERS PUBLIC FUNCTIONS
3584 =============================================================================
3592 void FS_StripExtension (const char *in, char *out, size_t size_out)
3600 while ((currentchar = *in) && size_out > 1)
3602 if (currentchar == '.')
3604 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3606 *out++ = currentchar;
3622 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3626 // if path doesn't have a .EXT, append extension
3627 // (extension should include the .)
3628 src = path + strlen(path);
3630 while (*src != '/' && src != path)
3633 return; // it has an extension
3637 dp_strlcat (path, extension, size_path);
3645 Look for a file in the packages and in the filesystem
3648 int FS_FileType (const char *filename)
3650 searchpath_t *search;
3651 char fullpath[MAX_OSPATH];
3653 search = FS_FindFile (filename, NULL, NULL, true);
3655 return FS_FILETYPE_NONE;
3657 if(search->pack && !search->pack->vpack)
3658 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3660 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3661 return FS_SysFileType(fullpath);
3669 Look for a file in the packages and in the filesystem
3670 Returns its canonical name (VFS path with correct capitalisation) if found, else NULL.
3671 If the file is found outside a pak, this will be the same pointer as passed in.
3674 const char *FS_FileExists (const char *filename)
3676 const char *canonicalname;
3678 return FS_FindFile(filename, NULL, &canonicalname, true) ? canonicalname : NULL;
3686 Look for a file in the filesystem only
3689 int FS_SysFileType (const char *path)
3692 // Sajt - some older sdks are missing this define
3693 # ifndef INVALID_FILE_ATTRIBUTES
3694 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3696 wchar pathw[WSTRBUF] = {0};
3699 result = GetFileAttributesW(pathw);
3701 if(result == INVALID_FILE_ATTRIBUTES)
3702 return FS_FILETYPE_NONE;
3704 if(result & FILE_ATTRIBUTE_DIRECTORY)
3705 return FS_FILETYPE_DIRECTORY;
3707 return FS_FILETYPE_FILE;
3711 if (stat (path,&buf) == -1)
3712 return FS_FILETYPE_NONE;
3715 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3717 if(S_ISDIR(buf.st_mode))
3718 return FS_FILETYPE_DIRECTORY;
3720 return FS_FILETYPE_FILE;
3724 qbool FS_SysFileExists (const char *path)
3726 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3733 Allocate and fill a search structure with information on matching filenames.
3736 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet, const char *packfile)
3739 searchpath_t *searchpath;
3741 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3742 stringlist_t resultlist;
3743 stringlist_t dirlist;
3744 stringlist_t matchedSet, foundSet;
3745 const char *start, *slash, *backslash, *colon, *separator;
3748 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3753 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3757 stringlistinit(&resultlist);
3758 stringlistinit(&dirlist);
3760 slash = strrchr(pattern, '/');
3761 backslash = strrchr(pattern, '\\');
3762 colon = strrchr(pattern, ':');
3763 separator = max(slash, backslash);
3764 separator = max(separator, colon);
3765 basepathlength = separator ? (separator + 1 - pattern) : 0;
3766 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3768 memcpy(basepath, pattern, basepathlength);
3769 basepath[basepathlength] = 0;
3771 // search through the path, one element at a time
3772 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3774 // is the element a pak file?
3775 if (searchpath->pack && !searchpath->pack->vpack)
3777 // look through all the pak file elements
3778 pak = searchpath->pack;
3781 if(strcmp(packfile, pak->shortname))
3784 for (i = 0;i < pak->numfiles;i++)
3786 char temp[MAX_OSPATH];
3787 dp_strlcpy(temp, pak->files[i].name, sizeof(temp));
3790 if (matchpattern(temp, (char *)pattern, true))
3792 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3793 if (!strcmp(resultlist.strings[resultlistindex], temp))
3795 if (resultlistindex == resultlist.numstrings)
3797 stringlistappend(&resultlist, temp);
3798 if (!quiet && developer_loading.integer)
3799 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3802 // strip off one path element at a time until empty
3803 // this way directories are added to the listing if they match the pattern
3804 slash = strrchr(temp, '/');
3805 backslash = strrchr(temp, '\\');
3806 colon = strrchr(temp, ':');
3808 if (separator < slash)
3810 if (separator < backslash)
3811 separator = backslash;
3812 if (separator < colon)
3814 *((char *)separator) = 0;
3825 stringlistinit(&matchedSet);
3826 stringlistinit(&foundSet);
3827 // add a first entry to the set
3828 stringlistappend(&matchedSet, "");
3829 // iterate through pattern's path
3832 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3833 char subpath[MAX_OSPATH];
3834 char subpattern[MAX_OSPATH];
3836 // find the next wildcard
3837 wildcard = strchr(start, '?');
3838 asterisk = strchr(start, '*');
3839 if (asterisk && (!wildcard || asterisk < wildcard))
3841 wildcard = asterisk;
3846 nextseparator = strchr( wildcard, '/' );
3850 nextseparator = NULL;
3853 if( !nextseparator ) {
3854 nextseparator = start + strlen( start );
3857 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3858 // copy everything up except nextseperator
3859 dp_ustr2stp(subpattern, sizeof(subpattern), pattern, nextseparator - pattern);
3860 // find the last '/' before the wildcard
3861 prevseparator = strrchr( subpattern, '/' );
3863 prevseparator = subpattern;
3866 // copy everything from start to the previous including the '/' (before the wildcard)
3867 // everything up to start is already included in the path of matchedSet's entries
3868 dp_ustr2stp(subpath, sizeof(subpath), start, (prevseparator - subpattern) - (start - pattern));
3870 // for each entry in matchedSet try to open the subdirectories specified in subpath
3871 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3872 char temp[MAX_OSPATH];
3873 dp_strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3874 dp_strlcat( temp, subpath, sizeof(temp) );
3875 listdirectory( &foundSet, searchpath->filename, temp );
3877 if( dirlistindex == 0 ) {
3880 // reset the current result set
3881 stringlistfreecontents( &matchedSet );
3882 // match against the pattern
3883 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3884 const char *direntry = foundSet.strings[ dirlistindex ];
3885 if (matchpattern(direntry, subpattern, true)) {
3886 stringlistappend( &matchedSet, direntry );
3889 stringlistfreecontents( &foundSet );
3891 start = nextseparator;
3894 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3896 const char *matchtemp = matchedSet.strings[dirlistindex];
3897 if (matchpattern(matchtemp, (char *)pattern, true))
3899 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3900 if (!strcmp(resultlist.strings[resultlistindex], matchtemp))
3902 if (resultlistindex == resultlist.numstrings)
3904 stringlistappend(&resultlist, matchtemp);
3905 if (!quiet && developer_loading.integer)
3906 Con_Printf("SearchDirFile: %s\n", matchtemp);
3910 stringlistfreecontents( &matchedSet );
3914 if (resultlist.numstrings)
3916 stringlistsort(&resultlist, true);
3917 numfiles = resultlist.numstrings;
3919 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3920 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3921 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3922 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3923 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3924 search->numfilenames = (int)numfiles;
3927 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3930 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3931 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3932 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3934 numchars += (int)textlen;
3937 stringlistfreecontents(&resultlist);
3943 void FS_FreeSearch(fssearch_t *search)
3948 extern int con_linewidth;
3949 static int FS_ListDirectory(const char *pattern, int oneperline)
3958 char linebuf[MAX_INPUTLINE];
3960 search = FS_Search(pattern, true, true, NULL);
3963 numfiles = search->numfilenames;
3966 // FIXME: the names could be added to one column list and then
3967 // gradually shifted into the next column if they fit, and then the
3968 // next to make a compact variable width listing but it's a lot more
3970 // find width for columns
3972 for (i = 0;i < numfiles;i++)
3974 l = (int)strlen(search->filenames[i]);
3975 if (columnwidth < l)
3978 // count the spacing character
3980 // calculate number of columns
3981 numcolumns = con_linewidth / columnwidth;
3982 // don't bother with the column printing if it's only one column
3983 if (numcolumns >= 2)
3985 numlines = (numfiles + numcolumns - 1) / numcolumns;
3986 for (i = 0;i < numlines;i++)
3989 for (k = 0;k < numcolumns;k++)
3991 l = i * numcolumns + k;
3994 name = search->filenames[l];
3995 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3996 linebuf[linebufpos++] = name[j];
3997 // space out name unless it's the last on the line
3998 if (k + 1 < numcolumns && l + 1 < numfiles)
3999 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
4000 linebuf[linebufpos++] = ' ';
4003 linebuf[linebufpos] = 0;
4004 Con_Printf("%s\n", linebuf);
4011 for (i = 0;i < numfiles;i++)
4012 Con_Printf("%s\n", search->filenames[i]);
4013 FS_FreeSearch(search);
4014 return (int)numfiles;
4017 static void FS_ListDirectoryCmd (cmd_state_t *cmd, const char* cmdname, int oneperline)
4019 const char *pattern;
4020 if (Cmd_Argc(cmd) >= 3)
4022 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
4025 if (Cmd_Argc(cmd) == 2)
4026 pattern = Cmd_Argv(cmd, 1);
4029 if (!FS_ListDirectory(pattern, oneperline))
4030 Con_Print("No files found.\n");
4033 void FS_Dir_f(cmd_state_t *cmd)
4035 FS_ListDirectoryCmd(cmd, "dir", true);
4038 void FS_Ls_f(cmd_state_t *cmd)
4040 FS_ListDirectoryCmd(cmd, "ls", false);
4043 void FS_Which_f(cmd_state_t *cmd)
4045 const char *filename;
4048 if (Cmd_Argc(cmd) != 2)
4050 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(cmd, 0));
4053 filename = Cmd_Argv(cmd, 1);
4054 sp = FS_FindFile(filename, &index, NULL, true);
4056 Con_Printf("%s isn't anywhere\n", filename);
4062 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
4064 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
4067 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
4071 const char *FS_WhichPack(const char *filename)
4074 searchpath_t *sp = FS_FindFile(filename, &index, NULL, true);
4076 return sp->pack->shortname;
4084 ====================
4085 FS_IsRegisteredQuakePack
4087 Look for a proof of purchase file file in the requested package
4089 If it is found, this file should NOT be downloaded.
4090 ====================
4092 qbool FS_IsRegisteredQuakePack(const char *name)
4094 searchpath_t *search;
4097 // search through the path, one element at a time
4098 for (search = fs_searchpaths;search;search = search->next)
4100 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
4101 // TODO do we want to support vpacks in here too?
4103 int (*strcmp_funct) (const char* str1, const char* str2);
4104 int left, right, middle;
4107 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
4109 // Look for the file (binary search)
4111 right = pak->numfiles - 1;
4112 while (left <= right)
4116 middle = (left + right) / 2;
4117 diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
4123 // If we're too far in the list
4130 // we found the requested pack but it is not registered quake
4138 int FS_CRCFile(const char *filename, size_t *filesizepointer)
4141 unsigned char *filedata;
4142 fs_offset_t filesize;
4143 if (filesizepointer)
4144 *filesizepointer = 0;
4145 if (!filename || !*filename)
4147 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
4150 if (filesizepointer)
4151 *filesizepointer = filesize;
4152 crc = CRC_Block(filedata, filesize);
4158 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
4161 unsigned char *out = NULL;
4165 #ifndef LINK_TO_ZLIB
4170 memset(&strm, 0, sizeof(strm));
4171 strm.zalloc = Z_NULL;
4172 strm.zfree = Z_NULL;
4173 strm.opaque = Z_NULL;
4176 level = Z_DEFAULT_COMPRESSION;
4178 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
4180 Con_Printf("FS_Deflate: deflate init error!\n");
4184 strm.next_in = (unsigned char*)data;
4185 strm.avail_in = (unsigned int)size;
4187 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
4190 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
4191 qz_deflateEnd(&strm);
4195 strm.next_out = tmp;
4196 strm.avail_out = (unsigned int)size;
4198 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
4200 Con_Printf("FS_Deflate: deflate failed!\n");
4201 qz_deflateEnd(&strm);
4206 if(qz_deflateEnd(&strm) != Z_OK)
4208 Con_Printf("FS_Deflate: deflateEnd failed\n");
4213 if(strm.total_out >= size)
4215 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
4220 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
4223 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
4228 *deflated_size = (size_t)strm.total_out;
4230 memcpy(out, tmp, strm.total_out);
4236 static void AssertBufsize(sizebuf_t *buf, int length)
4238 if(buf->cursize + length > buf->maxsize)
4240 int oldsize = buf->maxsize;
4241 unsigned char *olddata;
4242 olddata = buf->data;
4243 buf->maxsize += length;
4244 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
4247 memcpy(buf->data, olddata, oldsize);
4253 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
4257 unsigned char *out = NULL;
4258 unsigned char tmp[2048];
4263 #ifndef LINK_TO_ZLIB
4268 memset(&outbuf, 0, sizeof(outbuf));
4269 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
4270 outbuf.maxsize = sizeof(tmp);
4272 memset(&strm, 0, sizeof(strm));
4273 strm.zalloc = Z_NULL;
4274 strm.zfree = Z_NULL;
4275 strm.opaque = Z_NULL;
4277 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
4279 Con_Printf("FS_Inflate: inflate init error!\n");
4280 Mem_Free(outbuf.data);
4284 strm.next_in = (unsigned char*)data;
4285 strm.avail_in = (unsigned int)size;
4289 strm.next_out = tmp;
4290 strm.avail_out = sizeof(tmp);
4291 ret = qz_inflate(&strm, Z_NO_FLUSH);
4292 // it either returns Z_OK on progress, Z_STREAM_END on end
4300 case Z_STREAM_ERROR:
4301 Con_Print("FS_Inflate: stream error!\n");
4304 Con_Print("FS_Inflate: data error!\n");
4307 Con_Print("FS_Inflate: mem error!\n");
4310 Con_Print("FS_Inflate: buf error!\n");
4313 Con_Print("FS_Inflate: unknown error!\n");
4317 if(ret != Z_OK && ret != Z_STREAM_END)
4319 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4320 Mem_Free(outbuf.data);
4321 qz_inflateEnd(&strm);
4324 have = sizeof(tmp) - strm.avail_out;
4325 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4326 SZ_Write(&outbuf, tmp, have);
4327 } while(ret != Z_STREAM_END);
4329 qz_inflateEnd(&strm);
4331 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4334 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4335 Mem_Free(outbuf.data);
4339 memcpy(out, outbuf.data, outbuf.cursize);
4340 Mem_Free(outbuf.data);
4342 *inflated_size = (size_t)outbuf.cursize;