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
36 # include <sys/stat.h>
43 // Win32 requires us to add O_BINARY, but the other OSes don't have it
48 // In case the system doesn't support the O_NONBLOCK flag
53 // largefile support for Win32
55 # define lseek _lseeki64
59 // suppress deprecated warnings
60 # include <sys/stat.h>
65 # define unlink _unlink
69 /** \page fs File System
71 All of Quake's data access is through a hierchal file system, but the contents
72 of the file system can be transparently merged from several sources.
74 The "base directory" is the path to the directory holding the quake.exe and
75 all game directories. The sys_* files pass this to host_init in
76 quakeparms_t->basedir. This can be overridden with the "-basedir" command
77 line parm to allow code debugging in a different directory. The base
78 directory is only used during filesystem initialization.
80 The "game directory" is the first tree on the search path and directory that
81 all generated files (savegames, screenshots, demos, config files) will be
82 saved to. This can be overridden with the "-game" command line parameter.
83 The game directory can never be changed while quake is executing. This is a
84 precaution against having a malicious server instruct clients to write files
85 over areas they shouldn't.
91 =============================================================================
95 =============================================================================
98 // Magic numbers of a ZIP file (big-endian format)
99 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
100 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
101 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
103 // Other constants for ZIP files
104 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
105 #define ZIP_END_CDIR_SIZE 22
106 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
107 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
112 #define qz_inflate inflate
113 #define qz_inflateEnd inflateEnd
114 #define qz_inflateInit2_ inflateInit2_
115 #define qz_inflateReset inflateReset
116 #define qz_deflateInit2_ deflateInit2_
117 #define qz_deflateEnd deflateEnd
118 #define qz_deflate deflate
119 #define Z_MEMLEVEL_DEFAULT 8
122 // Zlib constants (from zlib.h)
123 #define Z_SYNC_FLUSH 2
126 #define Z_STREAM_END 1
127 #define Z_STREAM_ERROR (-2)
128 #define Z_DATA_ERROR (-3)
129 #define Z_MEM_ERROR (-4)
130 #define Z_BUF_ERROR (-5)
131 #define ZLIB_VERSION "1.2.3"
135 #define Z_MEMLEVEL_DEFAULT 8
138 #define Z_DEFAULT_COMPRESSION (-1)
140 #define Z_SYNC_FLUSH 2
141 #define Z_FULL_FLUSH 3
144 // Uncomment the following line if the zlib DLL you have still uses
145 // the 1.1.x series calling convention on Win32 (WINAPI)
146 //#define ZLIB_USES_WINAPI
150 =============================================================================
154 =============================================================================
157 /*! Zlib stream (from zlib.h)
158 * \warning: some pointers we don't use directly have
159 * been cast to "void*" for a matter of simplicity
163 unsigned char *next_in; ///< next input byte
164 unsigned int avail_in; ///< number of bytes available at next_in
165 unsigned long total_in; ///< total nb of input bytes read so far
167 unsigned char *next_out; ///< next output byte should be put there
168 unsigned int avail_out; ///< remaining free space at next_out
169 unsigned long total_out; ///< total nb of bytes output so far
171 char *msg; ///< last error message, NULL if no error
172 void *state; ///< not visible by applications
174 void *zalloc; ///< used to allocate the internal state
175 void *zfree; ///< used to free the internal state
176 void *opaque; ///< private data object passed to zalloc and zfree
178 int data_type; ///< best guess about the data type: ascii or binary
179 unsigned long adler; ///< adler32 value of the uncompressed data
180 unsigned long reserved; ///< reserved for future use
185 /// inside a package (PAK or PK3)
186 #define QFILE_FLAG_PACKED (1 << 0)
187 /// file is compressed using the deflate algorithm (PK3 only)
188 #define QFILE_FLAG_DEFLATED (1 << 1)
189 /// file is actually already loaded data
190 #define QFILE_FLAG_DATA (1 << 2)
192 #define FILE_BUFF_SIZE 2048
196 size_t comp_length; ///< length of the compressed file
197 size_t in_ind, in_len; ///< input buffer current index and length
198 size_t in_position; ///< position in the compressed file
199 unsigned char input [FILE_BUFF_SIZE];
205 int handle; ///< file descriptor
206 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
207 fs_offset_t position; ///< current position in the file
208 fs_offset_t offset; ///< offset into the package (0 if external file)
209 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
212 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
213 unsigned char buff [FILE_BUFF_SIZE];
215 ztoolkit_t* ztk; ///< For zipped files.
217 const unsigned char *data; ///< For data files.
221 // ------ PK3 files on disk ------ //
223 // You can get the complete ZIP format description from PKWARE website
225 typedef struct pk3_endOfCentralDir_s
227 unsigned int signature;
228 unsigned short disknum;
229 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
230 unsigned short localentries; ///< number of entries in the central directory on this disk
231 unsigned short nbentries; ///< total number of entries in the central directory on this disk
232 unsigned int cdir_size; ///< size of the central directory
233 unsigned int cdir_offset; ///< with respect to the starting disk number
234 unsigned short comment_size;
235 } pk3_endOfCentralDir_t;
238 // ------ PAK files on disk ------ //
239 typedef struct dpackfile_s
242 int filepos, filelen;
245 typedef struct dpackheader_s
253 /*! \name Packages in memory
256 /// the offset in packfile_t is the true contents offset
257 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
258 /// file compressed using the deflate algorithm
259 #define PACKFILE_FLAG_DEFLATED (1 << 1)
260 /// file is a symbolic link
261 #define PACKFILE_FLAG_SYMLINK (1 << 2)
263 typedef struct packfile_s
265 char name [MAX_QPATH];
268 fs_offset_t packsize; ///< size in the package
269 fs_offset_t realsize; ///< real file size (uncompressed)
272 typedef struct pack_s
274 char filename [MAX_OSPATH];
275 char shortname [MAX_QPATH];
277 int ignorecase; ///< PK3 ignores case
284 /// Search paths for files (including packages)
285 typedef struct searchpath_s
287 // only one of filename / pack will be used
288 char filename[MAX_OSPATH];
290 struct searchpath_s *next;
295 =============================================================================
299 =============================================================================
304 void FS_Which_f(void);
306 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
307 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
308 fs_offset_t offset, fs_offset_t packsize,
309 fs_offset_t realsize, int flags);
313 =============================================================================
317 =============================================================================
320 mempool_t *fs_mempool;
322 searchpath_t *fs_searchpaths = NULL;
323 const char *const fs_checkgamedir_missing = "missing";
325 #define MAX_FILES_IN_PACK 65536
327 char fs_userdir[MAX_OSPATH];
328 char fs_gamedir[MAX_OSPATH];
329 char fs_basedir[MAX_OSPATH];
331 // list of active game directories (empty if not running a mod)
332 int fs_numgamedirs = 0;
333 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
335 // list of all gamedirs with modinfo.txt
336 gamedir_t *fs_all_gamedirs = NULL;
337 int fs_all_gamedirs_count = 0;
339 cvar_t scr_screenshot_name = {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)"};
340 cvar_t fs_empty_files_in_pack_mark_deletions = {0, "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"};
341 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
345 =============================================================================
347 PRIVATE FUNCTIONS - PK3 HANDLING
349 =============================================================================
353 // Functions exported from zlib
354 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
355 # define ZEXPORT WINAPI
360 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
361 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
362 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
363 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
364 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
365 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
366 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
369 #define qz_inflateInit2(strm, windowBits) \
370 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
371 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
372 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
375 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
377 static dllfunction_t zlibfuncs[] =
379 {"inflate", (void **) &qz_inflate},
380 {"inflateEnd", (void **) &qz_inflateEnd},
381 {"inflateInit2_", (void **) &qz_inflateInit2_},
382 {"inflateReset", (void **) &qz_inflateReset},
383 {"deflateInit2_", (void **) &qz_deflateInit2_},
384 {"deflateEnd", (void **) &qz_deflateEnd},
385 {"deflate", (void **) &qz_deflate},
389 /// Handle for Zlib DLL
390 static dllhandle_t zlib_dll = NULL;
394 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
395 static dllfunction_t shfolderfuncs[] =
397 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
400 static dllhandle_t shfolder_dll = NULL;
410 void PK3_CloseLibrary (void)
413 Sys_UnloadLibrary (&zlib_dll);
422 Try to load the Zlib DLL
425 qboolean PK3_OpenLibrary (void)
430 const char* dllnames [] =
433 # ifdef ZLIB_USES_WINAPI
439 #elif defined(MACOSX)
453 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
461 See if zlib is available
464 qboolean FS_HasZlib(void)
469 PK3_OpenLibrary(); // to be safe
470 return (zlib_dll != 0);
476 PK3_GetEndOfCentralDir
478 Extract the end of the central directory from a PK3 package
481 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
483 fs_offset_t filesize, maxsize;
484 unsigned char *buffer, *ptr;
487 // Get the package size
488 filesize = lseek (packhandle, 0, SEEK_END);
489 if (filesize < ZIP_END_CDIR_SIZE)
492 // Load the end of the file in memory
493 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
496 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
497 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
498 lseek (packhandle, filesize - maxsize, SEEK_SET);
499 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
505 // Look for the end of central dir signature around the end of the file
506 maxsize -= ZIP_END_CDIR_SIZE;
507 ptr = &buffer[maxsize];
509 while (BuffBigLong (ptr) != ZIP_END_HEADER)
521 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
522 eocd->signature = LittleLong (eocd->signature);
523 eocd->disknum = LittleShort (eocd->disknum);
524 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
525 eocd->localentries = LittleShort (eocd->localentries);
526 eocd->nbentries = LittleShort (eocd->nbentries);
527 eocd->cdir_size = LittleLong (eocd->cdir_size);
528 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
529 eocd->comment_size = LittleShort (eocd->comment_size);
541 Extract the file list from a PK3 file
544 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
546 unsigned char *central_dir, *ptr;
548 fs_offset_t remaining;
550 // Load the central directory in memory
551 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
552 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
553 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
555 Mem_Free (central_dir);
559 // Extract the files properties
560 // The parsing is done "by hand" because some fields have variable sizes and
561 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
562 remaining = eocd->cdir_size;
565 for (ind = 0; ind < eocd->nbentries; ind++)
567 fs_offset_t namesize, count;
569 // Checking the remaining size
570 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
572 Mem_Free (central_dir);
575 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
578 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
580 Mem_Free (central_dir);
584 namesize = BuffLittleShort (&ptr[28]); // filename length
586 // Check encryption, compression, and attributes
587 // 1st uint8 : general purpose bit flag
588 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
590 // LordHavoc: bit 3 would be a problem if we were scanning the archive
591 // but is not a problem in the central directory where the values are
594 // bit 3 seems to always be set by the standard Mac OSX zip maker
596 // 2nd uint8 : external file attributes
597 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
598 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
600 // Still enough bytes for the name?
601 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
603 Mem_Free (central_dir);
607 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
608 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
610 char filename [sizeof (pack->files[0].name)];
611 fs_offset_t offset, packsize, realsize;
614 // Extract the name (strip it if necessary)
615 namesize = min(namesize, (int)sizeof (filename) - 1);
616 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
617 filename[namesize] = '\0';
619 if (BuffLittleShort (&ptr[10]))
620 flags = PACKFILE_FLAG_DEFLATED;
623 offset = BuffLittleLong (&ptr[42]);
624 packsize = BuffLittleLong (&ptr[20]);
625 realsize = BuffLittleLong (&ptr[24]);
627 switch(ptr[5]) // C_VERSION_MADE_BY_1
632 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
633 // can't use S_ISLNK here, as this has to compile on non-UNIX too
634 flags |= PACKFILE_FLAG_SYMLINK;
638 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
642 // Skip the name, additionnal field, and comment
643 // 1er uint16 : extra field length
644 // 2eme uint16 : file comment length
645 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
646 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
650 // If the package is empty, central_dir is NULL here
651 if (central_dir != NULL)
652 Mem_Free (central_dir);
653 return pack->numfiles;
661 Create a package entry associated with a PK3 file
664 pack_t *FS_LoadPackPK3 (const char *packfile)
667 pk3_endOfCentralDir_t eocd;
672 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
674 packhandle = open (packfile, O_RDONLY | O_BINARY);
679 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
681 Con_Printf ("%s is not a PK3 file\n", packfile);
686 // Multi-volume ZIP archives are NOT allowed
687 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
689 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
694 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
695 // since eocd.nbentries is an unsigned 16 bits integer
696 #if MAX_FILES_IN_PACK < 65535
697 if (eocd.nbentries > MAX_FILES_IN_PACK)
699 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
705 // Create a package structure in memory
706 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
707 pack->ignorecase = true; // PK3 ignores case
708 strlcpy (pack->filename, packfile, sizeof (pack->filename));
709 pack->handle = packhandle;
710 pack->numfiles = eocd.nbentries;
711 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
713 real_nb_files = PK3_BuildFileList (pack, &eocd);
714 if (real_nb_files < 0)
716 Con_Printf ("%s is not a valid PK3 file\n", packfile);
722 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
729 PK3_GetTrueFileOffset
731 Find where the true file data offset is
734 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
736 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
740 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
743 // Load the local file description
744 lseek (pack->handle, pfile->offset, SEEK_SET);
745 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
746 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
748 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
752 // Skip name and extra field
753 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
755 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
761 =============================================================================
763 OTHER PRIVATE FUNCTIONS
765 =============================================================================
773 Add a file to the list of files contained into a package
776 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
777 fs_offset_t offset, fs_offset_t packsize,
778 fs_offset_t realsize, int flags)
780 int (*strcmp_funct) (const char* str1, const char* str2);
781 int left, right, middle;
784 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
786 // Look for the slot we should put that file into (binary search)
788 right = pack->numfiles - 1;
789 while (left <= right)
793 middle = (left + right) / 2;
794 diff = strcmp_funct (pack->files[middle].name, name);
796 // If we found the file, there's a problem
798 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
800 // If we're too far in the list
807 // We have to move the right of the list by one slot to free the one we need
808 pfile = &pack->files[left];
809 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
812 strlcpy (pfile->name, name, sizeof (pfile->name));
813 pfile->offset = offset;
814 pfile->packsize = packsize;
815 pfile->realsize = realsize;
816 pfile->flags = flags;
826 Only used for FS_OpenRealFile.
829 void FS_CreatePath (char *path)
833 for (ofs = path+1 ; *ofs ; ofs++)
835 if (*ofs == '/' || *ofs == '\\')
837 // create the directory
853 void FS_Path_f (void)
857 Con_Print("Current search path:\n");
858 for (s=fs_searchpaths ; s ; s=s->next)
863 Con_Printf("%s (virtual pack)\n", s->pack->filename);
865 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
868 Con_Printf("%s\n", s->filename);
878 /*! Takes an explicit (not game tree related) path to a pak file.
879 *Loads the header and directory, adding the files at the beginning
880 *of the list so they override previous pack files.
882 pack_t *FS_LoadPackPAK (const char *packfile)
884 dpackheader_t header;
891 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
893 packhandle = open (packfile, O_RDONLY | O_BINARY);
897 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
899 Con_Printf ("%s is not a packfile\n", packfile);
903 if (memcmp(header.id, "PACK", 4))
905 Con_Printf ("%s is not a packfile\n", packfile);
909 header.dirofs = LittleLong (header.dirofs);
910 header.dirlen = LittleLong (header.dirlen);
912 if (header.dirlen % sizeof(dpackfile_t))
914 Con_Printf ("%s has an invalid directory size\n", packfile);
919 numpackfiles = header.dirlen / sizeof(dpackfile_t);
921 if (numpackfiles > MAX_FILES_IN_PACK)
923 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
928 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
929 lseek (packhandle, header.dirofs, SEEK_SET);
930 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
932 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
938 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
939 pack->ignorecase = false; // PAK is case sensitive
940 strlcpy (pack->filename, packfile, sizeof (pack->filename));
941 pack->handle = packhandle;
943 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
945 // parse the directory
946 for (i = 0;i < numpackfiles;i++)
948 fs_offset_t offset = LittleLong (info[i].filepos);
949 fs_offset_t size = LittleLong (info[i].filelen);
951 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
956 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
964 Create a package entry associated with a directory file
967 pack_t *FS_LoadPackVirtual (const char *dirname)
970 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
972 pack->ignorecase = false;
973 strlcpy (pack->filename, dirname, sizeof(pack->filename));
977 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
986 /*! Adds the given pack to the search path.
987 * The pack type is autodetected by the file extension.
989 * Returns true if the file was successfully added to the
990 * search path or if it was already included.
992 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
996 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
998 searchpath_t *search;
1000 const char *ext = FS_FileExtension(pakfile);
1002 for(search = fs_searchpaths; search; search = search->next)
1004 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1007 *already_loaded = true;
1008 return true; // already loaded
1013 *already_loaded = false;
1015 if(FS_SysFileType(pakfile) == FS_FILETYPE_DIRECTORY)
1016 pak = FS_LoadPackVirtual (pakfile);
1017 else if(!strcasecmp(ext, "pak"))
1018 pak = FS_LoadPackPAK (pakfile);
1019 else if(!strcasecmp(ext, "pk3"))
1020 pak = FS_LoadPackPK3 (pakfile);
1022 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1026 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1028 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1031 // find the first item whose next one is a pack or NULL
1032 searchpath_t *insertion_point = 0;
1033 if(fs_searchpaths && !fs_searchpaths->pack)
1035 insertion_point = fs_searchpaths;
1038 if(!insertion_point->next)
1040 if(insertion_point->next->pack)
1042 insertion_point = insertion_point->next;
1045 // If insertion_point is NULL, this means that either there is no
1046 // item in the list yet, or that the very first item is a pack. In
1047 // that case, we want to insert at the beginning...
1048 if(!insertion_point)
1050 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1051 search->next = fs_searchpaths;
1052 fs_searchpaths = search;
1055 // otherwise we want to append directly after insertion_point.
1057 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1058 search->next = insertion_point->next;
1059 insertion_point->next = search;
1064 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1065 search->next = fs_searchpaths;
1066 fs_searchpaths = search;
1070 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1075 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1086 /*! Adds the given pack to the search path and searches for it in the game path.
1087 * The pack type is autodetected by the file extension.
1089 * Returns true if the file was successfully added to the
1090 * search path or if it was already included.
1092 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1093 * plain directories.
1095 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1097 char fullpath[MAX_OSPATH];
1099 searchpath_t *search;
1102 *already_loaded = false;
1104 // then find the real name...
1105 search = FS_FindFile(pakfile, &index, true);
1106 if(!search || search->pack)
1108 Con_Printf("could not find pak \"%s\"\n", pakfile);
1112 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1114 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1122 Sets fs_gamedir, adds the directory to the head of the path,
1123 then loads and adds pak1.pak pak2.pak ...
1126 void FS_AddGameDirectory (const char *dir)
1130 searchpath_t *search;
1132 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1134 stringlistinit(&list);
1135 listdirectory(&list, "", dir);
1136 stringlistsort(&list);
1138 // add any PAK package in the directory
1139 for (i = 0;i < list.numstrings;i++)
1141 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1143 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1147 // add any PK3 package in the directory
1148 for (i = 0;i < list.numstrings;i++)
1150 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
1152 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1156 stringlistfreecontents(&list);
1158 // Add the directory to the search path
1159 // (unpacked files have the priority over packed files)
1160 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1161 strlcpy (search->filename, dir, sizeof (search->filename));
1162 search->next = fs_searchpaths;
1163 fs_searchpaths = search;
1172 void FS_AddGameHierarchy (const char *dir)
1174 // Add the common game directory
1175 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1178 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1187 const char *FS_FileExtension (const char *in)
1189 const char *separator, *backslash, *colon, *dot;
1191 separator = strrchr(in, '/');
1192 backslash = strrchr(in, '\\');
1193 if (!separator || separator < backslash)
1194 separator = backslash;
1195 colon = strrchr(in, ':');
1196 if (!separator || separator < colon)
1199 dot = strrchr(in, '.');
1200 if (dot == NULL || (separator && (dot < separator)))
1212 const char *FS_FileWithoutPath (const char *in)
1214 const char *separator, *backslash, *colon;
1216 separator = strrchr(in, '/');
1217 backslash = strrchr(in, '\\');
1218 if (!separator || separator < backslash)
1219 separator = backslash;
1220 colon = strrchr(in, ':');
1221 if (!separator || separator < colon)
1223 return separator ? separator + 1 : in;
1232 void FS_ClearSearchPath (void)
1234 // unload all packs and directory information, close all pack files
1235 // (if a qfile is still reading a pack it won't be harmed because it used
1236 // dup() to get its own handle already)
1237 while (fs_searchpaths)
1239 searchpath_t *search = fs_searchpaths;
1240 fs_searchpaths = search->next;
1243 if(!search->pack->vpack)
1246 close(search->pack->handle);
1247 // free any memory associated with it
1248 if (search->pack->files)
1249 Mem_Free(search->pack->files);
1251 Mem_Free(search->pack);
1263 void FS_Rescan (void)
1266 qboolean fs_modified = false;
1267 char gamedirbuf[MAX_INPUTLINE];
1269 FS_ClearSearchPath();
1271 // add the game-specific paths
1272 // gamedirname1 (typically id1)
1273 FS_AddGameHierarchy (gamedirname1);
1274 // update the com_modname (used for server info)
1275 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1277 // add the game-specific path, if any
1278 // (only used for mission packs and the like, which should set fs_modified)
1282 FS_AddGameHierarchy (gamedirname2);
1286 // Adds basedir/gamedir as an override game
1287 // LordHavoc: now supports multiple -game directories
1288 // set the com_modname (reported in server info)
1290 for (i = 0;i < fs_numgamedirs;i++)
1293 FS_AddGameHierarchy (fs_gamedirs[i]);
1294 // update the com_modname (used server info)
1295 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1297 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1299 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1301 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1303 // set the default screenshot name to either the mod name or the
1304 // gamemode screenshot name
1305 if (strcmp(com_modname, gamedirname1))
1306 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1308 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1310 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1311 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1313 // If "-condebug" is in the command line, remove the previous log file
1314 if (COM_CheckParm ("-condebug") != 0)
1315 unlink (va("%s/qconsole.log", fs_gamedir));
1317 // look for the pop.lmp file and set registered to true if it is found
1318 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1321 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1323 Con_Print("Playing shareware version.\n");
1327 Cvar_Set ("registered", "1");
1328 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1329 Con_Print("Playing registered version.\n");
1332 // unload all wads so that future queries will return the new data
1336 void FS_Rescan_f(void)
1346 extern void Host_SaveConfig (void);
1347 extern void Host_LoadConfig_f (void);
1348 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1353 if (fs_numgamedirs == numgamedirs)
1355 for (i = 0;i < numgamedirs;i++)
1356 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1358 if (i == numgamedirs)
1359 return true; // already using this set of gamedirs, do nothing
1362 if (numgamedirs > MAX_GAMEDIRS)
1365 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1366 return false; // too many gamedirs
1369 for (i = 0;i < numgamedirs;i++)
1371 // if string is nasty, reject it
1372 p = FS_CheckGameDir(gamedirs[i]);
1376 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1377 return false; // nasty gamedirs
1379 if(p == fs_checkgamedir_missing && failmissing)
1382 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1383 return false; // missing gamedirs
1389 fs_numgamedirs = numgamedirs;
1390 for (i = 0;i < fs_numgamedirs;i++)
1391 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1393 // reinitialize filesystem to detect the new paks
1396 // exec the new config
1397 Host_LoadConfig_f();
1399 // unload all sounds so they will be reloaded from the new files as needed
1400 S_UnloadAllSounds_f();
1402 // reinitialize renderer (this reloads hud/console background/etc)
1403 R_Modules_Restart();
1413 void FS_GameDir_f (void)
1417 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1421 Con_Printf("gamedirs active:");
1422 for (i = 0;i < fs_numgamedirs;i++)
1423 Con_Printf(" %s", fs_gamedirs[i]);
1428 numgamedirs = Cmd_Argc() - 1;
1429 if (numgamedirs > MAX_GAMEDIRS)
1431 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1435 for (i = 0;i < numgamedirs;i++)
1436 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1438 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1440 // actually, changing during game would work fine, but would be stupid
1441 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1445 // halt demo playback to close the file
1448 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1451 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking);
1452 static const char *FS_SysCheckGameDir(const char *gamedir)
1454 static char buf[8192];
1460 stringlistinit(&list);
1461 listdirectory(&list, gamedir, "");
1462 success = list.numstrings > 0;
1463 stringlistfreecontents(&list);
1467 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1470 n = FS_Read (f, buf, sizeof(buf) - 1);
1490 const char *FS_CheckGameDir(const char *gamedir)
1494 if (FS_CheckNastyPath(gamedir, true))
1497 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1502 // get description from basedir
1503 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1511 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1515 return fs_checkgamedir_missing;
1518 static void FS_ListGameDirs(void)
1520 stringlist_t list, list2;
1524 fs_all_gamedirs_count = 0;
1526 Mem_Free(fs_all_gamedirs);
1528 stringlistinit(&list);
1529 listdirectory(&list, va("%s/", fs_basedir), "");
1530 listdirectory(&list, va("%s/", fs_userdir), "");
1531 stringlistsort(&list);
1533 stringlistinit(&list2);
1534 for(i = 0; i < list.numstrings; ++i)
1537 if(!strcmp(list.strings[i-1], list.strings[i]))
1539 info = FS_CheckGameDir(list.strings[i]);
1542 if(info == fs_checkgamedir_missing)
1546 stringlistappend(&list2, list.strings[i]);
1548 stringlistfreecontents(&list);
1550 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1551 for(i = 0; i < list2.numstrings; ++i)
1553 info = FS_CheckGameDir(list2.strings[i]);
1554 // all this cannot happen any more, but better be safe than sorry
1557 if(info == fs_checkgamedir_missing)
1561 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1562 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1563 ++fs_all_gamedirs_count;
1577 TCHAR mydocsdir[MAX_PATH + 1];
1578 #if _MSC_VER >= 1400
1585 const char* dllnames [] =
1587 "shfolder.dll", // IE 4, or Win NT and higher
1590 Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1591 // don't care for the result; if it fails, %USERPROFILE% will be used instead
1594 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1596 // Add the personal game directory
1597 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1599 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1601 else if(COM_CheckParm("-nohome"))
1608 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1610 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1611 Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1615 // use the environment
1616 #if _MSC_VER >= 1400
1617 _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1619 homedir = getenv("USERPROFILE");
1624 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1625 #if _MSC_VER >= 1400
1628 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1633 Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1635 homedir = getenv ("HOME");
1637 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1640 Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1644 if(!COM_CheckParm("-mygames"))
1646 #if _MSC_VER >= 1400
1648 _sopen_s(&fd, va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
1650 int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1655 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1661 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1663 // If the base directory is explicitly defined by the compilation process
1664 #ifdef DP_FS_BASEDIR
1665 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1670 // FIXME: is there a better way to find the directory outside the .app?
1671 if (strstr(com_argv[0], ".app/"))
1675 split = strstr(com_argv[0], ".app/");
1676 while (split > com_argv[0] && *split != '/')
1678 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1679 fs_basedir[split - com_argv[0]] = 0;
1687 // Overrides the system supplied base directory (under GAMENAME)
1688 // 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)
1689 i = COM_CheckParm ("-basedir");
1690 if (i && i < com_argc-1)
1692 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1693 i = (int)strlen (fs_basedir);
1694 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1695 fs_basedir[i-1] = 0;
1698 // add a path separator to the end of the basedir if it lacks one
1699 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1700 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1704 p = FS_CheckGameDir(gamedirname1);
1705 if(!p || p == fs_checkgamedir_missing)
1706 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1710 p = FS_CheckGameDir(gamedirname2);
1711 if(!p || p == fs_checkgamedir_missing)
1712 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1716 // Adds basedir/gamedir as an override game
1717 // LordHavoc: now supports multiple -game directories
1718 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1722 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1725 p = FS_CheckGameDir(com_argv[i]);
1727 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1728 if(p == fs_checkgamedir_missing)
1729 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1730 // add the gamedir to the list of active gamedirs
1731 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1736 // generate the searchpath
1740 void FS_Init_Commands(void)
1742 Cvar_RegisterVariable (&scr_screenshot_name);
1743 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1744 Cvar_RegisterVariable (&cvar_fs_gamedir);
1746 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1747 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1748 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1749 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1750 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1751 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1759 void FS_Shutdown (void)
1761 // close all pack files and such
1762 // (hopefully there aren't any other open files, but they'll be cleaned up
1763 // by the OS anyway)
1764 FS_ClearSearchPath();
1765 Mem_FreePool (&fs_mempool);
1768 Sys_UnloadLibrary (&shfolder_dll);
1773 ====================
1776 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1777 ====================
1779 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1785 // Parse the mode string
1794 opt = O_CREAT | O_TRUNC;
1798 opt = O_CREAT | O_APPEND;
1801 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1804 for (ind = 1; mode[ind] != '\0'; ind++)
1815 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1816 filepath, mode, mode[ind]);
1823 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1824 memset (file, 0, sizeof (*file));
1827 #if _MSC_VER >= 1400
1828 _sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1830 file->handle = open (filepath, mod | opt, 0666);
1832 if (file->handle < 0)
1838 file->real_length = lseek (file->handle, 0, SEEK_END);
1840 // For files opened in append mode, we start at the end of the file
1842 file->position = file->real_length;
1844 lseek (file->handle, 0, SEEK_SET);
1854 Open a packed file using its package file descriptor
1857 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1863 pfile = &pack->files[pack_ind];
1865 // If we don't have the true offset, get it now
1866 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1867 if (!PK3_GetTrueFileOffset (pfile, pack))
1870 #ifndef LINK_TO_ZLIB
1871 // No Zlib DLL = no compressed files
1872 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1874 Con_Printf("WARNING: can't open the compressed file %s\n"
1875 "You need the Zlib DLL to use compressed files\n",
1881 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1882 // the dup() call to avoid having to close the dup_handle on error here
1883 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1885 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1886 pfile->name, pack->filename, (int) pfile->offset);
1890 dup_handle = dup (pack->handle);
1893 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1897 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1898 memset (file, 0, sizeof (*file));
1899 file->handle = dup_handle;
1900 file->flags = QFILE_FLAG_PACKED;
1901 file->real_length = pfile->realsize;
1902 file->offset = pfile->offset;
1906 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1910 file->flags |= QFILE_FLAG_DEFLATED;
1912 // We need some more variables
1913 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1915 ztk->comp_length = pfile->packsize;
1917 // Initialize zlib stream
1918 ztk->zstream.next_in = ztk->input;
1919 ztk->zstream.avail_in = 0;
1921 /* From Zlib's "unzip.c":
1923 * windowBits is passed < 0 to tell that there is no zlib header.
1924 * Note that in this case inflate *requires* an extra "dummy" byte
1925 * after the compressed stream in order to complete decompression and
1926 * return Z_STREAM_END.
1927 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1928 * size of both compressed and uncompressed data
1930 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1932 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1938 ztk->zstream.next_out = file->buff;
1939 ztk->zstream.avail_out = sizeof (file->buff);
1948 ====================
1951 Return true if the path should be rejected due to one of the following:
1952 1: path elements that are non-portable
1953 2: path elements that would allow access to files outside the game directory,
1954 or are just not a good idea for a mod to be using.
1955 ====================
1957 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1959 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1963 // Windows: don't allow \ in filenames (windows-only), period.
1964 // (on Windows \ is a directory separator, but / is also supported)
1965 if (strstr(path, "\\"))
1966 return 1; // non-portable
1968 // Mac: don't allow Mac-only filenames - : is a directory separator
1969 // instead of /, but we rely on / working already, so there's no reason to
1970 // support a Mac-only path
1971 // Amiga and Windows: : tries to go to root of drive
1972 if (strstr(path, ":"))
1973 return 1; // non-portable attempt to go to root of drive
1975 // Amiga: // is parent directory
1976 if (strstr(path, "//"))
1977 return 1; // non-portable attempt to go to parent directory
1979 // all: don't allow going to parent directory (../ or /../)
1980 if (strstr(path, ".."))
1981 return 2; // attempt to go outside the game directory
1983 // Windows and UNIXes: don't allow absolute paths
1985 return 2; // attempt to go outside the game directory
1987 // all: don't allow . characters before the last slash (it should only be used in filenames, not path elements), this catches all imaginable cases of ./, ../, .../, etc
1988 if (strchr(path, '.'))
1992 // gamedir is entirely path elements, so simply forbid . entirely
1995 if (strchr(path, '.') < strrchr(path, '/'))
1996 return 2; // possible attempt to go outside the game directory
1999 // all: forbid trailing slash on gamedir
2000 if (isgamedir && path[strlen(path)-1] == '/')
2003 // all: forbid leading dot on any filename for any reason
2004 if (strstr(path, "/."))
2005 return 2; // attempt to go outside the game directory
2007 // after all these checks we're pretty sure it's a / separated filename
2008 // and won't do much if any harm
2014 ====================
2017 Look for a file in the packages and in the filesystem
2019 Return the searchpath where the file was found (or NULL)
2020 and the file index in the package if relevant
2021 ====================
2023 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2025 searchpath_t *search;
2028 // search through the path, one element at a time
2029 for (search = fs_searchpaths;search;search = search->next)
2031 // is the element a pak file?
2032 if (search->pack && !search->pack->vpack)
2034 int (*strcmp_funct) (const char* str1, const char* str2);
2035 int left, right, middle;
2038 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2040 // Look for the file (binary search)
2042 right = pak->numfiles - 1;
2043 while (left <= right)
2047 middle = (left + right) / 2;
2048 diff = strcmp_funct (pak->files[middle].name, name);
2053 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2055 // yes, but the first one is empty so we treat it as not being there
2056 if (!quiet && developer_extra.integer)
2057 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2064 if (!quiet && developer_extra.integer)
2065 Con_DPrintf("FS_FindFile: %s in %s\n",
2066 pak->files[middle].name, pak->filename);
2073 // If we're too far in the list
2082 char netpath[MAX_OSPATH];
2083 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2084 if (FS_SysFileExists (netpath))
2086 if (!quiet && developer_extra.integer)
2087 Con_DPrintf("FS_FindFile: %s\n", netpath);
2096 if (!quiet && developer_extra.integer)
2097 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2109 Look for a file in the search paths and open it in read-only mode
2112 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2114 searchpath_t *search;
2117 search = FS_FindFile (filename, &pack_ind, quiet);
2123 // Found in the filesystem?
2126 // this works with vpacks, so we are fine
2127 char path [MAX_OSPATH];
2128 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2129 return FS_SysOpen (path, "rb", nonblocking);
2132 // So, we found it in a package...
2134 // Is it a PK3 symlink?
2135 // TODO also handle directory symlinks by parsing the whole structure...
2136 // but heck, file symlinks are good enough for now
2137 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2139 if(symlinkLevels <= 0)
2141 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2146 char linkbuf[MAX_QPATH];
2148 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2149 const char *mergeslash;
2154 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2160 // Now combine the paths...
2161 mergeslash = strrchr(filename, '/');
2162 mergestart = linkbuf;
2164 mergeslash = filename;
2165 while(!strncmp(mergestart, "../", 3))
2168 while(mergeslash > filename)
2171 if(*mergeslash == '/')
2175 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2176 if(mergeslash == filename)
2178 // Either mergeslash == filename, then we just replace the name (done below)
2182 // Or, we append the name after mergeslash;
2183 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2184 int spaceNeeded = mergeslash - filename + 1;
2185 int spaceRemoved = mergestart - linkbuf;
2186 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2188 Con_DPrintf("symlink: too long path rejected\n");
2191 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2192 memcpy(linkbuf, filename, spaceNeeded);
2193 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2194 mergestart = linkbuf;
2196 if (!quiet && developer_loading.integer)
2197 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2198 if(FS_CheckNastyPath (mergestart, false))
2200 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2203 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2207 return FS_OpenPackedFile (search->pack, pack_ind);
2212 =============================================================================
2214 MAIN PUBLIC FUNCTIONS
2216 =============================================================================
2220 ====================
2223 Open a file in the userpath. The syntax is the same as fopen
2224 Used for savegame scanning in menu, and all file writing.
2225 ====================
2227 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2229 char real_path [MAX_OSPATH];
2231 if (FS_CheckNastyPath(filepath, false))
2233 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2237 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2239 // If the file is opened in "write", "append", or "read/write" mode,
2240 // create directories up to the file.
2241 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2242 FS_CreatePath (real_path);
2243 return FS_SysOpen (real_path, mode, false);
2248 ====================
2251 Open a file. The syntax is the same as fopen
2252 ====================
2254 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2256 if (FS_CheckNastyPath(filepath, false))
2258 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2262 return FS_OpenReadFile (filepath, quiet, false, 16);
2267 ====================
2270 Open a file. The syntax is the same as fopen
2271 ====================
2273 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2276 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2277 memset (file, 0, sizeof (*file));
2278 file->flags = QFILE_FLAG_DATA;
2280 file->real_length = size;
2286 ====================
2290 ====================
2292 int FS_Close (qfile_t* file)
2294 if(file->flags & QFILE_FLAG_DATA)
2300 if (close (file->handle))
2305 qz_inflateEnd (&file->ztk->zstream);
2306 Mem_Free (file->ztk);
2315 ====================
2318 Write "datasize" bytes into a file
2319 ====================
2321 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2325 // If necessary, seek to the exact file position we're supposed to be
2326 if (file->buff_ind != file->buff_len)
2327 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2329 // Purge cached data
2332 // Write the buffer and update the position
2333 result = write (file->handle, data, (fs_offset_t)datasize);
2334 file->position = lseek (file->handle, 0, SEEK_CUR);
2335 if (file->real_length < file->position)
2336 file->real_length = file->position;
2346 ====================
2349 Read up to "buffersize" bytes from a file
2350 ====================
2352 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2354 fs_offset_t count, done;
2356 if (buffersize == 0)
2359 // Get rid of the ungetc character
2360 if (file->ungetc != EOF)
2362 ((char*)buffer)[0] = file->ungetc;
2370 if(file->flags & QFILE_FLAG_DATA)
2372 size_t left = file->real_length - file->position;
2373 if(buffersize > left)
2375 memcpy(buffer, file->data + file->position, buffersize);
2376 file->position += buffersize;
2380 // First, we copy as many bytes as we can from "buff"
2381 if (file->buff_ind < file->buff_len)
2383 count = file->buff_len - file->buff_ind;
2384 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2386 memcpy (buffer, &file->buff[file->buff_ind], count);
2387 file->buff_ind += count;
2389 buffersize -= count;
2390 if (buffersize == 0)
2394 // NOTE: at this point, the read buffer is always empty
2396 // If the file isn't compressed
2397 if (! (file->flags & QFILE_FLAG_DEFLATED))
2401 // We must take care to not read after the end of the file
2402 count = file->real_length - file->position;
2404 // If we have a lot of data to get, put them directly into "buffer"
2405 if (buffersize > sizeof (file->buff) / 2)
2407 if (count > (fs_offset_t)buffersize)
2408 count = (fs_offset_t)buffersize;
2409 lseek (file->handle, file->offset + file->position, SEEK_SET);
2410 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2414 file->position += nb;
2416 // Purge cached data
2422 if (count > (fs_offset_t)sizeof (file->buff))
2423 count = (fs_offset_t)sizeof (file->buff);
2424 lseek (file->handle, file->offset + file->position, SEEK_SET);
2425 nb = read (file->handle, file->buff, count);
2428 file->buff_len = nb;
2429 file->position += nb;
2431 // Copy the requested data in "buffer" (as much as we can)
2432 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2433 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2434 file->buff_ind = count;
2442 // If the file is compressed, it's more complicated...
2443 // We cycle through a few operations until we have read enough data
2444 while (buffersize > 0)
2446 ztoolkit_t *ztk = file->ztk;
2449 // NOTE: at this point, the read buffer is always empty
2451 // If "input" is also empty, we need to refill it
2452 if (ztk->in_ind == ztk->in_len)
2454 // If we are at the end of the file
2455 if (file->position == file->real_length)
2458 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2459 if (count > (fs_offset_t)sizeof (ztk->input))
2460 count = (fs_offset_t)sizeof (ztk->input);
2461 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2462 if (read (file->handle, ztk->input, count) != count)
2464 Con_Printf ("FS_Read: unexpected end of file\n");
2469 ztk->in_len = count;
2470 ztk->in_position += count;
2473 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2474 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2476 // Now that we are sure we have compressed data available, we need to determine
2477 // if it's better to inflate it in "file->buff" or directly in "buffer"
2479 // Inflate the data in "file->buff"
2480 if (buffersize < sizeof (file->buff) / 2)
2482 ztk->zstream.next_out = file->buff;
2483 ztk->zstream.avail_out = sizeof (file->buff);
2484 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2485 if (error != Z_OK && error != Z_STREAM_END)
2487 Con_Printf ("FS_Read: Can't inflate file\n");
2490 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2492 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2493 file->position += file->buff_len;
2495 // Copy the requested data in "buffer" (as much as we can)
2496 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2497 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2498 file->buff_ind = count;
2501 // Else, we inflate directly in "buffer"
2504 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2505 ztk->zstream.avail_out = (unsigned int)buffersize;
2506 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2507 if (error != Z_OK && error != Z_STREAM_END)
2509 Con_Printf ("FS_Read: Can't inflate file\n");
2512 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2514 // How much data did it inflate?
2515 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2516 file->position += count;
2518 // Purge cached data
2523 buffersize -= count;
2531 ====================
2534 Print a string into a file
2535 ====================
2537 int FS_Print (qfile_t* file, const char *msg)
2539 return (int)FS_Write (file, msg, strlen (msg));
2543 ====================
2546 Print a string into a file
2547 ====================
2549 int FS_Printf(qfile_t* file, const char* format, ...)
2554 va_start (args, format);
2555 result = FS_VPrintf (file, format, args);
2563 ====================
2566 Print a string into a file
2567 ====================
2569 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2572 fs_offset_t buff_size = MAX_INPUTLINE;
2577 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2578 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2579 if (len >= 0 && len < buff_size)
2581 Mem_Free (tempbuff);
2585 len = write (file->handle, tempbuff, len);
2586 Mem_Free (tempbuff);
2593 ====================
2596 Get the next character of a file
2597 ====================
2599 int FS_Getc (qfile_t* file)
2603 if (FS_Read (file, &c, 1) != 1)
2611 ====================
2614 Put a character back into the read buffer (only supports one character!)
2615 ====================
2617 int FS_UnGetc (qfile_t* file, unsigned char c)
2619 // If there's already a character waiting to be read
2620 if (file->ungetc != EOF)
2629 ====================
2632 Move the position index in a file
2633 ====================
2635 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2638 unsigned char* buffer;
2639 fs_offset_t buffersize;
2641 // Compute the file offset
2645 offset += file->position - file->buff_len + file->buff_ind;
2652 offset += file->real_length;
2658 if (offset < 0 || offset > file->real_length)
2661 if(file->flags & QFILE_FLAG_DATA)
2663 file->position = offset;
2667 // If we have the data in our read buffer, we don't need to actually seek
2668 if (file->position - file->buff_len <= offset && offset <= file->position)
2670 file->buff_ind = offset + file->buff_len - file->position;
2674 // Purge cached data
2677 // Unpacked or uncompressed files can seek directly
2678 if (! (file->flags & QFILE_FLAG_DEFLATED))
2680 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2682 file->position = offset;
2686 // Seeking in compressed files is more a hack than anything else,
2687 // but we need to support it, so here we go.
2690 // If we have to go back in the file, we need to restart from the beginning
2691 if (offset <= file->position)
2695 ztk->in_position = 0;
2697 lseek (file->handle, file->offset, SEEK_SET);
2699 // Reset the Zlib stream
2700 ztk->zstream.next_in = ztk->input;
2701 ztk->zstream.avail_in = 0;
2702 qz_inflateReset (&ztk->zstream);
2705 // We need a big buffer to force inflating into it directly
2706 buffersize = 2 * sizeof (file->buff);
2707 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2709 // Skip all data until we reach the requested offset
2710 while (offset > file->position)
2712 fs_offset_t diff = offset - file->position;
2713 fs_offset_t count, len;
2715 count = (diff > buffersize) ? buffersize : diff;
2716 len = FS_Read (file, buffer, count);
2730 ====================
2733 Give the current position in a file
2734 ====================
2736 fs_offset_t FS_Tell (qfile_t* file)
2738 return file->position - file->buff_len + file->buff_ind;
2743 ====================
2746 Give the total size of a file
2747 ====================
2749 fs_offset_t FS_FileSize (qfile_t* file)
2751 return file->real_length;
2756 ====================
2759 Erases any buffered input or output data
2760 ====================
2762 void FS_Purge (qfile_t* file)
2774 Filename are relative to the quake directory.
2775 Always appends a 0 byte.
2778 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2781 unsigned char *buf = NULL;
2782 fs_offset_t filesize = 0;
2784 file = FS_OpenVirtualFile(path, quiet);
2787 filesize = file->real_length;
2790 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2795 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2796 buf[filesize] = '\0';
2797 FS_Read (file, buf, filesize);
2799 if (developer_loadfile.integer)
2800 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2803 if (filesizepointer)
2804 *filesizepointer = filesize;
2813 The filename will be prefixed by the current game directory
2816 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2820 file = FS_OpenRealFile(filename, "wb", false);
2823 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2827 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2828 FS_Write (file, data, len);
2835 =============================================================================
2837 OTHERS PUBLIC FUNCTIONS
2839 =============================================================================
2847 void FS_StripExtension (const char *in, char *out, size_t size_out)
2855 while ((currentchar = *in) && size_out > 1)
2857 if (currentchar == '.')
2859 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2861 *out++ = currentchar;
2877 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2881 // if path doesn't have a .EXT, append extension
2882 // (extension should include the .)
2883 src = path + strlen(path) - 1;
2885 while (*src != '/' && src != path)
2888 return; // it has an extension
2892 strlcat (path, extension, size_path);
2900 Look for a file in the packages and in the filesystem
2903 int FS_FileType (const char *filename)
2905 searchpath_t *search;
2906 char fullpath[MAX_OSPATH];
2908 search = FS_FindFile (filename, NULL, true);
2910 return FS_FILETYPE_NONE;
2912 if(search->pack && !search->pack->vpack)
2913 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2915 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2916 return FS_SysFileType(fullpath);
2924 Look for a file in the packages and in the filesystem
2927 qboolean FS_FileExists (const char *filename)
2929 return (FS_FindFile (filename, NULL, true) != NULL);
2937 Look for a file in the filesystem only
2940 int FS_SysFileType (const char *path)
2943 // Sajt - some older sdks are missing this define
2944 # ifndef INVALID_FILE_ATTRIBUTES
2945 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
2948 DWORD result = GetFileAttributes(path);
2950 if(result == INVALID_FILE_ATTRIBUTES)
2951 return FS_FILETYPE_NONE;
2953 if(result & FILE_ATTRIBUTE_DIRECTORY)
2954 return FS_FILETYPE_DIRECTORY;
2956 return FS_FILETYPE_FILE;
2960 if (stat (path,&buf) == -1)
2961 return FS_FILETYPE_NONE;
2964 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
2966 if(S_ISDIR(buf.st_mode))
2967 return FS_FILETYPE_DIRECTORY;
2969 return FS_FILETYPE_FILE;
2973 qboolean FS_SysFileExists (const char *path)
2975 return FS_SysFileType (path) != FS_FILETYPE_NONE;
2978 void FS_mkdir (const char *path)
2991 Allocate and fill a search structure with information on matching filenames.
2994 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2997 searchpath_t *searchpath;
2999 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3000 stringlist_t resultlist;
3001 stringlist_t dirlist;
3002 const char *slash, *backslash, *colon, *separator;
3004 char temp[MAX_OSPATH];
3006 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3011 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3015 stringlistinit(&resultlist);
3016 stringlistinit(&dirlist);
3018 slash = strrchr(pattern, '/');
3019 backslash = strrchr(pattern, '\\');
3020 colon = strrchr(pattern, ':');
3021 separator = max(slash, backslash);
3022 separator = max(separator, colon);
3023 basepathlength = separator ? (separator + 1 - pattern) : 0;
3024 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3026 memcpy(basepath, pattern, basepathlength);
3027 basepath[basepathlength] = 0;
3029 // search through the path, one element at a time
3030 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3032 // is the element a pak file?
3033 if (searchpath->pack && !searchpath->pack->vpack)
3035 // look through all the pak file elements
3036 pak = searchpath->pack;
3037 for (i = 0;i < pak->numfiles;i++)
3039 strlcpy(temp, pak->files[i].name, sizeof(temp));
3042 if (matchpattern(temp, (char *)pattern, true))
3044 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3045 if (!strcmp(resultlist.strings[resultlistindex], temp))
3047 if (resultlistindex == resultlist.numstrings)
3049 stringlistappend(&resultlist, temp);
3050 if (!quiet && developer_loading.integer)
3051 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3054 // strip off one path element at a time until empty
3055 // this way directories are added to the listing if they match the pattern
3056 slash = strrchr(temp, '/');
3057 backslash = strrchr(temp, '\\');
3058 colon = strrchr(temp, ':');
3060 if (separator < slash)
3062 if (separator < backslash)
3063 separator = backslash;
3064 if (separator < colon)
3066 *((char *)separator) = 0;
3072 stringlist_t matchedSet, foundSet;
3073 const char *start = pattern;
3075 stringlistinit(&matchedSet);
3076 stringlistinit(&foundSet);
3077 // add a first entry to the set
3078 stringlistappend(&matchedSet, "");
3079 // iterate through pattern's path
3082 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3083 char subpath[MAX_OSPATH];
3084 char subpattern[MAX_OSPATH];
3086 // find the next wildcard
3087 wildcard = strchr(start, '?');
3088 asterisk = strchr(start, '*');
3089 if (asterisk && (!wildcard || asterisk < wildcard))
3091 wildcard = asterisk;
3096 nextseparator = strchr( wildcard, '/' );
3100 nextseparator = NULL;
3103 if( !nextseparator ) {
3104 nextseparator = start + strlen( start );
3107 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3108 // copy everything up except nextseperator
3109 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3110 // find the last '/' before the wildcard
3111 prevseparator = strrchr( subpattern, '/' );
3113 prevseparator = subpattern;
3116 // copy everything from start to the previous including the '/' (before the wildcard)
3117 // everything up to start is already included in the path of matchedSet's entries
3118 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3120 // for each entry in matchedSet try to open the subdirectories specified in subpath
3121 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3122 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3123 strlcat( temp, subpath, sizeof(temp) );
3124 listdirectory( &foundSet, searchpath->filename, temp );
3126 if( dirlistindex == 0 ) {
3129 // reset the current result set
3130 stringlistfreecontents( &matchedSet );
3131 // match against the pattern
3132 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3133 const char *direntry = foundSet.strings[ dirlistindex ];
3134 if (matchpattern(direntry, subpattern, true)) {
3135 stringlistappend( &matchedSet, direntry );
3138 stringlistfreecontents( &foundSet );
3140 start = nextseparator;
3143 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3145 const char *temp = matchedSet.strings[dirlistindex];
3146 if (matchpattern(temp, (char *)pattern, true))
3148 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3149 if (!strcmp(resultlist.strings[resultlistindex], temp))
3151 if (resultlistindex == resultlist.numstrings)
3153 stringlistappend(&resultlist, temp);
3154 if (!quiet && developer_loading.integer)
3155 Con_Printf("SearchDirFile: %s\n", temp);
3159 stringlistfreecontents( &matchedSet );
3163 if (resultlist.numstrings)
3165 stringlistsort(&resultlist);
3166 numfiles = resultlist.numstrings;
3168 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3169 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3170 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3171 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3172 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3173 search->numfilenames = (int)numfiles;
3176 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3179 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3180 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3181 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3183 numchars += (int)textlen;
3186 stringlistfreecontents(&resultlist);
3192 void FS_FreeSearch(fssearch_t *search)
3197 extern int con_linewidth;
3198 int FS_ListDirectory(const char *pattern, int oneperline)
3207 char linebuf[MAX_INPUTLINE];
3209 search = FS_Search(pattern, true, true);
3212 numfiles = search->numfilenames;
3215 // FIXME: the names could be added to one column list and then
3216 // gradually shifted into the next column if they fit, and then the
3217 // next to make a compact variable width listing but it's a lot more
3219 // find width for columns
3221 for (i = 0;i < numfiles;i++)
3223 l = (int)strlen(search->filenames[i]);
3224 if (columnwidth < l)
3227 // count the spacing character
3229 // calculate number of columns
3230 numcolumns = con_linewidth / columnwidth;
3231 // don't bother with the column printing if it's only one column
3232 if (numcolumns >= 2)
3234 numlines = (numfiles + numcolumns - 1) / numcolumns;
3235 for (i = 0;i < numlines;i++)
3238 for (k = 0;k < numcolumns;k++)
3240 l = i * numcolumns + k;
3243 name = search->filenames[l];
3244 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3245 linebuf[linebufpos++] = name[j];
3246 // space out name unless it's the last on the line
3247 if (k + 1 < numcolumns && l + 1 < numfiles)
3248 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3249 linebuf[linebufpos++] = ' ';
3252 linebuf[linebufpos] = 0;
3253 Con_Printf("%s\n", linebuf);
3260 for (i = 0;i < numfiles;i++)
3261 Con_Printf("%s\n", search->filenames[i]);
3262 FS_FreeSearch(search);
3263 return (int)numfiles;
3266 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3268 const char *pattern;
3271 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3274 if (Cmd_Argc() == 2)
3275 pattern = Cmd_Argv(1);
3278 if (!FS_ListDirectory(pattern, oneperline))
3279 Con_Print("No files found.\n");
3284 FS_ListDirectoryCmd("dir", true);
3289 FS_ListDirectoryCmd("ls", false);
3292 void FS_Which_f(void)
3294 const char *filename;
3297 if (Cmd_Argc() != 2)
3299 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3302 filename = Cmd_Argv(1);
3303 sp = FS_FindFile(filename, &index, true);
3305 Con_Printf("%s isn't anywhere\n", filename);
3309 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3311 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3315 const char *FS_WhichPack(const char *filename)
3318 searchpath_t *sp = FS_FindFile(filename, &index, true);
3320 return sp->pack->shortname;
3326 ====================
3327 FS_IsRegisteredQuakePack
3329 Look for a proof of purchase file file in the requested package
3331 If it is found, this file should NOT be downloaded.
3332 ====================
3334 qboolean FS_IsRegisteredQuakePack(const char *name)
3336 searchpath_t *search;
3339 // search through the path, one element at a time
3340 for (search = fs_searchpaths;search;search = search->next)
3342 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3343 // TODO do we want to support vpacks in here too?
3345 int (*strcmp_funct) (const char* str1, const char* str2);
3346 int left, right, middle;
3349 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3351 // Look for the file (binary search)
3353 right = pak->numfiles - 1;
3354 while (left <= right)
3358 middle = (left + right) / 2;
3359 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3365 // If we're too far in the list
3372 // we found the requested pack but it is not registered quake
3380 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3383 unsigned char *filedata;
3384 fs_offset_t filesize;
3385 if (filesizepointer)
3386 *filesizepointer = 0;
3387 if (!filename || !*filename)
3389 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3392 if (filesizepointer)
3393 *filesizepointer = filesize;
3394 crc = CRC_Block(filedata, filesize);
3400 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3403 unsigned char *out = NULL;
3407 #ifndef LINK_TO_ZLIB
3412 memset(&strm, 0, sizeof(strm));
3413 strm.zalloc = Z_NULL;
3414 strm.zfree = Z_NULL;
3415 strm.opaque = Z_NULL;
3418 level = Z_DEFAULT_COMPRESSION;
3420 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3422 Con_Printf("FS_Deflate: deflate init error!\n");
3426 strm.next_in = (unsigned char*)data;
3427 strm.avail_in = size;
3429 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3432 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3433 qz_deflateEnd(&strm);
3437 strm.next_out = tmp;
3438 strm.avail_out = size;
3440 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3442 Con_Printf("FS_Deflate: deflate failed!\n");
3443 qz_deflateEnd(&strm);
3448 if(qz_deflateEnd(&strm) != Z_OK)
3450 Con_Printf("FS_Deflate: deflateEnd failed\n");
3455 if(strm.total_out >= size)
3457 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3462 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3465 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3471 *deflated_size = (size_t)strm.total_out;
3473 memcpy(out, tmp, strm.total_out);
3479 static void AssertBufsize(sizebuf_t *buf, int length)
3481 if(buf->cursize + length > buf->maxsize)
3483 int oldsize = buf->maxsize;
3484 unsigned char *olddata;
3485 olddata = buf->data;
3486 buf->maxsize += length;
3487 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3490 memcpy(buf->data, olddata, oldsize);
3496 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3500 unsigned char *out = NULL;
3501 unsigned char tmp[2048];
3506 #ifndef LINK_TO_ZLIB
3511 memset(&outbuf, 0, sizeof(outbuf));
3512 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3513 outbuf.maxsize = sizeof(tmp);
3515 memset(&strm, 0, sizeof(strm));
3516 strm.zalloc = Z_NULL;
3517 strm.zfree = Z_NULL;
3518 strm.opaque = Z_NULL;
3520 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3522 Con_Printf("FS_Inflate: inflate init error!\n");
3523 Mem_Free(outbuf.data);
3527 strm.next_in = (unsigned char*)data;
3528 strm.avail_in = size;
3532 strm.next_out = tmp;
3533 strm.avail_out = sizeof(tmp);
3534 ret = qz_inflate(&strm, Z_NO_FLUSH);
3535 // it either returns Z_OK on progress, Z_STREAM_END on end
3543 case Z_STREAM_ERROR:
3544 Con_Print("FS_Inflate: stream error!\n");
3547 Con_Print("FS_Inflate: data error!\n");
3550 Con_Print("FS_Inflate: mem error!\n");
3553 Con_Print("FS_Inflate: buf error!\n");
3556 Con_Print("FS_Inflate: unknown error!\n");
3560 if(ret != Z_OK && ret != Z_STREAM_END)
3562 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3563 Mem_Free(outbuf.data);
3564 qz_inflateEnd(&strm);
3567 have = sizeof(tmp) - strm.avail_out;
3568 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3569 SZ_Write(&outbuf, tmp, have);
3570 } while(ret != Z_STREAM_END);
3572 qz_inflateEnd(&strm);
3574 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3577 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3578 Mem_Free(outbuf.data);
3582 memcpy(out, outbuf.data, outbuf.cursize);
3583 Mem_Free(outbuf.data);
3586 *inflated_size = (size_t)outbuf.cursize;