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
283 /// Search paths for files (including packages)
284 typedef struct searchpath_s
286 // only one of filename / pack will be used
287 char filename[MAX_OSPATH];
289 const char *vpack; // points into filename where the pack short name starts
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)
861 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
863 Con_Printf("%s (virtual pack)\n", s->filename);
865 Con_Printf("%s\n", s->filename);
875 /*! Takes an explicit (not game tree related) path to a pak file.
876 *Loads the header and directory, adding the files at the beginning
877 *of the list so they override previous pack files.
879 pack_t *FS_LoadPackPAK (const char *packfile)
881 dpackheader_t header;
888 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
890 packhandle = open (packfile, O_RDONLY | O_BINARY);
894 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
896 Con_Printf ("%s is not a packfile\n", packfile);
900 if (memcmp(header.id, "PACK", 4))
902 Con_Printf ("%s is not a packfile\n", packfile);
906 header.dirofs = LittleLong (header.dirofs);
907 header.dirlen = LittleLong (header.dirlen);
909 if (header.dirlen % sizeof(dpackfile_t))
911 Con_Printf ("%s has an invalid directory size\n", packfile);
916 numpackfiles = header.dirlen / sizeof(dpackfile_t);
918 if (numpackfiles > MAX_FILES_IN_PACK)
920 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
925 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
926 lseek (packhandle, header.dirofs, SEEK_SET);
927 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
929 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
935 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
936 pack->ignorecase = false; // PAK is case sensitive
937 strlcpy (pack->filename, packfile, sizeof (pack->filename));
938 pack->handle = packhandle;
940 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
942 // parse the directory
943 for (i = 0;i < numpackfiles;i++)
945 fs_offset_t offset = LittleLong (info[i].filepos);
946 fs_offset_t size = LittleLong (info[i].filelen);
948 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
953 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
962 /*! Adds the given pack to the search path.
963 * The pack type is autodetected by the file extension.
965 * Returns true if the file was successfully added to the
966 * search path or if it was already included.
968 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
972 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
974 searchpath_t *search;
976 qboolean fakepack = true;
977 const char *ext = FS_FileExtension(pakfile);
979 for(search = fs_searchpaths; search; search = search->next)
981 if(search->pack ? !strcasecmp(search->pack->filename, pakfile) : (search->vpack && !strcasecmp(search->filename, pakfile)))
984 *already_loaded = true;
985 return true; // already loaded
990 *already_loaded = false;
992 if(FS_SysFileType(pakfile) == FS_FILETYPE_DIRECTORY)
995 Con_DPrintf("Added packfile %s (virtual pack)\n", pakfile);
997 else if(!strcasecmp(ext, "pak"))
998 pak = FS_LoadPackPAK (pakfile);
999 else if(!strcasecmp(ext, "pk3"))
1000 pak = FS_LoadPackPK3 (pakfile);
1002 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1006 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1007 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1010 // find the first item whose next one is a pack or NULL
1011 searchpath_t *insertion_point = 0;
1012 if(fs_searchpaths && !fs_searchpaths->pack)
1014 insertion_point = fs_searchpaths;
1017 if(!insertion_point->next)
1019 if(insertion_point->next->vpack)
1021 insertion_point = insertion_point->next;
1024 // If insertion_point is NULL, this means that either there is no
1025 // item in the list yet, or that the very first item is a pack. In
1026 // that case, we want to insert at the beginning...
1027 if(!insertion_point)
1029 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1030 search->next = fs_searchpaths;
1031 fs_searchpaths = search;
1034 // otherwise we want to append directly after insertion_point.
1036 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1037 search->next = insertion_point->next;
1038 insertion_point->next = search;
1043 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1044 search->next = fs_searchpaths;
1045 fs_searchpaths = search;
1050 strlcpy(search->filename, pakfile, sizeof(search->filename));
1051 if(strlen(search->filename) >= strlen(shortname))
1052 search->vpack = search->filename + strlen(search->filename) - strlen(shortname);
1054 search->vpack = search->filename;
1057 search->vpack = search->pack->shortname;
1062 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1073 /*! Adds the given pack to the search path and searches for it in the game path.
1074 * The pack type is autodetected by the file extension.
1076 * Returns true if the file was successfully added to the
1077 * search path or if it was already included.
1079 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1080 * plain directories.
1082 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1084 char fullpath[MAX_OSPATH];
1086 searchpath_t *search;
1089 *already_loaded = false;
1091 // then find the real name...
1092 search = FS_FindFile(pakfile, &index, true);
1093 if(!search || search->vpack)
1095 Con_Printf("could not find pak \"%s\"\n", pakfile);
1099 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1101 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1109 Sets fs_gamedir, adds the directory to the head of the path,
1110 then loads and adds pak1.pak pak2.pak ...
1113 void FS_AddGameDirectory (const char *dir)
1117 searchpath_t *search;
1119 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1121 stringlistinit(&list);
1122 listdirectory(&list, "", dir);
1123 stringlistsort(&list);
1125 // add any PAK package in the directory
1126 for (i = 0;i < list.numstrings;i++)
1128 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1130 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1134 // add any PK3 package in the directory
1135 for (i = 0;i < list.numstrings;i++)
1137 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
1139 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1143 stringlistfreecontents(&list);
1145 // Add the directory to the search path
1146 // (unpacked files have the priority over packed files)
1147 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1148 strlcpy (search->filename, dir, sizeof (search->filename));
1149 search->next = fs_searchpaths;
1150 fs_searchpaths = search;
1159 void FS_AddGameHierarchy (const char *dir)
1161 // Add the common game directory
1162 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1165 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1174 const char *FS_FileExtension (const char *in)
1176 const char *separator, *backslash, *colon, *dot;
1178 separator = strrchr(in, '/');
1179 backslash = strrchr(in, '\\');
1180 if (!separator || separator < backslash)
1181 separator = backslash;
1182 colon = strrchr(in, ':');
1183 if (!separator || separator < colon)
1186 dot = strrchr(in, '.');
1187 if (dot == NULL || (separator && (dot < separator)))
1199 const char *FS_FileWithoutPath (const char *in)
1201 const char *separator, *backslash, *colon;
1203 separator = strrchr(in, '/');
1204 backslash = strrchr(in, '\\');
1205 if (!separator || separator < backslash)
1206 separator = backslash;
1207 colon = strrchr(in, ':');
1208 if (!separator || separator < colon)
1210 return separator ? separator + 1 : in;
1219 void FS_ClearSearchPath (void)
1221 // unload all packs and directory information, close all pack files
1222 // (if a qfile is still reading a pack it won't be harmed because it used
1223 // dup() to get its own handle already)
1224 while (fs_searchpaths)
1226 searchpath_t *search = fs_searchpaths;
1227 fs_searchpaths = search->next;
1231 close(search->pack->handle);
1232 // free any memory associated with it
1233 if (search->pack->files)
1234 Mem_Free(search->pack->files);
1235 Mem_Free(search->pack);
1247 void FS_Rescan (void)
1250 qboolean fs_modified = false;
1251 char gamedirbuf[MAX_INPUTLINE];
1253 FS_ClearSearchPath();
1255 // add the game-specific paths
1256 // gamedirname1 (typically id1)
1257 FS_AddGameHierarchy (gamedirname1);
1258 // update the com_modname (used for server info)
1259 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1261 // add the game-specific path, if any
1262 // (only used for mission packs and the like, which should set fs_modified)
1266 FS_AddGameHierarchy (gamedirname2);
1270 // Adds basedir/gamedir as an override game
1271 // LordHavoc: now supports multiple -game directories
1272 // set the com_modname (reported in server info)
1274 for (i = 0;i < fs_numgamedirs;i++)
1277 FS_AddGameHierarchy (fs_gamedirs[i]);
1278 // update the com_modname (used server info)
1279 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1281 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1283 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1285 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1287 // set the default screenshot name to either the mod name or the
1288 // gamemode screenshot name
1289 if (strcmp(com_modname, gamedirname1))
1290 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1292 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1294 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1295 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1297 // If "-condebug" is in the command line, remove the previous log file
1298 if (COM_CheckParm ("-condebug") != 0)
1299 unlink (va("%s/qconsole.log", fs_gamedir));
1301 // look for the pop.lmp file and set registered to true if it is found
1302 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1305 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1307 Con_Print("Playing shareware version.\n");
1311 Cvar_Set ("registered", "1");
1312 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1313 Con_Print("Playing registered version.\n");
1316 // unload all wads so that future queries will return the new data
1320 void FS_Rescan_f(void)
1330 extern void Host_SaveConfig (void);
1331 extern void Host_LoadConfig_f (void);
1332 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1337 if (fs_numgamedirs == numgamedirs)
1339 for (i = 0;i < numgamedirs;i++)
1340 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1342 if (i == numgamedirs)
1343 return true; // already using this set of gamedirs, do nothing
1346 if (numgamedirs > MAX_GAMEDIRS)
1349 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1350 return false; // too many gamedirs
1353 for (i = 0;i < numgamedirs;i++)
1355 // if string is nasty, reject it
1356 p = FS_CheckGameDir(gamedirs[i]);
1360 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1361 return false; // nasty gamedirs
1363 if(p == fs_checkgamedir_missing && failmissing)
1366 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1367 return false; // missing gamedirs
1373 fs_numgamedirs = numgamedirs;
1374 for (i = 0;i < fs_numgamedirs;i++)
1375 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1377 // reinitialize filesystem to detect the new paks
1380 // exec the new config
1381 Host_LoadConfig_f();
1383 // unload all sounds so they will be reloaded from the new files as needed
1384 S_UnloadAllSounds_f();
1386 // reinitialize renderer (this reloads hud/console background/etc)
1387 R_Modules_Restart();
1397 void FS_GameDir_f (void)
1401 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1405 Con_Printf("gamedirs active:");
1406 for (i = 0;i < fs_numgamedirs;i++)
1407 Con_Printf(" %s", fs_gamedirs[i]);
1412 numgamedirs = Cmd_Argc() - 1;
1413 if (numgamedirs > MAX_GAMEDIRS)
1415 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1419 for (i = 0;i < numgamedirs;i++)
1420 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1422 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1424 // actually, changing during game would work fine, but would be stupid
1425 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1429 // halt demo playback to close the file
1432 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1435 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking);
1436 static const char *FS_SysCheckGameDir(const char *gamedir)
1438 static char buf[8192];
1444 stringlistinit(&list);
1445 listdirectory(&list, gamedir, "");
1446 success = list.numstrings > 0;
1447 stringlistfreecontents(&list);
1451 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1454 n = FS_Read (f, buf, sizeof(buf) - 1);
1474 const char *FS_CheckGameDir(const char *gamedir)
1478 if (FS_CheckNastyPath(gamedir, true))
1481 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1486 // get description from basedir
1487 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1495 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1499 return fs_checkgamedir_missing;
1502 static void FS_ListGameDirs(void)
1504 stringlist_t list, list2;
1508 fs_all_gamedirs_count = 0;
1510 Mem_Free(fs_all_gamedirs);
1512 stringlistinit(&list);
1513 listdirectory(&list, va("%s/", fs_basedir), "");
1514 listdirectory(&list, va("%s/", fs_userdir), "");
1515 stringlistsort(&list);
1517 stringlistinit(&list2);
1518 for(i = 0; i < list.numstrings; ++i)
1521 if(!strcmp(list.strings[i-1], list.strings[i]))
1523 info = FS_CheckGameDir(list.strings[i]);
1526 if(info == fs_checkgamedir_missing)
1530 stringlistappend(&list2, list.strings[i]);
1532 stringlistfreecontents(&list);
1534 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1535 for(i = 0; i < list2.numstrings; ++i)
1537 info = FS_CheckGameDir(list2.strings[i]);
1538 // all this cannot happen any more, but better be safe than sorry
1541 if(info == fs_checkgamedir_missing)
1545 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1546 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1547 ++fs_all_gamedirs_count;
1561 TCHAR mydocsdir[MAX_PATH + 1];
1562 #if _MSC_VER >= 1400
1569 const char* dllnames [] =
1571 "shfolder.dll", // IE 4, or Win NT and higher
1574 Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1575 // don't care for the result; if it fails, %USERPROFILE% will be used instead
1578 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1580 // Add the personal game directory
1581 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1583 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1585 else if(COM_CheckParm("-nohome"))
1592 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1594 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1595 Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1599 // use the environment
1600 #if _MSC_VER >= 1400
1601 _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1603 homedir = getenv("USERPROFILE");
1608 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1609 #if _MSC_VER >= 1400
1612 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1617 Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1619 homedir = getenv ("HOME");
1621 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1624 Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1628 if(!COM_CheckParm("-mygames"))
1630 #if _MSC_VER >= 1400
1632 _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!
1634 int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1639 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1645 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1647 // If the base directory is explicitly defined by the compilation process
1648 #ifdef DP_FS_BASEDIR
1649 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1654 // FIXME: is there a better way to find the directory outside the .app?
1655 if (strstr(com_argv[0], ".app/"))
1659 split = strstr(com_argv[0], ".app/");
1660 while (split > com_argv[0] && *split != '/')
1662 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1663 fs_basedir[split - com_argv[0]] = 0;
1671 // Overrides the system supplied base directory (under GAMENAME)
1672 // 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)
1673 i = COM_CheckParm ("-basedir");
1674 if (i && i < com_argc-1)
1676 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1677 i = (int)strlen (fs_basedir);
1678 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1679 fs_basedir[i-1] = 0;
1682 // add a path separator to the end of the basedir if it lacks one
1683 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1684 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1688 p = FS_CheckGameDir(gamedirname1);
1689 if(!p || p == fs_checkgamedir_missing)
1690 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1694 p = FS_CheckGameDir(gamedirname2);
1695 if(!p || p == fs_checkgamedir_missing)
1696 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1700 // Adds basedir/gamedir as an override game
1701 // LordHavoc: now supports multiple -game directories
1702 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1706 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1709 p = FS_CheckGameDir(com_argv[i]);
1711 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1712 if(p == fs_checkgamedir_missing)
1713 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1714 // add the gamedir to the list of active gamedirs
1715 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1720 // generate the searchpath
1724 void FS_Init_Commands(void)
1726 Cvar_RegisterVariable (&scr_screenshot_name);
1727 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1728 Cvar_RegisterVariable (&cvar_fs_gamedir);
1730 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1731 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1732 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1733 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1734 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1735 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1743 void FS_Shutdown (void)
1745 // close all pack files and such
1746 // (hopefully there aren't any other open files, but they'll be cleaned up
1747 // by the OS anyway)
1748 FS_ClearSearchPath();
1749 Mem_FreePool (&fs_mempool);
1752 Sys_UnloadLibrary (&shfolder_dll);
1757 ====================
1760 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1761 ====================
1763 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1769 // Parse the mode string
1778 opt = O_CREAT | O_TRUNC;
1782 opt = O_CREAT | O_APPEND;
1785 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1788 for (ind = 1; mode[ind] != '\0'; ind++)
1799 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1800 filepath, mode, mode[ind]);
1807 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1808 memset (file, 0, sizeof (*file));
1811 #if _MSC_VER >= 1400
1812 _sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1814 file->handle = open (filepath, mod | opt, 0666);
1816 if (file->handle < 0)
1822 file->real_length = lseek (file->handle, 0, SEEK_END);
1824 // For files opened in append mode, we start at the end of the file
1826 file->position = file->real_length;
1828 lseek (file->handle, 0, SEEK_SET);
1838 Open a packed file using its package file descriptor
1841 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1847 pfile = &pack->files[pack_ind];
1849 // If we don't have the true offset, get it now
1850 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1851 if (!PK3_GetTrueFileOffset (pfile, pack))
1854 #ifndef LINK_TO_ZLIB
1855 // No Zlib DLL = no compressed files
1856 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1858 Con_Printf("WARNING: can't open the compressed file %s\n"
1859 "You need the Zlib DLL to use compressed files\n",
1865 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1866 // the dup() call to avoid having to close the dup_handle on error here
1867 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1869 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1870 pfile->name, pack->filename, (int) pfile->offset);
1874 dup_handle = dup (pack->handle);
1877 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1881 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1882 memset (file, 0, sizeof (*file));
1883 file->handle = dup_handle;
1884 file->flags = QFILE_FLAG_PACKED;
1885 file->real_length = pfile->realsize;
1886 file->offset = pfile->offset;
1890 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1894 file->flags |= QFILE_FLAG_DEFLATED;
1896 // We need some more variables
1897 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1899 ztk->comp_length = pfile->packsize;
1901 // Initialize zlib stream
1902 ztk->zstream.next_in = ztk->input;
1903 ztk->zstream.avail_in = 0;
1905 /* From Zlib's "unzip.c":
1907 * windowBits is passed < 0 to tell that there is no zlib header.
1908 * Note that in this case inflate *requires* an extra "dummy" byte
1909 * after the compressed stream in order to complete decompression and
1910 * return Z_STREAM_END.
1911 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1912 * size of both compressed and uncompressed data
1914 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1916 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1922 ztk->zstream.next_out = file->buff;
1923 ztk->zstream.avail_out = sizeof (file->buff);
1932 ====================
1935 Return true if the path should be rejected due to one of the following:
1936 1: path elements that are non-portable
1937 2: path elements that would allow access to files outside the game directory,
1938 or are just not a good idea for a mod to be using.
1939 ====================
1941 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1943 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1947 // Windows: don't allow \ in filenames (windows-only), period.
1948 // (on Windows \ is a directory separator, but / is also supported)
1949 if (strstr(path, "\\"))
1950 return 1; // non-portable
1952 // Mac: don't allow Mac-only filenames - : is a directory separator
1953 // instead of /, but we rely on / working already, so there's no reason to
1954 // support a Mac-only path
1955 // Amiga and Windows: : tries to go to root of drive
1956 if (strstr(path, ":"))
1957 return 1; // non-portable attempt to go to root of drive
1959 // Amiga: // is parent directory
1960 if (strstr(path, "//"))
1961 return 1; // non-portable attempt to go to parent directory
1963 // all: don't allow going to parent directory (../ or /../)
1964 if (strstr(path, ".."))
1965 return 2; // attempt to go outside the game directory
1967 // Windows and UNIXes: don't allow absolute paths
1969 return 2; // attempt to go outside the game directory
1971 // 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
1972 if (strchr(path, '.'))
1976 // gamedir is entirely path elements, so simply forbid . entirely
1979 if (strchr(path, '.') < strrchr(path, '/'))
1980 return 2; // possible attempt to go outside the game directory
1983 // all: forbid trailing slash on gamedir
1984 if (isgamedir && path[strlen(path)-1] == '/')
1987 // all: forbid leading dot on any filename for any reason
1988 if (strstr(path, "/."))
1989 return 2; // attempt to go outside the game directory
1991 // after all these checks we're pretty sure it's a / separated filename
1992 // and won't do much if any harm
1998 ====================
2001 Look for a file in the packages and in the filesystem
2003 Return the searchpath where the file was found (or NULL)
2004 and the file index in the package if relevant
2005 ====================
2007 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2009 searchpath_t *search;
2012 // search through the path, one element at a time
2013 for (search = fs_searchpaths;search;search = search->next)
2015 // is the element a pak file?
2018 int (*strcmp_funct) (const char* str1, const char* str2);
2019 int left, right, middle;
2022 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2024 // Look for the file (binary search)
2026 right = pak->numfiles - 1;
2027 while (left <= right)
2031 middle = (left + right) / 2;
2032 diff = strcmp_funct (pak->files[middle].name, name);
2037 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2039 // yes, but the first one is empty so we treat it as not being there
2040 if (!quiet && developer_extra.integer)
2041 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2048 if (!quiet && developer_extra.integer)
2049 Con_DPrintf("FS_FindFile: %s in %s\n",
2050 pak->files[middle].name, pak->filename);
2057 // If we're too far in the list
2066 char netpath[MAX_OSPATH];
2067 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2068 if (FS_SysFileExists (netpath))
2070 if (!quiet && developer_extra.integer)
2071 Con_DPrintf("FS_FindFile: %s\n", netpath);
2080 if (!quiet && developer_extra.integer)
2081 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2093 Look for a file in the search paths and open it in read-only mode
2096 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2098 searchpath_t *search;
2101 search = FS_FindFile (filename, &pack_ind, quiet);
2107 // Found in the filesystem?
2110 // this works with vpacks, so we are fine
2111 char path [MAX_OSPATH];
2112 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2113 return FS_SysOpen (path, "rb", nonblocking);
2116 // So, we found it in a package...
2118 // Is it a PK3 symlink?
2119 // TODO also handle directory symlinks by parsing the whole structure...
2120 // but heck, file symlinks are good enough for now
2121 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2123 if(symlinkLevels <= 0)
2125 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2130 char linkbuf[MAX_QPATH];
2132 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2133 const char *mergeslash;
2138 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2144 // Now combine the paths...
2145 mergeslash = strrchr(filename, '/');
2146 mergestart = linkbuf;
2148 mergeslash = filename;
2149 while(!strncmp(mergestart, "../", 3))
2152 while(mergeslash > filename)
2155 if(*mergeslash == '/')
2159 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2160 if(mergeslash == filename)
2162 // Either mergeslash == filename, then we just replace the name (done below)
2166 // Or, we append the name after mergeslash;
2167 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2168 int spaceNeeded = mergeslash - filename + 1;
2169 int spaceRemoved = mergestart - linkbuf;
2170 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2172 Con_DPrintf("symlink: too long path rejected\n");
2175 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2176 memcpy(linkbuf, filename, spaceNeeded);
2177 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2178 mergestart = linkbuf;
2180 if (!quiet && developer_loading.integer)
2181 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2182 if(FS_CheckNastyPath (mergestart, false))
2184 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2187 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2191 return FS_OpenPackedFile (search->pack, pack_ind);
2196 =============================================================================
2198 MAIN PUBLIC FUNCTIONS
2200 =============================================================================
2204 ====================
2207 Open a file in the userpath. The syntax is the same as fopen
2208 Used for savegame scanning in menu, and all file writing.
2209 ====================
2211 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2213 char real_path [MAX_OSPATH];
2215 if (FS_CheckNastyPath(filepath, false))
2217 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2221 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2223 // If the file is opened in "write", "append", or "read/write" mode,
2224 // create directories up to the file.
2225 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2226 FS_CreatePath (real_path);
2227 return FS_SysOpen (real_path, mode, false);
2232 ====================
2235 Open a file. The syntax is the same as fopen
2236 ====================
2238 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2240 if (FS_CheckNastyPath(filepath, false))
2242 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2246 return FS_OpenReadFile (filepath, quiet, false, 16);
2251 ====================
2254 Open a file. The syntax is the same as fopen
2255 ====================
2257 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2260 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2261 memset (file, 0, sizeof (*file));
2262 file->flags = QFILE_FLAG_DATA;
2264 file->real_length = size;
2270 ====================
2274 ====================
2276 int FS_Close (qfile_t* file)
2278 if(file->flags & QFILE_FLAG_DATA)
2284 if (close (file->handle))
2289 qz_inflateEnd (&file->ztk->zstream);
2290 Mem_Free (file->ztk);
2299 ====================
2302 Write "datasize" bytes into a file
2303 ====================
2305 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2309 // If necessary, seek to the exact file position we're supposed to be
2310 if (file->buff_ind != file->buff_len)
2311 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2313 // Purge cached data
2316 // Write the buffer and update the position
2317 result = write (file->handle, data, (fs_offset_t)datasize);
2318 file->position = lseek (file->handle, 0, SEEK_CUR);
2319 if (file->real_length < file->position)
2320 file->real_length = file->position;
2330 ====================
2333 Read up to "buffersize" bytes from a file
2334 ====================
2336 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2338 fs_offset_t count, done;
2340 if (buffersize == 0)
2343 // Get rid of the ungetc character
2344 if (file->ungetc != EOF)
2346 ((char*)buffer)[0] = file->ungetc;
2354 if(file->flags & QFILE_FLAG_DATA)
2356 size_t left = file->real_length - file->position;
2357 if(buffersize > left)
2359 memcpy(buffer, file->data + file->position, buffersize);
2360 file->position += buffersize;
2364 // First, we copy as many bytes as we can from "buff"
2365 if (file->buff_ind < file->buff_len)
2367 count = file->buff_len - file->buff_ind;
2368 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2370 memcpy (buffer, &file->buff[file->buff_ind], count);
2371 file->buff_ind += count;
2373 buffersize -= count;
2374 if (buffersize == 0)
2378 // NOTE: at this point, the read buffer is always empty
2380 // If the file isn't compressed
2381 if (! (file->flags & QFILE_FLAG_DEFLATED))
2385 // We must take care to not read after the end of the file
2386 count = file->real_length - file->position;
2388 // If we have a lot of data to get, put them directly into "buffer"
2389 if (buffersize > sizeof (file->buff) / 2)
2391 if (count > (fs_offset_t)buffersize)
2392 count = (fs_offset_t)buffersize;
2393 lseek (file->handle, file->offset + file->position, SEEK_SET);
2394 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2398 file->position += nb;
2400 // Purge cached data
2406 if (count > (fs_offset_t)sizeof (file->buff))
2407 count = (fs_offset_t)sizeof (file->buff);
2408 lseek (file->handle, file->offset + file->position, SEEK_SET);
2409 nb = read (file->handle, file->buff, count);
2412 file->buff_len = nb;
2413 file->position += nb;
2415 // Copy the requested data in "buffer" (as much as we can)
2416 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2417 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2418 file->buff_ind = count;
2426 // If the file is compressed, it's more complicated...
2427 // We cycle through a few operations until we have read enough data
2428 while (buffersize > 0)
2430 ztoolkit_t *ztk = file->ztk;
2433 // NOTE: at this point, the read buffer is always empty
2435 // If "input" is also empty, we need to refill it
2436 if (ztk->in_ind == ztk->in_len)
2438 // If we are at the end of the file
2439 if (file->position == file->real_length)
2442 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2443 if (count > (fs_offset_t)sizeof (ztk->input))
2444 count = (fs_offset_t)sizeof (ztk->input);
2445 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2446 if (read (file->handle, ztk->input, count) != count)
2448 Con_Printf ("FS_Read: unexpected end of file\n");
2453 ztk->in_len = count;
2454 ztk->in_position += count;
2457 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2458 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2460 // Now that we are sure we have compressed data available, we need to determine
2461 // if it's better to inflate it in "file->buff" or directly in "buffer"
2463 // Inflate the data in "file->buff"
2464 if (buffersize < sizeof (file->buff) / 2)
2466 ztk->zstream.next_out = file->buff;
2467 ztk->zstream.avail_out = sizeof (file->buff);
2468 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2469 if (error != Z_OK && error != Z_STREAM_END)
2471 Con_Printf ("FS_Read: Can't inflate file\n");
2474 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2476 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2477 file->position += file->buff_len;
2479 // Copy the requested data in "buffer" (as much as we can)
2480 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2481 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2482 file->buff_ind = count;
2485 // Else, we inflate directly in "buffer"
2488 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2489 ztk->zstream.avail_out = (unsigned int)buffersize;
2490 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2491 if (error != Z_OK && error != Z_STREAM_END)
2493 Con_Printf ("FS_Read: Can't inflate file\n");
2496 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2498 // How much data did it inflate?
2499 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2500 file->position += count;
2502 // Purge cached data
2507 buffersize -= count;
2515 ====================
2518 Print a string into a file
2519 ====================
2521 int FS_Print (qfile_t* file, const char *msg)
2523 return (int)FS_Write (file, msg, strlen (msg));
2527 ====================
2530 Print a string into a file
2531 ====================
2533 int FS_Printf(qfile_t* file, const char* format, ...)
2538 va_start (args, format);
2539 result = FS_VPrintf (file, format, args);
2547 ====================
2550 Print a string into a file
2551 ====================
2553 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2556 fs_offset_t buff_size = MAX_INPUTLINE;
2561 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2562 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2563 if (len >= 0 && len < buff_size)
2565 Mem_Free (tempbuff);
2569 len = write (file->handle, tempbuff, len);
2570 Mem_Free (tempbuff);
2577 ====================
2580 Get the next character of a file
2581 ====================
2583 int FS_Getc (qfile_t* file)
2587 if (FS_Read (file, &c, 1) != 1)
2595 ====================
2598 Put a character back into the read buffer (only supports one character!)
2599 ====================
2601 int FS_UnGetc (qfile_t* file, unsigned char c)
2603 // If there's already a character waiting to be read
2604 if (file->ungetc != EOF)
2613 ====================
2616 Move the position index in a file
2617 ====================
2619 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2622 unsigned char* buffer;
2623 fs_offset_t buffersize;
2625 // Compute the file offset
2629 offset += file->position - file->buff_len + file->buff_ind;
2636 offset += file->real_length;
2642 if (offset < 0 || offset > file->real_length)
2645 if(file->flags & QFILE_FLAG_DATA)
2647 file->position = offset;
2651 // If we have the data in our read buffer, we don't need to actually seek
2652 if (file->position - file->buff_len <= offset && offset <= file->position)
2654 file->buff_ind = offset + file->buff_len - file->position;
2658 // Purge cached data
2661 // Unpacked or uncompressed files can seek directly
2662 if (! (file->flags & QFILE_FLAG_DEFLATED))
2664 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2666 file->position = offset;
2670 // Seeking in compressed files is more a hack than anything else,
2671 // but we need to support it, so here we go.
2674 // If we have to go back in the file, we need to restart from the beginning
2675 if (offset <= file->position)
2679 ztk->in_position = 0;
2681 lseek (file->handle, file->offset, SEEK_SET);
2683 // Reset the Zlib stream
2684 ztk->zstream.next_in = ztk->input;
2685 ztk->zstream.avail_in = 0;
2686 qz_inflateReset (&ztk->zstream);
2689 // We need a big buffer to force inflating into it directly
2690 buffersize = 2 * sizeof (file->buff);
2691 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2693 // Skip all data until we reach the requested offset
2694 while (offset > file->position)
2696 fs_offset_t diff = offset - file->position;
2697 fs_offset_t count, len;
2699 count = (diff > buffersize) ? buffersize : diff;
2700 len = FS_Read (file, buffer, count);
2714 ====================
2717 Give the current position in a file
2718 ====================
2720 fs_offset_t FS_Tell (qfile_t* file)
2722 return file->position - file->buff_len + file->buff_ind;
2727 ====================
2730 Give the total size of a file
2731 ====================
2733 fs_offset_t FS_FileSize (qfile_t* file)
2735 return file->real_length;
2740 ====================
2743 Erases any buffered input or output data
2744 ====================
2746 void FS_Purge (qfile_t* file)
2758 Filename are relative to the quake directory.
2759 Always appends a 0 byte.
2762 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2765 unsigned char *buf = NULL;
2766 fs_offset_t filesize = 0;
2768 file = FS_OpenVirtualFile(path, quiet);
2771 filesize = file->real_length;
2774 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2779 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2780 buf[filesize] = '\0';
2781 FS_Read (file, buf, filesize);
2783 if (developer_loadfile.integer)
2784 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2787 if (filesizepointer)
2788 *filesizepointer = filesize;
2797 The filename will be prefixed by the current game directory
2800 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2804 file = FS_OpenRealFile(filename, "wb", false);
2807 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2811 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2812 FS_Write (file, data, len);
2819 =============================================================================
2821 OTHERS PUBLIC FUNCTIONS
2823 =============================================================================
2831 void FS_StripExtension (const char *in, char *out, size_t size_out)
2839 while ((currentchar = *in) && size_out > 1)
2841 if (currentchar == '.')
2843 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2845 *out++ = currentchar;
2861 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2865 // if path doesn't have a .EXT, append extension
2866 // (extension should include the .)
2867 src = path + strlen(path) - 1;
2869 while (*src != '/' && src != path)
2872 return; // it has an extension
2876 strlcat (path, extension, size_path);
2884 Look for a file in the packages and in the filesystem
2887 int FS_FileType (const char *filename)
2889 searchpath_t *search;
2890 char fullpath[MAX_OSPATH];
2892 search = FS_FindFile (filename, NULL, true);
2894 return FS_FILETYPE_NONE;
2897 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2899 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2900 return FS_SysFileType(fullpath);
2908 Look for a file in the packages and in the filesystem
2911 qboolean FS_FileExists (const char *filename)
2913 return (FS_FindFile (filename, NULL, true) != NULL);
2921 Look for a file in the filesystem only
2924 int FS_SysFileType (const char *path)
2927 // Sajt - some older sdks are missing this define
2928 # ifndef INVALID_FILE_ATTRIBUTES
2929 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
2932 DWORD result = GetFileAttributes(path);
2934 if(result == INVALID_FILE_ATTRIBUTES)
2935 return FS_FILETYPE_NONE;
2937 if(result & FILE_ATTRIBUTE_DIRECTORY)
2938 return FS_FILETYPE_DIRECTORY;
2940 return FS_FILETYPE_FILE;
2944 if (stat (path,&buf) == -1)
2945 return FS_FILETYPE_NONE;
2948 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
2950 if(S_ISDIR(buf.st_mode))
2951 return FS_FILETYPE_DIRECTORY;
2953 return FS_FILETYPE_FILE;
2957 qboolean FS_SysFileExists (const char *path)
2959 return FS_SysFileType (path) != FS_FILETYPE_NONE;
2962 void FS_mkdir (const char *path)
2975 Allocate and fill a search structure with information on matching filenames.
2978 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2981 searchpath_t *searchpath;
2983 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2984 stringlist_t resultlist;
2985 stringlist_t dirlist;
2986 const char *slash, *backslash, *colon, *separator;
2988 char temp[MAX_OSPATH];
2990 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2995 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2999 stringlistinit(&resultlist);
3000 stringlistinit(&dirlist);
3002 slash = strrchr(pattern, '/');
3003 backslash = strrchr(pattern, '\\');
3004 colon = strrchr(pattern, ':');
3005 separator = max(slash, backslash);
3006 separator = max(separator, colon);
3007 basepathlength = separator ? (separator + 1 - pattern) : 0;
3008 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3010 memcpy(basepath, pattern, basepathlength);
3011 basepath[basepathlength] = 0;
3013 // search through the path, one element at a time
3014 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3016 // is the element a pak file?
3017 if (searchpath->pack)
3019 // look through all the pak file elements
3020 pak = searchpath->pack;
3021 for (i = 0;i < pak->numfiles;i++)
3023 strlcpy(temp, pak->files[i].name, sizeof(temp));
3026 if (matchpattern(temp, (char *)pattern, true))
3028 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3029 if (!strcmp(resultlist.strings[resultlistindex], temp))
3031 if (resultlistindex == resultlist.numstrings)
3033 stringlistappend(&resultlist, temp);
3034 if (!quiet && developer_loading.integer)
3035 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3038 // strip off one path element at a time until empty
3039 // this way directories are added to the listing if they match the pattern
3040 slash = strrchr(temp, '/');
3041 backslash = strrchr(temp, '\\');
3042 colon = strrchr(temp, ':');
3044 if (separator < slash)
3046 if (separator < backslash)
3047 separator = backslash;
3048 if (separator < colon)
3050 *((char *)separator) = 0;
3056 stringlist_t matchedSet, foundSet;
3057 const char *start = pattern;
3059 stringlistinit(&matchedSet);
3060 stringlistinit(&foundSet);
3061 // add a first entry to the set
3062 stringlistappend(&matchedSet, "");
3063 // iterate through pattern's path
3066 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3067 char subpath[MAX_OSPATH];
3068 char subpattern[MAX_OSPATH];
3070 // find the next wildcard
3071 wildcard = strchr(start, '?');
3072 asterisk = strchr(start, '*');
3073 if (asterisk && (!wildcard || asterisk < wildcard))
3075 wildcard = asterisk;
3080 nextseparator = strchr( wildcard, '/' );
3084 nextseparator = NULL;
3087 if( !nextseparator ) {
3088 nextseparator = start + strlen( start );
3091 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3092 // copy everything up except nextseperator
3093 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3094 // find the last '/' before the wildcard
3095 prevseparator = strrchr( subpattern, '/' );
3097 prevseparator = subpattern;
3100 // copy everything from start to the previous including the '/' (before the wildcard)
3101 // everything up to start is already included in the path of matchedSet's entries
3102 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3104 // for each entry in matchedSet try to open the subdirectories specified in subpath
3105 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3106 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3107 strlcat( temp, subpath, sizeof(temp) );
3108 listdirectory( &foundSet, searchpath->filename, temp );
3110 if( dirlistindex == 0 ) {
3113 // reset the current result set
3114 stringlistfreecontents( &matchedSet );
3115 // match against the pattern
3116 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3117 const char *direntry = foundSet.strings[ dirlistindex ];
3118 if (matchpattern(direntry, subpattern, true)) {
3119 stringlistappend( &matchedSet, direntry );
3122 stringlistfreecontents( &foundSet );
3124 start = nextseparator;
3127 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3129 const char *temp = matchedSet.strings[dirlistindex];
3130 if (matchpattern(temp, (char *)pattern, true))
3132 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3133 if (!strcmp(resultlist.strings[resultlistindex], temp))
3135 if (resultlistindex == resultlist.numstrings)
3137 stringlistappend(&resultlist, temp);
3138 if (!quiet && developer_loading.integer)
3139 Con_Printf("SearchDirFile: %s\n", temp);
3143 stringlistfreecontents( &matchedSet );
3147 if (resultlist.numstrings)
3149 stringlistsort(&resultlist);
3150 numfiles = resultlist.numstrings;
3152 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3153 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3154 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3155 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3156 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3157 search->numfilenames = (int)numfiles;
3160 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3163 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3164 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3165 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3167 numchars += (int)textlen;
3170 stringlistfreecontents(&resultlist);
3176 void FS_FreeSearch(fssearch_t *search)
3181 extern int con_linewidth;
3182 int FS_ListDirectory(const char *pattern, int oneperline)
3191 char linebuf[MAX_INPUTLINE];
3193 search = FS_Search(pattern, true, true);
3196 numfiles = search->numfilenames;
3199 // FIXME: the names could be added to one column list and then
3200 // gradually shifted into the next column if they fit, and then the
3201 // next to make a compact variable width listing but it's a lot more
3203 // find width for columns
3205 for (i = 0;i < numfiles;i++)
3207 l = (int)strlen(search->filenames[i]);
3208 if (columnwidth < l)
3211 // count the spacing character
3213 // calculate number of columns
3214 numcolumns = con_linewidth / columnwidth;
3215 // don't bother with the column printing if it's only one column
3216 if (numcolumns >= 2)
3218 numlines = (numfiles + numcolumns - 1) / numcolumns;
3219 for (i = 0;i < numlines;i++)
3222 for (k = 0;k < numcolumns;k++)
3224 l = i * numcolumns + k;
3227 name = search->filenames[l];
3228 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3229 linebuf[linebufpos++] = name[j];
3230 // space out name unless it's the last on the line
3231 if (k + 1 < numcolumns && l + 1 < numfiles)
3232 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3233 linebuf[linebufpos++] = ' ';
3236 linebuf[linebufpos] = 0;
3237 Con_Printf("%s\n", linebuf);
3244 for (i = 0;i < numfiles;i++)
3245 Con_Printf("%s\n", search->filenames[i]);
3246 FS_FreeSearch(search);
3247 return (int)numfiles;
3250 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3252 const char *pattern;
3255 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3258 if (Cmd_Argc() == 2)
3259 pattern = Cmd_Argv(1);
3262 if (!FS_ListDirectory(pattern, oneperline))
3263 Con_Print("No files found.\n");
3268 FS_ListDirectoryCmd("dir", true);
3273 FS_ListDirectoryCmd("ls", false);
3276 void FS_Which_f(void)
3278 const char *filename;
3281 if (Cmd_Argc() != 2)
3283 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3286 filename = Cmd_Argv(1);
3287 sp = FS_FindFile(filename, &index, true);
3289 Con_Printf("%s isn't anywhere\n", filename);
3293 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3295 Con_Printf("%s is in virtual package %s\n", filename, sp->vpack);
3297 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3301 const char *FS_WhichPack(const char *filename)
3304 searchpath_t *sp = FS_FindFile(filename, &index, true);
3306 return sp->pack->shortname;
3307 else if(sp && sp->vpack)
3314 ====================
3315 FS_IsRegisteredQuakePack
3317 Look for a proof of purchase file file in the requested package
3319 If it is found, this file should NOT be downloaded.
3320 ====================
3322 qboolean FS_IsRegisteredQuakePack(const char *name)
3324 searchpath_t *search;
3327 // search through the path, one element at a time
3328 for (search = fs_searchpaths;search;search = search->next)
3330 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3332 int (*strcmp_funct) (const char* str1, const char* str2);
3333 int left, right, middle;
3336 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3338 // Look for the file (binary search)
3340 right = pak->numfiles - 1;
3341 while (left <= right)
3345 middle = (left + right) / 2;
3346 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3352 // If we're too far in the list
3359 // we found the requested pack but it is not registered quake
3362 // TODO do we want to support vpacks in here too?
3368 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3371 unsigned char *filedata;
3372 fs_offset_t filesize;
3373 if (filesizepointer)
3374 *filesizepointer = 0;
3375 if (!filename || !*filename)
3377 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3380 if (filesizepointer)
3381 *filesizepointer = filesize;
3382 crc = CRC_Block(filedata, filesize);
3388 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3391 unsigned char *out = NULL;
3395 #ifndef LINK_TO_ZLIB
3400 memset(&strm, 0, sizeof(strm));
3401 strm.zalloc = Z_NULL;
3402 strm.zfree = Z_NULL;
3403 strm.opaque = Z_NULL;
3406 level = Z_DEFAULT_COMPRESSION;
3408 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3410 Con_Printf("FS_Deflate: deflate init error!\n");
3414 strm.next_in = (unsigned char*)data;
3415 strm.avail_in = size;
3417 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3420 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3421 qz_deflateEnd(&strm);
3425 strm.next_out = tmp;
3426 strm.avail_out = size;
3428 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3430 Con_Printf("FS_Deflate: deflate failed!\n");
3431 qz_deflateEnd(&strm);
3436 if(qz_deflateEnd(&strm) != Z_OK)
3438 Con_Printf("FS_Deflate: deflateEnd failed\n");
3443 if(strm.total_out >= size)
3445 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3450 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3453 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3459 *deflated_size = (size_t)strm.total_out;
3461 memcpy(out, tmp, strm.total_out);
3467 static void AssertBufsize(sizebuf_t *buf, int length)
3469 if(buf->cursize + length > buf->maxsize)
3471 int oldsize = buf->maxsize;
3472 unsigned char *olddata;
3473 olddata = buf->data;
3474 buf->maxsize += length;
3475 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3478 memcpy(buf->data, olddata, oldsize);
3484 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3488 unsigned char *out = NULL;
3489 unsigned char tmp[2048];
3494 #ifndef LINK_TO_ZLIB
3499 memset(&outbuf, 0, sizeof(outbuf));
3500 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3501 outbuf.maxsize = sizeof(tmp);
3503 memset(&strm, 0, sizeof(strm));
3504 strm.zalloc = Z_NULL;
3505 strm.zfree = Z_NULL;
3506 strm.opaque = Z_NULL;
3508 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3510 Con_Printf("FS_Inflate: inflate init error!\n");
3511 Mem_Free(outbuf.data);
3515 strm.next_in = (unsigned char*)data;
3516 strm.avail_in = size;
3520 strm.next_out = tmp;
3521 strm.avail_out = sizeof(tmp);
3522 ret = qz_inflate(&strm, Z_NO_FLUSH);
3523 // it either returns Z_OK on progress, Z_STREAM_END on end
3531 case Z_STREAM_ERROR:
3532 Con_Print("FS_Inflate: stream error!\n");
3535 Con_Print("FS_Inflate: data error!\n");
3538 Con_Print("FS_Inflate: mem error!\n");
3541 Con_Print("FS_Inflate: buf error!\n");
3544 Con_Print("FS_Inflate: unknown error!\n");
3548 if(ret != Z_OK && ret != Z_STREAM_END)
3550 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3551 Mem_Free(outbuf.data);
3552 qz_inflateEnd(&strm);
3555 have = sizeof(tmp) - strm.avail_out;
3556 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3557 SZ_Write(&outbuf, tmp, have);
3558 } while(ret != Z_STREAM_END);
3560 qz_inflateEnd(&strm);
3562 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3565 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3566 Mem_Free(outbuf.data);
3570 memcpy(out, outbuf.data, outbuf.cursize);
3571 Mem_Free(outbuf.data);
3574 *inflated_size = (size_t)outbuf.cursize;