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
30 // visual studio does not have a dirent.h, so we use
31 // https://github.com/tronkko/dirent
32 # include "vsdirent.h"
41 # include <sys/stat.h>
45 # include <sys/types.h>
46 # include <sys/stat.h>
53 // include SDL for IPHONEOS code
62 // Win32 requires us to add O_BINARY, but the other OSes don't have it
67 // In case the system doesn't support the O_NONBLOCK flag
72 // largefile support for Win32
75 # define lseek _lseeki64
78 // suppress deprecated warnings
83 # define unlink _unlink
89 typedef SDL_RWops *filedesc_t;
90 # define FILEDESC_INVALID NULL
91 # define FILEDESC_ISVALID(fd) ((fd) != NULL)
92 # define FILEDESC_READ(fd,buf,count) ((fs_offset_t)SDL_RWread(fd, buf, 1, count))
93 # define FILEDESC_WRITE(fd,buf,count) ((fs_offset_t)SDL_RWwrite(fd, buf, 1, count))
94 # define FILEDESC_CLOSE SDL_RWclose
95 # define FILEDESC_SEEK SDL_RWseek
96 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
97 filedesc_t new_fd = SDL_RWFromFile(filename, "rb");
98 if (SDL_RWseek(new_fd, SDL_RWseek(fd, 0, RW_SEEK_CUR), RW_SEEK_SET) < 0) {
104 # define unlink(name) Con_DPrintf("Sorry, no unlink support when trying to unlink %s.\n", (name))
106 typedef int filedesc_t;
107 # define FILEDESC_INVALID -1
108 # define FILEDESC_ISVALID(fd) ((fd) != -1)
109 # define FILEDESC_READ read
110 # define FILEDESC_WRITE write
111 # define FILEDESC_CLOSE close
112 # define FILEDESC_SEEK lseek
113 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
118 /** \page fs File System
120 All of Quake's data access is through a hierchal file system, but the contents
121 of the file system can be transparently merged from several sources.
123 The "base directory" is the path to the directory holding the quake.exe and
124 all game directories. The sys_* files pass this to host_init in
125 quakeparms_t->basedir. This can be overridden with the "-basedir" command
126 line parm to allow code debugging in a different directory. The base
127 directory is only used during filesystem initialization.
129 The "game directory" is the first tree on the search path and directory that
130 all generated files (savegames, screenshots, demos, config files) will be
131 saved to. This can be overridden with the "-game" command line parameter.
132 The game directory can never be changed while quake is executing. This is a
133 precaution against having a malicious server instruct clients to write files
134 over areas they shouldn't.
140 =============================================================================
144 =============================================================================
147 // Magic numbers of a ZIP file (big-endian format)
148 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
149 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
150 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
152 // Other constants for ZIP files
153 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
154 #define ZIP_END_CDIR_SIZE 22
155 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
156 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
161 #define qz_inflate inflate
162 #define qz_inflateEnd inflateEnd
163 #define qz_inflateInit2_ inflateInit2_
164 #define qz_inflateReset inflateReset
165 #define qz_deflateInit2_ deflateInit2_
166 #define qz_deflateEnd deflateEnd
167 #define qz_deflate deflate
168 #define Z_MEMLEVEL_DEFAULT 8
171 // Zlib constants (from zlib.h)
172 #define Z_SYNC_FLUSH 2
175 #define Z_STREAM_END 1
176 #define Z_STREAM_ERROR (-2)
177 #define Z_DATA_ERROR (-3)
178 #define Z_MEM_ERROR (-4)
179 #define Z_BUF_ERROR (-5)
180 #define ZLIB_VERSION "1.2.3"
184 #define Z_MEMLEVEL_DEFAULT 8
187 #define Z_DEFAULT_COMPRESSION (-1)
189 #define Z_SYNC_FLUSH 2
190 #define Z_FULL_FLUSH 3
193 // Uncomment the following line if the zlib DLL you have still uses
194 // the 1.1.x series calling convention on Win32 (WINAPI)
195 //#define ZLIB_USES_WINAPI
199 =============================================================================
203 =============================================================================
206 /*! Zlib stream (from zlib.h)
207 * \warning: some pointers we don't use directly have
208 * been cast to "void*" for a matter of simplicity
212 unsigned char *next_in; ///< next input byte
213 unsigned int avail_in; ///< number of bytes available at next_in
214 unsigned long total_in; ///< total nb of input bytes read so far
216 unsigned char *next_out; ///< next output byte should be put there
217 unsigned int avail_out; ///< remaining free space at next_out
218 unsigned long total_out; ///< total nb of bytes output so far
220 char *msg; ///< last error message, NULL if no error
221 void *state; ///< not visible by applications
223 void *zalloc; ///< used to allocate the internal state
224 void *zfree; ///< used to free the internal state
225 void *opaque; ///< private data object passed to zalloc and zfree
227 int data_type; ///< best guess about the data type: ascii or binary
228 unsigned long adler; ///< adler32 value of the uncompressed data
229 unsigned long reserved; ///< reserved for future use
234 /// inside a package (PAK or PK3)
235 #define QFILE_FLAG_PACKED (1 << 0)
236 /// file is compressed using the deflate algorithm (PK3 only)
237 #define QFILE_FLAG_DEFLATED (1 << 1)
238 /// file is actually already loaded data
239 #define QFILE_FLAG_DATA (1 << 2)
240 /// real file will be removed on close
241 #define QFILE_FLAG_REMOVE (1 << 3)
243 #define FILE_BUFF_SIZE 2048
247 size_t comp_length; ///< length of the compressed file
248 size_t in_ind, in_len; ///< input buffer current index and length
249 size_t in_position; ///< position in the compressed file
250 unsigned char input [FILE_BUFF_SIZE];
256 filedesc_t handle; ///< file descriptor
257 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
258 fs_offset_t position; ///< current position in the file
259 fs_offset_t offset; ///< offset into the package (0 if external file)
260 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
263 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
264 unsigned char buff [FILE_BUFF_SIZE];
266 ztoolkit_t* ztk; ///< For zipped files.
268 const unsigned char *data; ///< For data files.
270 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
274 // ------ PK3 files on disk ------ //
276 // You can get the complete ZIP format description from PKWARE website
278 typedef struct pk3_endOfCentralDir_s
280 unsigned int signature;
281 unsigned short disknum;
282 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
283 unsigned short localentries; ///< number of entries in the central directory on this disk
284 unsigned short nbentries; ///< total number of entries in the central directory on this disk
285 unsigned int cdir_size; ///< size of the central directory
286 unsigned int cdir_offset; ///< with respect to the starting disk number
287 unsigned short comment_size;
288 fs_offset_t prepended_garbage;
289 } pk3_endOfCentralDir_t;
292 // ------ PAK files on disk ------ //
293 typedef struct dpackfile_s
296 int filepos, filelen;
299 typedef struct dpackheader_s
307 /*! \name Packages in memory
310 /// the offset in packfile_t is the true contents offset
311 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
312 /// file compressed using the deflate algorithm
313 #define PACKFILE_FLAG_DEFLATED (1 << 1)
314 /// file is a symbolic link
315 #define PACKFILE_FLAG_SYMLINK (1 << 2)
317 typedef struct packfile_s
319 char name [MAX_QPATH];
322 fs_offset_t packsize; ///< size in the package
323 fs_offset_t realsize; ///< real file size (uncompressed)
326 typedef struct pack_s
328 char filename [MAX_OSPATH];
329 char shortname [MAX_QPATH];
331 int ignorecase; ///< PK3 ignores case
338 /// Search paths for files (including packages)
339 typedef struct searchpath_s
341 // only one of filename / pack will be used
342 char filename[MAX_OSPATH];
344 struct searchpath_s *next;
349 =============================================================================
353 =============================================================================
356 void FS_Dir_f(cmd_state_t *cmd);
357 void FS_Ls_f(cmd_state_t *cmd);
358 void FS_Which_f(cmd_state_t *cmd);
360 static searchpath_t *FS_FindFile (const char *name, int* index, qbool quiet);
361 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
362 fs_offset_t offset, fs_offset_t packsize,
363 fs_offset_t realsize, int flags);
367 =============================================================================
371 =============================================================================
374 mempool_t *fs_mempool;
375 void *fs_mutex = NULL;
377 searchpath_t *fs_searchpaths = NULL;
378 const char *const fs_checkgamedir_missing = "missing";
380 #define MAX_FILES_IN_PACK 65536
382 char fs_userdir[MAX_OSPATH];
383 char fs_gamedir[MAX_OSPATH];
384 char fs_basedir[MAX_OSPATH];
385 static pack_t *fs_selfpack = NULL;
387 // list of active game directories (empty if not running a mod)
388 int fs_numgamedirs = 0;
389 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
391 // list of all gamedirs with modinfo.txt
392 gamedir_t *fs_all_gamedirs = NULL;
393 int fs_all_gamedirs_count = 0;
395 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)"};
396 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"};
397 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)"};
401 =============================================================================
403 PRIVATE FUNCTIONS - PK3 HANDLING
405 =============================================================================
409 // Functions exported from zlib
410 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
411 # define ZEXPORT WINAPI
416 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
417 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
418 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
419 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
420 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
421 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
422 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
425 #define qz_inflateInit2(strm, windowBits) \
426 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
427 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
428 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
431 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
433 static dllfunction_t zlibfuncs[] =
435 {"inflate", (void **) &qz_inflate},
436 {"inflateEnd", (void **) &qz_inflateEnd},
437 {"inflateInit2_", (void **) &qz_inflateInit2_},
438 {"inflateReset", (void **) &qz_inflateReset},
439 {"deflateInit2_", (void **) &qz_deflateInit2_},
440 {"deflateEnd", (void **) &qz_deflateEnd},
441 {"deflate", (void **) &qz_deflate},
445 /// Handle for Zlib DLL
446 static dllhandle_t zlib_dll = NULL;
450 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
451 static dllfunction_t shfolderfuncs[] =
453 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
456 static const char* shfolderdllnames [] =
458 "shfolder.dll", // IE 4, or Win NT and higher
461 static dllhandle_t shfolder_dll = NULL;
463 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
464 #define qREFKNOWNFOLDERID const GUID *
465 #define qKF_FLAG_CREATE 0x8000
466 #define qKF_FLAG_NO_ALIAS 0x1000
467 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
468 static dllfunction_t shell32funcs[] =
470 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
473 static const char* shell32dllnames [] =
475 "shell32.dll", // Vista and higher
478 static dllhandle_t shell32_dll = NULL;
480 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
481 static void (WINAPI *qCoUninitialize)(void);
482 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
483 static dllfunction_t ole32funcs[] =
485 {"CoInitializeEx", (void **) &qCoInitializeEx},
486 {"CoUninitialize", (void **) &qCoUninitialize},
487 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
490 static const char* ole32dllnames [] =
492 "ole32.dll", // 2000 and higher
495 static dllhandle_t ole32_dll = NULL;
505 static void PK3_CloseLibrary (void)
508 Sys_FreeLibrary (&zlib_dll);
517 Try to load the Zlib DLL
520 static qbool PK3_OpenLibrary (void)
525 const char* dllnames [] =
528 # ifdef ZLIB_USES_WINAPI
534 #elif defined(MACOSX)
548 return Sys_LoadDependency (dllnames, &zlib_dll, zlibfuncs);
556 See if zlib is available
559 qbool FS_HasZlib(void)
564 PK3_OpenLibrary(); // to be safe
565 return (zlib_dll != 0);
571 PK3_GetEndOfCentralDir
573 Extract the end of the central directory from a PK3 package
576 static qbool PK3_GetEndOfCentralDir (const char *packfile, filedesc_t packhandle, pk3_endOfCentralDir_t *eocd)
578 fs_offset_t filesize, maxsize;
579 unsigned char *buffer, *ptr;
582 // Get the package size
583 filesize = FILEDESC_SEEK (packhandle, 0, SEEK_END);
584 if (filesize < ZIP_END_CDIR_SIZE)
587 // Load the end of the file in memory
588 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
591 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
592 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
593 FILEDESC_SEEK (packhandle, filesize - maxsize, SEEK_SET);
594 if (FILEDESC_READ (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
600 // Look for the end of central dir signature around the end of the file
601 maxsize -= ZIP_END_CDIR_SIZE;
602 ptr = &buffer[maxsize];
604 while (BuffBigLong (ptr) != ZIP_END_HEADER)
616 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
617 eocd->signature = LittleLong (eocd->signature);
618 eocd->disknum = LittleShort (eocd->disknum);
619 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
620 eocd->localentries = LittleShort (eocd->localentries);
621 eocd->nbentries = LittleShort (eocd->nbentries);
622 eocd->cdir_size = LittleLong (eocd->cdir_size);
623 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
624 eocd->comment_size = LittleShort (eocd->comment_size);
625 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
626 eocd->cdir_offset += eocd->prepended_garbage;
631 eocd->cdir_size > filesize ||
632 eocd->cdir_offset >= filesize ||
633 eocd->cdir_offset + eocd->cdir_size > filesize
636 // Obviously invalid central directory.
648 Extract the file list from a PK3 file
651 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
653 unsigned char *central_dir, *ptr;
655 fs_offset_t remaining;
657 // Load the central directory in memory
658 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
659 if (FILEDESC_SEEK (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
661 Mem_Free (central_dir);
664 if(FILEDESC_READ (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
666 Mem_Free (central_dir);
670 // Extract the files properties
671 // The parsing is done "by hand" because some fields have variable sizes and
672 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
673 remaining = eocd->cdir_size;
676 for (ind = 0; ind < eocd->nbentries; ind++)
678 fs_offset_t namesize, count;
680 // Checking the remaining size
681 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
683 Mem_Free (central_dir);
686 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
689 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
691 Mem_Free (central_dir);
695 namesize = BuffLittleShort (&ptr[28]); // filename length
697 // Check encryption, compression, and attributes
698 // 1st uint8 : general purpose bit flag
699 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
701 // LadyHavoc: bit 3 would be a problem if we were scanning the archive
702 // but is not a problem in the central directory where the values are
705 // bit 3 seems to always be set by the standard Mac OSX zip maker
707 // 2nd uint8 : external file attributes
708 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
709 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
711 // Still enough bytes for the name?
712 if (namesize < 0 || remaining < namesize || namesize >= (int)sizeof (*pack->files))
714 Mem_Free (central_dir);
718 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
719 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
721 char filename [sizeof (pack->files[0].name)];
722 fs_offset_t offset, packsize, realsize;
725 // Extract the name (strip it if necessary)
726 namesize = min(namesize, (int)sizeof (filename) - 1);
727 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
728 filename[namesize] = '\0';
730 if (BuffLittleShort (&ptr[10]))
731 flags = PACKFILE_FLAG_DEFLATED;
734 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
735 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
736 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
738 switch(ptr[5]) // C_VERSION_MADE_BY_1
743 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
744 // can't use S_ISLNK here, as this has to compile on non-UNIX too
745 flags |= PACKFILE_FLAG_SYMLINK;
749 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
753 // Skip the name, additionnal field, and comment
754 // 1er uint16 : extra field length
755 // 2eme uint16 : file comment length
756 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
757 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
761 // If the package is empty, central_dir is NULL here
762 if (central_dir != NULL)
763 Mem_Free (central_dir);
764 return pack->numfiles;
772 Create a package entry associated with a PK3 file
775 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, filedesc_t packhandle, qbool silent)
777 pk3_endOfCentralDir_t eocd;
781 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
784 Con_Printf ("%s is not a PK3 file\n", packfile);
785 FILEDESC_CLOSE(packhandle);
789 // Multi-volume ZIP archives are NOT allowed
790 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
792 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
793 FILEDESC_CLOSE(packhandle);
797 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
798 // since eocd.nbentries is an unsigned 16 bits integer
799 #if MAX_FILES_IN_PACK < 65535
800 if (eocd.nbentries > MAX_FILES_IN_PACK)
802 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
803 FILEDESC_CLOSE(packhandle);
808 // Create a package structure in memory
809 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
810 pack->ignorecase = true; // PK3 ignores case
811 strlcpy (pack->filename, packfile, sizeof (pack->filename));
812 pack->handle = packhandle;
813 pack->numfiles = eocd.nbentries;
814 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
816 real_nb_files = PK3_BuildFileList (pack, &eocd);
817 if (real_nb_files < 0)
819 Con_Printf ("%s is not a valid PK3 file\n", packfile);
820 FILEDESC_CLOSE(pack->handle);
825 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
829 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qbool nonblocking);
830 static pack_t *FS_LoadPackPK3 (const char *packfile)
832 filedesc_t packhandle;
833 packhandle = FS_SysOpenFiledesc (packfile, "rb", false);
834 if (!FILEDESC_ISVALID(packhandle))
836 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
842 PK3_GetTrueFileOffset
844 Find where the true file data offset is
847 static qbool PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
849 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
853 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
856 // Load the local file description
857 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
859 Con_Printf ("Can't seek in package %s\n", pack->filename);
862 count = FILEDESC_READ (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
863 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
865 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
869 // Skip name and extra field
870 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
872 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
878 =============================================================================
880 OTHER PRIVATE FUNCTIONS
882 =============================================================================
890 Add a file to the list of files contained into a package
893 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
894 fs_offset_t offset, fs_offset_t packsize,
895 fs_offset_t realsize, int flags)
897 int (*strcmp_funct) (const char* str1, const char* str2);
898 int left, right, middle;
901 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
903 // Look for the slot we should put that file into (binary search)
905 right = pack->numfiles - 1;
906 while (left <= right)
910 middle = (left + right) / 2;
911 diff = strcmp_funct (pack->files[middle].name, name);
913 // If we found the file, there's a problem
915 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
917 // If we're too far in the list
924 // We have to move the right of the list by one slot to free the one we need
925 pfile = &pack->files[left];
926 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
929 strlcpy (pfile->name, name, sizeof (pfile->name));
930 pfile->offset = offset;
931 pfile->packsize = packsize;
932 pfile->realsize = realsize;
933 pfile->flags = flags;
939 static void FS_mkdir (const char *path)
941 if(Sys_CheckParm("-readonly"))
945 if (_mkdir (path) == -1)
947 if (mkdir (path, 0777) == -1)
950 // No logging for this. The only caller is FS_CreatePath (which
951 // calls it in ways that will intentionally produce EEXIST),
952 // and its own callers always use the directory afterwards and
953 // thus will detect failure that way.
957 int FS_rmtree(const char *dir)
962 char vabuf[1024] = { 0 };
968 Con_DPrintf("FS_rmtree(): can't open dir `%s`: %s\n", dir, strerror(errno));
972 while ((ep = readdir(dp)))
974 if (!strcmp(".", ep->d_name) || !strcmp("..", ep->d_name))
975 continue; // NB: do these even appear in readdir() output?
977 if (dpsnprintf(vabuf, sizeof(vabuf), "%s/%s", dir, ep->d_name) >= (int)sizeof(vabuf))
979 // this is some wacky shit, better abort lest we fuck some poor sod's files up
980 Con_DPrintf("FS_rmtree(): path `%s` is longer than the path buffer, aborting\n", vabuf);
985 if (stat(vabuf, &st) < 0)
987 Con_DPrintf("FS_rmtree(): can't stat `%s`: %s\n", vabuf, strerror(errno));
992 ret = (S_ISDIR(st.st_mode)) ? FS_rmtree(vabuf) : remove(vabuf);
995 Con_DPrintf("FS_rmtree(): can't remove `%s`: %s\n", vabuf, strerror(errno));
1005 if (ret) Con_DPrintf("FS_rmtree(): can't remove `%s`: %s\n", dir, strerror(errno));
1015 Only used for FS_OpenRealFile.
1018 void FS_CreatePath (char *path)
1022 for (ofs = path+1 ; *ofs ; ofs++)
1024 if (*ofs == '/' || *ofs == '\\')
1026 // create the directory
1042 static void FS_Path_f(cmd_state_t *cmd)
1046 Con_Print("Current search path:\n");
1047 for (s=fs_searchpaths ; s ; s=s->next)
1052 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
1054 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1057 Con_Printf("%s\n", s->filename);
1067 /*! Takes an explicit (not game tree related) path to a pak file.
1068 *Loads the header and directory, adding the files at the beginning
1069 *of the list so they override previous pack files.
1071 static pack_t *FS_LoadPackPAK (const char *packfile)
1073 dpackheader_t header;
1074 int i, numpackfiles;
1075 filedesc_t packhandle;
1079 packhandle = FS_SysOpenFiledesc(packfile, "rb", false);
1080 if (!FILEDESC_ISVALID(packhandle))
1082 if(FILEDESC_READ (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
1084 Con_Printf ("%s is not a packfile\n", packfile);
1085 FILEDESC_CLOSE(packhandle);
1088 if (memcmp(header.id, "PACK", 4))
1090 Con_Printf ("%s is not a packfile\n", packfile);
1091 FILEDESC_CLOSE(packhandle);
1094 header.dirofs = LittleLong (header.dirofs);
1095 header.dirlen = LittleLong (header.dirlen);
1097 if (header.dirlen % sizeof(dpackfile_t))
1099 Con_Printf ("%s has an invalid directory size\n", packfile);
1100 FILEDESC_CLOSE(packhandle);
1104 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1106 if (numpackfiles < 0 || numpackfiles > MAX_FILES_IN_PACK)
1108 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
1109 FILEDESC_CLOSE(packhandle);
1113 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1114 FILEDESC_SEEK (packhandle, header.dirofs, SEEK_SET);
1115 if(header.dirlen != FILEDESC_READ (packhandle, (void *)info, header.dirlen))
1117 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1119 FILEDESC_CLOSE(packhandle);
1123 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1124 pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
1125 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1126 pack->handle = packhandle;
1128 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1130 // parse the directory
1131 for (i = 0;i < numpackfiles;i++)
1133 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1134 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1136 // Ensure a zero terminated file name (required by format).
1137 info[i].name[sizeof(info[i].name) - 1] = 0;
1139 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1144 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1149 ====================
1152 Create a package entry associated with a directory file
1153 ====================
1155 static pack_t *FS_LoadPackVirtual (const char *dirname)
1158 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1160 pack->ignorecase = false;
1161 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1162 pack->handle = FILEDESC_INVALID;
1163 pack->numfiles = -1;
1165 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1174 /*! Adds the given pack to the search path.
1175 * The pack type is autodetected by the file extension.
1177 * Returns true if the file was successfully added to the
1178 * search path or if it was already included.
1180 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1181 * plain directories.
1184 static qbool FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qbool *already_loaded, qbool keep_plain_dirs)
1186 searchpath_t *search;
1188 const char *ext = FS_FileExtension(pakfile);
1191 for(search = fs_searchpaths; search; search = search->next)
1193 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1196 *already_loaded = true;
1197 return true; // already loaded
1202 *already_loaded = false;
1204 if(!strcasecmp(ext, "pk3dir"))
1205 pak = FS_LoadPackVirtual (pakfile);
1206 else if(!strcasecmp(ext, "pak"))
1207 pak = FS_LoadPackPAK (pakfile);
1208 else if(!strcasecmp(ext, "pk3"))
1209 pak = FS_LoadPackPK3 (pakfile);
1210 else if(!strcasecmp(ext, "obb")) // android apk expansion
1211 pak = FS_LoadPackPK3 (pakfile);
1213 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1217 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1219 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1222 // find the first item whose next one is a pack or NULL
1223 searchpath_t *insertion_point = 0;
1224 if(fs_searchpaths && !fs_searchpaths->pack)
1226 insertion_point = fs_searchpaths;
1229 if(!insertion_point->next)
1231 if(insertion_point->next->pack)
1233 insertion_point = insertion_point->next;
1236 // If insertion_point is NULL, this means that either there is no
1237 // item in the list yet, or that the very first item is a pack. In
1238 // that case, we want to insert at the beginning...
1239 if(!insertion_point)
1241 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1242 search->next = fs_searchpaths;
1243 fs_searchpaths = search;
1246 // otherwise we want to append directly after insertion_point.
1248 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1249 search->next = insertion_point->next;
1250 insertion_point->next = search;
1255 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1256 search->next = fs_searchpaths;
1257 fs_searchpaths = search;
1262 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1263 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1264 // same goes for the name inside the pack structure
1265 l = strlen(pak->shortname);
1267 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1268 pak->shortname[l - 3] = 0;
1269 l = strlen(pak->filename);
1271 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1272 pak->filename[l - 3] = 0;
1278 Con_Printf(CON_ERROR "unable to load pak \"%s\"\n", pakfile);
1289 /*! Adds the given pack to the search path and searches for it in the game path.
1290 * The pack type is autodetected by the file extension.
1292 * Returns true if the file was successfully added to the
1293 * search path or if it was already included.
1295 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1296 * plain directories.
1298 qbool FS_AddPack(const char *pakfile, qbool *already_loaded, qbool keep_plain_dirs)
1300 char fullpath[MAX_OSPATH];
1302 searchpath_t *search;
1305 *already_loaded = false;
1307 // then find the real name...
1308 search = FS_FindFile(pakfile, &index, true);
1309 if(!search || search->pack)
1311 Con_Printf("could not find pak \"%s\"\n", pakfile);
1315 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1317 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1325 Sets fs_gamedir, adds the directory to the head of the path,
1326 then loads and adds pak1.pak pak2.pak ...
1329 static void FS_AddGameDirectory (const char *dir)
1333 searchpath_t *search;
1335 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1337 stringlistinit(&list);
1338 listdirectory(&list, "", dir);
1339 stringlistsort(&list, false);
1341 // add any PAK package in the directory
1342 for (i = 0;i < list.numstrings;i++)
1344 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1346 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1350 // add any PK3 package in the directory
1351 for (i = 0;i < list.numstrings;i++)
1353 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1355 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1359 stringlistfreecontents(&list);
1361 // Add the directory to the search path
1362 // (unpacked files have the priority over packed files)
1363 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1364 strlcpy (search->filename, dir, sizeof (search->filename));
1365 search->next = fs_searchpaths;
1366 fs_searchpaths = search;
1375 static void FS_AddGameHierarchy (const char *dir)
1378 // Add the common game directory
1379 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1382 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1391 const char *FS_FileExtension (const char *in)
1393 const char *separator, *backslash, *colon, *dot;
1395 dot = strrchr(in, '.');
1399 separator = strrchr(in, '/');
1400 backslash = strrchr(in, '\\');
1401 if (!separator || separator < backslash)
1402 separator = backslash;
1403 colon = strrchr(in, ':');
1404 if (!separator || separator < colon)
1407 if (separator && (dot < separator))
1419 const char *FS_FileWithoutPath (const char *in)
1421 const char *separator, *backslash, *colon;
1423 separator = strrchr(in, '/');
1424 backslash = strrchr(in, '\\');
1425 if (!separator || separator < backslash)
1426 separator = backslash;
1427 colon = strrchr(in, ':');
1428 if (!separator || separator < colon)
1430 return separator ? separator + 1 : in;
1439 static void FS_ClearSearchPath (void)
1441 // unload all packs and directory information, close all pack files
1442 // (if a qfile is still reading a pack it won't be harmed because it used
1443 // dup() to get its own handle already)
1444 while (fs_searchpaths)
1446 searchpath_t *search = fs_searchpaths;
1447 fs_searchpaths = search->next;
1448 if (search->pack && search->pack != fs_selfpack)
1450 if(!search->pack->vpack)
1453 FILEDESC_CLOSE(search->pack->handle);
1454 // free any memory associated with it
1455 if (search->pack->files)
1456 Mem_Free(search->pack->files);
1458 Mem_Free(search->pack);
1464 static void FS_AddSelfPack(void)
1468 searchpath_t *search;
1469 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1470 search->next = fs_searchpaths;
1471 search->pack = fs_selfpack;
1472 fs_searchpaths = search;
1482 void FS_Rescan (void)
1485 qbool fs_modified = false;
1486 qbool reset = false;
1487 char gamedirbuf[MAX_INPUTLINE];
1492 FS_ClearSearchPath();
1494 // automatically activate gamemode for the gamedirs specified
1496 COM_ChangeGameTypeForGameDirs();
1498 // add the game-specific paths
1499 // gamedirname1 (typically id1)
1500 FS_AddGameHierarchy (gamedirname1);
1501 // update the com_modname (used for server info)
1502 if (gamedirname2 && gamedirname2[0])
1503 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1505 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1507 // add the game-specific path, if any
1508 // (only used for mission packs and the like, which should set fs_modified)
1509 if (gamedirname2 && gamedirname2[0])
1512 FS_AddGameHierarchy (gamedirname2);
1516 // Adds basedir/gamedir as an override game
1517 // LadyHavoc: now supports multiple -game directories
1518 // set the com_modname (reported in server info)
1520 for (i = 0;i < fs_numgamedirs;i++)
1523 FS_AddGameHierarchy (fs_gamedirs[i]);
1524 // update the com_modname (used server info)
1525 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1527 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1529 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1531 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1533 // add back the selfpack as new first item
1536 // set the default screenshot name to either the mod name or the
1537 // gamemode screenshot name
1538 if (strcmp(com_modname, gamedirname1))
1539 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1541 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1543 if((i = Sys_CheckParm("-modname")) && i < sys.argc - 1)
1544 strlcpy(com_modname, sys.argv[i+1], sizeof(com_modname));
1546 // If "-condebug" is in the command line, remove the previous log file
1547 if (Sys_CheckParm ("-condebug") != 0)
1548 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1550 // look for the pop.lmp file and set registered to true if it is found
1551 if (FS_FileExists("gfx/pop.lmp"))
1552 Cvar_SetValueQuick(®istered, 1);
1558 if (!registered.integer)
1561 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1563 Con_Print("Playing shareware version.\n");
1566 Con_Print("Playing registered version.\n");
1568 case GAME_STEELSTORM:
1569 if (registered.integer)
1570 Con_Print("Playing registered version.\n");
1572 Con_Print("Playing shareware version.\n");
1578 // unload all wads so that future queries will return the new data
1582 static void FS_Rescan_f(cmd_state_t *cmd)
1592 extern qbool vid_opened;
1593 qbool FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qbool complain, qbool failmissing)
1598 if (fs_numgamedirs == numgamedirs)
1600 for (i = 0;i < numgamedirs;i++)
1601 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1603 if (i == numgamedirs)
1604 return true; // already using this set of gamedirs, do nothing
1607 if (numgamedirs > MAX_GAMEDIRS)
1610 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1611 return false; // too many gamedirs
1614 for (i = 0;i < numgamedirs;i++)
1616 // if string is nasty, reject it
1617 p = FS_CheckGameDir(gamedirs[i]);
1621 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1622 return false; // nasty gamedirs
1624 if(p == fs_checkgamedir_missing && failmissing)
1627 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1628 return false; // missing gamedirs
1632 Host_SaveConfig(CONFIGFILENAME);
1634 fs_numgamedirs = numgamedirs;
1635 for (i = 0;i < fs_numgamedirs;i++)
1636 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1638 // reinitialize filesystem to detect the new paks
1641 if (cls.demoplayback)
1647 // unload all sounds so they will be reloaded from the new files as needed
1648 S_UnloadAllSounds_f(cmd_local);
1650 // restart the video subsystem after the config is executed
1651 Cbuf_InsertText(cmd_local, "\nloadconfig\nvid_restart\n\n");
1661 static void FS_GameDir_f(cmd_state_t *cmd)
1665 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1667 if (Cmd_Argc(cmd) < 2)
1669 Con_Printf("gamedirs active:");
1670 for (i = 0;i < fs_numgamedirs;i++)
1671 Con_Printf(" %s", fs_gamedirs[i]);
1676 numgamedirs = Cmd_Argc(cmd) - 1;
1677 if (numgamedirs > MAX_GAMEDIRS)
1679 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1683 for (i = 0;i < numgamedirs;i++)
1684 strlcpy(gamedirs[i], Cmd_Argv(cmd, i+1), sizeof(gamedirs[i]));
1686 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1688 // actually, changing during game would work fine, but would be stupid
1689 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1693 // halt demo playback to close the file
1696 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1699 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1707 stringlistinit(&list);
1708 listdirectory(&list, gamedir, "");
1709 success = list.numstrings > 0;
1710 stringlistfreecontents(&list);
1714 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1717 n = FS_Read (f, buf, buflength - 1);
1737 const char *FS_CheckGameDir(const char *gamedir)
1740 static char buf[8192];
1743 if (FS_CheckNastyPath(gamedir, true))
1746 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1751 // get description from basedir
1752 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1760 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1764 return fs_checkgamedir_missing;
1767 static void FS_ListGameDirs(void)
1769 stringlist_t list, list2;
1774 fs_all_gamedirs_count = 0;
1776 Mem_Free(fs_all_gamedirs);
1778 stringlistinit(&list);
1779 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1780 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1781 stringlistsort(&list, false);
1783 stringlistinit(&list2);
1784 for(i = 0; i < list.numstrings; ++i)
1787 if(!strcmp(list.strings[i-1], list.strings[i]))
1789 info = FS_CheckGameDir(list.strings[i]);
1792 if(info == fs_checkgamedir_missing)
1796 stringlistappend(&list2, list.strings[i]);
1798 stringlistfreecontents(&list);
1800 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1801 for(i = 0; i < list2.numstrings; ++i)
1803 info = FS_CheckGameDir(list2.strings[i]);
1804 // all this cannot happen any more, but better be safe than sorry
1807 if(info == fs_checkgamedir_missing)
1811 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1812 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1813 ++fs_all_gamedirs_count;
1819 #pragma comment(lib, "shell32.lib")
1824 static void COM_InsertFlags(const char *buf) {
1827 const char **new_argv;
1829 int args_left = 256;
1830 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*sys.argv) * (sys.argc + args_left + 2));
1832 new_argv[0] = "dummy"; // Can't really happen.
1834 new_argv[0] = sys.argv[0];
1837 while(COM_ParseToken_Console(&p))
1839 size_t sz = strlen(com_token) + 1; // shut up clang
1842 q = (char *)Mem_Alloc(fs_mempool, sz);
1843 strlcpy(q, com_token, sz);
1847 // Now: i <= args_left + 1.
1850 memcpy((char *)(&new_argv[i]), &sys.argv[1], sizeof(*sys.argv) * (sys.argc - 1));
1853 // Now: i <= args_left + (sys.argc || 1).
1855 sys.argv = new_argv;
1859 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1861 #if defined(__IPHONEOS__)
1862 if (userdirmode == USERDIRMODE_HOME)
1864 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1865 // fs_userdir stores configurations to the Documents folder of the app
1866 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1871 #elif defined(WIN32)
1873 #if _MSC_VER >= 1400
1876 TCHAR mydocsdir[MAX_PATH + 1];
1877 wchar_t *savedgamesdirw;
1878 char savedgamesdir[MAX_OSPATH];
1887 case USERDIRMODE_NOHOME:
1888 strlcpy(userdir, fs_basedir, userdirsize);
1890 case USERDIRMODE_MYGAMES:
1892 Sys_LoadDependency(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1894 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1896 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1899 #if _MSC_VER >= 1400
1900 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1903 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1908 homedir = getenv("USERPROFILE");
1911 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1916 case USERDIRMODE_SAVEDGAMES:
1918 Sys_LoadDependency(shell32dllnames, &shell32_dll, shell32funcs);
1920 Sys_LoadDependency(ole32dllnames, &ole32_dll, ole32funcs);
1921 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1923 savedgamesdir[0] = 0;
1924 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1927 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1929 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1932 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1934 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1935 #if _MSC_VER >= 1400
1936 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1938 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1940 qCoTaskMemFree(savedgamesdirw);
1943 if (savedgamesdir[0])
1945 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1960 case USERDIRMODE_NOHOME:
1961 strlcpy(userdir, fs_basedir, userdirsize);
1963 case USERDIRMODE_HOME:
1964 homedir = getenv("HOME");
1967 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1971 case USERDIRMODE_SAVEDGAMES:
1972 homedir = getenv("HOME");
1976 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1978 // the XDG say some files would need to go in:
1979 // XDG_CONFIG_HOME (or ~/.config/%s/)
1980 // XDG_DATA_HOME (or ~/.local/share/%s/)
1981 // XDG_CACHE_HOME (or ~/.cache/%s/)
1982 // and also search the following global locations if defined:
1983 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1984 // XDG_DATA_DIRS (normally /usr/share/%s/)
1985 // this would be too complicated...
1995 #if !defined(__IPHONEOS__)
1998 // historical behavior...
1999 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
2000 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
2003 // see if we can write to this path (note: won't create path)
2005 // no access() here, we must try to open the file for appending
2006 fd = FS_SysOpenFiledesc(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
2010 // on Unix, we don't need to ACTUALLY attempt to open the file
2011 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
2018 return 1; // good choice - the path exists and is writable
2022 if (userdirmode == USERDIRMODE_NOHOME)
2023 return -1; // path usually already exists, we lack permissions
2025 return 0; // probably good - failed to write but maybe we need to create path
2030 void FS_Init_Commands(void)
2032 Cvar_RegisterVariable (&scr_screenshot_name);
2033 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2034 Cvar_RegisterVariable (&cvar_fs_gamedir);
2036 Cmd_AddCommand(CF_SHARED, "gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2037 Cmd_AddCommand(CF_SHARED, "fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2038 Cmd_AddCommand(CF_SHARED, "path", FS_Path_f, "print searchpath (game directories and archives)");
2039 Cmd_AddCommand(CF_SHARED, "dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2040 Cmd_AddCommand(CF_SHARED, "ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2041 Cmd_AddCommand(CF_SHARED, "which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2044 static void FS_Init_Dir (void)
2054 // Overrides the system supplied base directory (under GAMENAME)
2055 // 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)
2056 i = Sys_CheckParm ("-basedir");
2057 if (i && i < sys.argc-1)
2059 strlcpy (fs_basedir, sys.argv[i+1], sizeof (fs_basedir));
2060 i = (int)strlen (fs_basedir);
2061 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
2062 fs_basedir[i-1] = 0;
2066 // If the base directory is explicitly defined by the compilation process
2067 #ifdef DP_FS_BASEDIR
2068 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
2069 #elif defined(__ANDROID__)
2070 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
2071 #elif defined(MACOSX)
2072 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
2073 if (strstr(sys.argv[0], ".app/"))
2076 strlcpy(fs_basedir, sys.argv[0], sizeof(fs_basedir));
2077 split = strstr(fs_basedir, ".app/");
2080 struct stat statresult;
2082 // truncate to just after the .app/
2084 // see if gamedir exists in Resources
2085 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
2087 // found gamedir inside Resources, use it
2088 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
2092 // no gamedir found in Resources, gamedir is probably
2093 // outside the .app, remove .app part of path
2094 while (split > fs_basedir && *split != '/')
2103 // make sure the appending of a path separator won't create an unterminated string
2104 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
2105 // add a path separator to the end of the basedir if it lacks one
2106 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
2107 strlcat(fs_basedir, "/", sizeof(fs_basedir));
2109 // Add the personal game directory
2110 if((i = Sys_CheckParm("-userdir")) && i < sys.argc - 1)
2111 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", sys.argv[i+1]);
2112 else if (Sys_CheckParm("-nohome"))
2113 *fs_userdir = 0; // user wants roaming installation, no userdir
2116 #ifdef DP_FS_USERDIR
2117 strlcpy(fs_userdir, DP_FS_USERDIR, sizeof(fs_userdir));
2120 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2121 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2122 int userdirstatus[USERDIRMODE_COUNT];
2124 // historical behavior...
2125 if (!strcmp(gamedirname1, "id1"))
2126 preferreduserdirmode = USERDIRMODE_NOHOME;
2128 // check what limitations the user wants to impose
2129 if (Sys_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2130 if (Sys_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2131 if (Sys_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2132 // gather the status of the possible userdirs
2133 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2135 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2136 if (userdirstatus[dirmode] == 1)
2137 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2138 else if (userdirstatus[dirmode] == 0)
2139 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2141 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2143 // some games may prefer writing to basedir, but if write fails we
2144 // have to search for a real userdir...
2145 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2146 preferreduserdirmode = highestuserdirmode;
2147 // check for an existing userdir and continue using it if possible...
2148 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2149 if (userdirstatus[dirmode] == 1)
2151 // if no existing userdir found, make a new one...
2152 if (dirmode == 0 && preferreduserdirmode > 0)
2153 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2154 if (userdirstatus[dirmode] >= 0)
2156 // and finally, we picked one...
2157 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2158 Con_DPrintf("userdir %i is the winner\n", dirmode);
2162 // if userdir equal to basedir, clear it to avoid confusion later
2163 if (!strcmp(fs_basedir, fs_userdir))
2168 p = FS_CheckGameDir(gamedirname1);
2169 if(!p || p == fs_checkgamedir_missing)
2170 Con_Printf(CON_WARN "WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2174 p = FS_CheckGameDir(gamedirname2);
2175 if(!p || p == fs_checkgamedir_missing)
2176 Con_Printf(CON_WARN "WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2180 // Adds basedir/gamedir as an override game
2181 // LadyHavoc: now supports multiple -game directories
2182 for (i = 1;i < sys.argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2186 if (!strcmp (sys.argv[i], "-game") && i < sys.argc-1)
2189 p = FS_CheckGameDir(sys.argv[i]);
2191 Con_Printf("WARNING: Nasty -game name rejected: %s\n", sys.argv[i]);
2192 if(p == fs_checkgamedir_missing)
2193 Con_Printf(CON_WARN "WARNING: -game %s%s/ not found!\n", fs_basedir, sys.argv[i]);
2194 // add the gamedir to the list of active gamedirs
2195 strlcpy (fs_gamedirs[fs_numgamedirs], sys.argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2200 // generate the searchpath
2203 if (Thread_HasThreads())
2204 fs_mutex = Thread_CreateMutex();
2212 void FS_Init_SelfPack (void)
2216 // Load darkplaces.opt from the FS.
2217 if (!Sys_CheckParm("-noopt"))
2219 buf = (char *) FS_SysLoadFile("darkplaces.opt", tempmempool, true, NULL);
2222 COM_InsertFlags(buf);
2228 // Provide the SelfPack.
2229 if (!Sys_CheckParm("-noselfpack") && sys.selffd >= 0)
2231 fs_selfpack = FS_LoadPackPK3FromFD(sys.argv[0], sys.selffd, true);
2235 if (!Sys_CheckParm("-noopt"))
2237 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
2240 COM_InsertFlags(buf);
2257 fs_mempool = Mem_AllocPool("file management", 0, NULL);
2263 // initialize the self-pack (must be before COM_InitGameType as it may add command line options)
2266 // detect gamemode from commandline options or executable name
2277 void FS_Shutdown (void)
2279 // close all pack files and such
2280 // (hopefully there aren't any other open files, but they'll be cleaned up
2281 // by the OS anyway)
2282 FS_ClearSearchPath();
2283 Mem_FreePool (&fs_mempool);
2284 PK3_CloseLibrary ();
2287 Sys_FreeLibrary (&shfolder_dll);
2288 Sys_FreeLibrary (&shell32_dll);
2289 Sys_FreeLibrary (&ole32_dll);
2293 Thread_DestroyMutex(fs_mutex);
2296 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qbool nonblocking)
2298 filedesc_t handle = FILEDESC_INVALID;
2301 qbool dolock = false;
2303 // Parse the mode string
2312 opt = O_CREAT | O_TRUNC;
2316 opt = O_CREAT | O_APPEND;
2319 Con_Printf(CON_ERROR "FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2320 return FILEDESC_INVALID;
2322 for (ind = 1; mode[ind] != '\0'; ind++)
2336 Con_Printf(CON_ERROR "FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2337 filepath, mode, mode[ind]);
2344 if(Sys_CheckParm("-readonly") && mod != O_RDONLY)
2345 return FILEDESC_INVALID;
2349 return FILEDESC_INVALID;
2350 handle = SDL_RWFromFile(filepath, mode);
2353 # if _MSC_VER >= 1400
2354 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2356 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2359 handle = open (filepath, mod | opt, 0666);
2360 if(handle >= 0 && dolock)
2363 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2364 l.l_whence = SEEK_SET;
2367 if(fcntl(handle, F_SETLK, &l) == -1)
2369 FILEDESC_CLOSE(handle);
2379 int FS_SysOpenFD(const char *filepath, const char *mode, qbool nonblocking)
2384 return FS_SysOpenFiledesc(filepath, mode, nonblocking);
2389 ====================
2392 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2393 ====================
2395 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qbool nonblocking)
2399 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2401 file->handle = FS_SysOpenFiledesc(filepath, mode, nonblocking);
2402 if (!FILEDESC_ISVALID(file->handle))
2408 file->filename = Mem_strdup(fs_mempool, filepath);
2410 file->real_length = FILEDESC_SEEK (file->handle, 0, SEEK_END);
2412 // For files opened in append mode, we start at the end of the file
2414 file->position = file->real_length;
2416 FILEDESC_SEEK (file->handle, 0, SEEK_SET);
2426 Open a packed file using its package file descriptor
2429 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2432 filedesc_t dup_handle;
2435 pfile = &pack->files[pack_ind];
2437 // If we don't have the true offset, get it now
2438 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2439 if (!PK3_GetTrueFileOffset (pfile, pack))
2442 #ifndef LINK_TO_ZLIB
2443 // No Zlib DLL = no compressed files
2444 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2446 Con_Printf(CON_WARN "WARNING: can't open the compressed file %s\n"
2447 "You need the Zlib DLL to use compressed files\n",
2453 // LadyHavoc: FILEDESC_SEEK affects all duplicates of a handle so we do it before
2454 // the dup() call to avoid having to close the dup_handle on error here
2455 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
2457 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2458 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2462 dup_handle = FILEDESC_DUP (pack->filename, pack->handle);
2463 if (!FILEDESC_ISVALID(dup_handle))
2465 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2469 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2470 memset (file, 0, sizeof (*file));
2471 file->handle = dup_handle;
2472 file->flags = QFILE_FLAG_PACKED;
2473 file->real_length = pfile->realsize;
2474 file->offset = pfile->offset;
2478 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2482 file->flags |= QFILE_FLAG_DEFLATED;
2484 // We need some more variables
2485 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2487 ztk->comp_length = pfile->packsize;
2489 // Initialize zlib stream
2490 ztk->zstream.next_in = ztk->input;
2491 ztk->zstream.avail_in = 0;
2493 /* From Zlib's "unzip.c":
2495 * windowBits is passed < 0 to tell that there is no zlib header.
2496 * Note that in this case inflate *requires* an extra "dummy" byte
2497 * after the compressed stream in order to complete decompression and
2498 * return Z_STREAM_END.
2499 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2500 * size of both compressed and uncompressed data
2502 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2504 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2505 FILEDESC_CLOSE(dup_handle);
2510 ztk->zstream.next_out = file->buff;
2511 ztk->zstream.avail_out = sizeof (file->buff);
2520 ====================
2523 Return true if the path should be rejected due to one of the following:
2524 1: path elements that are non-portable
2525 2: path elements that would allow access to files outside the game directory,
2526 or are just not a good idea for a mod to be using.
2527 ====================
2529 int FS_CheckNastyPath (const char *path, qbool isgamedir)
2531 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2535 // Windows: don't allow \ in filenames (windows-only), period.
2536 // (on Windows \ is a directory separator, but / is also supported)
2537 if (strstr(path, "\\"))
2538 return 1; // non-portable
2540 // Mac: don't allow Mac-only filenames - : is a directory separator
2541 // instead of /, but we rely on / working already, so there's no reason to
2542 // support a Mac-only path
2543 // Amiga and Windows: : tries to go to root of drive
2544 if (strstr(path, ":"))
2545 return 1; // non-portable attempt to go to root of drive
2547 // Amiga: // is parent directory
2548 if (strstr(path, "//"))
2549 return 1; // non-portable attempt to go to parent directory
2551 // all: don't allow going to parent directory (../ or /../)
2552 if (strstr(path, ".."))
2553 return 2; // attempt to go outside the game directory
2555 // Windows and UNIXes: don't allow absolute paths
2557 return 2; // attempt to go outside the game directory
2559 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2560 if (strstr(path, "./"))
2561 return 2; // possible attempt to go outside the game directory
2563 // all: forbid trailing slash on gamedir
2564 if (isgamedir && path[strlen(path)-1] == '/')
2567 // all: forbid leading dot on any filename for any reason
2568 if (strstr(path, "/."))
2569 return 2; // attempt to go outside the game directory
2571 // after all these checks we're pretty sure it's a / separated filename
2572 // and won't do much if any harm
2577 ====================
2580 Sanitize path (replace non-portable characters
2581 with portable ones in-place, etc)
2582 ====================
2584 void FS_SanitizePath(char *path)
2586 for (; *path; path++)
2592 ====================
2595 Look for a file in the packages and in the filesystem
2597 Return the searchpath where the file was found (or NULL)
2598 and the file index in the package if relevant
2599 ====================
2601 static searchpath_t *FS_FindFile (const char *name, int* index, qbool quiet)
2603 searchpath_t *search;
2606 // search through the path, one element at a time
2607 for (search = fs_searchpaths;search;search = search->next)
2609 // is the element a pak file?
2610 if (search->pack && !search->pack->vpack)
2612 int (*strcmp_funct) (const char* str1, const char* str2);
2613 int left, right, middle;
2616 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2618 // Look for the file (binary search)
2620 right = pak->numfiles - 1;
2621 while (left <= right)
2625 middle = (left + right) / 2;
2626 diff = strcmp_funct (pak->files[middle].name, name);
2631 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2633 // yes, but the first one is empty so we treat it as not being there
2634 if (!quiet && developer_extra.integer)
2635 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2642 if (!quiet && developer_extra.integer)
2643 Con_DPrintf("FS_FindFile: %s in %s\n",
2644 pak->files[middle].name, pak->filename);
2651 // If we're too far in the list
2660 char netpath[MAX_OSPATH];
2661 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2662 if (FS_SysFileExists (netpath))
2664 if (!quiet && developer_extra.integer)
2665 Con_DPrintf("FS_FindFile: %s\n", netpath);
2674 if (!quiet && developer_extra.integer)
2675 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2687 Look for a file in the search paths and open it in read-only mode
2690 static qfile_t *FS_OpenReadFile (const char *filename, qbool quiet, qbool nonblocking, int symlinkLevels)
2692 searchpath_t *search;
2695 search = FS_FindFile (filename, &pack_ind, quiet);
2701 // Found in the filesystem?
2704 // this works with vpacks, so we are fine
2705 char path [MAX_OSPATH];
2706 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2707 return FS_SysOpen (path, "rb", nonblocking);
2710 // So, we found it in a package...
2712 // Is it a PK3 symlink?
2713 // TODO also handle directory symlinks by parsing the whole structure...
2714 // but heck, file symlinks are good enough for now
2715 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2717 if(symlinkLevels <= 0)
2719 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2724 char linkbuf[MAX_QPATH];
2726 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2727 const char *mergeslash;
2732 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2738 // Now combine the paths...
2739 mergeslash = strrchr(filename, '/');
2740 mergestart = linkbuf;
2742 mergeslash = filename;
2743 while(!strncmp(mergestart, "../", 3))
2746 while(mergeslash > filename)
2749 if(*mergeslash == '/')
2753 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2754 if(mergeslash == filename)
2756 // Either mergeslash == filename, then we just replace the name (done below)
2760 // Or, we append the name after mergeslash;
2761 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2762 int spaceNeeded = mergeslash - filename + 1;
2763 int spaceRemoved = mergestart - linkbuf;
2764 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2766 Con_DPrintf("symlink: too long path rejected\n");
2769 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2770 memcpy(linkbuf, filename, spaceNeeded);
2771 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2772 mergestart = linkbuf;
2774 if (!quiet && developer_loading.integer)
2775 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2776 if(FS_CheckNastyPath (mergestart, false))
2778 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2781 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2785 return FS_OpenPackedFile (search->pack, pack_ind);
2790 =============================================================================
2792 MAIN PUBLIC FUNCTIONS
2794 =============================================================================
2798 ====================
2801 Open a file in the userpath. The syntax is the same as fopen
2802 Used for savegame scanning in menu, and all file writing.
2803 ====================
2805 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qbool quiet)
2807 char real_path [MAX_OSPATH];
2809 if (FS_CheckNastyPath(filepath, false))
2811 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2815 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2817 // If the file is opened in "write", "append", or "read/write" mode,
2818 // create directories up to the file.
2819 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2820 FS_CreatePath (real_path);
2821 return FS_SysOpen (real_path, mode, false);
2826 ====================
2829 Open a file. The syntax is the same as fopen
2830 ====================
2832 qfile_t* FS_OpenVirtualFile (const char* filepath, qbool quiet)
2834 qfile_t *result = NULL;
2835 if (FS_CheckNastyPath(filepath, false))
2837 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2841 if (fs_mutex) Thread_LockMutex(fs_mutex);
2842 result = FS_OpenReadFile (filepath, quiet, false, 16);
2843 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2849 ====================
2852 Open a file. The syntax is the same as fopen
2853 ====================
2855 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qbool quiet)
2858 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2859 memset (file, 0, sizeof (*file));
2860 file->flags = QFILE_FLAG_DATA;
2862 file->real_length = size;
2868 ====================
2872 ====================
2874 int FS_Close (qfile_t* file)
2876 if(file->flags & QFILE_FLAG_DATA)
2882 if (FILEDESC_CLOSE (file->handle))
2887 if (file->flags & QFILE_FLAG_REMOVE)
2889 if (remove(file->filename) == -1)
2891 // No need to report this. If removing a just
2892 // written file failed, this most likely means
2893 // someone else deleted it first - which we
2898 Mem_Free((void *) file->filename);
2903 qz_inflateEnd (&file->ztk->zstream);
2904 Mem_Free (file->ztk);
2911 void FS_RemoveOnClose(qfile_t* file)
2913 file->flags |= QFILE_FLAG_REMOVE;
2917 ====================
2920 Write "datasize" bytes into a file
2921 ====================
2923 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2925 fs_offset_t written = 0;
2927 // If necessary, seek to the exact file position we're supposed to be
2928 if (file->buff_ind != file->buff_len)
2930 if (FILEDESC_SEEK (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
2932 Con_Printf(CON_WARN "WARNING: could not seek in %s.\n", file->filename);
2936 // Purge cached data
2939 // Write the buffer and update the position
2940 // 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)
2941 while (written < (fs_offset_t)datasize)
2943 // figure out how much to write in one chunk
2944 fs_offset_t maxchunk = 1<<30; // 1 GiB
2945 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2946 int result = (int)FILEDESC_WRITE (file->handle, (const unsigned char *)data + written, chunk);
2947 // if at least some was written, add it to our accumulator
2950 // if the result is not what we expected, consider the write to be incomplete
2951 if (result != chunk)
2954 file->position = FILEDESC_SEEK (file->handle, 0, SEEK_CUR);
2955 if (file->real_length < file->position)
2956 file->real_length = file->position;
2958 // note that this will never be less than 0 even if the write failed
2964 ====================
2967 Read up to "buffersize" bytes from a file
2968 ====================
2970 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2972 fs_offset_t count, done;
2974 if (buffersize == 0 || !buffer)
2977 // Get rid of the ungetc character
2978 if (file->ungetc != EOF)
2980 ((char*)buffer)[0] = file->ungetc;
2988 if(file->flags & QFILE_FLAG_DATA)
2990 size_t left = file->real_length - file->position;
2991 if(buffersize > left)
2993 memcpy(buffer, file->data + file->position, buffersize);
2994 file->position += buffersize;
2998 // First, we copy as many bytes as we can from "buff"
2999 if (file->buff_ind < file->buff_len)
3001 count = file->buff_len - file->buff_ind;
3002 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
3004 memcpy (buffer, &file->buff[file->buff_ind], count);
3005 file->buff_ind += count;
3007 buffersize -= count;
3008 if (buffersize == 0)
3012 // NOTE: at this point, the read buffer is always empty
3014 // If the file isn't compressed
3015 if (! (file->flags & QFILE_FLAG_DEFLATED))
3019 // We must take care to not read after the end of the file
3020 count = file->real_length - file->position;
3022 // If we have a lot of data to get, put them directly into "buffer"
3023 if (buffersize > sizeof (file->buff) / 2)
3025 if (count > (fs_offset_t)buffersize)
3026 count = (fs_offset_t)buffersize;
3027 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
3029 // Seek failed. When reading from a pipe, and
3030 // the caller never called FS_Seek, this still
3031 // works fine. So no reporting this error.
3033 nb = FILEDESC_READ (file->handle, &((unsigned char*)buffer)[done], count);
3037 file->position += nb;
3039 // Purge cached data
3045 if (count > (fs_offset_t)sizeof (file->buff))
3046 count = (fs_offset_t)sizeof (file->buff);
3047 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
3049 // Seek failed. When reading from a pipe, and
3050 // the caller never called FS_Seek, this still
3051 // works fine. So no reporting this error.
3053 nb = FILEDESC_READ (file->handle, file->buff, count);
3056 file->buff_len = nb;
3057 file->position += nb;
3059 // Copy the requested data in "buffer" (as much as we can)
3060 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
3061 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
3062 file->buff_ind = count;
3070 // If the file is compressed, it's more complicated...
3071 // We cycle through a few operations until we have read enough data
3072 while (buffersize > 0)
3074 ztoolkit_t *ztk = file->ztk;
3077 // NOTE: at this point, the read buffer is always empty
3079 // If "input" is also empty, we need to refill it
3080 if (ztk->in_ind == ztk->in_len)
3082 // If we are at the end of the file
3083 if (file->position == file->real_length)
3086 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
3087 if (count > (fs_offset_t)sizeof (ztk->input))
3088 count = (fs_offset_t)sizeof (ztk->input);
3089 FILEDESC_SEEK (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
3090 if (FILEDESC_READ (file->handle, ztk->input, count) != count)
3092 Con_Printf ("FS_Read: unexpected end of file\n");
3097 ztk->in_len = count;
3098 ztk->in_position += count;
3101 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
3102 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
3104 // Now that we are sure we have compressed data available, we need to determine
3105 // if it's better to inflate it in "file->buff" or directly in "buffer"
3107 // Inflate the data in "file->buff"
3108 if (buffersize < sizeof (file->buff) / 2)
3110 ztk->zstream.next_out = file->buff;
3111 ztk->zstream.avail_out = sizeof (file->buff);
3112 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3113 if (error != Z_OK && error != Z_STREAM_END)
3115 Con_Printf ("FS_Read: Can't inflate file\n");
3118 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3120 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
3121 file->position += file->buff_len;
3123 // Copy the requested data in "buffer" (as much as we can)
3124 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
3125 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
3126 file->buff_ind = count;
3129 // Else, we inflate directly in "buffer"
3132 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
3133 ztk->zstream.avail_out = (unsigned int)buffersize;
3134 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3135 if (error != Z_OK && error != Z_STREAM_END)
3137 Con_Printf ("FS_Read: Can't inflate file\n");
3140 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3142 // How much data did it inflate?
3143 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
3144 file->position += count;
3146 // Purge cached data
3151 buffersize -= count;
3159 ====================
3162 Print a string into a file
3163 ====================
3165 int FS_Print (qfile_t* file, const char *msg)
3167 return (int)FS_Write (file, msg, strlen (msg));
3171 ====================
3174 Print a string into a file
3175 ====================
3177 int FS_Printf(qfile_t* file, const char* format, ...)
3182 va_start (args, format);
3183 result = FS_VPrintf (file, format, args);
3191 ====================
3194 Print a string into a file
3195 ====================
3197 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3200 fs_offset_t buff_size = MAX_INPUTLINE;
3205 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3206 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3207 if (len >= 0 && len < buff_size)
3209 Mem_Free (tempbuff);
3213 len = FILEDESC_WRITE (file->handle, tempbuff, len);
3214 Mem_Free (tempbuff);
3221 ====================
3224 Get the next character of a file
3225 ====================
3227 int FS_Getc (qfile_t* file)
3231 if (FS_Read (file, &c, 1) != 1)
3239 ====================
3242 Put a character back into the read buffer (only supports one character!)
3243 ====================
3245 int FS_UnGetc (qfile_t* file, unsigned char c)
3247 // If there's already a character waiting to be read
3248 if (file->ungetc != EOF)
3257 ====================
3260 Move the position index in a file
3261 ====================
3263 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3266 unsigned char* buffer;
3267 fs_offset_t buffersize;
3269 // Compute the file offset
3273 offset += file->position - file->buff_len + file->buff_ind;
3280 offset += file->real_length;
3286 if (offset < 0 || offset > file->real_length)
3289 if(file->flags & QFILE_FLAG_DATA)
3291 file->position = offset;
3295 // If we have the data in our read buffer, we don't need to actually seek
3296 if (file->position - file->buff_len <= offset && offset <= file->position)
3298 file->buff_ind = offset + file->buff_len - file->position;
3302 // Purge cached data
3305 // Unpacked or uncompressed files can seek directly
3306 if (! (file->flags & QFILE_FLAG_DEFLATED))
3308 if (FILEDESC_SEEK (file->handle, file->offset + offset, SEEK_SET) == -1)
3310 file->position = offset;
3314 // Seeking in compressed files is more a hack than anything else,
3315 // but we need to support it, so here we go.
3318 // If we have to go back in the file, we need to restart from the beginning
3319 if (offset <= file->position)
3323 ztk->in_position = 0;
3325 if (FILEDESC_SEEK (file->handle, file->offset, SEEK_SET) == -1)
3326 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3328 // Reset the Zlib stream
3329 ztk->zstream.next_in = ztk->input;
3330 ztk->zstream.avail_in = 0;
3331 qz_inflateReset (&ztk->zstream);
3334 // We need a big buffer to force inflating into it directly
3335 buffersize = 2 * sizeof (file->buff);
3336 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3338 // Skip all data until we reach the requested offset
3339 while (offset > (file->position - file->buff_len + file->buff_ind))
3341 fs_offset_t diff = offset - (file->position - file->buff_len + file->buff_ind);
3342 fs_offset_t count, len;
3344 count = (diff > buffersize) ? buffersize : diff;
3345 len = FS_Read (file, buffer, count);
3359 ====================
3362 Give the current position in a file
3363 ====================
3365 fs_offset_t FS_Tell (qfile_t* file)
3367 return file->position - file->buff_len + file->buff_ind;
3372 ====================
3375 Give the total size of a file
3376 ====================
3378 fs_offset_t FS_FileSize (qfile_t* file)
3380 return file->real_length;
3385 ====================
3388 Erases any buffered input or output data
3389 ====================
3391 void FS_Purge (qfile_t* file)
3401 FS_LoadAndCloseQFile
3403 Loads full content of a qfile_t and closes it.
3404 Always appends a 0 byte.
3407 static unsigned char *FS_LoadAndCloseQFile (qfile_t *file, const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3409 unsigned char *buf = NULL;
3410 fs_offset_t filesize = 0;
3414 filesize = file->real_length;
3417 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3422 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3423 buf[filesize] = '\0';
3424 FS_Read (file, buf, filesize);
3426 if (developer_loadfile.integer)
3427 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3430 if (filesizepointer)
3431 *filesizepointer = filesize;
3440 Filename are relative to the quake directory.
3441 Always appends a 0 byte.
3444 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3446 qfile_t *file = FS_OpenVirtualFile(path, quiet);
3447 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3455 Filename are OS paths.
3456 Always appends a 0 byte.
3459 unsigned char *FS_SysLoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
3461 qfile_t *file = FS_SysOpen(path, "rb", false);
3462 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3470 The filename will be prefixed by the current game directory
3473 qbool FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3477 fs_offset_t lentotal;
3479 file = FS_OpenRealFile(filename, "wb", false);
3482 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3487 for(i = 0; i < count; ++i)
3489 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3490 for(i = 0; i < count; ++i)
3491 FS_Write (file, data[i], len[i]);
3496 qbool FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3498 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3503 =============================================================================
3505 OTHERS PUBLIC FUNCTIONS
3507 =============================================================================
3515 void FS_StripExtension (const char *in, char *out, size_t size_out)
3523 while ((currentchar = *in) && size_out > 1)
3525 if (currentchar == '.')
3527 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3529 *out++ = currentchar;
3545 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3549 // if path doesn't have a .EXT, append extension
3550 // (extension should include the .)
3551 src = path + strlen(path);
3553 while (*src != '/' && src != path)
3556 return; // it has an extension
3560 strlcat (path, extension, size_path);
3568 Look for a file in the packages and in the filesystem
3571 int FS_FileType (const char *filename)
3573 searchpath_t *search;
3574 char fullpath[MAX_OSPATH];
3576 search = FS_FindFile (filename, NULL, true);
3578 return FS_FILETYPE_NONE;
3580 if(search->pack && !search->pack->vpack)
3581 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3583 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3584 return FS_SysFileType(fullpath);
3592 Look for a file in the packages and in the filesystem
3595 qbool FS_FileExists (const char *filename)
3597 return (FS_FindFile (filename, NULL, true) != NULL);
3605 Look for a file in the filesystem only
3608 int FS_SysFileType (const char *path)
3611 // Sajt - some older sdks are missing this define
3612 # ifndef INVALID_FILE_ATTRIBUTES
3613 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3616 DWORD result = GetFileAttributes(path);
3618 if(result == INVALID_FILE_ATTRIBUTES)
3619 return FS_FILETYPE_NONE;
3621 if(result & FILE_ATTRIBUTE_DIRECTORY)
3622 return FS_FILETYPE_DIRECTORY;
3624 return FS_FILETYPE_FILE;
3628 if (stat (path,&buf) == -1)
3629 return FS_FILETYPE_NONE;
3632 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3634 if(S_ISDIR(buf.st_mode))
3635 return FS_FILETYPE_DIRECTORY;
3637 return FS_FILETYPE_FILE;
3641 qbool FS_SysFileExists (const char *path)
3643 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3650 Allocate and fill a search structure with information on matching filenames.
3653 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet, const char *packfile)
3656 searchpath_t *searchpath;
3658 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3659 stringlist_t resultlist;
3660 stringlist_t dirlist;
3661 stringlist_t matchedSet, foundSet;
3662 const char *start, *slash, *backslash, *colon, *separator;
3665 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3670 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3674 stringlistinit(&resultlist);
3675 stringlistinit(&dirlist);
3677 slash = strrchr(pattern, '/');
3678 backslash = strrchr(pattern, '\\');
3679 colon = strrchr(pattern, ':');
3680 separator = max(slash, backslash);
3681 separator = max(separator, colon);
3682 basepathlength = separator ? (separator + 1 - pattern) : 0;
3683 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3685 memcpy(basepath, pattern, basepathlength);
3686 basepath[basepathlength] = 0;
3688 // search through the path, one element at a time
3689 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3691 // is the element a pak file?
3692 if (searchpath->pack && !searchpath->pack->vpack)
3694 // look through all the pak file elements
3695 pak = searchpath->pack;
3698 if(strcmp(packfile, pak->shortname))
3701 for (i = 0;i < pak->numfiles;i++)
3703 char temp[MAX_OSPATH];
3704 strlcpy(temp, pak->files[i].name, sizeof(temp));
3707 if (matchpattern(temp, (char *)pattern, true))
3709 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3710 if (!strcmp(resultlist.strings[resultlistindex], temp))
3712 if (resultlistindex == resultlist.numstrings)
3714 stringlistappend(&resultlist, temp);
3715 if (!quiet && developer_loading.integer)
3716 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3719 // strip off one path element at a time until empty
3720 // this way directories are added to the listing if they match the pattern
3721 slash = strrchr(temp, '/');
3722 backslash = strrchr(temp, '\\');
3723 colon = strrchr(temp, ':');
3725 if (separator < slash)
3727 if (separator < backslash)
3728 separator = backslash;
3729 if (separator < colon)
3731 *((char *)separator) = 0;
3742 stringlistinit(&matchedSet);
3743 stringlistinit(&foundSet);
3744 // add a first entry to the set
3745 stringlistappend(&matchedSet, "");
3746 // iterate through pattern's path
3749 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3750 char subpath[MAX_OSPATH];
3751 char subpattern[MAX_OSPATH];
3753 // find the next wildcard
3754 wildcard = strchr(start, '?');
3755 asterisk = strchr(start, '*');
3756 if (asterisk && (!wildcard || asterisk < wildcard))
3758 wildcard = asterisk;
3763 nextseparator = strchr( wildcard, '/' );
3767 nextseparator = NULL;
3770 if( !nextseparator ) {
3771 nextseparator = start + strlen( start );
3774 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3775 // copy everything up except nextseperator
3776 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3777 // find the last '/' before the wildcard
3778 prevseparator = strrchr( subpattern, '/' );
3780 prevseparator = subpattern;
3783 // copy everything from start to the previous including the '/' (before the wildcard)
3784 // everything up to start is already included in the path of matchedSet's entries
3785 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3787 // for each entry in matchedSet try to open the subdirectories specified in subpath
3788 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3789 char temp[MAX_OSPATH];
3790 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3791 strlcat( temp, subpath, sizeof(temp) );
3792 listdirectory( &foundSet, searchpath->filename, temp );
3794 if( dirlistindex == 0 ) {
3797 // reset the current result set
3798 stringlistfreecontents( &matchedSet );
3799 // match against the pattern
3800 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3801 const char *direntry = foundSet.strings[ dirlistindex ];
3802 if (matchpattern(direntry, subpattern, true)) {
3803 stringlistappend( &matchedSet, direntry );
3806 stringlistfreecontents( &foundSet );
3808 start = nextseparator;
3811 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3813 const char *matchtemp = matchedSet.strings[dirlistindex];
3814 if (matchpattern(matchtemp, (char *)pattern, true))
3816 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3817 if (!strcmp(resultlist.strings[resultlistindex], matchtemp))
3819 if (resultlistindex == resultlist.numstrings)
3821 stringlistappend(&resultlist, matchtemp);
3822 if (!quiet && developer_loading.integer)
3823 Con_Printf("SearchDirFile: %s\n", matchtemp);
3827 stringlistfreecontents( &matchedSet );
3831 if (resultlist.numstrings)
3833 stringlistsort(&resultlist, true);
3834 numfiles = resultlist.numstrings;
3836 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3837 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3838 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3839 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3840 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3841 search->numfilenames = (int)numfiles;
3844 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3847 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3848 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3849 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3851 numchars += (int)textlen;
3854 stringlistfreecontents(&resultlist);
3860 void FS_FreeSearch(fssearch_t *search)
3865 extern int con_linewidth;
3866 static int FS_ListDirectory(const char *pattern, int oneperline)
3875 char linebuf[MAX_INPUTLINE];
3877 search = FS_Search(pattern, true, true, NULL);
3880 numfiles = search->numfilenames;
3883 // FIXME: the names could be added to one column list and then
3884 // gradually shifted into the next column if they fit, and then the
3885 // next to make a compact variable width listing but it's a lot more
3887 // find width for columns
3889 for (i = 0;i < numfiles;i++)
3891 l = (int)strlen(search->filenames[i]);
3892 if (columnwidth < l)
3895 // count the spacing character
3897 // calculate number of columns
3898 numcolumns = con_linewidth / columnwidth;
3899 // don't bother with the column printing if it's only one column
3900 if (numcolumns >= 2)
3902 numlines = (numfiles + numcolumns - 1) / numcolumns;
3903 for (i = 0;i < numlines;i++)
3906 for (k = 0;k < numcolumns;k++)
3908 l = i * numcolumns + k;
3911 name = search->filenames[l];
3912 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3913 linebuf[linebufpos++] = name[j];
3914 // space out name unless it's the last on the line
3915 if (k + 1 < numcolumns && l + 1 < numfiles)
3916 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3917 linebuf[linebufpos++] = ' ';
3920 linebuf[linebufpos] = 0;
3921 Con_Printf("%s\n", linebuf);
3928 for (i = 0;i < numfiles;i++)
3929 Con_Printf("%s\n", search->filenames[i]);
3930 FS_FreeSearch(search);
3931 return (int)numfiles;
3934 static void FS_ListDirectoryCmd (cmd_state_t *cmd, const char* cmdname, int oneperline)
3936 const char *pattern;
3937 if (Cmd_Argc(cmd) >= 3)
3939 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3942 if (Cmd_Argc(cmd) == 2)
3943 pattern = Cmd_Argv(cmd, 1);
3946 if (!FS_ListDirectory(pattern, oneperline))
3947 Con_Print("No files found.\n");
3950 void FS_Dir_f(cmd_state_t *cmd)
3952 FS_ListDirectoryCmd(cmd, "dir", true);
3955 void FS_Ls_f(cmd_state_t *cmd)
3957 FS_ListDirectoryCmd(cmd, "ls", false);
3960 void FS_Which_f(cmd_state_t *cmd)
3962 const char *filename;
3965 if (Cmd_Argc(cmd) != 2)
3967 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(cmd, 0));
3970 filename = Cmd_Argv(cmd, 1);
3971 sp = FS_FindFile(filename, &index, true);
3973 Con_Printf("%s isn't anywhere\n", filename);
3979 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3981 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3984 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3988 const char *FS_WhichPack(const char *filename)
3991 searchpath_t *sp = FS_FindFile(filename, &index, true);
3993 return sp->pack->shortname;
4001 ====================
4002 FS_IsRegisteredQuakePack
4004 Look for a proof of purchase file file in the requested package
4006 If it is found, this file should NOT be downloaded.
4007 ====================
4009 qbool FS_IsRegisteredQuakePack(const char *name)
4011 searchpath_t *search;
4014 // search through the path, one element at a time
4015 for (search = fs_searchpaths;search;search = search->next)
4017 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
4018 // TODO do we want to support vpacks in here too?
4020 int (*strcmp_funct) (const char* str1, const char* str2);
4021 int left, right, middle;
4024 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
4026 // Look for the file (binary search)
4028 right = pak->numfiles - 1;
4029 while (left <= right)
4033 middle = (left + right) / 2;
4034 diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
4040 // If we're too far in the list
4047 // we found the requested pack but it is not registered quake
4055 int FS_CRCFile(const char *filename, size_t *filesizepointer)
4058 unsigned char *filedata;
4059 fs_offset_t filesize;
4060 if (filesizepointer)
4061 *filesizepointer = 0;
4062 if (!filename || !*filename)
4064 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
4067 if (filesizepointer)
4068 *filesizepointer = filesize;
4069 crc = CRC_Block(filedata, filesize);
4075 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
4078 unsigned char *out = NULL;
4082 #ifndef LINK_TO_ZLIB
4087 memset(&strm, 0, sizeof(strm));
4088 strm.zalloc = Z_NULL;
4089 strm.zfree = Z_NULL;
4090 strm.opaque = Z_NULL;
4093 level = Z_DEFAULT_COMPRESSION;
4095 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
4097 Con_Printf("FS_Deflate: deflate init error!\n");
4101 strm.next_in = (unsigned char*)data;
4102 strm.avail_in = (unsigned int)size;
4104 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
4107 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
4108 qz_deflateEnd(&strm);
4112 strm.next_out = tmp;
4113 strm.avail_out = (unsigned int)size;
4115 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
4117 Con_Printf("FS_Deflate: deflate failed!\n");
4118 qz_deflateEnd(&strm);
4123 if(qz_deflateEnd(&strm) != Z_OK)
4125 Con_Printf("FS_Deflate: deflateEnd failed\n");
4130 if(strm.total_out >= size)
4132 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
4137 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
4140 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
4145 *deflated_size = (size_t)strm.total_out;
4147 memcpy(out, tmp, strm.total_out);
4153 static void AssertBufsize(sizebuf_t *buf, int length)
4155 if(buf->cursize + length > buf->maxsize)
4157 int oldsize = buf->maxsize;
4158 unsigned char *olddata;
4159 olddata = buf->data;
4160 buf->maxsize += length;
4161 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
4164 memcpy(buf->data, olddata, oldsize);
4170 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
4174 unsigned char *out = NULL;
4175 unsigned char tmp[2048];
4180 #ifndef LINK_TO_ZLIB
4185 memset(&outbuf, 0, sizeof(outbuf));
4186 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
4187 outbuf.maxsize = sizeof(tmp);
4189 memset(&strm, 0, sizeof(strm));
4190 strm.zalloc = Z_NULL;
4191 strm.zfree = Z_NULL;
4192 strm.opaque = Z_NULL;
4194 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
4196 Con_Printf("FS_Inflate: inflate init error!\n");
4197 Mem_Free(outbuf.data);
4201 strm.next_in = (unsigned char*)data;
4202 strm.avail_in = (unsigned int)size;
4206 strm.next_out = tmp;
4207 strm.avail_out = sizeof(tmp);
4208 ret = qz_inflate(&strm, Z_NO_FLUSH);
4209 // it either returns Z_OK on progress, Z_STREAM_END on end
4217 case Z_STREAM_ERROR:
4218 Con_Print("FS_Inflate: stream error!\n");
4221 Con_Print("FS_Inflate: data error!\n");
4224 Con_Print("FS_Inflate: mem error!\n");
4227 Con_Print("FS_Inflate: buf error!\n");
4230 Con_Print("FS_Inflate: unknown error!\n");
4234 if(ret != Z_OK && ret != Z_STREAM_END)
4236 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4237 Mem_Free(outbuf.data);
4238 qz_inflateEnd(&strm);
4241 have = sizeof(tmp) - strm.avail_out;
4242 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4243 SZ_Write(&outbuf, tmp, have);
4244 } while(ret != Z_STREAM_END);
4246 qz_inflateEnd(&strm);
4248 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4251 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4252 Mem_Free(outbuf.data);
4256 memcpy(out, outbuf.data, outbuf.cursize);
4257 Mem_Free(outbuf.data);
4259 *inflated_size = (size_t)outbuf.cursize;