4 Copyright (C) 2003-2006 Mathieu Olivier
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 See the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to:
20 Free Software Foundation, Inc.
21 59 Temple Place - Suite 330
22 Boston, MA 02111-1307, USA
32 # include <sys/stat.h>
36 # include <sys/stat.h>
43 // include SDL for IPHONEOS code
52 // Win32 requires us to add O_BINARY, but the other OSes don't have it
57 // In case the system doesn't support the O_NONBLOCK flag
62 // largefile support for Win32
65 # define lseek _lseeki64
68 // suppress deprecated warnings
73 # define unlink _unlink
79 typedef SDL_RWops *filedesc_t;
80 # define FILEDESC_INVALID NULL
81 # define FILEDESC_ISVALID(fd) ((fd) != NULL)
82 # define FILEDESC_READ(fd,buf,count) ((fs_offset_t)SDL_RWread(fd, buf, 1, count))
83 # define FILEDESC_WRITE(fd,buf,count) ((fs_offset_t)SDL_RWwrite(fd, buf, 1, count))
84 # define FILEDESC_CLOSE SDL_RWclose
85 # define FILEDESC_SEEK SDL_RWseek
86 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
87 filedesc_t new_fd = SDL_RWFromFile(filename, "rb");
88 if (SDL_RWseek(new_fd, SDL_RWseek(fd, 0, RW_SEEK_CUR), RW_SEEK_SET) < 0) {
94 # define unlink(name) Con_DPrintf("Sorry, no unlink support when trying to unlink %s.\n", (name))
96 typedef int filedesc_t;
97 # define FILEDESC_INVALID -1
98 # define FILEDESC_ISVALID(fd) ((fd) != -1)
99 # define FILEDESC_READ read
100 # define FILEDESC_WRITE write
101 # define FILEDESC_CLOSE close
102 # define FILEDESC_SEEK lseek
103 static filedesc_t FILEDESC_DUP(const char *filename, filedesc_t fd) {
108 /** \page fs File System
110 All of Quake's data access is through a hierchal file system, but the contents
111 of the file system can be transparently merged from several sources.
113 The "base directory" is the path to the directory holding the quake.exe and
114 all game directories. The sys_* files pass this to host_init in
115 quakeparms_t->basedir. This can be overridden with the "-basedir" command
116 line parm to allow code debugging in a different directory. The base
117 directory is only used during filesystem initialization.
119 The "game directory" is the first tree on the search path and directory that
120 all generated files (savegames, screenshots, demos, config files) will be
121 saved to. This can be overridden with the "-game" command line parameter.
122 The game directory can never be changed while quake is executing. This is a
123 precaution against having a malicious server instruct clients to write files
124 over areas they shouldn't.
130 =============================================================================
134 =============================================================================
137 // Magic numbers of a ZIP file (big-endian format)
138 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
139 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
140 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
142 // Other constants for ZIP files
143 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
144 #define ZIP_END_CDIR_SIZE 22
145 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
146 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
151 #define qz_inflate inflate
152 #define qz_inflateEnd inflateEnd
153 #define qz_inflateInit2_ inflateInit2_
154 #define qz_inflateReset inflateReset
155 #define qz_deflateInit2_ deflateInit2_
156 #define qz_deflateEnd deflateEnd
157 #define qz_deflate deflate
158 #define Z_MEMLEVEL_DEFAULT 8
161 // Zlib constants (from zlib.h)
162 #define Z_SYNC_FLUSH 2
165 #define Z_STREAM_END 1
166 #define Z_STREAM_ERROR (-2)
167 #define Z_DATA_ERROR (-3)
168 #define Z_MEM_ERROR (-4)
169 #define Z_BUF_ERROR (-5)
170 #define ZLIB_VERSION "1.2.3"
174 #define Z_MEMLEVEL_DEFAULT 8
177 #define Z_DEFAULT_COMPRESSION (-1)
179 #define Z_SYNC_FLUSH 2
180 #define Z_FULL_FLUSH 3
183 // Uncomment the following line if the zlib DLL you have still uses
184 // the 1.1.x series calling convention on Win32 (WINAPI)
185 //#define ZLIB_USES_WINAPI
189 =============================================================================
193 =============================================================================
196 /*! Zlib stream (from zlib.h)
197 * \warning: some pointers we don't use directly have
198 * been cast to "void*" for a matter of simplicity
202 unsigned char *next_in; ///< next input byte
203 unsigned int avail_in; ///< number of bytes available at next_in
204 unsigned long total_in; ///< total nb of input bytes read so far
206 unsigned char *next_out; ///< next output byte should be put there
207 unsigned int avail_out; ///< remaining free space at next_out
208 unsigned long total_out; ///< total nb of bytes output so far
210 char *msg; ///< last error message, NULL if no error
211 void *state; ///< not visible by applications
213 void *zalloc; ///< used to allocate the internal state
214 void *zfree; ///< used to free the internal state
215 void *opaque; ///< private data object passed to zalloc and zfree
217 int data_type; ///< best guess about the data type: ascii or binary
218 unsigned long adler; ///< adler32 value of the uncompressed data
219 unsigned long reserved; ///< reserved for future use
224 /// inside a package (PAK or PK3)
225 #define QFILE_FLAG_PACKED (1 << 0)
226 /// file is compressed using the deflate algorithm (PK3 only)
227 #define QFILE_FLAG_DEFLATED (1 << 1)
228 /// file is actually already loaded data
229 #define QFILE_FLAG_DATA (1 << 2)
230 /// real file will be removed on close
231 #define QFILE_FLAG_REMOVE (1 << 3)
233 #define FILE_BUFF_SIZE 2048
237 size_t comp_length; ///< length of the compressed file
238 size_t in_ind, in_len; ///< input buffer current index and length
239 size_t in_position; ///< position in the compressed file
240 unsigned char input [FILE_BUFF_SIZE];
246 filedesc_t handle; ///< file descriptor
247 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
248 fs_offset_t position; ///< current position in the file
249 fs_offset_t offset; ///< offset into the package (0 if external file)
250 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
253 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
254 unsigned char buff [FILE_BUFF_SIZE];
256 ztoolkit_t* ztk; ///< For zipped files.
258 const unsigned char *data; ///< For data files.
260 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
264 // ------ PK3 files on disk ------ //
266 // You can get the complete ZIP format description from PKWARE website
268 typedef struct pk3_endOfCentralDir_s
270 unsigned int signature;
271 unsigned short disknum;
272 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
273 unsigned short localentries; ///< number of entries in the central directory on this disk
274 unsigned short nbentries; ///< total number of entries in the central directory on this disk
275 unsigned int cdir_size; ///< size of the central directory
276 unsigned int cdir_offset; ///< with respect to the starting disk number
277 unsigned short comment_size;
278 fs_offset_t prepended_garbage;
279 } pk3_endOfCentralDir_t;
282 // ------ PAK files on disk ------ //
283 typedef struct dpackfile_s
286 int filepos, filelen;
289 typedef struct dpackheader_s
297 /*! \name Packages in memory
300 /// the offset in packfile_t is the true contents offset
301 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
302 /// file compressed using the deflate algorithm
303 #define PACKFILE_FLAG_DEFLATED (1 << 1)
304 /// file is a symbolic link
305 #define PACKFILE_FLAG_SYMLINK (1 << 2)
307 typedef struct packfile_s
309 char name [MAX_QPATH];
312 fs_offset_t packsize; ///< size in the package
313 fs_offset_t realsize; ///< real file size (uncompressed)
316 typedef struct pack_s
318 char filename [MAX_OSPATH];
319 char shortname [MAX_QPATH];
321 int ignorecase; ///< PK3 ignores case
328 /// Search paths for files (including packages)
329 typedef struct searchpath_s
331 // only one of filename / pack will be used
332 char filename[MAX_OSPATH];
334 struct searchpath_s *next;
339 =============================================================================
343 =============================================================================
346 void FS_Dir_f(cmd_state_t *cmd);
347 void FS_Ls_f(cmd_state_t *cmd);
348 void FS_Which_f(cmd_state_t *cmd);
350 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
351 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
352 fs_offset_t offset, fs_offset_t packsize,
353 fs_offset_t realsize, int flags);
357 =============================================================================
361 =============================================================================
364 mempool_t *fs_mempool;
365 void *fs_mutex = NULL;
367 searchpath_t *fs_searchpaths = NULL;
368 const char *const fs_checkgamedir_missing = "missing";
370 #define MAX_FILES_IN_PACK 65536
372 char fs_userdir[MAX_OSPATH];
373 char fs_gamedir[MAX_OSPATH];
374 char fs_basedir[MAX_OSPATH];
375 static pack_t *fs_selfpack = NULL;
377 // list of active game directories (empty if not running a mod)
378 int fs_numgamedirs = 0;
379 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
381 // list of all gamedirs with modinfo.txt
382 gamedir_t *fs_all_gamedirs = NULL;
383 int fs_all_gamedirs_count = 0;
385 cvar_t scr_screenshot_name = {CVAR_CLIENT | CVAR_NORESETTODEFAULTS, "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)"};
386 cvar_t fs_empty_files_in_pack_mark_deletions = {CVAR_CLIENT | CVAR_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"};
387 cvar_t cvar_fs_gamedir = {CVAR_CLIENT | CVAR_SERVER | CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
391 =============================================================================
393 PRIVATE FUNCTIONS - PK3 HANDLING
395 =============================================================================
399 // Functions exported from zlib
400 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
401 # define ZEXPORT WINAPI
406 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
407 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
408 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
409 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
410 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
411 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
412 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
415 #define qz_inflateInit2(strm, windowBits) \
416 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
417 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
418 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
421 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
423 static dllfunction_t zlibfuncs[] =
425 {"inflate", (void **) &qz_inflate},
426 {"inflateEnd", (void **) &qz_inflateEnd},
427 {"inflateInit2_", (void **) &qz_inflateInit2_},
428 {"inflateReset", (void **) &qz_inflateReset},
429 {"deflateInit2_", (void **) &qz_deflateInit2_},
430 {"deflateEnd", (void **) &qz_deflateEnd},
431 {"deflate", (void **) &qz_deflate},
435 /// Handle for Zlib DLL
436 static dllhandle_t zlib_dll = NULL;
440 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
441 static dllfunction_t shfolderfuncs[] =
443 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
446 static const char* shfolderdllnames [] =
448 "shfolder.dll", // IE 4, or Win NT and higher
451 static dllhandle_t shfolder_dll = NULL;
453 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
454 #define qREFKNOWNFOLDERID const GUID *
455 #define qKF_FLAG_CREATE 0x8000
456 #define qKF_FLAG_NO_ALIAS 0x1000
457 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
458 static dllfunction_t shell32funcs[] =
460 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
463 static const char* shell32dllnames [] =
465 "shell32.dll", // Vista and higher
468 static dllhandle_t shell32_dll = NULL;
470 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
471 static void (WINAPI *qCoUninitialize)(void);
472 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
473 static dllfunction_t ole32funcs[] =
475 {"CoInitializeEx", (void **) &qCoInitializeEx},
476 {"CoUninitialize", (void **) &qCoUninitialize},
477 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
480 static const char* ole32dllnames [] =
482 "ole32.dll", // 2000 and higher
485 static dllhandle_t ole32_dll = NULL;
495 static void PK3_CloseLibrary (void)
498 Sys_UnloadLibrary (&zlib_dll);
507 Try to load the Zlib DLL
510 static qboolean PK3_OpenLibrary (void)
515 const char* dllnames [] =
518 # ifdef ZLIB_USES_WINAPI
524 #elif defined(MACOSX)
538 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
546 See if zlib is available
549 qboolean FS_HasZlib(void)
554 PK3_OpenLibrary(); // to be safe
555 return (zlib_dll != 0);
561 PK3_GetEndOfCentralDir
563 Extract the end of the central directory from a PK3 package
566 static qboolean PK3_GetEndOfCentralDir (const char *packfile, filedesc_t packhandle, pk3_endOfCentralDir_t *eocd)
568 fs_offset_t filesize, maxsize;
569 unsigned char *buffer, *ptr;
572 // Get the package size
573 filesize = FILEDESC_SEEK (packhandle, 0, SEEK_END);
574 if (filesize < ZIP_END_CDIR_SIZE)
577 // Load the end of the file in memory
578 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
581 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
582 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
583 FILEDESC_SEEK (packhandle, filesize - maxsize, SEEK_SET);
584 if (FILEDESC_READ (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
590 // Look for the end of central dir signature around the end of the file
591 maxsize -= ZIP_END_CDIR_SIZE;
592 ptr = &buffer[maxsize];
594 while (BuffBigLong (ptr) != ZIP_END_HEADER)
606 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
607 eocd->signature = LittleLong (eocd->signature);
608 eocd->disknum = LittleShort (eocd->disknum);
609 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
610 eocd->localentries = LittleShort (eocd->localentries);
611 eocd->nbentries = LittleShort (eocd->nbentries);
612 eocd->cdir_size = LittleLong (eocd->cdir_size);
613 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
614 eocd->comment_size = LittleShort (eocd->comment_size);
615 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
616 eocd->cdir_offset += eocd->prepended_garbage;
621 eocd->cdir_size > filesize ||
622 eocd->cdir_offset >= filesize ||
623 eocd->cdir_offset + eocd->cdir_size > filesize
626 // Obviously invalid central directory.
638 Extract the file list from a PK3 file
641 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
643 unsigned char *central_dir, *ptr;
645 fs_offset_t remaining;
647 // Load the central directory in memory
648 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
649 if (FILEDESC_SEEK (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
651 Mem_Free (central_dir);
654 if(FILEDESC_READ (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
656 Mem_Free (central_dir);
660 // Extract the files properties
661 // The parsing is done "by hand" because some fields have variable sizes and
662 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
663 remaining = eocd->cdir_size;
666 for (ind = 0; ind < eocd->nbentries; ind++)
668 fs_offset_t namesize, count;
670 // Checking the remaining size
671 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
673 Mem_Free (central_dir);
676 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
679 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
681 Mem_Free (central_dir);
685 namesize = BuffLittleShort (&ptr[28]); // filename length
687 // Check encryption, compression, and attributes
688 // 1st uint8 : general purpose bit flag
689 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
691 // LadyHavoc: bit 3 would be a problem if we were scanning the archive
692 // but is not a problem in the central directory where the values are
695 // bit 3 seems to always be set by the standard Mac OSX zip maker
697 // 2nd uint8 : external file attributes
698 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
699 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
701 // Still enough bytes for the name?
702 if (namesize < 0 || remaining < namesize || namesize >= (int)sizeof (*pack->files))
704 Mem_Free (central_dir);
708 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
709 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
711 char filename [sizeof (pack->files[0].name)];
712 fs_offset_t offset, packsize, realsize;
715 // Extract the name (strip it if necessary)
716 namesize = min(namesize, (int)sizeof (filename) - 1);
717 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
718 filename[namesize] = '\0';
720 if (BuffLittleShort (&ptr[10]))
721 flags = PACKFILE_FLAG_DEFLATED;
724 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
725 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
726 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
728 switch(ptr[5]) // C_VERSION_MADE_BY_1
733 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
734 // can't use S_ISLNK here, as this has to compile on non-UNIX too
735 flags |= PACKFILE_FLAG_SYMLINK;
739 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
743 // Skip the name, additionnal field, and comment
744 // 1er uint16 : extra field length
745 // 2eme uint16 : file comment length
746 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
747 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
751 // If the package is empty, central_dir is NULL here
752 if (central_dir != NULL)
753 Mem_Free (central_dir);
754 return pack->numfiles;
762 Create a package entry associated with a PK3 file
765 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, filedesc_t packhandle, qboolean silent)
767 pk3_endOfCentralDir_t eocd;
771 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
774 Con_Printf ("%s is not a PK3 file\n", packfile);
775 FILEDESC_CLOSE(packhandle);
779 // Multi-volume ZIP archives are NOT allowed
780 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
782 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
783 FILEDESC_CLOSE(packhandle);
787 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
788 // since eocd.nbentries is an unsigned 16 bits integer
789 #if MAX_FILES_IN_PACK < 65535
790 if (eocd.nbentries > MAX_FILES_IN_PACK)
792 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
793 FILEDESC_CLOSE(packhandle);
798 // Create a package structure in memory
799 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
800 pack->ignorecase = true; // PK3 ignores case
801 strlcpy (pack->filename, packfile, sizeof (pack->filename));
802 pack->handle = packhandle;
803 pack->numfiles = eocd.nbentries;
804 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
806 real_nb_files = PK3_BuildFileList (pack, &eocd);
807 if (real_nb_files < 0)
809 Con_Printf ("%s is not a valid PK3 file\n", packfile);
810 FILEDESC_CLOSE(pack->handle);
815 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
819 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qboolean nonblocking);
820 static pack_t *FS_LoadPackPK3 (const char *packfile)
822 filedesc_t packhandle;
823 packhandle = FS_SysOpenFiledesc (packfile, "rb", false);
824 if (!FILEDESC_ISVALID(packhandle))
826 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
832 PK3_GetTrueFileOffset
834 Find where the true file data offset is
837 static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
839 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
843 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
846 // Load the local file description
847 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
849 Con_Printf ("Can't seek in package %s\n", pack->filename);
852 count = FILEDESC_READ (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
853 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
855 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
859 // Skip name and extra field
860 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
862 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
868 =============================================================================
870 OTHER PRIVATE FUNCTIONS
872 =============================================================================
880 Add a file to the list of files contained into a package
883 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
884 fs_offset_t offset, fs_offset_t packsize,
885 fs_offset_t realsize, int flags)
887 int (*strcmp_funct) (const char* str1, const char* str2);
888 int left, right, middle;
891 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
893 // Look for the slot we should put that file into (binary search)
895 right = pack->numfiles - 1;
896 while (left <= right)
900 middle = (left + right) / 2;
901 diff = strcmp_funct (pack->files[middle].name, name);
903 // If we found the file, there's a problem
905 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
907 // If we're too far in the list
914 // We have to move the right of the list by one slot to free the one we need
915 pfile = &pack->files[left];
916 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
919 strlcpy (pfile->name, name, sizeof (pfile->name));
920 pfile->offset = offset;
921 pfile->packsize = packsize;
922 pfile->realsize = realsize;
923 pfile->flags = flags;
929 static void FS_mkdir (const char *path)
931 if(COM_CheckParm("-readonly"))
935 if (_mkdir (path) == -1)
937 if (mkdir (path, 0777) == -1)
940 // No logging for this. The only caller is FS_CreatePath (which
941 // calls it in ways that will intentionally produce EEXIST),
942 // and its own callers always use the directory afterwards and
943 // thus will detect failure that way.
952 Only used for FS_OpenRealFile.
955 void FS_CreatePath (char *path)
959 for (ofs = path+1 ; *ofs ; ofs++)
961 if (*ofs == '/' || *ofs == '\\')
963 // create the directory
979 static void FS_Path_f(cmd_state_t *cmd)
983 Con_Print("Current search path:\n");
984 for (s=fs_searchpaths ; s ; s=s->next)
989 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
991 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
994 Con_Printf("%s\n", s->filename);
1004 /*! Takes an explicit (not game tree related) path to a pak file.
1005 *Loads the header and directory, adding the files at the beginning
1006 *of the list so they override previous pack files.
1008 static pack_t *FS_LoadPackPAK (const char *packfile)
1010 dpackheader_t header;
1011 int i, numpackfiles;
1012 filedesc_t packhandle;
1016 packhandle = FS_SysOpenFiledesc(packfile, "rb", false);
1017 if (!FILEDESC_ISVALID(packhandle))
1019 if(FILEDESC_READ (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
1021 Con_Printf ("%s is not a packfile\n", packfile);
1022 FILEDESC_CLOSE(packhandle);
1025 if (memcmp(header.id, "PACK", 4))
1027 Con_Printf ("%s is not a packfile\n", packfile);
1028 FILEDESC_CLOSE(packhandle);
1031 header.dirofs = LittleLong (header.dirofs);
1032 header.dirlen = LittleLong (header.dirlen);
1034 if (header.dirlen % sizeof(dpackfile_t))
1036 Con_Printf ("%s has an invalid directory size\n", packfile);
1037 FILEDESC_CLOSE(packhandle);
1041 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1043 if (numpackfiles < 0 || numpackfiles > MAX_FILES_IN_PACK)
1045 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
1046 FILEDESC_CLOSE(packhandle);
1050 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1051 FILEDESC_SEEK (packhandle, header.dirofs, SEEK_SET);
1052 if(header.dirlen != FILEDESC_READ (packhandle, (void *)info, header.dirlen))
1054 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1056 FILEDESC_CLOSE(packhandle);
1060 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1061 pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
1062 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1063 pack->handle = packhandle;
1065 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1067 // parse the directory
1068 for (i = 0;i < numpackfiles;i++)
1070 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1071 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1073 // Ensure a zero terminated file name (required by format).
1074 info[i].name[sizeof(info[i].name) - 1] = 0;
1076 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1081 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1086 ====================
1089 Create a package entry associated with a directory file
1090 ====================
1092 static pack_t *FS_LoadPackVirtual (const char *dirname)
1095 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1097 pack->ignorecase = false;
1098 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1099 pack->handle = FILEDESC_INVALID;
1100 pack->numfiles = -1;
1102 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1111 /*! Adds the given pack to the search path.
1112 * The pack type is autodetected by the file extension.
1114 * Returns true if the file was successfully added to the
1115 * search path or if it was already included.
1117 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1118 * plain directories.
1121 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1123 searchpath_t *search;
1125 const char *ext = FS_FileExtension(pakfile);
1128 for(search = fs_searchpaths; search; search = search->next)
1130 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1133 *already_loaded = true;
1134 return true; // already loaded
1139 *already_loaded = false;
1141 if(!strcasecmp(ext, "pk3dir"))
1142 pak = FS_LoadPackVirtual (pakfile);
1143 else if(!strcasecmp(ext, "pak"))
1144 pak = FS_LoadPackPAK (pakfile);
1145 else if(!strcasecmp(ext, "pk3"))
1146 pak = FS_LoadPackPK3 (pakfile);
1147 else if(!strcasecmp(ext, "obb")) // android apk expansion
1148 pak = FS_LoadPackPK3 (pakfile);
1150 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1154 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1156 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1159 // find the first item whose next one is a pack or NULL
1160 searchpath_t *insertion_point = 0;
1161 if(fs_searchpaths && !fs_searchpaths->pack)
1163 insertion_point = fs_searchpaths;
1166 if(!insertion_point->next)
1168 if(insertion_point->next->pack)
1170 insertion_point = insertion_point->next;
1173 // If insertion_point is NULL, this means that either there is no
1174 // item in the list yet, or that the very first item is a pack. In
1175 // that case, we want to insert at the beginning...
1176 if(!insertion_point)
1178 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1179 search->next = fs_searchpaths;
1180 fs_searchpaths = search;
1183 // otherwise we want to append directly after insertion_point.
1185 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1186 search->next = insertion_point->next;
1187 insertion_point->next = search;
1192 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1193 search->next = fs_searchpaths;
1194 fs_searchpaths = search;
1199 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1200 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1201 // same goes for the name inside the pack structure
1202 l = strlen(pak->shortname);
1204 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1205 pak->shortname[l - 3] = 0;
1206 l = strlen(pak->filename);
1208 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1209 pak->filename[l - 3] = 0;
1215 Con_Errorf("unable to load pak \"%s\"\n", pakfile);
1226 /*! Adds the given pack to the search path and searches for it in the game path.
1227 * The pack type is autodetected by the file extension.
1229 * Returns true if the file was successfully added to the
1230 * search path or if it was already included.
1232 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1233 * plain directories.
1235 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1237 char fullpath[MAX_OSPATH];
1239 searchpath_t *search;
1242 *already_loaded = false;
1244 // then find the real name...
1245 search = FS_FindFile(pakfile, &index, true);
1246 if(!search || search->pack)
1248 Con_Printf("could not find pak \"%s\"\n", pakfile);
1252 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1254 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1262 Sets fs_gamedir, adds the directory to the head of the path,
1263 then loads and adds pak1.pak pak2.pak ...
1266 static void FS_AddGameDirectory (const char *dir)
1270 searchpath_t *search;
1272 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1274 stringlistinit(&list);
1275 listdirectory(&list, "", dir);
1276 stringlistsort(&list, false);
1278 // add any PAK package in the directory
1279 for (i = 0;i < list.numstrings;i++)
1281 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1283 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1287 // add any PK3 package in the directory
1288 for (i = 0;i < list.numstrings;i++)
1290 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1292 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1296 stringlistfreecontents(&list);
1298 // Add the directory to the search path
1299 // (unpacked files have the priority over packed files)
1300 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1301 strlcpy (search->filename, dir, sizeof (search->filename));
1302 search->next = fs_searchpaths;
1303 fs_searchpaths = search;
1312 static void FS_AddGameHierarchy (const char *dir)
1315 // Add the common game directory
1316 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1319 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1328 const char *FS_FileExtension (const char *in)
1330 const char *separator, *backslash, *colon, *dot;
1332 separator = strrchr(in, '/');
1333 backslash = strrchr(in, '\\');
1334 if (!separator || separator < backslash)
1335 separator = backslash;
1336 colon = strrchr(in, ':');
1337 if (!separator || separator < colon)
1340 dot = strrchr(in, '.');
1341 if (dot == NULL || (separator && (dot < separator)))
1353 const char *FS_FileWithoutPath (const char *in)
1355 const char *separator, *backslash, *colon;
1357 separator = strrchr(in, '/');
1358 backslash = strrchr(in, '\\');
1359 if (!separator || separator < backslash)
1360 separator = backslash;
1361 colon = strrchr(in, ':');
1362 if (!separator || separator < colon)
1364 return separator ? separator + 1 : in;
1373 static void FS_ClearSearchPath (void)
1375 // unload all packs and directory information, close all pack files
1376 // (if a qfile is still reading a pack it won't be harmed because it used
1377 // dup() to get its own handle already)
1378 while (fs_searchpaths)
1380 searchpath_t *search = fs_searchpaths;
1381 fs_searchpaths = search->next;
1382 if (search->pack && search->pack != fs_selfpack)
1384 if(!search->pack->vpack)
1387 FILEDESC_CLOSE(search->pack->handle);
1388 // free any memory associated with it
1389 if (search->pack->files)
1390 Mem_Free(search->pack->files);
1392 Mem_Free(search->pack);
1398 static void FS_AddSelfPack(void)
1402 searchpath_t *search;
1403 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1404 search->next = fs_searchpaths;
1405 search->pack = fs_selfpack;
1406 fs_searchpaths = search;
1416 void FS_Rescan (void)
1419 qboolean fs_modified = false;
1420 qboolean reset = false;
1421 char gamedirbuf[MAX_INPUTLINE];
1426 FS_ClearSearchPath();
1428 // automatically activate gamemode for the gamedirs specified
1430 COM_ChangeGameTypeForGameDirs();
1432 // add the game-specific paths
1433 // gamedirname1 (typically id1)
1434 FS_AddGameHierarchy (gamedirname1);
1435 // update the com_modname (used for server info)
1436 if (gamedirname2 && gamedirname2[0])
1437 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1439 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1441 // add the game-specific path, if any
1442 // (only used for mission packs and the like, which should set fs_modified)
1443 if (gamedirname2 && gamedirname2[0])
1446 FS_AddGameHierarchy (gamedirname2);
1450 // Adds basedir/gamedir as an override game
1451 // LadyHavoc: now supports multiple -game directories
1452 // set the com_modname (reported in server info)
1454 for (i = 0;i < fs_numgamedirs;i++)
1457 FS_AddGameHierarchy (fs_gamedirs[i]);
1458 // update the com_modname (used server info)
1459 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1461 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1463 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1465 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1467 // add back the selfpack as new first item
1470 // set the default screenshot name to either the mod name or the
1471 // gamemode screenshot name
1472 if (strcmp(com_modname, gamedirname1))
1473 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1475 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1477 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1478 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1480 // If "-condebug" is in the command line, remove the previous log file
1481 if (COM_CheckParm ("-condebug") != 0)
1482 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1484 // look for the pop.lmp file and set registered to true if it is found
1485 if (FS_FileExists("gfx/pop.lmp"))
1486 Cvar_SetValueQuick(®istered, 1);
1492 if (!registered.integer)
1495 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1497 Con_Print("Playing shareware version.\n");
1500 Con_Print("Playing registered version.\n");
1502 case GAME_STEELSTORM:
1503 if (registered.integer)
1504 Con_Print("Playing registered version.\n");
1506 Con_Print("Playing shareware version.\n");
1512 // unload all wads so that future queries will return the new data
1516 static void FS_Rescan_f(cmd_state_t *cmd)
1526 extern qboolean vid_opened;
1527 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1532 if (fs_numgamedirs == numgamedirs)
1534 for (i = 0;i < numgamedirs;i++)
1535 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1537 if (i == numgamedirs)
1538 return true; // already using this set of gamedirs, do nothing
1541 if (numgamedirs > MAX_GAMEDIRS)
1544 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1545 return false; // too many gamedirs
1548 for (i = 0;i < numgamedirs;i++)
1550 // if string is nasty, reject it
1551 p = FS_CheckGameDir(gamedirs[i]);
1555 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1556 return false; // nasty gamedirs
1558 if(p == fs_checkgamedir_missing && failmissing)
1561 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1562 return false; // missing gamedirs
1568 fs_numgamedirs = numgamedirs;
1569 for (i = 0;i < fs_numgamedirs;i++)
1570 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1572 // reinitialize filesystem to detect the new paks
1575 if (cls.demoplayback)
1577 CL_Disconnect_f(&cmd_client);
1581 // unload all sounds so they will be reloaded from the new files as needed
1582 S_UnloadAllSounds_f(&cmd_client);
1584 // restart the video subsystem after the config is executed
1585 Cbuf_InsertText(&cmd_client, "\nloadconfig\nvid_restart\n\n");
1595 static void FS_GameDir_f(cmd_state_t *cmd)
1599 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1601 if (Cmd_Argc(cmd) < 2)
1603 Con_Printf("gamedirs active:");
1604 for (i = 0;i < fs_numgamedirs;i++)
1605 Con_Printf(" %s", fs_gamedirs[i]);
1610 numgamedirs = Cmd_Argc(cmd) - 1;
1611 if (numgamedirs > MAX_GAMEDIRS)
1613 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1617 for (i = 0;i < numgamedirs;i++)
1618 strlcpy(gamedirs[i], Cmd_Argv(cmd, i+1), sizeof(gamedirs[i]));
1620 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1622 // actually, changing during game would work fine, but would be stupid
1623 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1627 // halt demo playback to close the file
1630 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1633 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1641 stringlistinit(&list);
1642 listdirectory(&list, gamedir, "");
1643 success = list.numstrings > 0;
1644 stringlistfreecontents(&list);
1648 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1651 n = FS_Read (f, buf, buflength - 1);
1671 const char *FS_CheckGameDir(const char *gamedir)
1674 static char buf[8192];
1677 if (FS_CheckNastyPath(gamedir, true))
1680 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1685 // get description from basedir
1686 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1694 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1698 return fs_checkgamedir_missing;
1701 static void FS_ListGameDirs(void)
1703 stringlist_t list, list2;
1708 fs_all_gamedirs_count = 0;
1710 Mem_Free(fs_all_gamedirs);
1712 stringlistinit(&list);
1713 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1714 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1715 stringlistsort(&list, false);
1717 stringlistinit(&list2);
1718 for(i = 0; i < list.numstrings; ++i)
1721 if(!strcmp(list.strings[i-1], list.strings[i]))
1723 info = FS_CheckGameDir(list.strings[i]);
1726 if(info == fs_checkgamedir_missing)
1730 stringlistappend(&list2, list.strings[i]);
1732 stringlistfreecontents(&list);
1734 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1735 for(i = 0; i < list2.numstrings; ++i)
1737 info = FS_CheckGameDir(list2.strings[i]);
1738 // all this cannot happen any more, but better be safe than sorry
1741 if(info == fs_checkgamedir_missing)
1745 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1746 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1747 ++fs_all_gamedirs_count;
1753 #pragma comment(lib, "shell32.lib")
1758 static void COM_InsertFlags(const char *buf) {
1761 const char **new_argv;
1763 int args_left = 256;
1764 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1766 new_argv[0] = "dummy"; // Can't really happen.
1768 new_argv[0] = com_argv[0];
1771 while(COM_ParseToken_Console(&p))
1773 size_t sz = strlen(com_token) + 1; // shut up clang
1776 q = (char *)Mem_Alloc(fs_mempool, sz);
1777 strlcpy(q, com_token, sz);
1781 // Now: i <= args_left + 1.
1784 memcpy((char *)(&new_argv[i]), &com_argv[1], sizeof(*com_argv) * (com_argc - 1));
1787 // Now: i <= args_left + (com_argc || 1).
1789 com_argv = new_argv;
1798 void FS_Init_SelfPack (void)
1801 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1803 // Load darkplaces.opt from the FS.
1804 if (!COM_CheckParm("-noopt"))
1806 char *buf = (char *) FS_SysLoadFile("darkplaces.opt", tempmempool, true, NULL);
1808 COM_InsertFlags(buf);
1813 // Provide the SelfPack.
1814 if (!COM_CheckParm("-noselfpack"))
1816 if (com_selffd >= 0)
1818 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1822 if (!COM_CheckParm("-noopt"))
1824 char *buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1826 COM_InsertFlags(buf);
1835 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1837 #if defined(__IPHONEOS__)
1838 if (userdirmode == USERDIRMODE_HOME)
1840 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1841 // fs_userdir stores configurations to the Documents folder of the app
1842 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1847 #elif defined(WIN32)
1849 #if _MSC_VER >= 1400
1852 TCHAR mydocsdir[MAX_PATH + 1];
1853 wchar_t *savedgamesdirw;
1854 char savedgamesdir[MAX_OSPATH];
1863 case USERDIRMODE_NOHOME:
1864 strlcpy(userdir, fs_basedir, userdirsize);
1866 case USERDIRMODE_MYGAMES:
1868 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1870 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1872 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1875 #if _MSC_VER >= 1400
1876 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1879 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1884 homedir = getenv("USERPROFILE");
1887 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1892 case USERDIRMODE_SAVEDGAMES:
1894 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1896 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1897 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1899 savedgamesdir[0] = 0;
1900 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1903 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1905 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1908 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1910 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1911 #if _MSC_VER >= 1400
1912 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1914 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1916 qCoTaskMemFree(savedgamesdirw);
1919 if (savedgamesdir[0])
1921 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1936 case USERDIRMODE_NOHOME:
1937 strlcpy(userdir, fs_basedir, userdirsize);
1939 case USERDIRMODE_HOME:
1940 homedir = getenv("HOME");
1943 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1947 case USERDIRMODE_SAVEDGAMES:
1948 homedir = getenv("HOME");
1952 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1954 // the XDG say some files would need to go in:
1955 // XDG_CONFIG_HOME (or ~/.config/%s/)
1956 // XDG_DATA_HOME (or ~/.local/share/%s/)
1957 // XDG_CACHE_HOME (or ~/.cache/%s/)
1958 // and also search the following global locations if defined:
1959 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1960 // XDG_DATA_DIRS (normally /usr/share/%s/)
1961 // this would be too complicated...
1971 #if !defined(__IPHONEOS__)
1974 // historical behavior...
1975 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1976 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
1979 // see if we can write to this path (note: won't create path)
1981 // no access() here, we must try to open the file for appending
1982 fd = FS_SysOpenFiledesc(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1986 // on Unix, we don't need to ACTUALLY attempt to open the file
1987 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1994 return 1; // good choice - the path exists and is writable
1998 if (userdirmode == USERDIRMODE_NOHOME)
1999 return -1; // path usually already exists, we lack permissions
2001 return 0; // probably good - failed to write but maybe we need to create path
2021 // Overrides the system supplied base directory (under GAMENAME)
2022 // 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)
2023 i = COM_CheckParm ("-basedir");
2024 if (i && i < com_argc-1)
2026 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
2027 i = (int)strlen (fs_basedir);
2028 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
2029 fs_basedir[i-1] = 0;
2033 // If the base directory is explicitly defined by the compilation process
2034 #ifdef DP_FS_BASEDIR
2035 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
2036 #elif defined(__ANDROID__)
2037 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
2038 #elif defined(MACOSX)
2039 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
2040 if (strstr(com_argv[0], ".app/"))
2043 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
2044 split = strstr(fs_basedir, ".app/");
2047 struct stat statresult;
2049 // truncate to just after the .app/
2051 // see if gamedir exists in Resources
2052 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
2054 // found gamedir inside Resources, use it
2055 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
2059 // no gamedir found in Resources, gamedir is probably
2060 // outside the .app, remove .app part of path
2061 while (split > fs_basedir && *split != '/')
2070 // make sure the appending of a path separator won't create an unterminated string
2071 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
2072 // add a path separator to the end of the basedir if it lacks one
2073 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
2074 strlcat(fs_basedir, "/", sizeof(fs_basedir));
2076 // Add the personal game directory
2077 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
2078 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
2079 else if (COM_CheckParm("-nohome"))
2080 *fs_userdir = 0; // user wants roaming installation, no userdir
2083 #ifdef DP_FS_USERDIR
2084 strlcpy(fs_userdir, DP_FS_USERDIR, sizeof(fs_userdir));
2087 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2088 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2089 int userdirstatus[USERDIRMODE_COUNT];
2091 // historical behavior...
2092 if (!strcmp(gamedirname1, "id1"))
2093 preferreduserdirmode = USERDIRMODE_NOHOME;
2095 // check what limitations the user wants to impose
2096 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2097 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2098 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2099 // gather the status of the possible userdirs
2100 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2102 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2103 if (userdirstatus[dirmode] == 1)
2104 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2105 else if (userdirstatus[dirmode] == 0)
2106 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2108 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2110 // some games may prefer writing to basedir, but if write fails we
2111 // have to search for a real userdir...
2112 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2113 preferreduserdirmode = highestuserdirmode;
2114 // check for an existing userdir and continue using it if possible...
2115 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2116 if (userdirstatus[dirmode] == 1)
2118 // if no existing userdir found, make a new one...
2119 if (dirmode == 0 && preferreduserdirmode > 0)
2120 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2121 if (userdirstatus[dirmode] >= 0)
2123 // and finally, we picked one...
2124 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2125 Con_DPrintf("userdir %i is the winner\n", dirmode);
2129 // if userdir equal to basedir, clear it to avoid confusion later
2130 if (!strcmp(fs_basedir, fs_userdir))
2135 p = FS_CheckGameDir(gamedirname1);
2136 if(!p || p == fs_checkgamedir_missing)
2137 Con_Warnf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2141 p = FS_CheckGameDir(gamedirname2);
2142 if(!p || p == fs_checkgamedir_missing)
2143 Con_Warnf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2147 // Adds basedir/gamedir as an override game
2148 // LadyHavoc: now supports multiple -game directories
2149 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2153 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2156 p = FS_CheckGameDir(com_argv[i]);
2158 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2159 if(p == fs_checkgamedir_missing)
2160 Con_Warnf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2161 // add the gamedir to the list of active gamedirs
2162 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2167 // generate the searchpath
2170 if (Thread_HasThreads())
2171 fs_mutex = Thread_CreateMutex();
2174 void FS_Init_Commands(void)
2176 Cvar_RegisterVariable (&scr_screenshot_name);
2177 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2178 Cvar_RegisterVariable (&cvar_fs_gamedir);
2180 Cmd_AddCommand(&cmd_client, "gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2181 Cmd_AddCommand(&cmd_client, "fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2182 Cmd_AddCommand(&cmd_client, "path", FS_Path_f, "print searchpath (game directories and archives)");
2183 Cmd_AddCommand(&cmd_client, "dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2184 Cmd_AddCommand(&cmd_client, "ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2185 Cmd_AddCommand(&cmd_client, "which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2187 Cmd_AddCommand(&cmd_server, "gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2188 Cmd_AddCommand(&cmd_server, "fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2189 Cmd_AddCommand(&cmd_server, "path", FS_Path_f, "print searchpath (game directories and archives)");
2190 Cmd_AddCommand(&cmd_server, "dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2191 Cmd_AddCommand(&cmd_server, "ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2192 Cmd_AddCommand(&cmd_server, "which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2200 void FS_Shutdown (void)
2202 // close all pack files and such
2203 // (hopefully there aren't any other open files, but they'll be cleaned up
2204 // by the OS anyway)
2205 FS_ClearSearchPath();
2206 Mem_FreePool (&fs_mempool);
2207 PK3_CloseLibrary ();
2210 Sys_UnloadLibrary (&shfolder_dll);
2211 Sys_UnloadLibrary (&shell32_dll);
2212 Sys_UnloadLibrary (&ole32_dll);
2216 Thread_DestroyMutex(fs_mutex);
2219 static filedesc_t FS_SysOpenFiledesc(const char *filepath, const char *mode, qboolean nonblocking)
2221 filedesc_t handle = FILEDESC_INVALID;
2224 qboolean dolock = false;
2226 // Parse the mode string
2235 opt = O_CREAT | O_TRUNC;
2239 opt = O_CREAT | O_APPEND;
2242 Con_Errorf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2243 return FILEDESC_INVALID;
2245 for (ind = 1; mode[ind] != '\0'; ind++)
2259 Con_Errorf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2260 filepath, mode, mode[ind]);
2267 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2268 return FILEDESC_INVALID;
2272 return FILEDESC_INVALID;
2273 handle = SDL_RWFromFile(filepath, mode);
2276 # if _MSC_VER >= 1400
2277 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2279 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2282 handle = open (filepath, mod | opt, 0666);
2283 if(handle >= 0 && dolock)
2286 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2287 l.l_whence = SEEK_SET;
2290 if(fcntl(handle, F_SETLK, &l) == -1)
2292 FILEDESC_CLOSE(handle);
2302 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2307 return FS_SysOpenFiledesc(filepath, mode, nonblocking);
2312 ====================
2315 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2316 ====================
2318 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2322 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2324 file->handle = FS_SysOpenFiledesc(filepath, mode, nonblocking);
2325 if (!FILEDESC_ISVALID(file->handle))
2331 file->filename = Mem_strdup(fs_mempool, filepath);
2333 file->real_length = FILEDESC_SEEK (file->handle, 0, SEEK_END);
2335 // For files opened in append mode, we start at the end of the file
2337 file->position = file->real_length;
2339 FILEDESC_SEEK (file->handle, 0, SEEK_SET);
2349 Open a packed file using its package file descriptor
2352 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2355 filedesc_t dup_handle;
2358 pfile = &pack->files[pack_ind];
2360 // If we don't have the true offset, get it now
2361 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2362 if (!PK3_GetTrueFileOffset (pfile, pack))
2365 #ifndef LINK_TO_ZLIB
2366 // No Zlib DLL = no compressed files
2367 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2369 Con_Warnf("WARNING: can't open the compressed file %s\n"
2370 "You need the Zlib DLL to use compressed files\n",
2376 // LadyHavoc: FILEDESC_SEEK affects all duplicates of a handle so we do it before
2377 // the dup() call to avoid having to close the dup_handle on error here
2378 if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
2380 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2381 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2385 dup_handle = FILEDESC_DUP (pack->filename, pack->handle);
2386 if (!FILEDESC_ISVALID(dup_handle))
2388 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2392 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2393 memset (file, 0, sizeof (*file));
2394 file->handle = dup_handle;
2395 file->flags = QFILE_FLAG_PACKED;
2396 file->real_length = pfile->realsize;
2397 file->offset = pfile->offset;
2401 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2405 file->flags |= QFILE_FLAG_DEFLATED;
2407 // We need some more variables
2408 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2410 ztk->comp_length = pfile->packsize;
2412 // Initialize zlib stream
2413 ztk->zstream.next_in = ztk->input;
2414 ztk->zstream.avail_in = 0;
2416 /* From Zlib's "unzip.c":
2418 * windowBits is passed < 0 to tell that there is no zlib header.
2419 * Note that in this case inflate *requires* an extra "dummy" byte
2420 * after the compressed stream in order to complete decompression and
2421 * return Z_STREAM_END.
2422 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2423 * size of both compressed and uncompressed data
2425 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2427 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2428 FILEDESC_CLOSE(dup_handle);
2433 ztk->zstream.next_out = file->buff;
2434 ztk->zstream.avail_out = sizeof (file->buff);
2443 ====================
2446 Return true if the path should be rejected due to one of the following:
2447 1: path elements that are non-portable
2448 2: path elements that would allow access to files outside the game directory,
2449 or are just not a good idea for a mod to be using.
2450 ====================
2452 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2454 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2458 // Windows: don't allow \ in filenames (windows-only), period.
2459 // (on Windows \ is a directory separator, but / is also supported)
2460 if (strstr(path, "\\"))
2461 return 1; // non-portable
2463 // Mac: don't allow Mac-only filenames - : is a directory separator
2464 // instead of /, but we rely on / working already, so there's no reason to
2465 // support a Mac-only path
2466 // Amiga and Windows: : tries to go to root of drive
2467 if (strstr(path, ":"))
2468 return 1; // non-portable attempt to go to root of drive
2470 // Amiga: // is parent directory
2471 if (strstr(path, "//"))
2472 return 1; // non-portable attempt to go to parent directory
2474 // all: don't allow going to parent directory (../ or /../)
2475 if (strstr(path, ".."))
2476 return 2; // attempt to go outside the game directory
2478 // Windows and UNIXes: don't allow absolute paths
2480 return 2; // attempt to go outside the game directory
2482 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2483 if (strstr(path, "./"))
2484 return 2; // possible attempt to go outside the game directory
2486 // all: forbid trailing slash on gamedir
2487 if (isgamedir && path[strlen(path)-1] == '/')
2490 // all: forbid leading dot on any filename for any reason
2491 if (strstr(path, "/."))
2492 return 2; // attempt to go outside the game directory
2494 // after all these checks we're pretty sure it's a / separated filename
2495 // and won't do much if any harm
2501 ====================
2504 Look for a file in the packages and in the filesystem
2506 Return the searchpath where the file was found (or NULL)
2507 and the file index in the package if relevant
2508 ====================
2510 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2512 searchpath_t *search;
2515 // search through the path, one element at a time
2516 for (search = fs_searchpaths;search;search = search->next)
2518 // is the element a pak file?
2519 if (search->pack && !search->pack->vpack)
2521 int (*strcmp_funct) (const char* str1, const char* str2);
2522 int left, right, middle;
2525 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2527 // Look for the file (binary search)
2529 right = pak->numfiles - 1;
2530 while (left <= right)
2534 middle = (left + right) / 2;
2535 diff = strcmp_funct (pak->files[middle].name, name);
2540 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2542 // yes, but the first one is empty so we treat it as not being there
2543 if (!quiet && developer_extra.integer)
2544 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2551 if (!quiet && developer_extra.integer)
2552 Con_DPrintf("FS_FindFile: %s in %s\n",
2553 pak->files[middle].name, pak->filename);
2560 // If we're too far in the list
2569 char netpath[MAX_OSPATH];
2570 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2571 if (FS_SysFileExists (netpath))
2573 if (!quiet && developer_extra.integer)
2574 Con_DPrintf("FS_FindFile: %s\n", netpath);
2583 if (!quiet && developer_extra.integer)
2584 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2596 Look for a file in the search paths and open it in read-only mode
2599 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2601 searchpath_t *search;
2604 search = FS_FindFile (filename, &pack_ind, quiet);
2610 // Found in the filesystem?
2613 // this works with vpacks, so we are fine
2614 char path [MAX_OSPATH];
2615 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2616 return FS_SysOpen (path, "rb", nonblocking);
2619 // So, we found it in a package...
2621 // Is it a PK3 symlink?
2622 // TODO also handle directory symlinks by parsing the whole structure...
2623 // but heck, file symlinks are good enough for now
2624 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2626 if(symlinkLevels <= 0)
2628 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2633 char linkbuf[MAX_QPATH];
2635 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2636 const char *mergeslash;
2641 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2647 // Now combine the paths...
2648 mergeslash = strrchr(filename, '/');
2649 mergestart = linkbuf;
2651 mergeslash = filename;
2652 while(!strncmp(mergestart, "../", 3))
2655 while(mergeslash > filename)
2658 if(*mergeslash == '/')
2662 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2663 if(mergeslash == filename)
2665 // Either mergeslash == filename, then we just replace the name (done below)
2669 // Or, we append the name after mergeslash;
2670 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2671 int spaceNeeded = mergeslash - filename + 1;
2672 int spaceRemoved = mergestart - linkbuf;
2673 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2675 Con_DPrintf("symlink: too long path rejected\n");
2678 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2679 memcpy(linkbuf, filename, spaceNeeded);
2680 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2681 mergestart = linkbuf;
2683 if (!quiet && developer_loading.integer)
2684 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2685 if(FS_CheckNastyPath (mergestart, false))
2687 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2690 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2694 return FS_OpenPackedFile (search->pack, pack_ind);
2699 =============================================================================
2701 MAIN PUBLIC FUNCTIONS
2703 =============================================================================
2707 ====================
2710 Open a file in the userpath. The syntax is the same as fopen
2711 Used for savegame scanning in menu, and all file writing.
2712 ====================
2714 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2716 char real_path [MAX_OSPATH];
2718 if (FS_CheckNastyPath(filepath, false))
2720 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2724 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2726 // If the file is opened in "write", "append", or "read/write" mode,
2727 // create directories up to the file.
2728 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2729 FS_CreatePath (real_path);
2730 return FS_SysOpen (real_path, mode, false);
2735 ====================
2738 Open a file. The syntax is the same as fopen
2739 ====================
2741 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2743 qfile_t *result = NULL;
2744 if (FS_CheckNastyPath(filepath, false))
2746 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2750 if (fs_mutex) Thread_LockMutex(fs_mutex);
2751 result = FS_OpenReadFile (filepath, quiet, false, 16);
2752 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2758 ====================
2761 Open a file. The syntax is the same as fopen
2762 ====================
2764 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2767 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2768 memset (file, 0, sizeof (*file));
2769 file->flags = QFILE_FLAG_DATA;
2771 file->real_length = size;
2777 ====================
2781 ====================
2783 int FS_Close (qfile_t* file)
2785 if(file->flags & QFILE_FLAG_DATA)
2791 if (FILEDESC_CLOSE (file->handle))
2796 if (file->flags & QFILE_FLAG_REMOVE)
2798 if (remove(file->filename) == -1)
2800 // No need to report this. If removing a just
2801 // written file failed, this most likely means
2802 // someone else deleted it first - which we
2807 Mem_Free((void *) file->filename);
2812 qz_inflateEnd (&file->ztk->zstream);
2813 Mem_Free (file->ztk);
2820 void FS_RemoveOnClose(qfile_t* file)
2822 file->flags |= QFILE_FLAG_REMOVE;
2826 ====================
2829 Write "datasize" bytes into a file
2830 ====================
2832 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2834 fs_offset_t written = 0;
2836 // If necessary, seek to the exact file position we're supposed to be
2837 if (file->buff_ind != file->buff_len)
2839 if (FILEDESC_SEEK (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
2841 Con_Warnf("WARNING: could not seek in %s.\n", file->filename);
2845 // Purge cached data
2848 // Write the buffer and update the position
2849 // 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)
2850 while (written < (fs_offset_t)datasize)
2852 // figure out how much to write in one chunk
2853 fs_offset_t maxchunk = 1<<30; // 1 GiB
2854 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2855 int result = (int)FILEDESC_WRITE (file->handle, (const unsigned char *)data + written, chunk);
2856 // if at least some was written, add it to our accumulator
2859 // if the result is not what we expected, consider the write to be incomplete
2860 if (result != chunk)
2863 file->position = FILEDESC_SEEK (file->handle, 0, SEEK_CUR);
2864 if (file->real_length < file->position)
2865 file->real_length = file->position;
2867 // note that this will never be less than 0 even if the write failed
2873 ====================
2876 Read up to "buffersize" bytes from a file
2877 ====================
2879 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2881 fs_offset_t count, done;
2883 if (buffersize == 0)
2886 // Get rid of the ungetc character
2887 if (file->ungetc != EOF)
2889 ((char*)buffer)[0] = file->ungetc;
2897 if(file->flags & QFILE_FLAG_DATA)
2899 size_t left = file->real_length - file->position;
2900 if(buffersize > left)
2902 memcpy(buffer, file->data + file->position, buffersize);
2903 file->position += buffersize;
2907 // First, we copy as many bytes as we can from "buff"
2908 if (file->buff_ind < file->buff_len)
2910 count = file->buff_len - file->buff_ind;
2911 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2913 memcpy (buffer, &file->buff[file->buff_ind], count);
2914 file->buff_ind += count;
2916 buffersize -= count;
2917 if (buffersize == 0)
2921 // NOTE: at this point, the read buffer is always empty
2923 // If the file isn't compressed
2924 if (! (file->flags & QFILE_FLAG_DEFLATED))
2928 // We must take care to not read after the end of the file
2929 count = file->real_length - file->position;
2931 // If we have a lot of data to get, put them directly into "buffer"
2932 if (buffersize > sizeof (file->buff) / 2)
2934 if (count > (fs_offset_t)buffersize)
2935 count = (fs_offset_t)buffersize;
2936 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
2938 // Seek failed. When reading from a pipe, and
2939 // the caller never called FS_Seek, this still
2940 // works fine. So no reporting this error.
2942 nb = FILEDESC_READ (file->handle, &((unsigned char*)buffer)[done], count);
2946 file->position += nb;
2948 // Purge cached data
2954 if (count > (fs_offset_t)sizeof (file->buff))
2955 count = (fs_offset_t)sizeof (file->buff);
2956 if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
2958 // Seek failed. When reading from a pipe, and
2959 // the caller never called FS_Seek, this still
2960 // works fine. So no reporting this error.
2962 nb = FILEDESC_READ (file->handle, file->buff, count);
2965 file->buff_len = nb;
2966 file->position += nb;
2968 // Copy the requested data in "buffer" (as much as we can)
2969 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2970 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2971 file->buff_ind = count;
2979 // If the file is compressed, it's more complicated...
2980 // We cycle through a few operations until we have read enough data
2981 while (buffersize > 0)
2983 ztoolkit_t *ztk = file->ztk;
2986 // NOTE: at this point, the read buffer is always empty
2988 // If "input" is also empty, we need to refill it
2989 if (ztk->in_ind == ztk->in_len)
2991 // If we are at the end of the file
2992 if (file->position == file->real_length)
2995 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2996 if (count > (fs_offset_t)sizeof (ztk->input))
2997 count = (fs_offset_t)sizeof (ztk->input);
2998 FILEDESC_SEEK (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2999 if (FILEDESC_READ (file->handle, ztk->input, count) != count)
3001 Con_Printf ("FS_Read: unexpected end of file\n");
3006 ztk->in_len = count;
3007 ztk->in_position += count;
3010 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
3011 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
3013 // Now that we are sure we have compressed data available, we need to determine
3014 // if it's better to inflate it in "file->buff" or directly in "buffer"
3016 // Inflate the data in "file->buff"
3017 if (buffersize < sizeof (file->buff) / 2)
3019 ztk->zstream.next_out = file->buff;
3020 ztk->zstream.avail_out = sizeof (file->buff);
3021 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3022 if (error != Z_OK && error != Z_STREAM_END)
3024 Con_Printf ("FS_Read: Can't inflate file\n");
3027 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3029 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
3030 file->position += file->buff_len;
3032 // Copy the requested data in "buffer" (as much as we can)
3033 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
3034 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
3035 file->buff_ind = count;
3038 // Else, we inflate directly in "buffer"
3041 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
3042 ztk->zstream.avail_out = (unsigned int)buffersize;
3043 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
3044 if (error != Z_OK && error != Z_STREAM_END)
3046 Con_Printf ("FS_Read: Can't inflate file\n");
3049 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
3051 // How much data did it inflate?
3052 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
3053 file->position += count;
3055 // Purge cached data
3060 buffersize -= count;
3068 ====================
3071 Print a string into a file
3072 ====================
3074 int FS_Print (qfile_t* file, const char *msg)
3076 return (int)FS_Write (file, msg, strlen (msg));
3080 ====================
3083 Print a string into a file
3084 ====================
3086 int FS_Printf(qfile_t* file, const char* format, ...)
3091 va_start (args, format);
3092 result = FS_VPrintf (file, format, args);
3100 ====================
3103 Print a string into a file
3104 ====================
3106 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3109 fs_offset_t buff_size = MAX_INPUTLINE;
3114 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3115 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3116 if (len >= 0 && len < buff_size)
3118 Mem_Free (tempbuff);
3122 len = FILEDESC_WRITE (file->handle, tempbuff, len);
3123 Mem_Free (tempbuff);
3130 ====================
3133 Get the next character of a file
3134 ====================
3136 int FS_Getc (qfile_t* file)
3140 if (FS_Read (file, &c, 1) != 1)
3148 ====================
3151 Put a character back into the read buffer (only supports one character!)
3152 ====================
3154 int FS_UnGetc (qfile_t* file, unsigned char c)
3156 // If there's already a character waiting to be read
3157 if (file->ungetc != EOF)
3166 ====================
3169 Move the position index in a file
3170 ====================
3172 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3175 unsigned char* buffer;
3176 fs_offset_t buffersize;
3178 // Compute the file offset
3182 offset += file->position - file->buff_len + file->buff_ind;
3189 offset += file->real_length;
3195 if (offset < 0 || offset > file->real_length)
3198 if(file->flags & QFILE_FLAG_DATA)
3200 file->position = offset;
3204 // If we have the data in our read buffer, we don't need to actually seek
3205 if (file->position - file->buff_len <= offset && offset <= file->position)
3207 file->buff_ind = offset + file->buff_len - file->position;
3211 // Purge cached data
3214 // Unpacked or uncompressed files can seek directly
3215 if (! (file->flags & QFILE_FLAG_DEFLATED))
3217 if (FILEDESC_SEEK (file->handle, file->offset + offset, SEEK_SET) == -1)
3219 file->position = offset;
3223 // Seeking in compressed files is more a hack than anything else,
3224 // but we need to support it, so here we go.
3227 // If we have to go back in the file, we need to restart from the beginning
3228 if (offset <= file->position)
3232 ztk->in_position = 0;
3234 if (FILEDESC_SEEK (file->handle, file->offset, SEEK_SET) == -1)
3235 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3237 // Reset the Zlib stream
3238 ztk->zstream.next_in = ztk->input;
3239 ztk->zstream.avail_in = 0;
3240 qz_inflateReset (&ztk->zstream);
3243 // We need a big buffer to force inflating into it directly
3244 buffersize = 2 * sizeof (file->buff);
3245 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3247 // Skip all data until we reach the requested offset
3248 while (offset > (file->position - file->buff_len + file->buff_ind))
3250 fs_offset_t diff = offset - (file->position - file->buff_len + file->buff_ind);
3251 fs_offset_t count, len;
3253 count = (diff > buffersize) ? buffersize : diff;
3254 len = FS_Read (file, buffer, count);
3268 ====================
3271 Give the current position in a file
3272 ====================
3274 fs_offset_t FS_Tell (qfile_t* file)
3276 return file->position - file->buff_len + file->buff_ind;
3281 ====================
3284 Give the total size of a file
3285 ====================
3287 fs_offset_t FS_FileSize (qfile_t* file)
3289 return file->real_length;
3294 ====================
3297 Erases any buffered input or output data
3298 ====================
3300 void FS_Purge (qfile_t* file)
3310 FS_LoadAndCloseQFile
3312 Loads full content of a qfile_t and closes it.
3313 Always appends a 0 byte.
3316 static unsigned char *FS_LoadAndCloseQFile (qfile_t *file, const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3318 unsigned char *buf = NULL;
3319 fs_offset_t filesize = 0;
3323 filesize = file->real_length;
3326 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3331 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3332 buf[filesize] = '\0';
3333 FS_Read (file, buf, filesize);
3335 if (developer_loadfile.integer)
3336 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3339 if (filesizepointer)
3340 *filesizepointer = filesize;
3349 Filename are relative to the quake directory.
3350 Always appends a 0 byte.
3353 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3355 qfile_t *file = FS_OpenVirtualFile(path, quiet);
3356 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3364 Filename are OS paths.
3365 Always appends a 0 byte.
3368 unsigned char *FS_SysLoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3370 qfile_t *file = FS_SysOpen(path, "rb", false);
3371 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3379 The filename will be prefixed by the current game directory
3382 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3386 fs_offset_t lentotal;
3388 file = FS_OpenRealFile(filename, "wb", false);
3391 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3396 for(i = 0; i < count; ++i)
3398 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3399 for(i = 0; i < count; ++i)
3400 FS_Write (file, data[i], len[i]);
3405 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3407 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3412 =============================================================================
3414 OTHERS PUBLIC FUNCTIONS
3416 =============================================================================
3424 void FS_StripExtension (const char *in, char *out, size_t size_out)
3432 while ((currentchar = *in) && size_out > 1)
3434 if (currentchar == '.')
3436 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3438 *out++ = currentchar;
3454 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3458 // if path doesn't have a .EXT, append extension
3459 // (extension should include the .)
3460 src = path + strlen(path);
3462 while (*src != '/' && src != path)
3465 return; // it has an extension
3469 strlcat (path, extension, size_path);
3477 Look for a file in the packages and in the filesystem
3480 int FS_FileType (const char *filename)
3482 searchpath_t *search;
3483 char fullpath[MAX_OSPATH];
3485 search = FS_FindFile (filename, NULL, true);
3487 return FS_FILETYPE_NONE;
3489 if(search->pack && !search->pack->vpack)
3490 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3492 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3493 return FS_SysFileType(fullpath);
3501 Look for a file in the packages and in the filesystem
3504 qboolean FS_FileExists (const char *filename)
3506 return (FS_FindFile (filename, NULL, true) != NULL);
3514 Look for a file in the filesystem only
3517 int FS_SysFileType (const char *path)
3520 // Sajt - some older sdks are missing this define
3521 # ifndef INVALID_FILE_ATTRIBUTES
3522 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3525 DWORD result = GetFileAttributes(path);
3527 if(result == INVALID_FILE_ATTRIBUTES)
3528 return FS_FILETYPE_NONE;
3530 if(result & FILE_ATTRIBUTE_DIRECTORY)
3531 return FS_FILETYPE_DIRECTORY;
3533 return FS_FILETYPE_FILE;
3537 if (stat (path,&buf) == -1)
3538 return FS_FILETYPE_NONE;
3541 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3543 if(S_ISDIR(buf.st_mode))
3544 return FS_FILETYPE_DIRECTORY;
3546 return FS_FILETYPE_FILE;
3550 qboolean FS_SysFileExists (const char *path)
3552 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3559 Allocate and fill a search structure with information on matching filenames.
3562 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3565 searchpath_t *searchpath;
3567 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3568 stringlist_t resultlist;
3569 stringlist_t dirlist;
3570 const char *slash, *backslash, *colon, *separator;
3573 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3578 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3582 stringlistinit(&resultlist);
3583 stringlistinit(&dirlist);
3585 slash = strrchr(pattern, '/');
3586 backslash = strrchr(pattern, '\\');
3587 colon = strrchr(pattern, ':');
3588 separator = max(slash, backslash);
3589 separator = max(separator, colon);
3590 basepathlength = separator ? (separator + 1 - pattern) : 0;
3591 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3593 memcpy(basepath, pattern, basepathlength);
3594 basepath[basepathlength] = 0;
3596 // search through the path, one element at a time
3597 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3599 // is the element a pak file?
3600 if (searchpath->pack && !searchpath->pack->vpack)
3602 // look through all the pak file elements
3603 pak = searchpath->pack;
3604 for (i = 0;i < pak->numfiles;i++)
3606 char temp[MAX_OSPATH];
3607 strlcpy(temp, pak->files[i].name, sizeof(temp));
3610 if (matchpattern(temp, (char *)pattern, true))
3612 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3613 if (!strcmp(resultlist.strings[resultlistindex], temp))
3615 if (resultlistindex == resultlist.numstrings)
3617 stringlistappend(&resultlist, temp);
3618 if (!quiet && developer_loading.integer)
3619 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3622 // strip off one path element at a time until empty
3623 // this way directories are added to the listing if they match the pattern
3624 slash = strrchr(temp, '/');
3625 backslash = strrchr(temp, '\\');
3626 colon = strrchr(temp, ':');
3628 if (separator < slash)
3630 if (separator < backslash)
3631 separator = backslash;
3632 if (separator < colon)
3634 *((char *)separator) = 0;
3640 stringlist_t matchedSet, foundSet;
3641 const char *start = pattern;
3643 stringlistinit(&matchedSet);
3644 stringlistinit(&foundSet);
3645 // add a first entry to the set
3646 stringlistappend(&matchedSet, "");
3647 // iterate through pattern's path
3650 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3651 char subpath[MAX_OSPATH];
3652 char subpattern[MAX_OSPATH];
3654 // find the next wildcard
3655 wildcard = strchr(start, '?');
3656 asterisk = strchr(start, '*');
3657 if (asterisk && (!wildcard || asterisk < wildcard))
3659 wildcard = asterisk;
3664 nextseparator = strchr( wildcard, '/' );
3668 nextseparator = NULL;
3671 if( !nextseparator ) {
3672 nextseparator = start + strlen( start );
3675 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3676 // copy everything up except nextseperator
3677 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3678 // find the last '/' before the wildcard
3679 prevseparator = strrchr( subpattern, '/' );
3681 prevseparator = subpattern;
3684 // copy everything from start to the previous including the '/' (before the wildcard)
3685 // everything up to start is already included in the path of matchedSet's entries
3686 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3688 // for each entry in matchedSet try to open the subdirectories specified in subpath
3689 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3690 char temp[MAX_OSPATH];
3691 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3692 strlcat( temp, subpath, sizeof(temp) );
3693 listdirectory( &foundSet, searchpath->filename, temp );
3695 if( dirlistindex == 0 ) {
3698 // reset the current result set
3699 stringlistfreecontents( &matchedSet );
3700 // match against the pattern
3701 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3702 const char *direntry = foundSet.strings[ dirlistindex ];
3703 if (matchpattern(direntry, subpattern, true)) {
3704 stringlistappend( &matchedSet, direntry );
3707 stringlistfreecontents( &foundSet );
3709 start = nextseparator;
3712 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3714 const char *matchtemp = matchedSet.strings[dirlistindex];
3715 if (matchpattern(matchtemp, (char *)pattern, true))
3717 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3718 if (!strcmp(resultlist.strings[resultlistindex], matchtemp))
3720 if (resultlistindex == resultlist.numstrings)
3722 stringlistappend(&resultlist, matchtemp);
3723 if (!quiet && developer_loading.integer)
3724 Con_Printf("SearchDirFile: %s\n", matchtemp);
3728 stringlistfreecontents( &matchedSet );
3732 if (resultlist.numstrings)
3734 stringlistsort(&resultlist, true);
3735 numfiles = resultlist.numstrings;
3737 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3738 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3739 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3740 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3741 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3742 search->numfilenames = (int)numfiles;
3745 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3748 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3749 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3750 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3752 numchars += (int)textlen;
3755 stringlistfreecontents(&resultlist);
3761 void FS_FreeSearch(fssearch_t *search)
3766 extern int con_linewidth;
3767 static int FS_ListDirectory(const char *pattern, int oneperline)
3776 char linebuf[MAX_INPUTLINE];
3778 search = FS_Search(pattern, true, true);
3781 numfiles = search->numfilenames;
3784 // FIXME: the names could be added to one column list and then
3785 // gradually shifted into the next column if they fit, and then the
3786 // next to make a compact variable width listing but it's a lot more
3788 // find width for columns
3790 for (i = 0;i < numfiles;i++)
3792 l = (int)strlen(search->filenames[i]);
3793 if (columnwidth < l)
3796 // count the spacing character
3798 // calculate number of columns
3799 numcolumns = con_linewidth / columnwidth;
3800 // don't bother with the column printing if it's only one column
3801 if (numcolumns >= 2)
3803 numlines = (numfiles + numcolumns - 1) / numcolumns;
3804 for (i = 0;i < numlines;i++)
3807 for (k = 0;k < numcolumns;k++)
3809 l = i * numcolumns + k;
3812 name = search->filenames[l];
3813 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3814 linebuf[linebufpos++] = name[j];
3815 // space out name unless it's the last on the line
3816 if (k + 1 < numcolumns && l + 1 < numfiles)
3817 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3818 linebuf[linebufpos++] = ' ';
3821 linebuf[linebufpos] = 0;
3822 Con_Printf("%s\n", linebuf);
3829 for (i = 0;i < numfiles;i++)
3830 Con_Printf("%s\n", search->filenames[i]);
3831 FS_FreeSearch(search);
3832 return (int)numfiles;
3835 static void FS_ListDirectoryCmd (cmd_state_t *cmd, const char* cmdname, int oneperline)
3837 const char *pattern;
3838 if (Cmd_Argc(cmd) >= 3)
3840 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3843 if (Cmd_Argc(cmd) == 2)
3844 pattern = Cmd_Argv(cmd, 1);
3847 if (!FS_ListDirectory(pattern, oneperline))
3848 Con_Print("No files found.\n");
3851 void FS_Dir_f(cmd_state_t *cmd)
3853 FS_ListDirectoryCmd(cmd, "dir", true);
3856 void FS_Ls_f(cmd_state_t *cmd)
3858 FS_ListDirectoryCmd(cmd, "ls", false);
3861 void FS_Which_f(cmd_state_t *cmd)
3863 const char *filename;
3866 if (Cmd_Argc(cmd) != 2)
3868 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(cmd, 0));
3871 filename = Cmd_Argv(cmd, 1);
3872 sp = FS_FindFile(filename, &index, true);
3874 Con_Printf("%s isn't anywhere\n", filename);
3880 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3882 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3885 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3889 const char *FS_WhichPack(const char *filename)
3892 searchpath_t *sp = FS_FindFile(filename, &index, true);
3894 return sp->pack->shortname;
3902 ====================
3903 FS_IsRegisteredQuakePack
3905 Look for a proof of purchase file file in the requested package
3907 If it is found, this file should NOT be downloaded.
3908 ====================
3910 qboolean FS_IsRegisteredQuakePack(const char *name)
3912 searchpath_t *search;
3915 // search through the path, one element at a time
3916 for (search = fs_searchpaths;search;search = search->next)
3918 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3919 // TODO do we want to support vpacks in here too?
3921 int (*strcmp_funct) (const char* str1, const char* str2);
3922 int left, right, middle;
3925 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3927 // Look for the file (binary search)
3929 right = pak->numfiles - 1;
3930 while (left <= right)
3934 middle = (left + right) / 2;
3935 diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3941 // If we're too far in the list
3948 // we found the requested pack but it is not registered quake
3956 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3959 unsigned char *filedata;
3960 fs_offset_t filesize;
3961 if (filesizepointer)
3962 *filesizepointer = 0;
3963 if (!filename || !*filename)
3965 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3968 if (filesizepointer)
3969 *filesizepointer = filesize;
3970 crc = CRC_Block(filedata, filesize);
3976 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3979 unsigned char *out = NULL;
3983 #ifndef LINK_TO_ZLIB
3988 memset(&strm, 0, sizeof(strm));
3989 strm.zalloc = Z_NULL;
3990 strm.zfree = Z_NULL;
3991 strm.opaque = Z_NULL;
3994 level = Z_DEFAULT_COMPRESSION;
3996 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3998 Con_Printf("FS_Deflate: deflate init error!\n");
4002 strm.next_in = (unsigned char*)data;
4003 strm.avail_in = (unsigned int)size;
4005 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
4008 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
4009 qz_deflateEnd(&strm);
4013 strm.next_out = tmp;
4014 strm.avail_out = (unsigned int)size;
4016 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
4018 Con_Printf("FS_Deflate: deflate failed!\n");
4019 qz_deflateEnd(&strm);
4024 if(qz_deflateEnd(&strm) != Z_OK)
4026 Con_Printf("FS_Deflate: deflateEnd failed\n");
4031 if(strm.total_out >= size)
4033 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
4038 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
4041 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
4046 *deflated_size = (size_t)strm.total_out;
4048 memcpy(out, tmp, strm.total_out);
4054 static void AssertBufsize(sizebuf_t *buf, int length)
4056 if(buf->cursize + length > buf->maxsize)
4058 int oldsize = buf->maxsize;
4059 unsigned char *olddata;
4060 olddata = buf->data;
4061 buf->maxsize += length;
4062 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
4065 memcpy(buf->data, olddata, oldsize);
4071 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
4075 unsigned char *out = NULL;
4076 unsigned char tmp[2048];
4081 #ifndef LINK_TO_ZLIB
4086 memset(&outbuf, 0, sizeof(outbuf));
4087 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
4088 outbuf.maxsize = sizeof(tmp);
4090 memset(&strm, 0, sizeof(strm));
4091 strm.zalloc = Z_NULL;
4092 strm.zfree = Z_NULL;
4093 strm.opaque = Z_NULL;
4095 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
4097 Con_Printf("FS_Inflate: inflate init error!\n");
4098 Mem_Free(outbuf.data);
4102 strm.next_in = (unsigned char*)data;
4103 strm.avail_in = (unsigned int)size;
4107 strm.next_out = tmp;
4108 strm.avail_out = sizeof(tmp);
4109 ret = qz_inflate(&strm, Z_NO_FLUSH);
4110 // it either returns Z_OK on progress, Z_STREAM_END on end
4118 case Z_STREAM_ERROR:
4119 Con_Print("FS_Inflate: stream error!\n");
4122 Con_Print("FS_Inflate: data error!\n");
4125 Con_Print("FS_Inflate: mem error!\n");
4128 Con_Print("FS_Inflate: buf error!\n");
4131 Con_Print("FS_Inflate: unknown error!\n");
4135 if(ret != Z_OK && ret != Z_STREAM_END)
4137 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4138 Mem_Free(outbuf.data);
4139 qz_inflateEnd(&strm);
4142 have = sizeof(tmp) - strm.avail_out;
4143 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4144 SZ_Write(&outbuf, tmp, have);
4145 } while(ret != Z_STREAM_END);
4147 qz_inflateEnd(&strm);
4149 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4152 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4153 Mem_Free(outbuf.data);
4157 memcpy(out, outbuf.data, outbuf.cursize);
4158 Mem_Free(outbuf.data);
4160 *inflated_size = (size_t)outbuf.cursize;