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("%sdir (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);
1003 for(search = fs_searchpaths; search; search = search->next)
1005 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1008 *already_loaded = true;
1009 return true; // already loaded
1014 *already_loaded = false;
1016 if(!strcasecmp(ext, "pk3dir"))
1017 pak = FS_LoadPackVirtual (pakfile);
1018 else if(!strcasecmp(ext, "pak"))
1019 pak = FS_LoadPackPAK (pakfile);
1020 else if(!strcasecmp(ext, "pk3"))
1021 pak = FS_LoadPackPK3 (pakfile);
1023 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1027 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1029 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1032 // find the first item whose next one is a pack or NULL
1033 searchpath_t *insertion_point = 0;
1034 if(fs_searchpaths && !fs_searchpaths->pack)
1036 insertion_point = fs_searchpaths;
1039 if(!insertion_point->next)
1041 if(insertion_point->next->pack)
1043 insertion_point = insertion_point->next;
1046 // If insertion_point is NULL, this means that either there is no
1047 // item in the list yet, or that the very first item is a pack. In
1048 // that case, we want to insert at the beginning...
1049 if(!insertion_point)
1051 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1052 search->next = fs_searchpaths;
1053 fs_searchpaths = search;
1056 // otherwise we want to append directly after insertion_point.
1058 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1059 search->next = insertion_point->next;
1060 insertion_point->next = search;
1065 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1066 search->next = fs_searchpaths;
1067 fs_searchpaths = search;
1072 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1073 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1074 // same goes for the name inside the pack structure
1075 l = strlen(pak->shortname);
1077 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1078 pak->shortname[l - 3] = 0;
1079 l = strlen(pak->filename);
1081 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1082 pak->filename[l - 3] = 0;
1088 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1099 /*! Adds the given pack to the search path and searches for it in the game path.
1100 * The pack type is autodetected by the file extension.
1102 * Returns true if the file was successfully added to the
1103 * search path or if it was already included.
1105 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1106 * plain directories.
1108 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1110 char fullpath[MAX_OSPATH];
1112 searchpath_t *search;
1115 *already_loaded = false;
1117 // then find the real name...
1118 search = FS_FindFile(pakfile, &index, true);
1119 if(!search || search->pack)
1121 Con_Printf("could not find pak \"%s\"\n", pakfile);
1125 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1127 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1135 Sets fs_gamedir, adds the directory to the head of the path,
1136 then loads and adds pak1.pak pak2.pak ...
1139 void FS_AddGameDirectory (const char *dir)
1143 searchpath_t *search;
1145 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1147 stringlistinit(&list);
1148 listdirectory(&list, "", dir);
1149 stringlistsort(&list);
1151 // add any PAK package in the directory
1152 for (i = 0;i < list.numstrings;i++)
1154 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1156 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1160 // add any PK3 package in the directory
1161 for (i = 0;i < list.numstrings;i++)
1163 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1165 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1169 stringlistfreecontents(&list);
1171 // Add the directory to the search path
1172 // (unpacked files have the priority over packed files)
1173 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1174 strlcpy (search->filename, dir, sizeof (search->filename));
1175 search->next = fs_searchpaths;
1176 fs_searchpaths = search;
1185 void FS_AddGameHierarchy (const char *dir)
1187 // Add the common game directory
1188 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1191 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1200 const char *FS_FileExtension (const char *in)
1202 const char *separator, *backslash, *colon, *dot;
1204 separator = strrchr(in, '/');
1205 backslash = strrchr(in, '\\');
1206 if (!separator || separator < backslash)
1207 separator = backslash;
1208 colon = strrchr(in, ':');
1209 if (!separator || separator < colon)
1212 dot = strrchr(in, '.');
1213 if (dot == NULL || (separator && (dot < separator)))
1225 const char *FS_FileWithoutPath (const char *in)
1227 const char *separator, *backslash, *colon;
1229 separator = strrchr(in, '/');
1230 backslash = strrchr(in, '\\');
1231 if (!separator || separator < backslash)
1232 separator = backslash;
1233 colon = strrchr(in, ':');
1234 if (!separator || separator < colon)
1236 return separator ? separator + 1 : in;
1245 void FS_ClearSearchPath (void)
1247 // unload all packs and directory information, close all pack files
1248 // (if a qfile is still reading a pack it won't be harmed because it used
1249 // dup() to get its own handle already)
1250 while (fs_searchpaths)
1252 searchpath_t *search = fs_searchpaths;
1253 fs_searchpaths = search->next;
1256 if(!search->pack->vpack)
1259 close(search->pack->handle);
1260 // free any memory associated with it
1261 if (search->pack->files)
1262 Mem_Free(search->pack->files);
1264 Mem_Free(search->pack);
1276 void FS_Rescan (void)
1279 qboolean fs_modified = false;
1280 char gamedirbuf[MAX_INPUTLINE];
1282 FS_ClearSearchPath();
1284 // add the game-specific paths
1285 // gamedirname1 (typically id1)
1286 FS_AddGameHierarchy (gamedirname1);
1287 // update the com_modname (used for server info)
1288 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1290 // add the game-specific path, if any
1291 // (only used for mission packs and the like, which should set fs_modified)
1295 FS_AddGameHierarchy (gamedirname2);
1299 // Adds basedir/gamedir as an override game
1300 // LordHavoc: now supports multiple -game directories
1301 // set the com_modname (reported in server info)
1303 for (i = 0;i < fs_numgamedirs;i++)
1306 FS_AddGameHierarchy (fs_gamedirs[i]);
1307 // update the com_modname (used server info)
1308 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1310 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1312 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1314 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1316 // set the default screenshot name to either the mod name or the
1317 // gamemode screenshot name
1318 if (strcmp(com_modname, gamedirname1))
1319 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1321 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1323 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1324 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1326 // If "-condebug" is in the command line, remove the previous log file
1327 if (COM_CheckParm ("-condebug") != 0)
1328 unlink (va("%s/qconsole.log", fs_gamedir));
1330 // look for the pop.lmp file and set registered to true if it is found
1331 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1334 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1336 Con_Print("Playing shareware version.\n");
1340 Cvar_Set ("registered", "1");
1341 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1342 Con_Print("Playing registered version.\n");
1345 // unload all wads so that future queries will return the new data
1349 void FS_Rescan_f(void)
1359 extern void Host_SaveConfig (void);
1360 extern void Host_LoadConfig_f (void);
1361 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1366 if (fs_numgamedirs == numgamedirs)
1368 for (i = 0;i < numgamedirs;i++)
1369 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1371 if (i == numgamedirs)
1372 return true; // already using this set of gamedirs, do nothing
1375 if (numgamedirs > MAX_GAMEDIRS)
1378 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1379 return false; // too many gamedirs
1382 for (i = 0;i < numgamedirs;i++)
1384 // if string is nasty, reject it
1385 p = FS_CheckGameDir(gamedirs[i]);
1389 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1390 return false; // nasty gamedirs
1392 if(p == fs_checkgamedir_missing && failmissing)
1395 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1396 return false; // missing gamedirs
1402 fs_numgamedirs = numgamedirs;
1403 for (i = 0;i < fs_numgamedirs;i++)
1404 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1406 // reinitialize filesystem to detect the new paks
1409 // exec the new config
1410 Host_LoadConfig_f();
1412 // unload all sounds so they will be reloaded from the new files as needed
1413 S_UnloadAllSounds_f();
1415 // reinitialize renderer (this reloads hud/console background/etc)
1416 R_Modules_Restart();
1426 void FS_GameDir_f (void)
1430 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1434 Con_Printf("gamedirs active:");
1435 for (i = 0;i < fs_numgamedirs;i++)
1436 Con_Printf(" %s", fs_gamedirs[i]);
1441 numgamedirs = Cmd_Argc() - 1;
1442 if (numgamedirs > MAX_GAMEDIRS)
1444 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1448 for (i = 0;i < numgamedirs;i++)
1449 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1451 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1453 // actually, changing during game would work fine, but would be stupid
1454 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1458 // halt demo playback to close the file
1461 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1464 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking);
1465 static const char *FS_SysCheckGameDir(const char *gamedir)
1467 static char buf[8192];
1473 stringlistinit(&list);
1474 listdirectory(&list, gamedir, "");
1475 success = list.numstrings > 0;
1476 stringlistfreecontents(&list);
1480 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1483 n = FS_Read (f, buf, sizeof(buf) - 1);
1503 const char *FS_CheckGameDir(const char *gamedir)
1507 if (FS_CheckNastyPath(gamedir, true))
1510 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1515 // get description from basedir
1516 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1524 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1528 return fs_checkgamedir_missing;
1531 static void FS_ListGameDirs(void)
1533 stringlist_t list, list2;
1537 fs_all_gamedirs_count = 0;
1539 Mem_Free(fs_all_gamedirs);
1541 stringlistinit(&list);
1542 listdirectory(&list, va("%s/", fs_basedir), "");
1543 listdirectory(&list, va("%s/", fs_userdir), "");
1544 stringlistsort(&list);
1546 stringlistinit(&list2);
1547 for(i = 0; i < list.numstrings; ++i)
1550 if(!strcmp(list.strings[i-1], list.strings[i]))
1552 info = FS_CheckGameDir(list.strings[i]);
1555 if(info == fs_checkgamedir_missing)
1559 stringlistappend(&list2, list.strings[i]);
1561 stringlistfreecontents(&list);
1563 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1564 for(i = 0; i < list2.numstrings; ++i)
1566 info = FS_CheckGameDir(list2.strings[i]);
1567 // all this cannot happen any more, but better be safe than sorry
1570 if(info == fs_checkgamedir_missing)
1574 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1575 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1576 ++fs_all_gamedirs_count;
1590 TCHAR mydocsdir[MAX_PATH + 1];
1591 #if _MSC_VER >= 1400
1598 const char* dllnames [] =
1600 "shfolder.dll", // IE 4, or Win NT and higher
1603 Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1604 // don't care for the result; if it fails, %USERPROFILE% will be used instead
1607 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1609 // Add the personal game directory
1610 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1612 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1614 else if(COM_CheckParm("-nohome"))
1621 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1623 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1624 Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1628 // use the environment
1629 #if _MSC_VER >= 1400
1630 _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1632 homedir = getenv("USERPROFILE");
1637 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1638 #if _MSC_VER >= 1400
1641 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1646 Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1648 homedir = getenv ("HOME");
1650 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1653 Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1657 if(!COM_CheckParm("-mygames"))
1659 #if _MSC_VER >= 1400
1661 _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!
1663 int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1668 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1674 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1676 // If the base directory is explicitly defined by the compilation process
1677 #ifdef DP_FS_BASEDIR
1678 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1683 // FIXME: is there a better way to find the directory outside the .app?
1684 if (strstr(com_argv[0], ".app/"))
1688 split = strstr(com_argv[0], ".app/");
1689 while (split > com_argv[0] && *split != '/')
1691 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1692 fs_basedir[split - com_argv[0]] = 0;
1700 // Overrides the system supplied base directory (under GAMENAME)
1701 // 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)
1702 i = COM_CheckParm ("-basedir");
1703 if (i && i < com_argc-1)
1705 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1706 i = (int)strlen (fs_basedir);
1707 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1708 fs_basedir[i-1] = 0;
1711 // add a path separator to the end of the basedir if it lacks one
1712 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1713 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1717 p = FS_CheckGameDir(gamedirname1);
1718 if(!p || p == fs_checkgamedir_missing)
1719 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1723 p = FS_CheckGameDir(gamedirname2);
1724 if(!p || p == fs_checkgamedir_missing)
1725 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1729 // Adds basedir/gamedir as an override game
1730 // LordHavoc: now supports multiple -game directories
1731 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1735 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1738 p = FS_CheckGameDir(com_argv[i]);
1740 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1741 if(p == fs_checkgamedir_missing)
1742 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1743 // add the gamedir to the list of active gamedirs
1744 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1749 // generate the searchpath
1753 void FS_Init_Commands(void)
1755 Cvar_RegisterVariable (&scr_screenshot_name);
1756 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1757 Cvar_RegisterVariable (&cvar_fs_gamedir);
1759 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1760 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1761 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1762 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1763 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1764 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1772 void FS_Shutdown (void)
1774 // close all pack files and such
1775 // (hopefully there aren't any other open files, but they'll be cleaned up
1776 // by the OS anyway)
1777 FS_ClearSearchPath();
1778 Mem_FreePool (&fs_mempool);
1781 Sys_UnloadLibrary (&shfolder_dll);
1786 ====================
1789 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1790 ====================
1792 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1798 // Parse the mode string
1807 opt = O_CREAT | O_TRUNC;
1811 opt = O_CREAT | O_APPEND;
1814 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1817 for (ind = 1; mode[ind] != '\0'; ind++)
1828 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1829 filepath, mode, mode[ind]);
1836 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1837 memset (file, 0, sizeof (*file));
1840 #if _MSC_VER >= 1400
1841 _sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1843 file->handle = open (filepath, mod | opt, 0666);
1845 if (file->handle < 0)
1851 file->real_length = lseek (file->handle, 0, SEEK_END);
1853 // For files opened in append mode, we start at the end of the file
1855 file->position = file->real_length;
1857 lseek (file->handle, 0, SEEK_SET);
1867 Open a packed file using its package file descriptor
1870 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1876 pfile = &pack->files[pack_ind];
1878 // If we don't have the true offset, get it now
1879 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1880 if (!PK3_GetTrueFileOffset (pfile, pack))
1883 #ifndef LINK_TO_ZLIB
1884 // No Zlib DLL = no compressed files
1885 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1887 Con_Printf("WARNING: can't open the compressed file %s\n"
1888 "You need the Zlib DLL to use compressed files\n",
1894 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1895 // the dup() call to avoid having to close the dup_handle on error here
1896 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1898 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1899 pfile->name, pack->filename, (int) pfile->offset);
1903 dup_handle = dup (pack->handle);
1906 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1910 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1911 memset (file, 0, sizeof (*file));
1912 file->handle = dup_handle;
1913 file->flags = QFILE_FLAG_PACKED;
1914 file->real_length = pfile->realsize;
1915 file->offset = pfile->offset;
1919 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1923 file->flags |= QFILE_FLAG_DEFLATED;
1925 // We need some more variables
1926 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1928 ztk->comp_length = pfile->packsize;
1930 // Initialize zlib stream
1931 ztk->zstream.next_in = ztk->input;
1932 ztk->zstream.avail_in = 0;
1934 /* From Zlib's "unzip.c":
1936 * windowBits is passed < 0 to tell that there is no zlib header.
1937 * Note that in this case inflate *requires* an extra "dummy" byte
1938 * after the compressed stream in order to complete decompression and
1939 * return Z_STREAM_END.
1940 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1941 * size of both compressed and uncompressed data
1943 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1945 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1951 ztk->zstream.next_out = file->buff;
1952 ztk->zstream.avail_out = sizeof (file->buff);
1961 ====================
1964 Return true if the path should be rejected due to one of the following:
1965 1: path elements that are non-portable
1966 2: path elements that would allow access to files outside the game directory,
1967 or are just not a good idea for a mod to be using.
1968 ====================
1970 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1972 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1976 // Windows: don't allow \ in filenames (windows-only), period.
1977 // (on Windows \ is a directory separator, but / is also supported)
1978 if (strstr(path, "\\"))
1979 return 1; // non-portable
1981 // Mac: don't allow Mac-only filenames - : is a directory separator
1982 // instead of /, but we rely on / working already, so there's no reason to
1983 // support a Mac-only path
1984 // Amiga and Windows: : tries to go to root of drive
1985 if (strstr(path, ":"))
1986 return 1; // non-portable attempt to go to root of drive
1988 // Amiga: // is parent directory
1989 if (strstr(path, "//"))
1990 return 1; // non-portable attempt to go to parent directory
1992 // all: don't allow going to parent directory (../ or /../)
1993 if (strstr(path, ".."))
1994 return 2; // attempt to go outside the game directory
1996 // Windows and UNIXes: don't allow absolute paths
1998 return 2; // attempt to go outside the game directory
2000 // 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
2001 if (strchr(path, '.'))
2005 // gamedir is entirely path elements, so simply forbid . entirely
2008 if (strchr(path, '.') < strrchr(path, '/'))
2009 return 2; // possible attempt to go outside the game directory
2012 // all: forbid trailing slash on gamedir
2013 if (isgamedir && path[strlen(path)-1] == '/')
2016 // all: forbid leading dot on any filename for any reason
2017 if (strstr(path, "/."))
2018 return 2; // attempt to go outside the game directory
2020 // after all these checks we're pretty sure it's a / separated filename
2021 // and won't do much if any harm
2027 ====================
2030 Look for a file in the packages and in the filesystem
2032 Return the searchpath where the file was found (or NULL)
2033 and the file index in the package if relevant
2034 ====================
2036 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2038 searchpath_t *search;
2041 // search through the path, one element at a time
2042 for (search = fs_searchpaths;search;search = search->next)
2044 // is the element a pak file?
2045 if (search->pack && !search->pack->vpack)
2047 int (*strcmp_funct) (const char* str1, const char* str2);
2048 int left, right, middle;
2051 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2053 // Look for the file (binary search)
2055 right = pak->numfiles - 1;
2056 while (left <= right)
2060 middle = (left + right) / 2;
2061 diff = strcmp_funct (pak->files[middle].name, name);
2066 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2068 // yes, but the first one is empty so we treat it as not being there
2069 if (!quiet && developer_extra.integer)
2070 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2077 if (!quiet && developer_extra.integer)
2078 Con_DPrintf("FS_FindFile: %s in %s\n",
2079 pak->files[middle].name, pak->filename);
2086 // If we're too far in the list
2095 char netpath[MAX_OSPATH];
2096 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2097 if (FS_SysFileExists (netpath))
2099 if (!quiet && developer_extra.integer)
2100 Con_DPrintf("FS_FindFile: %s\n", netpath);
2109 if (!quiet && developer_extra.integer)
2110 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2122 Look for a file in the search paths and open it in read-only mode
2125 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2127 searchpath_t *search;
2130 search = FS_FindFile (filename, &pack_ind, quiet);
2136 // Found in the filesystem?
2139 // this works with vpacks, so we are fine
2140 char path [MAX_OSPATH];
2141 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2142 return FS_SysOpen (path, "rb", nonblocking);
2145 // So, we found it in a package...
2147 // Is it a PK3 symlink?
2148 // TODO also handle directory symlinks by parsing the whole structure...
2149 // but heck, file symlinks are good enough for now
2150 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2152 if(symlinkLevels <= 0)
2154 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2159 char linkbuf[MAX_QPATH];
2161 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2162 const char *mergeslash;
2167 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2173 // Now combine the paths...
2174 mergeslash = strrchr(filename, '/');
2175 mergestart = linkbuf;
2177 mergeslash = filename;
2178 while(!strncmp(mergestart, "../", 3))
2181 while(mergeslash > filename)
2184 if(*mergeslash == '/')
2188 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2189 if(mergeslash == filename)
2191 // Either mergeslash == filename, then we just replace the name (done below)
2195 // Or, we append the name after mergeslash;
2196 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2197 int spaceNeeded = mergeslash - filename + 1;
2198 int spaceRemoved = mergestart - linkbuf;
2199 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2201 Con_DPrintf("symlink: too long path rejected\n");
2204 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2205 memcpy(linkbuf, filename, spaceNeeded);
2206 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2207 mergestart = linkbuf;
2209 if (!quiet && developer_loading.integer)
2210 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2211 if(FS_CheckNastyPath (mergestart, false))
2213 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2216 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2220 return FS_OpenPackedFile (search->pack, pack_ind);
2225 =============================================================================
2227 MAIN PUBLIC FUNCTIONS
2229 =============================================================================
2233 ====================
2236 Open a file in the userpath. The syntax is the same as fopen
2237 Used for savegame scanning in menu, and all file writing.
2238 ====================
2240 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2242 char real_path [MAX_OSPATH];
2244 if (FS_CheckNastyPath(filepath, false))
2246 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2250 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2252 // If the file is opened in "write", "append", or "read/write" mode,
2253 // create directories up to the file.
2254 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2255 FS_CreatePath (real_path);
2256 return FS_SysOpen (real_path, mode, false);
2261 ====================
2264 Open a file. The syntax is the same as fopen
2265 ====================
2267 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2269 if (FS_CheckNastyPath(filepath, false))
2271 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2275 return FS_OpenReadFile (filepath, quiet, false, 16);
2280 ====================
2283 Open a file. The syntax is the same as fopen
2284 ====================
2286 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2289 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2290 memset (file, 0, sizeof (*file));
2291 file->flags = QFILE_FLAG_DATA;
2293 file->real_length = size;
2299 ====================
2303 ====================
2305 int FS_Close (qfile_t* file)
2307 if(file->flags & QFILE_FLAG_DATA)
2313 if (close (file->handle))
2318 qz_inflateEnd (&file->ztk->zstream);
2319 Mem_Free (file->ztk);
2328 ====================
2331 Write "datasize" bytes into a file
2332 ====================
2334 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2338 // If necessary, seek to the exact file position we're supposed to be
2339 if (file->buff_ind != file->buff_len)
2340 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2342 // Purge cached data
2345 // Write the buffer and update the position
2346 result = write (file->handle, data, (fs_offset_t)datasize);
2347 file->position = lseek (file->handle, 0, SEEK_CUR);
2348 if (file->real_length < file->position)
2349 file->real_length = file->position;
2359 ====================
2362 Read up to "buffersize" bytes from a file
2363 ====================
2365 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2367 fs_offset_t count, done;
2369 if (buffersize == 0)
2372 // Get rid of the ungetc character
2373 if (file->ungetc != EOF)
2375 ((char*)buffer)[0] = file->ungetc;
2383 if(file->flags & QFILE_FLAG_DATA)
2385 size_t left = file->real_length - file->position;
2386 if(buffersize > left)
2388 memcpy(buffer, file->data + file->position, buffersize);
2389 file->position += buffersize;
2393 // First, we copy as many bytes as we can from "buff"
2394 if (file->buff_ind < file->buff_len)
2396 count = file->buff_len - file->buff_ind;
2397 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2399 memcpy (buffer, &file->buff[file->buff_ind], count);
2400 file->buff_ind += count;
2402 buffersize -= count;
2403 if (buffersize == 0)
2407 // NOTE: at this point, the read buffer is always empty
2409 // If the file isn't compressed
2410 if (! (file->flags & QFILE_FLAG_DEFLATED))
2414 // We must take care to not read after the end of the file
2415 count = file->real_length - file->position;
2417 // If we have a lot of data to get, put them directly into "buffer"
2418 if (buffersize > sizeof (file->buff) / 2)
2420 if (count > (fs_offset_t)buffersize)
2421 count = (fs_offset_t)buffersize;
2422 lseek (file->handle, file->offset + file->position, SEEK_SET);
2423 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2427 file->position += nb;
2429 // Purge cached data
2435 if (count > (fs_offset_t)sizeof (file->buff))
2436 count = (fs_offset_t)sizeof (file->buff);
2437 lseek (file->handle, file->offset + file->position, SEEK_SET);
2438 nb = read (file->handle, file->buff, count);
2441 file->buff_len = nb;
2442 file->position += nb;
2444 // Copy the requested data in "buffer" (as much as we can)
2445 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2446 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2447 file->buff_ind = count;
2455 // If the file is compressed, it's more complicated...
2456 // We cycle through a few operations until we have read enough data
2457 while (buffersize > 0)
2459 ztoolkit_t *ztk = file->ztk;
2462 // NOTE: at this point, the read buffer is always empty
2464 // If "input" is also empty, we need to refill it
2465 if (ztk->in_ind == ztk->in_len)
2467 // If we are at the end of the file
2468 if (file->position == file->real_length)
2471 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2472 if (count > (fs_offset_t)sizeof (ztk->input))
2473 count = (fs_offset_t)sizeof (ztk->input);
2474 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2475 if (read (file->handle, ztk->input, count) != count)
2477 Con_Printf ("FS_Read: unexpected end of file\n");
2482 ztk->in_len = count;
2483 ztk->in_position += count;
2486 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2487 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2489 // Now that we are sure we have compressed data available, we need to determine
2490 // if it's better to inflate it in "file->buff" or directly in "buffer"
2492 // Inflate the data in "file->buff"
2493 if (buffersize < sizeof (file->buff) / 2)
2495 ztk->zstream.next_out = file->buff;
2496 ztk->zstream.avail_out = sizeof (file->buff);
2497 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2498 if (error != Z_OK && error != Z_STREAM_END)
2500 Con_Printf ("FS_Read: Can't inflate file\n");
2503 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2505 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2506 file->position += file->buff_len;
2508 // Copy the requested data in "buffer" (as much as we can)
2509 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2510 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2511 file->buff_ind = count;
2514 // Else, we inflate directly in "buffer"
2517 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2518 ztk->zstream.avail_out = (unsigned int)buffersize;
2519 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2520 if (error != Z_OK && error != Z_STREAM_END)
2522 Con_Printf ("FS_Read: Can't inflate file\n");
2525 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2527 // How much data did it inflate?
2528 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2529 file->position += count;
2531 // Purge cached data
2536 buffersize -= count;
2544 ====================
2547 Print a string into a file
2548 ====================
2550 int FS_Print (qfile_t* file, const char *msg)
2552 return (int)FS_Write (file, msg, strlen (msg));
2556 ====================
2559 Print a string into a file
2560 ====================
2562 int FS_Printf(qfile_t* file, const char* format, ...)
2567 va_start (args, format);
2568 result = FS_VPrintf (file, format, args);
2576 ====================
2579 Print a string into a file
2580 ====================
2582 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2585 fs_offset_t buff_size = MAX_INPUTLINE;
2590 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2591 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2592 if (len >= 0 && len < buff_size)
2594 Mem_Free (tempbuff);
2598 len = write (file->handle, tempbuff, len);
2599 Mem_Free (tempbuff);
2606 ====================
2609 Get the next character of a file
2610 ====================
2612 int FS_Getc (qfile_t* file)
2616 if (FS_Read (file, &c, 1) != 1)
2624 ====================
2627 Put a character back into the read buffer (only supports one character!)
2628 ====================
2630 int FS_UnGetc (qfile_t* file, unsigned char c)
2632 // If there's already a character waiting to be read
2633 if (file->ungetc != EOF)
2642 ====================
2645 Move the position index in a file
2646 ====================
2648 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2651 unsigned char* buffer;
2652 fs_offset_t buffersize;
2654 // Compute the file offset
2658 offset += file->position - file->buff_len + file->buff_ind;
2665 offset += file->real_length;
2671 if (offset < 0 || offset > file->real_length)
2674 if(file->flags & QFILE_FLAG_DATA)
2676 file->position = offset;
2680 // If we have the data in our read buffer, we don't need to actually seek
2681 if (file->position - file->buff_len <= offset && offset <= file->position)
2683 file->buff_ind = offset + file->buff_len - file->position;
2687 // Purge cached data
2690 // Unpacked or uncompressed files can seek directly
2691 if (! (file->flags & QFILE_FLAG_DEFLATED))
2693 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2695 file->position = offset;
2699 // Seeking in compressed files is more a hack than anything else,
2700 // but we need to support it, so here we go.
2703 // If we have to go back in the file, we need to restart from the beginning
2704 if (offset <= file->position)
2708 ztk->in_position = 0;
2710 lseek (file->handle, file->offset, SEEK_SET);
2712 // Reset the Zlib stream
2713 ztk->zstream.next_in = ztk->input;
2714 ztk->zstream.avail_in = 0;
2715 qz_inflateReset (&ztk->zstream);
2718 // We need a big buffer to force inflating into it directly
2719 buffersize = 2 * sizeof (file->buff);
2720 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2722 // Skip all data until we reach the requested offset
2723 while (offset > file->position)
2725 fs_offset_t diff = offset - file->position;
2726 fs_offset_t count, len;
2728 count = (diff > buffersize) ? buffersize : diff;
2729 len = FS_Read (file, buffer, count);
2743 ====================
2746 Give the current position in a file
2747 ====================
2749 fs_offset_t FS_Tell (qfile_t* file)
2751 return file->position - file->buff_len + file->buff_ind;
2756 ====================
2759 Give the total size of a file
2760 ====================
2762 fs_offset_t FS_FileSize (qfile_t* file)
2764 return file->real_length;
2769 ====================
2772 Erases any buffered input or output data
2773 ====================
2775 void FS_Purge (qfile_t* file)
2787 Filename are relative to the quake directory.
2788 Always appends a 0 byte.
2791 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2794 unsigned char *buf = NULL;
2795 fs_offset_t filesize = 0;
2797 file = FS_OpenVirtualFile(path, quiet);
2800 filesize = file->real_length;
2803 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2808 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2809 buf[filesize] = '\0';
2810 FS_Read (file, buf, filesize);
2812 if (developer_loadfile.integer)
2813 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2816 if (filesizepointer)
2817 *filesizepointer = filesize;
2826 The filename will be prefixed by the current game directory
2829 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2833 file = FS_OpenRealFile(filename, "wb", false);
2836 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2840 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2841 FS_Write (file, data, len);
2848 =============================================================================
2850 OTHERS PUBLIC FUNCTIONS
2852 =============================================================================
2860 void FS_StripExtension (const char *in, char *out, size_t size_out)
2868 while ((currentchar = *in) && size_out > 1)
2870 if (currentchar == '.')
2872 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2874 *out++ = currentchar;
2890 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2894 // if path doesn't have a .EXT, append extension
2895 // (extension should include the .)
2896 src = path + strlen(path) - 1;
2898 while (*src != '/' && src != path)
2901 return; // it has an extension
2905 strlcat (path, extension, size_path);
2913 Look for a file in the packages and in the filesystem
2916 int FS_FileType (const char *filename)
2918 searchpath_t *search;
2919 char fullpath[MAX_OSPATH];
2921 search = FS_FindFile (filename, NULL, true);
2923 return FS_FILETYPE_NONE;
2925 if(search->pack && !search->pack->vpack)
2926 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2928 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2929 return FS_SysFileType(fullpath);
2937 Look for a file in the packages and in the filesystem
2940 qboolean FS_FileExists (const char *filename)
2942 return (FS_FindFile (filename, NULL, true) != NULL);
2950 Look for a file in the filesystem only
2953 int FS_SysFileType (const char *path)
2956 // Sajt - some older sdks are missing this define
2957 # ifndef INVALID_FILE_ATTRIBUTES
2958 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
2961 DWORD result = GetFileAttributes(path);
2963 if(result == INVALID_FILE_ATTRIBUTES)
2964 return FS_FILETYPE_NONE;
2966 if(result & FILE_ATTRIBUTE_DIRECTORY)
2967 return FS_FILETYPE_DIRECTORY;
2969 return FS_FILETYPE_FILE;
2973 if (stat (path,&buf) == -1)
2974 return FS_FILETYPE_NONE;
2977 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
2979 if(S_ISDIR(buf.st_mode))
2980 return FS_FILETYPE_DIRECTORY;
2982 return FS_FILETYPE_FILE;
2986 qboolean FS_SysFileExists (const char *path)
2988 return FS_SysFileType (path) != FS_FILETYPE_NONE;
2991 void FS_mkdir (const char *path)
3004 Allocate and fill a search structure with information on matching filenames.
3007 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3010 searchpath_t *searchpath;
3012 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3013 stringlist_t resultlist;
3014 stringlist_t dirlist;
3015 const char *slash, *backslash, *colon, *separator;
3017 char temp[MAX_OSPATH];
3019 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3024 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3028 stringlistinit(&resultlist);
3029 stringlistinit(&dirlist);
3031 slash = strrchr(pattern, '/');
3032 backslash = strrchr(pattern, '\\');
3033 colon = strrchr(pattern, ':');
3034 separator = max(slash, backslash);
3035 separator = max(separator, colon);
3036 basepathlength = separator ? (separator + 1 - pattern) : 0;
3037 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3039 memcpy(basepath, pattern, basepathlength);
3040 basepath[basepathlength] = 0;
3042 // search through the path, one element at a time
3043 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3045 // is the element a pak file?
3046 if (searchpath->pack && !searchpath->pack->vpack)
3048 // look through all the pak file elements
3049 pak = searchpath->pack;
3050 for (i = 0;i < pak->numfiles;i++)
3052 strlcpy(temp, pak->files[i].name, sizeof(temp));
3055 if (matchpattern(temp, (char *)pattern, true))
3057 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3058 if (!strcmp(resultlist.strings[resultlistindex], temp))
3060 if (resultlistindex == resultlist.numstrings)
3062 stringlistappend(&resultlist, temp);
3063 if (!quiet && developer_loading.integer)
3064 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3067 // strip off one path element at a time until empty
3068 // this way directories are added to the listing if they match the pattern
3069 slash = strrchr(temp, '/');
3070 backslash = strrchr(temp, '\\');
3071 colon = strrchr(temp, ':');
3073 if (separator < slash)
3075 if (separator < backslash)
3076 separator = backslash;
3077 if (separator < colon)
3079 *((char *)separator) = 0;
3085 stringlist_t matchedSet, foundSet;
3086 const char *start = pattern;
3088 stringlistinit(&matchedSet);
3089 stringlistinit(&foundSet);
3090 // add a first entry to the set
3091 stringlistappend(&matchedSet, "");
3092 // iterate through pattern's path
3095 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3096 char subpath[MAX_OSPATH];
3097 char subpattern[MAX_OSPATH];
3099 // find the next wildcard
3100 wildcard = strchr(start, '?');
3101 asterisk = strchr(start, '*');
3102 if (asterisk && (!wildcard || asterisk < wildcard))
3104 wildcard = asterisk;
3109 nextseparator = strchr( wildcard, '/' );
3113 nextseparator = NULL;
3116 if( !nextseparator ) {
3117 nextseparator = start + strlen( start );
3120 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3121 // copy everything up except nextseperator
3122 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3123 // find the last '/' before the wildcard
3124 prevseparator = strrchr( subpattern, '/' );
3126 prevseparator = subpattern;
3129 // copy everything from start to the previous including the '/' (before the wildcard)
3130 // everything up to start is already included in the path of matchedSet's entries
3131 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3133 // for each entry in matchedSet try to open the subdirectories specified in subpath
3134 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3135 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3136 strlcat( temp, subpath, sizeof(temp) );
3137 listdirectory( &foundSet, searchpath->filename, temp );
3139 if( dirlistindex == 0 ) {
3142 // reset the current result set
3143 stringlistfreecontents( &matchedSet );
3144 // match against the pattern
3145 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3146 const char *direntry = foundSet.strings[ dirlistindex ];
3147 if (matchpattern(direntry, subpattern, true)) {
3148 stringlistappend( &matchedSet, direntry );
3151 stringlistfreecontents( &foundSet );
3153 start = nextseparator;
3156 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3158 const char *temp = matchedSet.strings[dirlistindex];
3159 if (matchpattern(temp, (char *)pattern, true))
3161 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3162 if (!strcmp(resultlist.strings[resultlistindex], temp))
3164 if (resultlistindex == resultlist.numstrings)
3166 stringlistappend(&resultlist, temp);
3167 if (!quiet && developer_loading.integer)
3168 Con_Printf("SearchDirFile: %s\n", temp);
3172 stringlistfreecontents( &matchedSet );
3176 if (resultlist.numstrings)
3178 stringlistsort(&resultlist);
3179 numfiles = resultlist.numstrings;
3181 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3182 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3183 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3184 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3185 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3186 search->numfilenames = (int)numfiles;
3189 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3192 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3193 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3194 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3196 numchars += (int)textlen;
3199 stringlistfreecontents(&resultlist);
3205 void FS_FreeSearch(fssearch_t *search)
3210 extern int con_linewidth;
3211 int FS_ListDirectory(const char *pattern, int oneperline)
3220 char linebuf[MAX_INPUTLINE];
3222 search = FS_Search(pattern, true, true);
3225 numfiles = search->numfilenames;
3228 // FIXME: the names could be added to one column list and then
3229 // gradually shifted into the next column if they fit, and then the
3230 // next to make a compact variable width listing but it's a lot more
3232 // find width for columns
3234 for (i = 0;i < numfiles;i++)
3236 l = (int)strlen(search->filenames[i]);
3237 if (columnwidth < l)
3240 // count the spacing character
3242 // calculate number of columns
3243 numcolumns = con_linewidth / columnwidth;
3244 // don't bother with the column printing if it's only one column
3245 if (numcolumns >= 2)
3247 numlines = (numfiles + numcolumns - 1) / numcolumns;
3248 for (i = 0;i < numlines;i++)
3251 for (k = 0;k < numcolumns;k++)
3253 l = i * numcolumns + k;
3256 name = search->filenames[l];
3257 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3258 linebuf[linebufpos++] = name[j];
3259 // space out name unless it's the last on the line
3260 if (k + 1 < numcolumns && l + 1 < numfiles)
3261 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3262 linebuf[linebufpos++] = ' ';
3265 linebuf[linebufpos] = 0;
3266 Con_Printf("%s\n", linebuf);
3273 for (i = 0;i < numfiles;i++)
3274 Con_Printf("%s\n", search->filenames[i]);
3275 FS_FreeSearch(search);
3276 return (int)numfiles;
3279 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3281 const char *pattern;
3284 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3287 if (Cmd_Argc() == 2)
3288 pattern = Cmd_Argv(1);
3291 if (!FS_ListDirectory(pattern, oneperline))
3292 Con_Print("No files found.\n");
3297 FS_ListDirectoryCmd("dir", true);
3302 FS_ListDirectoryCmd("ls", false);
3305 void FS_Which_f(void)
3307 const char *filename;
3310 if (Cmd_Argc() != 2)
3312 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3315 filename = Cmd_Argv(1);
3316 sp = FS_FindFile(filename, &index, true);
3318 Con_Printf("%s isn't anywhere\n", filename);
3324 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3326 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3329 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3333 const char *FS_WhichPack(const char *filename)
3336 searchpath_t *sp = FS_FindFile(filename, &index, true);
3338 return sp->pack->shortname;
3344 ====================
3345 FS_IsRegisteredQuakePack
3347 Look for a proof of purchase file file in the requested package
3349 If it is found, this file should NOT be downloaded.
3350 ====================
3352 qboolean FS_IsRegisteredQuakePack(const char *name)
3354 searchpath_t *search;
3357 // search through the path, one element at a time
3358 for (search = fs_searchpaths;search;search = search->next)
3360 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3361 // TODO do we want to support vpacks in here too?
3363 int (*strcmp_funct) (const char* str1, const char* str2);
3364 int left, right, middle;
3367 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3369 // Look for the file (binary search)
3371 right = pak->numfiles - 1;
3372 while (left <= right)
3376 middle = (left + right) / 2;
3377 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3383 // If we're too far in the list
3390 // we found the requested pack but it is not registered quake
3398 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3401 unsigned char *filedata;
3402 fs_offset_t filesize;
3403 if (filesizepointer)
3404 *filesizepointer = 0;
3405 if (!filename || !*filename)
3407 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3410 if (filesizepointer)
3411 *filesizepointer = filesize;
3412 crc = CRC_Block(filedata, filesize);
3418 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3421 unsigned char *out = NULL;
3425 #ifndef LINK_TO_ZLIB
3430 memset(&strm, 0, sizeof(strm));
3431 strm.zalloc = Z_NULL;
3432 strm.zfree = Z_NULL;
3433 strm.opaque = Z_NULL;
3436 level = Z_DEFAULT_COMPRESSION;
3438 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3440 Con_Printf("FS_Deflate: deflate init error!\n");
3444 strm.next_in = (unsigned char*)data;
3445 strm.avail_in = size;
3447 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3450 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3451 qz_deflateEnd(&strm);
3455 strm.next_out = tmp;
3456 strm.avail_out = size;
3458 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3460 Con_Printf("FS_Deflate: deflate failed!\n");
3461 qz_deflateEnd(&strm);
3466 if(qz_deflateEnd(&strm) != Z_OK)
3468 Con_Printf("FS_Deflate: deflateEnd failed\n");
3473 if(strm.total_out >= size)
3475 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3480 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3483 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3489 *deflated_size = (size_t)strm.total_out;
3491 memcpy(out, tmp, strm.total_out);
3497 static void AssertBufsize(sizebuf_t *buf, int length)
3499 if(buf->cursize + length > buf->maxsize)
3501 int oldsize = buf->maxsize;
3502 unsigned char *olddata;
3503 olddata = buf->data;
3504 buf->maxsize += length;
3505 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3508 memcpy(buf->data, olddata, oldsize);
3514 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3518 unsigned char *out = NULL;
3519 unsigned char tmp[2048];
3524 #ifndef LINK_TO_ZLIB
3529 memset(&outbuf, 0, sizeof(outbuf));
3530 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3531 outbuf.maxsize = sizeof(tmp);
3533 memset(&strm, 0, sizeof(strm));
3534 strm.zalloc = Z_NULL;
3535 strm.zfree = Z_NULL;
3536 strm.opaque = Z_NULL;
3538 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3540 Con_Printf("FS_Inflate: inflate init error!\n");
3541 Mem_Free(outbuf.data);
3545 strm.next_in = (unsigned char*)data;
3546 strm.avail_in = size;
3550 strm.next_out = tmp;
3551 strm.avail_out = sizeof(tmp);
3552 ret = qz_inflate(&strm, Z_NO_FLUSH);
3553 // it either returns Z_OK on progress, Z_STREAM_END on end
3561 case Z_STREAM_ERROR:
3562 Con_Print("FS_Inflate: stream error!\n");
3565 Con_Print("FS_Inflate: data error!\n");
3568 Con_Print("FS_Inflate: mem error!\n");
3571 Con_Print("FS_Inflate: buf error!\n");
3574 Con_Print("FS_Inflate: unknown error!\n");
3578 if(ret != Z_OK && ret != Z_STREAM_END)
3580 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3581 Mem_Free(outbuf.data);
3582 qz_inflateEnd(&strm);
3585 have = sizeof(tmp) - strm.avail_out;
3586 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3587 SZ_Write(&outbuf, tmp, have);
3588 } while(ret != Z_STREAM_END);
3590 qz_inflateEnd(&strm);
3592 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3595 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3596 Mem_Free(outbuf.data);
3600 memcpy(out, outbuf.data, outbuf.cursize);
3601 Mem_Free(outbuf.data);
3604 *inflated_size = (size_t)outbuf.cursize;