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
26 // include SDL for IPHONEOS code
27 # include <TargetConditionals.h>
42 # include <sys/stat.h>
51 // Win32 requires us to add O_BINARY, but the other OSes don't have it
56 // In case the system doesn't support the O_NONBLOCK flag
61 // largefile support for Win32
64 # define lseek _lseeki64
68 // suppress deprecated warnings
69 # include <sys/stat.h>
74 # define unlink _unlink
78 /** \page fs File System
80 All of Quake's data access is through a hierchal file system, but the contents
81 of the file system can be transparently merged from several sources.
83 The "base directory" is the path to the directory holding the quake.exe and
84 all game directories. The sys_* files pass this to host_init in
85 quakeparms_t->basedir. This can be overridden with the "-basedir" command
86 line parm to allow code debugging in a different directory. The base
87 directory is only used during filesystem initialization.
89 The "game directory" is the first tree on the search path and directory that
90 all generated files (savegames, screenshots, demos, config files) will be
91 saved to. This can be overridden with the "-game" command line parameter.
92 The game directory can never be changed while quake is executing. This is a
93 precaution against having a malicious server instruct clients to write files
94 over areas they shouldn't.
100 =============================================================================
104 =============================================================================
107 // Magic numbers of a ZIP file (big-endian format)
108 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
109 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
110 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
112 // Other constants for ZIP files
113 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
114 #define ZIP_END_CDIR_SIZE 22
115 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
116 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
121 #define qz_inflate inflate
122 #define qz_inflateEnd inflateEnd
123 #define qz_inflateInit2_ inflateInit2_
124 #define qz_inflateReset inflateReset
125 #define qz_deflateInit2_ deflateInit2_
126 #define qz_deflateEnd deflateEnd
127 #define qz_deflate deflate
128 #define Z_MEMLEVEL_DEFAULT 8
131 // Zlib constants (from zlib.h)
132 #define Z_SYNC_FLUSH 2
135 #define Z_STREAM_END 1
136 #define Z_STREAM_ERROR (-2)
137 #define Z_DATA_ERROR (-3)
138 #define Z_MEM_ERROR (-4)
139 #define Z_BUF_ERROR (-5)
140 #define ZLIB_VERSION "1.2.3"
144 #define Z_MEMLEVEL_DEFAULT 8
147 #define Z_DEFAULT_COMPRESSION (-1)
149 #define Z_SYNC_FLUSH 2
150 #define Z_FULL_FLUSH 3
153 // Uncomment the following line if the zlib DLL you have still uses
154 // the 1.1.x series calling convention on Win32 (WINAPI)
155 //#define ZLIB_USES_WINAPI
159 =============================================================================
163 =============================================================================
166 /*! Zlib stream (from zlib.h)
167 * \warning: some pointers we don't use directly have
168 * been cast to "void*" for a matter of simplicity
172 unsigned char *next_in; ///< next input byte
173 unsigned int avail_in; ///< number of bytes available at next_in
174 unsigned long total_in; ///< total nb of input bytes read so far
176 unsigned char *next_out; ///< next output byte should be put there
177 unsigned int avail_out; ///< remaining free space at next_out
178 unsigned long total_out; ///< total nb of bytes output so far
180 char *msg; ///< last error message, NULL if no error
181 void *state; ///< not visible by applications
183 void *zalloc; ///< used to allocate the internal state
184 void *zfree; ///< used to free the internal state
185 void *opaque; ///< private data object passed to zalloc and zfree
187 int data_type; ///< best guess about the data type: ascii or binary
188 unsigned long adler; ///< adler32 value of the uncompressed data
189 unsigned long reserved; ///< reserved for future use
194 /// inside a package (PAK or PK3)
195 #define QFILE_FLAG_PACKED (1 << 0)
196 /// file is compressed using the deflate algorithm (PK3 only)
197 #define QFILE_FLAG_DEFLATED (1 << 1)
198 /// file is actually already loaded data
199 #define QFILE_FLAG_DATA (1 << 2)
200 /// real file will be removed on close
201 #define QFILE_FLAG_REMOVE (1 << 3)
203 #define FILE_BUFF_SIZE 2048
207 size_t comp_length; ///< length of the compressed file
208 size_t in_ind, in_len; ///< input buffer current index and length
209 size_t in_position; ///< position in the compressed file
210 unsigned char input [FILE_BUFF_SIZE];
216 int handle; ///< file descriptor
217 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
218 fs_offset_t position; ///< current position in the file
219 fs_offset_t offset; ///< offset into the package (0 if external file)
220 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
223 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
224 unsigned char buff [FILE_BUFF_SIZE];
226 ztoolkit_t* ztk; ///< For zipped files.
228 const unsigned char *data; ///< For data files.
230 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
234 // ------ PK3 files on disk ------ //
236 // You can get the complete ZIP format description from PKWARE website
238 typedef struct pk3_endOfCentralDir_s
240 unsigned int signature;
241 unsigned short disknum;
242 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
243 unsigned short localentries; ///< number of entries in the central directory on this disk
244 unsigned short nbentries; ///< total number of entries in the central directory on this disk
245 unsigned int cdir_size; ///< size of the central directory
246 unsigned int cdir_offset; ///< with respect to the starting disk number
247 unsigned short comment_size;
248 fs_offset_t prepended_garbage;
249 } pk3_endOfCentralDir_t;
252 // ------ PAK files on disk ------ //
253 typedef struct dpackfile_s
256 int filepos, filelen;
259 typedef struct dpackheader_s
267 /*! \name Packages in memory
270 /// the offset in packfile_t is the true contents offset
271 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
272 /// file compressed using the deflate algorithm
273 #define PACKFILE_FLAG_DEFLATED (1 << 1)
274 /// file is a symbolic link
275 #define PACKFILE_FLAG_SYMLINK (1 << 2)
277 typedef struct packfile_s
279 char name [MAX_QPATH];
282 fs_offset_t packsize; ///< size in the package
283 fs_offset_t realsize; ///< real file size (uncompressed)
286 typedef struct pack_s
288 char filename [MAX_OSPATH];
289 char shortname [MAX_QPATH];
291 int ignorecase; ///< PK3 ignores case
298 /// Search paths for files (including packages)
299 typedef struct searchpath_s
301 // only one of filename / pack will be used
302 char filename[MAX_OSPATH];
304 struct searchpath_s *next;
309 =============================================================================
313 =============================================================================
318 void FS_Which_f(void);
320 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
321 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
322 fs_offset_t offset, fs_offset_t packsize,
323 fs_offset_t realsize, int flags);
327 =============================================================================
331 =============================================================================
334 mempool_t *fs_mempool;
336 searchpath_t *fs_searchpaths = NULL;
337 const char *const fs_checkgamedir_missing = "missing";
339 #define MAX_FILES_IN_PACK 65536
341 char fs_userdir[MAX_OSPATH];
342 char fs_gamedir[MAX_OSPATH];
343 char fs_basedir[MAX_OSPATH];
344 static pack_t *fs_selfpack = NULL;
346 // list of active game directories (empty if not running a mod)
347 int fs_numgamedirs = 0;
348 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
350 // list of all gamedirs with modinfo.txt
351 gamedir_t *fs_all_gamedirs = NULL;
352 int fs_all_gamedirs_count = 0;
354 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)"};
355 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"};
356 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
360 =============================================================================
362 PRIVATE FUNCTIONS - PK3 HANDLING
364 =============================================================================
368 // Functions exported from zlib
369 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
370 # define ZEXPORT WINAPI
375 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
376 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
377 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
378 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
379 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
380 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
381 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
384 #define qz_inflateInit2(strm, windowBits) \
385 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
386 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
387 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
390 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
392 static dllfunction_t zlibfuncs[] =
394 {"inflate", (void **) &qz_inflate},
395 {"inflateEnd", (void **) &qz_inflateEnd},
396 {"inflateInit2_", (void **) &qz_inflateInit2_},
397 {"inflateReset", (void **) &qz_inflateReset},
398 {"deflateInit2_", (void **) &qz_deflateInit2_},
399 {"deflateEnd", (void **) &qz_deflateEnd},
400 {"deflate", (void **) &qz_deflate},
404 /// Handle for Zlib DLL
405 static dllhandle_t zlib_dll = NULL;
409 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
410 static dllfunction_t shfolderfuncs[] =
412 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
415 static const char* shfolderdllnames [] =
417 "shfolder.dll", // IE 4, or Win NT and higher
420 static dllhandle_t shfolder_dll = NULL;
422 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
423 #define qREFKNOWNFOLDERID const GUID *
424 #define qKF_FLAG_CREATE 0x8000
425 #define qKF_FLAG_NO_ALIAS 0x1000
426 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
427 static dllfunction_t shell32funcs[] =
429 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
432 static const char* shell32dllnames [] =
434 "shell32.dll", // Vista and higher
437 static dllhandle_t shell32_dll = NULL;
439 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
440 static void (WINAPI *qCoUninitialize)(void);
441 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
442 static dllfunction_t ole32funcs[] =
444 {"CoInitializeEx", (void **) &qCoInitializeEx},
445 {"CoUninitialize", (void **) &qCoUninitialize},
446 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
449 static const char* ole32dllnames [] =
451 "ole32.dll", // 2000 and higher
454 static dllhandle_t ole32_dll = NULL;
464 void PK3_CloseLibrary (void)
467 Sys_UnloadLibrary (&zlib_dll);
476 Try to load the Zlib DLL
479 qboolean PK3_OpenLibrary (void)
484 const char* dllnames [] =
487 # ifdef ZLIB_USES_WINAPI
493 #elif defined(MACOSX)
507 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
515 See if zlib is available
518 qboolean FS_HasZlib(void)
523 PK3_OpenLibrary(); // to be safe
524 return (zlib_dll != 0);
530 PK3_GetEndOfCentralDir
532 Extract the end of the central directory from a PK3 package
535 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
537 fs_offset_t filesize, maxsize;
538 unsigned char *buffer, *ptr;
541 // Get the package size
542 filesize = lseek (packhandle, 0, SEEK_END);
543 if (filesize < ZIP_END_CDIR_SIZE)
546 // Load the end of the file in memory
547 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
550 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
551 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
552 lseek (packhandle, filesize - maxsize, SEEK_SET);
553 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
559 // Look for the end of central dir signature around the end of the file
560 maxsize -= ZIP_END_CDIR_SIZE;
561 ptr = &buffer[maxsize];
563 while (BuffBigLong (ptr) != ZIP_END_HEADER)
575 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
576 eocd->signature = LittleLong (eocd->signature);
577 eocd->disknum = LittleShort (eocd->disknum);
578 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
579 eocd->localentries = LittleShort (eocd->localentries);
580 eocd->nbentries = LittleShort (eocd->nbentries);
581 eocd->cdir_size = LittleLong (eocd->cdir_size);
582 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
583 eocd->comment_size = LittleShort (eocd->comment_size);
584 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
585 eocd->cdir_offset += eocd->prepended_garbage;
597 Extract the file list from a PK3 file
600 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
602 unsigned char *central_dir, *ptr;
604 fs_offset_t remaining;
606 // Load the central directory in memory
607 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
608 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
609 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
611 Mem_Free (central_dir);
615 // Extract the files properties
616 // The parsing is done "by hand" because some fields have variable sizes and
617 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
618 remaining = eocd->cdir_size;
621 for (ind = 0; ind < eocd->nbentries; ind++)
623 fs_offset_t namesize, count;
625 // Checking the remaining size
626 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
628 Mem_Free (central_dir);
631 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
634 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
636 Mem_Free (central_dir);
640 namesize = BuffLittleShort (&ptr[28]); // filename length
642 // Check encryption, compression, and attributes
643 // 1st uint8 : general purpose bit flag
644 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
646 // LordHavoc: bit 3 would be a problem if we were scanning the archive
647 // but is not a problem in the central directory where the values are
650 // bit 3 seems to always be set by the standard Mac OSX zip maker
652 // 2nd uint8 : external file attributes
653 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
654 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
656 // Still enough bytes for the name?
657 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
659 Mem_Free (central_dir);
663 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
664 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
666 char filename [sizeof (pack->files[0].name)];
667 fs_offset_t offset, packsize, realsize;
670 // Extract the name (strip it if necessary)
671 namesize = min(namesize, (int)sizeof (filename) - 1);
672 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
673 filename[namesize] = '\0';
675 if (BuffLittleShort (&ptr[10]))
676 flags = PACKFILE_FLAG_DEFLATED;
679 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
680 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
681 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
683 switch(ptr[5]) // C_VERSION_MADE_BY_1
688 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
689 // can't use S_ISLNK here, as this has to compile on non-UNIX too
690 flags |= PACKFILE_FLAG_SYMLINK;
694 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
698 // Skip the name, additionnal field, and comment
699 // 1er uint16 : extra field length
700 // 2eme uint16 : file comment length
701 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
702 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
706 // If the package is empty, central_dir is NULL here
707 if (central_dir != NULL)
708 Mem_Free (central_dir);
709 return pack->numfiles;
717 Create a package entry associated with a PK3 file
720 pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
722 pk3_endOfCentralDir_t eocd;
726 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
729 Con_Printf ("%s is not a PK3 file\n", packfile);
734 // Multi-volume ZIP archives are NOT allowed
735 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
737 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
742 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
743 // since eocd.nbentries is an unsigned 16 bits integer
744 #if MAX_FILES_IN_PACK < 65535
745 if (eocd.nbentries > MAX_FILES_IN_PACK)
747 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
753 // Create a package structure in memory
754 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
755 pack->ignorecase = true; // PK3 ignores case
756 strlcpy (pack->filename, packfile, sizeof (pack->filename));
757 pack->handle = packhandle;
758 pack->numfiles = eocd.nbentries;
759 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
761 real_nb_files = PK3_BuildFileList (pack, &eocd);
762 if (real_nb_files < 0)
764 Con_Printf ("%s is not a valid PK3 file\n", packfile);
770 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
773 pack_t *FS_LoadPackPK3 (const char *packfile)
777 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
779 packhandle = open (packfile, O_RDONLY | O_BINARY);
783 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
789 PK3_GetTrueFileOffset
791 Find where the true file data offset is
794 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
796 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
800 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
803 // Load the local file description
804 lseek (pack->handle, pfile->offset, SEEK_SET);
805 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
806 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
808 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
812 // Skip name and extra field
813 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
815 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
821 =============================================================================
823 OTHER PRIVATE FUNCTIONS
825 =============================================================================
833 Add a file to the list of files contained into a package
836 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
837 fs_offset_t offset, fs_offset_t packsize,
838 fs_offset_t realsize, int flags)
840 int (*strcmp_funct) (const char* str1, const char* str2);
841 int left, right, middle;
844 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
846 // Look for the slot we should put that file into (binary search)
848 right = pack->numfiles - 1;
849 while (left <= right)
853 middle = (left + right) / 2;
854 diff = strcmp_funct (pack->files[middle].name, name);
856 // If we found the file, there's a problem
858 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
860 // If we're too far in the list
867 // We have to move the right of the list by one slot to free the one we need
868 pfile = &pack->files[left];
869 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
872 strlcpy (pfile->name, name, sizeof (pfile->name));
873 pfile->offset = offset;
874 pfile->packsize = packsize;
875 pfile->realsize = realsize;
876 pfile->flags = flags;
886 Only used for FS_OpenRealFile.
889 void FS_CreatePath (char *path)
893 for (ofs = path+1 ; *ofs ; ofs++)
895 if (*ofs == '/' || *ofs == '\\')
897 // create the directory
913 void FS_Path_f (void)
917 Con_Print("Current search path:\n");
918 for (s=fs_searchpaths ; s ; s=s->next)
923 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
925 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
928 Con_Printf("%s\n", s->filename);
938 /*! Takes an explicit (not game tree related) path to a pak file.
939 *Loads the header and directory, adding the files at the beginning
940 *of the list so they override previous pack files.
942 pack_t *FS_LoadPackPAK (const char *packfile)
944 dpackheader_t header;
951 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
953 packhandle = open (packfile, O_RDONLY | O_BINARY);
957 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
959 Con_Printf ("%s is not a packfile\n", packfile);
963 if (memcmp(header.id, "PACK", 4))
965 Con_Printf ("%s is not a packfile\n", packfile);
969 header.dirofs = LittleLong (header.dirofs);
970 header.dirlen = LittleLong (header.dirlen);
972 if (header.dirlen % sizeof(dpackfile_t))
974 Con_Printf ("%s has an invalid directory size\n", packfile);
979 numpackfiles = header.dirlen / sizeof(dpackfile_t);
981 if (numpackfiles > MAX_FILES_IN_PACK)
983 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
988 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
989 lseek (packhandle, header.dirofs, SEEK_SET);
990 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
992 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
998 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
999 pack->ignorecase = false; // PAK is case sensitive
1000 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1001 pack->handle = packhandle;
1003 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1005 // parse the directory
1006 for (i = 0;i < numpackfiles;i++)
1008 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1009 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1011 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1016 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1021 ====================
1024 Create a package entry associated with a directory file
1025 ====================
1027 pack_t *FS_LoadPackVirtual (const char *dirname)
1030 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1032 pack->ignorecase = false;
1033 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1035 pack->numfiles = -1;
1037 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1046 /*! Adds the given pack to the search path.
1047 * The pack type is autodetected by the file extension.
1049 * Returns true if the file was successfully added to the
1050 * search path or if it was already included.
1052 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1053 * plain directories.
1056 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1058 searchpath_t *search;
1060 const char *ext = FS_FileExtension(pakfile);
1063 for(search = fs_searchpaths; search; search = search->next)
1065 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1068 *already_loaded = true;
1069 return true; // already loaded
1074 *already_loaded = false;
1076 if(!strcasecmp(ext, "pk3dir"))
1077 pak = FS_LoadPackVirtual (pakfile);
1078 else if(!strcasecmp(ext, "pak"))
1079 pak = FS_LoadPackPAK (pakfile);
1080 else if(!strcasecmp(ext, "pk3"))
1081 pak = FS_LoadPackPK3 (pakfile);
1083 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1087 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1089 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1092 // find the first item whose next one is a pack or NULL
1093 searchpath_t *insertion_point = 0;
1094 if(fs_searchpaths && !fs_searchpaths->pack)
1096 insertion_point = fs_searchpaths;
1099 if(!insertion_point->next)
1101 if(insertion_point->next->pack)
1103 insertion_point = insertion_point->next;
1106 // If insertion_point is NULL, this means that either there is no
1107 // item in the list yet, or that the very first item is a pack. In
1108 // that case, we want to insert at the beginning...
1109 if(!insertion_point)
1111 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1112 search->next = fs_searchpaths;
1113 fs_searchpaths = search;
1116 // otherwise we want to append directly after insertion_point.
1118 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1119 search->next = insertion_point->next;
1120 insertion_point->next = search;
1125 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1126 search->next = fs_searchpaths;
1127 fs_searchpaths = search;
1132 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1133 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1134 // same goes for the name inside the pack structure
1135 l = strlen(pak->shortname);
1137 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1138 pak->shortname[l - 3] = 0;
1139 l = strlen(pak->filename);
1141 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1142 pak->filename[l - 3] = 0;
1148 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1159 /*! Adds the given pack to the search path and searches for it in the game path.
1160 * The pack type is autodetected by the file extension.
1162 * Returns true if the file was successfully added to the
1163 * search path or if it was already included.
1165 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1166 * plain directories.
1168 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1170 char fullpath[MAX_OSPATH];
1172 searchpath_t *search;
1175 *already_loaded = false;
1177 // then find the real name...
1178 search = FS_FindFile(pakfile, &index, true);
1179 if(!search || search->pack)
1181 Con_Printf("could not find pak \"%s\"\n", pakfile);
1185 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1187 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1195 Sets fs_gamedir, adds the directory to the head of the path,
1196 then loads and adds pak1.pak pak2.pak ...
1199 void FS_AddGameDirectory (const char *dir)
1203 searchpath_t *search;
1205 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1207 stringlistinit(&list);
1208 listdirectory(&list, "", dir);
1209 stringlistsort(&list, false);
1211 // add any PAK package in the directory
1212 for (i = 0;i < list.numstrings;i++)
1214 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1216 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1220 // add any PK3 package in the directory
1221 for (i = 0;i < list.numstrings;i++)
1223 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1225 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1229 stringlistfreecontents(&list);
1231 // Add the directory to the search path
1232 // (unpacked files have the priority over packed files)
1233 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1234 strlcpy (search->filename, dir, sizeof (search->filename));
1235 search->next = fs_searchpaths;
1236 fs_searchpaths = search;
1245 void FS_AddGameHierarchy (const char *dir)
1247 // Add the common game directory
1248 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1251 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1260 const char *FS_FileExtension (const char *in)
1262 const char *separator, *backslash, *colon, *dot;
1264 separator = strrchr(in, '/');
1265 backslash = strrchr(in, '\\');
1266 if (!separator || separator < backslash)
1267 separator = backslash;
1268 colon = strrchr(in, ':');
1269 if (!separator || separator < colon)
1272 dot = strrchr(in, '.');
1273 if (dot == NULL || (separator && (dot < separator)))
1285 const char *FS_FileWithoutPath (const char *in)
1287 const char *separator, *backslash, *colon;
1289 separator = strrchr(in, '/');
1290 backslash = strrchr(in, '\\');
1291 if (!separator || separator < backslash)
1292 separator = backslash;
1293 colon = strrchr(in, ':');
1294 if (!separator || separator < colon)
1296 return separator ? separator + 1 : in;
1305 void FS_ClearSearchPath (void)
1307 // unload all packs and directory information, close all pack files
1308 // (if a qfile is still reading a pack it won't be harmed because it used
1309 // dup() to get its own handle already)
1310 while (fs_searchpaths)
1312 searchpath_t *search = fs_searchpaths;
1313 fs_searchpaths = search->next;
1314 if (search->pack && search->pack != fs_selfpack)
1316 if(!search->pack->vpack)
1319 close(search->pack->handle);
1320 // free any memory associated with it
1321 if (search->pack->files)
1322 Mem_Free(search->pack->files);
1324 Mem_Free(search->pack);
1330 static void FS_AddSelfPack(void)
1334 searchpath_t *search;
1335 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1336 search->next = fs_searchpaths;
1337 search->pack = fs_selfpack;
1338 fs_searchpaths = search;
1348 void FS_Rescan (void)
1351 qboolean fs_modified = false;
1352 qboolean reset = false;
1353 char gamedirbuf[MAX_INPUTLINE];
1357 FS_ClearSearchPath();
1359 // automatically activate gamemode for the gamedirs specified
1361 COM_ChangeGameTypeForGameDirs();
1363 // add the game-specific paths
1364 // gamedirname1 (typically id1)
1365 FS_AddGameHierarchy (gamedirname1);
1366 // update the com_modname (used for server info)
1367 if (gamedirname2 && gamedirname2[0])
1368 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1370 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1372 // add the game-specific path, if any
1373 // (only used for mission packs and the like, which should set fs_modified)
1374 if (gamedirname2 && gamedirname2[0])
1377 FS_AddGameHierarchy (gamedirname2);
1381 // Adds basedir/gamedir as an override game
1382 // LordHavoc: now supports multiple -game directories
1383 // set the com_modname (reported in server info)
1385 for (i = 0;i < fs_numgamedirs;i++)
1388 FS_AddGameHierarchy (fs_gamedirs[i]);
1389 // update the com_modname (used server info)
1390 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1392 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1394 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1396 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1398 // add back the selfpack as new first item
1401 // set the default screenshot name to either the mod name or the
1402 // gamemode screenshot name
1403 if (strcmp(com_modname, gamedirname1))
1404 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1406 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1408 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1409 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1411 // If "-condebug" is in the command line, remove the previous log file
1412 if (COM_CheckParm ("-condebug") != 0)
1413 unlink (va("%s/qconsole.log", fs_gamedir));
1415 // look for the pop.lmp file and set registered to true if it is found
1416 if (FS_FileExists("gfx/pop.lmp"))
1417 Cvar_Set ("registered", "1");
1423 if (!registered.integer)
1426 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1428 Con_Print("Playing shareware version.\n");
1431 Con_Print("Playing registered version.\n");
1433 case GAME_STEELSTORM:
1434 if (registered.integer)
1435 Con_Print("Playing registered version.\n");
1437 Con_Print("Playing shareware version.\n");
1443 // unload all wads so that future queries will return the new data
1447 void FS_Rescan_f(void)
1457 extern void Host_SaveConfig (void);
1458 extern void Host_LoadConfig_f (void);
1459 extern qboolean vid_opened;
1460 extern void VID_Stop(void);
1461 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1466 if (fs_numgamedirs == numgamedirs)
1468 for (i = 0;i < numgamedirs;i++)
1469 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1471 if (i == numgamedirs)
1472 return true; // already using this set of gamedirs, do nothing
1475 if (numgamedirs > MAX_GAMEDIRS)
1478 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1479 return false; // too many gamedirs
1482 for (i = 0;i < numgamedirs;i++)
1484 // if string is nasty, reject it
1485 p = FS_CheckGameDir(gamedirs[i]);
1489 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1490 return false; // nasty gamedirs
1492 if(p == fs_checkgamedir_missing && failmissing)
1495 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1496 return false; // missing gamedirs
1502 fs_numgamedirs = numgamedirs;
1503 for (i = 0;i < fs_numgamedirs;i++)
1504 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1506 // reinitialize filesystem to detect the new paks
1509 if (cls.demoplayback)
1515 // unload all sounds so they will be reloaded from the new files as needed
1516 S_UnloadAllSounds_f();
1518 // close down the video subsystem, it will start up again when the config finishes...
1522 // restart the video subsystem after the config is executed
1523 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1533 void FS_GameDir_f (void)
1537 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1541 Con_Printf("gamedirs active:");
1542 for (i = 0;i < fs_numgamedirs;i++)
1543 Con_Printf(" %s", fs_gamedirs[i]);
1548 numgamedirs = Cmd_Argc() - 1;
1549 if (numgamedirs > MAX_GAMEDIRS)
1551 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1555 for (i = 0;i < numgamedirs;i++)
1556 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1558 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1560 // actually, changing during game would work fine, but would be stupid
1561 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1565 // halt demo playback to close the file
1568 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1571 static const char *FS_SysCheckGameDir(const char *gamedir)
1573 static char buf[8192];
1579 stringlistinit(&list);
1580 listdirectory(&list, gamedir, "");
1581 success = list.numstrings > 0;
1582 stringlistfreecontents(&list);
1586 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1589 n = FS_Read (f, buf, sizeof(buf) - 1);
1609 const char *FS_CheckGameDir(const char *gamedir)
1613 if (FS_CheckNastyPath(gamedir, true))
1616 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1621 // get description from basedir
1622 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1630 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1634 return fs_checkgamedir_missing;
1637 static void FS_ListGameDirs(void)
1639 stringlist_t list, list2;
1643 fs_all_gamedirs_count = 0;
1645 Mem_Free(fs_all_gamedirs);
1647 stringlistinit(&list);
1648 listdirectory(&list, va("%s/", fs_basedir), "");
1649 listdirectory(&list, va("%s/", fs_userdir), "");
1650 stringlistsort(&list, false);
1652 stringlistinit(&list2);
1653 for(i = 0; i < list.numstrings; ++i)
1656 if(!strcmp(list.strings[i-1], list.strings[i]))
1658 info = FS_CheckGameDir(list.strings[i]);
1661 if(info == fs_checkgamedir_missing)
1665 stringlistappend(&list2, list.strings[i]);
1667 stringlistfreecontents(&list);
1669 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1670 for(i = 0; i < list2.numstrings; ++i)
1672 info = FS_CheckGameDir(list2.strings[i]);
1673 // all this cannot happen any more, but better be safe than sorry
1676 if(info == fs_checkgamedir_missing)
1680 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1681 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1682 ++fs_all_gamedirs_count;
1688 #pragma comment(lib, "shell32.lib")
1698 void FS_Init_SelfPack (void)
1701 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1704 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1710 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1713 const char **new_argv;
1715 int args_left = 256;
1716 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1719 new_argv[0] = "dummy";
1724 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1727 while(COM_ParseToken_Console(&p))
1731 q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1732 strlcpy(q, com_token, strlen(com_token) + 1);
1733 new_argv[com_argc + i] = q;
1736 new_argv[i+com_argc] = NULL;
1737 com_argv = new_argv;
1738 com_argc = com_argc + i;
1745 int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1747 #if defined(__IPHONEOS__)
1748 if (userdirmode == USERDIRMODE_HOME)
1750 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1751 // fs_userdir stores configurations to the Documents folder of the app
1752 strlcpy(userdir, maxlength, "../Documents/");
1757 #elif defined(WIN32)
1759 #if _MSC_VER >= 1400
1762 TCHAR mydocsdir[MAX_PATH + 1];
1763 wchar_t *savedgamesdirw;
1764 char savedgamesdir[MAX_OSPATH];
1772 case USERDIRMODE_NOHOME:
1773 strlcpy(userdir, fs_basedir, userdirsize);
1775 case USERDIRMODE_MYGAMES:
1777 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1779 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1781 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1784 #if _MSC_VER >= 1400
1785 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1788 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1793 homedir = getenv("USERPROFILE");
1796 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1801 case USERDIRMODE_SAVEDGAMES:
1803 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1805 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1806 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1808 savedgamesdir[0] = 0;
1809 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1812 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1814 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1817 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1819 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1820 #if _MSC_VER >= 1400
1821 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1823 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1825 qCoTaskMemFree(savedgamesdirw);
1828 if (savedgamesdir[0])
1830 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1844 case USERDIRMODE_NOHOME:
1845 strlcpy(userdir, fs_basedir, userdirsize);
1847 case USERDIRMODE_HOME:
1848 homedir = getenv("HOME");
1851 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1855 case USERDIRMODE_SAVEDGAMES:
1856 homedir = getenv("HOME");
1860 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1862 // the XDG say some files would need to go in:
1863 // XDG_CONFIG_HOME (or ~/.config/%s/)
1864 // XDG_DATA_HOME (or ~/.local/share/%s/)
1865 // XDG_CACHE_HOME (or ~/.cache/%s/)
1866 // and also search the following global locations if defined:
1867 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1868 // XDG_DATA_DIRS (normally /usr/share/%s/)
1869 // this would be too complicated...
1880 // historical behavior...
1881 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1882 return 0; // don't bother checking if the basedir folder is writable, it's annoying... unless it is Quake on Windows where NOHOME is the default preferred and we have to check for an error case
1885 // see if we can write to this path (note: won't create path)
1887 # if _MSC_VER >= 1400
1888 _sopen_s(&fd, va("%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
1890 fd = open (va("%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1895 // on Unix, we don't need to ACTUALLY attempt to open the file
1896 if(access(va("%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1903 return 1; // good choice - the path exists and is writable
1907 if (userdirmode == USERDIRMODE_NOHOME)
1908 return -1; // path usually already exists, we lack permissions
1910 return 0; // probably good - failed to write but maybe we need to create path
1929 // Overrides the system supplied base directory (under GAMENAME)
1930 // 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)
1931 i = COM_CheckParm ("-basedir");
1932 if (i && i < com_argc-1)
1934 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1935 i = (int)strlen (fs_basedir);
1936 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1937 fs_basedir[i-1] = 0;
1941 // If the base directory is explicitly defined by the compilation process
1942 #ifdef DP_FS_BASEDIR
1943 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1944 #elif defined(MACOSX)
1945 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1946 if (strstr(com_argv[0], ".app/"))
1949 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1950 split = strstr(fs_basedir, ".app/");
1953 struct stat statresult;
1954 // truncate to just after the .app/
1956 // see if gamedir exists in Resources
1957 if (stat(va("%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1959 // found gamedir inside Resources, use it
1960 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1964 // no gamedir found in Resources, gamedir is probably
1965 // outside the .app, remove .app part of path
1966 while (split > fs_basedir && *split != '/')
1975 // make sure the appending of a path separator won't create an unterminated string
1976 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1977 // add a path separator to the end of the basedir if it lacks one
1978 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1979 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1981 // Add the personal game directory
1982 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1983 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1984 else if (COM_CheckParm("-nohome"))
1985 *fs_userdir = 0; // user wants roaming installation, no userdir
1989 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1990 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1991 int userdirstatus[USERDIRMODE_COUNT];
1993 // historical behavior...
1994 if (!strcmp(gamedirname1, "id1"))
1995 preferreduserdirmode = USERDIRMODE_NOHOME;
1997 // check what limitations the user wants to impose
1998 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
1999 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2000 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2001 // gather the status of the possible userdirs
2002 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2004 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2005 if (userdirstatus[dirmode] == 1)
2006 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2007 else if (userdirstatus[dirmode] == 0)
2008 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2010 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2012 // some games may prefer writing to basedir, but if write fails we
2013 // have to search for a real userdir...
2014 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2015 preferreduserdirmode = highestuserdirmode;
2016 // check for an existing userdir and continue using it if possible...
2017 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2018 if (userdirstatus[dirmode] == 1)
2020 // if no existing userdir found, make a new one...
2021 if (dirmode == 0 && preferreduserdirmode > 0)
2022 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2023 if (userdirstatus[dirmode] >= 0)
2025 // and finally, we picked one...
2026 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2027 Con_DPrintf("userdir %i is the winner\n", dirmode);
2030 // if userdir equal to basedir, clear it to avoid confusion later
2031 if (!strcmp(fs_basedir, fs_userdir))
2036 p = FS_CheckGameDir(gamedirname1);
2037 if(!p || p == fs_checkgamedir_missing)
2038 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2042 p = FS_CheckGameDir(gamedirname2);
2043 if(!p || p == fs_checkgamedir_missing)
2044 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2048 // Adds basedir/gamedir as an override game
2049 // LordHavoc: now supports multiple -game directories
2050 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2054 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2057 p = FS_CheckGameDir(com_argv[i]);
2059 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2060 if(p == fs_checkgamedir_missing)
2061 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2062 // add the gamedir to the list of active gamedirs
2063 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2068 // generate the searchpath
2072 void FS_Init_Commands(void)
2074 Cvar_RegisterVariable (&scr_screenshot_name);
2075 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2076 Cvar_RegisterVariable (&cvar_fs_gamedir);
2078 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2079 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2080 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2081 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2082 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2083 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2091 void FS_Shutdown (void)
2093 // close all pack files and such
2094 // (hopefully there aren't any other open files, but they'll be cleaned up
2095 // by the OS anyway)
2096 FS_ClearSearchPath();
2097 Mem_FreePool (&fs_mempool);
2100 Sys_UnloadLibrary (&shfolder_dll);
2101 Sys_UnloadLibrary (&shell32_dll);
2102 Sys_UnloadLibrary (&ole32_dll);
2106 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2112 // Parse the mode string
2121 opt = O_CREAT | O_TRUNC;
2125 opt = O_CREAT | O_APPEND;
2128 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2131 for (ind = 1; mode[ind] != '\0'; ind++)
2142 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2143 filepath, mode, mode[ind]);
2150 #if _MSC_VER >= 1400
2151 _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
2153 handle = open (filepath, mod | opt, 0666);
2159 ====================
2162 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2163 ====================
2165 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2169 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2171 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2172 if (file->handle < 0)
2178 file->filename = Mem_strdup(fs_mempool, filepath);
2180 file->real_length = lseek (file->handle, 0, SEEK_END);
2182 // For files opened in append mode, we start at the end of the file
2184 file->position = file->real_length;
2186 lseek (file->handle, 0, SEEK_SET);
2196 Open a packed file using its package file descriptor
2199 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2205 pfile = &pack->files[pack_ind];
2207 // If we don't have the true offset, get it now
2208 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2209 if (!PK3_GetTrueFileOffset (pfile, pack))
2212 #ifndef LINK_TO_ZLIB
2213 // No Zlib DLL = no compressed files
2214 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2216 Con_Printf("WARNING: can't open the compressed file %s\n"
2217 "You need the Zlib DLL to use compressed files\n",
2223 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2224 // the dup() call to avoid having to close the dup_handle on error here
2225 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2227 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2228 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2232 dup_handle = dup (pack->handle);
2235 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2239 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2240 memset (file, 0, sizeof (*file));
2241 file->handle = dup_handle;
2242 file->flags = QFILE_FLAG_PACKED;
2243 file->real_length = pfile->realsize;
2244 file->offset = pfile->offset;
2248 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2252 file->flags |= QFILE_FLAG_DEFLATED;
2254 // We need some more variables
2255 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2257 ztk->comp_length = pfile->packsize;
2259 // Initialize zlib stream
2260 ztk->zstream.next_in = ztk->input;
2261 ztk->zstream.avail_in = 0;
2263 /* From Zlib's "unzip.c":
2265 * windowBits is passed < 0 to tell that there is no zlib header.
2266 * Note that in this case inflate *requires* an extra "dummy" byte
2267 * after the compressed stream in order to complete decompression and
2268 * return Z_STREAM_END.
2269 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2270 * size of both compressed and uncompressed data
2272 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2274 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2280 ztk->zstream.next_out = file->buff;
2281 ztk->zstream.avail_out = sizeof (file->buff);
2290 ====================
2293 Return true if the path should be rejected due to one of the following:
2294 1: path elements that are non-portable
2295 2: path elements that would allow access to files outside the game directory,
2296 or are just not a good idea for a mod to be using.
2297 ====================
2299 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2301 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2305 // Windows: don't allow \ in filenames (windows-only), period.
2306 // (on Windows \ is a directory separator, but / is also supported)
2307 if (strstr(path, "\\"))
2308 return 1; // non-portable
2310 // Mac: don't allow Mac-only filenames - : is a directory separator
2311 // instead of /, but we rely on / working already, so there's no reason to
2312 // support a Mac-only path
2313 // Amiga and Windows: : tries to go to root of drive
2314 if (strstr(path, ":"))
2315 return 1; // non-portable attempt to go to root of drive
2317 // Amiga: // is parent directory
2318 if (strstr(path, "//"))
2319 return 1; // non-portable attempt to go to parent directory
2321 // all: don't allow going to parent directory (../ or /../)
2322 if (strstr(path, ".."))
2323 return 2; // attempt to go outside the game directory
2325 // Windows and UNIXes: don't allow absolute paths
2327 return 2; // attempt to go outside the game directory
2329 // 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
2330 if (strchr(path, '.'))
2334 // gamedir is entirely path elements, so simply forbid . entirely
2337 if (strchr(path, '.') < strrchr(path, '/'))
2338 return 2; // possible attempt to go outside the game directory
2341 // all: forbid trailing slash on gamedir
2342 if (isgamedir && path[strlen(path)-1] == '/')
2345 // all: forbid leading dot on any filename for any reason
2346 if (strstr(path, "/."))
2347 return 2; // attempt to go outside the game directory
2349 // after all these checks we're pretty sure it's a / separated filename
2350 // and won't do much if any harm
2356 ====================
2359 Look for a file in the packages and in the filesystem
2361 Return the searchpath where the file was found (or NULL)
2362 and the file index in the package if relevant
2363 ====================
2365 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2367 searchpath_t *search;
2370 // search through the path, one element at a time
2371 for (search = fs_searchpaths;search;search = search->next)
2373 // is the element a pak file?
2374 if (search->pack && !search->pack->vpack)
2376 int (*strcmp_funct) (const char* str1, const char* str2);
2377 int left, right, middle;
2380 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2382 // Look for the file (binary search)
2384 right = pak->numfiles - 1;
2385 while (left <= right)
2389 middle = (left + right) / 2;
2390 diff = strcmp_funct (pak->files[middle].name, name);
2395 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2397 // yes, but the first one is empty so we treat it as not being there
2398 if (!quiet && developer_extra.integer)
2399 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2406 if (!quiet && developer_extra.integer)
2407 Con_DPrintf("FS_FindFile: %s in %s\n",
2408 pak->files[middle].name, pak->filename);
2415 // If we're too far in the list
2424 char netpath[MAX_OSPATH];
2425 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2426 if (FS_SysFileExists (netpath))
2428 if (!quiet && developer_extra.integer)
2429 Con_DPrintf("FS_FindFile: %s\n", netpath);
2438 if (!quiet && developer_extra.integer)
2439 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2451 Look for a file in the search paths and open it in read-only mode
2454 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2456 searchpath_t *search;
2459 search = FS_FindFile (filename, &pack_ind, quiet);
2465 // Found in the filesystem?
2468 // this works with vpacks, so we are fine
2469 char path [MAX_OSPATH];
2470 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2471 return FS_SysOpen (path, "rb", nonblocking);
2474 // So, we found it in a package...
2476 // Is it a PK3 symlink?
2477 // TODO also handle directory symlinks by parsing the whole structure...
2478 // but heck, file symlinks are good enough for now
2479 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2481 if(symlinkLevels <= 0)
2483 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2488 char linkbuf[MAX_QPATH];
2490 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2491 const char *mergeslash;
2496 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2502 // Now combine the paths...
2503 mergeslash = strrchr(filename, '/');
2504 mergestart = linkbuf;
2506 mergeslash = filename;
2507 while(!strncmp(mergestart, "../", 3))
2510 while(mergeslash > filename)
2513 if(*mergeslash == '/')
2517 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2518 if(mergeslash == filename)
2520 // Either mergeslash == filename, then we just replace the name (done below)
2524 // Or, we append the name after mergeslash;
2525 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2526 int spaceNeeded = mergeslash - filename + 1;
2527 int spaceRemoved = mergestart - linkbuf;
2528 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2530 Con_DPrintf("symlink: too long path rejected\n");
2533 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2534 memcpy(linkbuf, filename, spaceNeeded);
2535 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2536 mergestart = linkbuf;
2538 if (!quiet && developer_loading.integer)
2539 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2540 if(FS_CheckNastyPath (mergestart, false))
2542 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2545 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2549 return FS_OpenPackedFile (search->pack, pack_ind);
2554 =============================================================================
2556 MAIN PUBLIC FUNCTIONS
2558 =============================================================================
2562 ====================
2565 Open a file in the userpath. The syntax is the same as fopen
2566 Used for savegame scanning in menu, and all file writing.
2567 ====================
2569 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2571 char real_path [MAX_OSPATH];
2573 if (FS_CheckNastyPath(filepath, false))
2575 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2579 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2581 // If the file is opened in "write", "append", or "read/write" mode,
2582 // create directories up to the file.
2583 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2584 FS_CreatePath (real_path);
2585 return FS_SysOpen (real_path, mode, false);
2590 ====================
2593 Open a file. The syntax is the same as fopen
2594 ====================
2596 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2598 if (FS_CheckNastyPath(filepath, false))
2600 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2604 return FS_OpenReadFile (filepath, quiet, false, 16);
2609 ====================
2612 Open a file. The syntax is the same as fopen
2613 ====================
2615 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2618 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2619 memset (file, 0, sizeof (*file));
2620 file->flags = QFILE_FLAG_DATA;
2622 file->real_length = size;
2628 ====================
2632 ====================
2634 int FS_Close (qfile_t* file)
2636 if(file->flags & QFILE_FLAG_DATA)
2642 if (close (file->handle))
2647 if (file->flags & QFILE_FLAG_REMOVE)
2648 remove(file->filename);
2650 Mem_Free((void *) file->filename);
2655 qz_inflateEnd (&file->ztk->zstream);
2656 Mem_Free (file->ztk);
2663 void FS_RemoveOnClose(qfile_t* file)
2665 file->flags |= QFILE_FLAG_REMOVE;
2669 ====================
2672 Write "datasize" bytes into a file
2673 ====================
2675 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2679 // If necessary, seek to the exact file position we're supposed to be
2680 if (file->buff_ind != file->buff_len)
2681 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2683 // Purge cached data
2686 // Write the buffer and update the position
2687 result = write (file->handle, data, (fs_offset_t)datasize);
2688 file->position = lseek (file->handle, 0, SEEK_CUR);
2689 if (file->real_length < file->position)
2690 file->real_length = file->position;
2700 ====================
2703 Read up to "buffersize" bytes from a file
2704 ====================
2706 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2708 fs_offset_t count, done;
2710 if (buffersize == 0)
2713 // Get rid of the ungetc character
2714 if (file->ungetc != EOF)
2716 ((char*)buffer)[0] = file->ungetc;
2724 if(file->flags & QFILE_FLAG_DATA)
2726 size_t left = file->real_length - file->position;
2727 if(buffersize > left)
2729 memcpy(buffer, file->data + file->position, buffersize);
2730 file->position += buffersize;
2734 // First, we copy as many bytes as we can from "buff"
2735 if (file->buff_ind < file->buff_len)
2737 count = file->buff_len - file->buff_ind;
2738 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2740 memcpy (buffer, &file->buff[file->buff_ind], count);
2741 file->buff_ind += count;
2743 buffersize -= count;
2744 if (buffersize == 0)
2748 // NOTE: at this point, the read buffer is always empty
2750 // If the file isn't compressed
2751 if (! (file->flags & QFILE_FLAG_DEFLATED))
2755 // We must take care to not read after the end of the file
2756 count = file->real_length - file->position;
2758 // If we have a lot of data to get, put them directly into "buffer"
2759 if (buffersize > sizeof (file->buff) / 2)
2761 if (count > (fs_offset_t)buffersize)
2762 count = (fs_offset_t)buffersize;
2763 lseek (file->handle, file->offset + file->position, SEEK_SET);
2764 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2768 file->position += nb;
2770 // Purge cached data
2776 if (count > (fs_offset_t)sizeof (file->buff))
2777 count = (fs_offset_t)sizeof (file->buff);
2778 lseek (file->handle, file->offset + file->position, SEEK_SET);
2779 nb = read (file->handle, file->buff, count);
2782 file->buff_len = nb;
2783 file->position += nb;
2785 // Copy the requested data in "buffer" (as much as we can)
2786 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2787 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2788 file->buff_ind = count;
2796 // If the file is compressed, it's more complicated...
2797 // We cycle through a few operations until we have read enough data
2798 while (buffersize > 0)
2800 ztoolkit_t *ztk = file->ztk;
2803 // NOTE: at this point, the read buffer is always empty
2805 // If "input" is also empty, we need to refill it
2806 if (ztk->in_ind == ztk->in_len)
2808 // If we are at the end of the file
2809 if (file->position == file->real_length)
2812 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2813 if (count > (fs_offset_t)sizeof (ztk->input))
2814 count = (fs_offset_t)sizeof (ztk->input);
2815 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2816 if (read (file->handle, ztk->input, count) != count)
2818 Con_Printf ("FS_Read: unexpected end of file\n");
2823 ztk->in_len = count;
2824 ztk->in_position += count;
2827 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2828 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2830 // Now that we are sure we have compressed data available, we need to determine
2831 // if it's better to inflate it in "file->buff" or directly in "buffer"
2833 // Inflate the data in "file->buff"
2834 if (buffersize < sizeof (file->buff) / 2)
2836 ztk->zstream.next_out = file->buff;
2837 ztk->zstream.avail_out = sizeof (file->buff);
2838 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2839 if (error != Z_OK && error != Z_STREAM_END)
2841 Con_Printf ("FS_Read: Can't inflate file\n");
2844 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2846 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2847 file->position += file->buff_len;
2849 // Copy the requested data in "buffer" (as much as we can)
2850 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2851 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2852 file->buff_ind = count;
2855 // Else, we inflate directly in "buffer"
2858 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2859 ztk->zstream.avail_out = (unsigned int)buffersize;
2860 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2861 if (error != Z_OK && error != Z_STREAM_END)
2863 Con_Printf ("FS_Read: Can't inflate file\n");
2866 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2868 // How much data did it inflate?
2869 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2870 file->position += count;
2872 // Purge cached data
2877 buffersize -= count;
2885 ====================
2888 Print a string into a file
2889 ====================
2891 int FS_Print (qfile_t* file, const char *msg)
2893 return (int)FS_Write (file, msg, strlen (msg));
2897 ====================
2900 Print a string into a file
2901 ====================
2903 int FS_Printf(qfile_t* file, const char* format, ...)
2908 va_start (args, format);
2909 result = FS_VPrintf (file, format, args);
2917 ====================
2920 Print a string into a file
2921 ====================
2923 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2926 fs_offset_t buff_size = MAX_INPUTLINE;
2931 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2932 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2933 if (len >= 0 && len < buff_size)
2935 Mem_Free (tempbuff);
2939 len = write (file->handle, tempbuff, len);
2940 Mem_Free (tempbuff);
2947 ====================
2950 Get the next character of a file
2951 ====================
2953 int FS_Getc (qfile_t* file)
2957 if (FS_Read (file, &c, 1) != 1)
2965 ====================
2968 Put a character back into the read buffer (only supports one character!)
2969 ====================
2971 int FS_UnGetc (qfile_t* file, unsigned char c)
2973 // If there's already a character waiting to be read
2974 if (file->ungetc != EOF)
2983 ====================
2986 Move the position index in a file
2987 ====================
2989 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2992 unsigned char* buffer;
2993 fs_offset_t buffersize;
2995 // Compute the file offset
2999 offset += file->position - file->buff_len + file->buff_ind;
3006 offset += file->real_length;
3012 if (offset < 0 || offset > file->real_length)
3015 if(file->flags & QFILE_FLAG_DATA)
3017 file->position = offset;
3021 // If we have the data in our read buffer, we don't need to actually seek
3022 if (file->position - file->buff_len <= offset && offset <= file->position)
3024 file->buff_ind = offset + file->buff_len - file->position;
3028 // Purge cached data
3031 // Unpacked or uncompressed files can seek directly
3032 if (! (file->flags & QFILE_FLAG_DEFLATED))
3034 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3036 file->position = offset;
3040 // Seeking in compressed files is more a hack than anything else,
3041 // but we need to support it, so here we go.
3044 // If we have to go back in the file, we need to restart from the beginning
3045 if (offset <= file->position)
3049 ztk->in_position = 0;
3051 lseek (file->handle, file->offset, SEEK_SET);
3053 // Reset the Zlib stream
3054 ztk->zstream.next_in = ztk->input;
3055 ztk->zstream.avail_in = 0;
3056 qz_inflateReset (&ztk->zstream);
3059 // We need a big buffer to force inflating into it directly
3060 buffersize = 2 * sizeof (file->buff);
3061 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3063 // Skip all data until we reach the requested offset
3064 while (offset > file->position)
3066 fs_offset_t diff = offset - file->position;
3067 fs_offset_t count, len;
3069 count = (diff > buffersize) ? buffersize : diff;
3070 len = FS_Read (file, buffer, count);
3084 ====================
3087 Give the current position in a file
3088 ====================
3090 fs_offset_t FS_Tell (qfile_t* file)
3092 return file->position - file->buff_len + file->buff_ind;
3097 ====================
3100 Give the total size of a file
3101 ====================
3103 fs_offset_t FS_FileSize (qfile_t* file)
3105 return file->real_length;
3110 ====================
3113 Erases any buffered input or output data
3114 ====================
3116 void FS_Purge (qfile_t* file)
3128 Filename are relative to the quake directory.
3129 Always appends a 0 byte.
3132 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3135 unsigned char *buf = NULL;
3136 fs_offset_t filesize = 0;
3138 file = FS_OpenVirtualFile(path, quiet);
3141 filesize = file->real_length;
3144 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3149 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3150 buf[filesize] = '\0';
3151 FS_Read (file, buf, filesize);
3153 if (developer_loadfile.integer)
3154 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3157 if (filesizepointer)
3158 *filesizepointer = filesize;
3167 The filename will be prefixed by the current game directory
3170 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3174 fs_offset_t lentotal;
3176 file = FS_OpenRealFile(filename, "wb", false);
3179 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3184 for(i = 0; i < count; ++i)
3186 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3187 for(i = 0; i < count; ++i)
3188 FS_Write (file, data[i], len[i]);
3193 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3195 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3200 =============================================================================
3202 OTHERS PUBLIC FUNCTIONS
3204 =============================================================================
3212 void FS_StripExtension (const char *in, char *out, size_t size_out)
3220 while ((currentchar = *in) && size_out > 1)
3222 if (currentchar == '.')
3224 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3226 *out++ = currentchar;
3242 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3246 // if path doesn't have a .EXT, append extension
3247 // (extension should include the .)
3248 src = path + strlen(path) - 1;
3250 while (*src != '/' && src != path)
3253 return; // it has an extension
3257 strlcat (path, extension, size_path);
3265 Look for a file in the packages and in the filesystem
3268 int FS_FileType (const char *filename)
3270 searchpath_t *search;
3271 char fullpath[MAX_OSPATH];
3273 search = FS_FindFile (filename, NULL, true);
3275 return FS_FILETYPE_NONE;
3277 if(search->pack && !search->pack->vpack)
3278 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3280 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3281 return FS_SysFileType(fullpath);
3289 Look for a file in the packages and in the filesystem
3292 qboolean FS_FileExists (const char *filename)
3294 return (FS_FindFile (filename, NULL, true) != NULL);
3302 Look for a file in the filesystem only
3305 int FS_SysFileType (const char *path)
3308 // Sajt - some older sdks are missing this define
3309 # ifndef INVALID_FILE_ATTRIBUTES
3310 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3313 DWORD result = GetFileAttributes(path);
3315 if(result == INVALID_FILE_ATTRIBUTES)
3316 return FS_FILETYPE_NONE;
3318 if(result & FILE_ATTRIBUTE_DIRECTORY)
3319 return FS_FILETYPE_DIRECTORY;
3321 return FS_FILETYPE_FILE;
3325 if (stat (path,&buf) == -1)
3326 return FS_FILETYPE_NONE;
3329 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3331 if(S_ISDIR(buf.st_mode))
3332 return FS_FILETYPE_DIRECTORY;
3334 return FS_FILETYPE_FILE;
3338 qboolean FS_SysFileExists (const char *path)
3340 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3343 void FS_mkdir (const char *path)
3356 Allocate and fill a search structure with information on matching filenames.
3359 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3362 searchpath_t *searchpath;
3364 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3365 stringlist_t resultlist;
3366 stringlist_t dirlist;
3367 const char *slash, *backslash, *colon, *separator;
3369 char temp[MAX_OSPATH];
3371 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3376 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3380 stringlistinit(&resultlist);
3381 stringlistinit(&dirlist);
3383 slash = strrchr(pattern, '/');
3384 backslash = strrchr(pattern, '\\');
3385 colon = strrchr(pattern, ':');
3386 separator = max(slash, backslash);
3387 separator = max(separator, colon);
3388 basepathlength = separator ? (separator + 1 - pattern) : 0;
3389 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3391 memcpy(basepath, pattern, basepathlength);
3392 basepath[basepathlength] = 0;
3394 // search through the path, one element at a time
3395 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3397 // is the element a pak file?
3398 if (searchpath->pack && !searchpath->pack->vpack)
3400 // look through all the pak file elements
3401 pak = searchpath->pack;
3402 for (i = 0;i < pak->numfiles;i++)
3404 strlcpy(temp, pak->files[i].name, sizeof(temp));
3407 if (matchpattern(temp, (char *)pattern, true))
3409 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3410 if (!strcmp(resultlist.strings[resultlistindex], temp))
3412 if (resultlistindex == resultlist.numstrings)
3414 stringlistappend(&resultlist, temp);
3415 if (!quiet && developer_loading.integer)
3416 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3419 // strip off one path element at a time until empty
3420 // this way directories are added to the listing if they match the pattern
3421 slash = strrchr(temp, '/');
3422 backslash = strrchr(temp, '\\');
3423 colon = strrchr(temp, ':');
3425 if (separator < slash)
3427 if (separator < backslash)
3428 separator = backslash;
3429 if (separator < colon)
3431 *((char *)separator) = 0;
3437 stringlist_t matchedSet, foundSet;
3438 const char *start = pattern;
3440 stringlistinit(&matchedSet);
3441 stringlistinit(&foundSet);
3442 // add a first entry to the set
3443 stringlistappend(&matchedSet, "");
3444 // iterate through pattern's path
3447 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3448 char subpath[MAX_OSPATH];
3449 char subpattern[MAX_OSPATH];
3451 // find the next wildcard
3452 wildcard = strchr(start, '?');
3453 asterisk = strchr(start, '*');
3454 if (asterisk && (!wildcard || asterisk < wildcard))
3456 wildcard = asterisk;
3461 nextseparator = strchr( wildcard, '/' );
3465 nextseparator = NULL;
3468 if( !nextseparator ) {
3469 nextseparator = start + strlen( start );
3472 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3473 // copy everything up except nextseperator
3474 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3475 // find the last '/' before the wildcard
3476 prevseparator = strrchr( subpattern, '/' );
3478 prevseparator = subpattern;
3481 // copy everything from start to the previous including the '/' (before the wildcard)
3482 // everything up to start is already included in the path of matchedSet's entries
3483 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3485 // for each entry in matchedSet try to open the subdirectories specified in subpath
3486 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3487 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3488 strlcat( temp, subpath, sizeof(temp) );
3489 listdirectory( &foundSet, searchpath->filename, temp );
3491 if( dirlistindex == 0 ) {
3494 // reset the current result set
3495 stringlistfreecontents( &matchedSet );
3496 // match against the pattern
3497 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3498 const char *direntry = foundSet.strings[ dirlistindex ];
3499 if (matchpattern(direntry, subpattern, true)) {
3500 stringlistappend( &matchedSet, direntry );
3503 stringlistfreecontents( &foundSet );
3505 start = nextseparator;
3508 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3510 const char *temp = matchedSet.strings[dirlistindex];
3511 if (matchpattern(temp, (char *)pattern, true))
3513 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3514 if (!strcmp(resultlist.strings[resultlistindex], temp))
3516 if (resultlistindex == resultlist.numstrings)
3518 stringlistappend(&resultlist, temp);
3519 if (!quiet && developer_loading.integer)
3520 Con_Printf("SearchDirFile: %s\n", temp);
3524 stringlistfreecontents( &matchedSet );
3528 if (resultlist.numstrings)
3530 stringlistsort(&resultlist, true);
3531 numfiles = resultlist.numstrings;
3533 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3534 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3535 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3536 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3537 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3538 search->numfilenames = (int)numfiles;
3541 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3544 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3545 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3546 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3548 numchars += (int)textlen;
3551 stringlistfreecontents(&resultlist);
3557 void FS_FreeSearch(fssearch_t *search)
3562 extern int con_linewidth;
3563 int FS_ListDirectory(const char *pattern, int oneperline)
3572 char linebuf[MAX_INPUTLINE];
3574 search = FS_Search(pattern, true, true);
3577 numfiles = search->numfilenames;
3580 // FIXME: the names could be added to one column list and then
3581 // gradually shifted into the next column if they fit, and then the
3582 // next to make a compact variable width listing but it's a lot more
3584 // find width for columns
3586 for (i = 0;i < numfiles;i++)
3588 l = (int)strlen(search->filenames[i]);
3589 if (columnwidth < l)
3592 // count the spacing character
3594 // calculate number of columns
3595 numcolumns = con_linewidth / columnwidth;
3596 // don't bother with the column printing if it's only one column
3597 if (numcolumns >= 2)
3599 numlines = (numfiles + numcolumns - 1) / numcolumns;
3600 for (i = 0;i < numlines;i++)
3603 for (k = 0;k < numcolumns;k++)
3605 l = i * numcolumns + k;
3608 name = search->filenames[l];
3609 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3610 linebuf[linebufpos++] = name[j];
3611 // space out name unless it's the last on the line
3612 if (k + 1 < numcolumns && l + 1 < numfiles)
3613 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3614 linebuf[linebufpos++] = ' ';
3617 linebuf[linebufpos] = 0;
3618 Con_Printf("%s\n", linebuf);
3625 for (i = 0;i < numfiles;i++)
3626 Con_Printf("%s\n", search->filenames[i]);
3627 FS_FreeSearch(search);
3628 return (int)numfiles;
3631 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3633 const char *pattern;
3634 if (Cmd_Argc() >= 3)
3636 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3639 if (Cmd_Argc() == 2)
3640 pattern = Cmd_Argv(1);
3643 if (!FS_ListDirectory(pattern, oneperline))
3644 Con_Print("No files found.\n");
3649 FS_ListDirectoryCmd("dir", true);
3654 FS_ListDirectoryCmd("ls", false);
3657 void FS_Which_f(void)
3659 const char *filename;
3662 if (Cmd_Argc() != 2)
3664 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3667 filename = Cmd_Argv(1);
3668 sp = FS_FindFile(filename, &index, true);
3670 Con_Printf("%s isn't anywhere\n", filename);
3676 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3678 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3681 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3685 const char *FS_WhichPack(const char *filename)
3688 searchpath_t *sp = FS_FindFile(filename, &index, true);
3690 return sp->pack->shortname;
3696 ====================
3697 FS_IsRegisteredQuakePack
3699 Look for a proof of purchase file file in the requested package
3701 If it is found, this file should NOT be downloaded.
3702 ====================
3704 qboolean FS_IsRegisteredQuakePack(const char *name)
3706 searchpath_t *search;
3709 // search through the path, one element at a time
3710 for (search = fs_searchpaths;search;search = search->next)
3712 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3713 // TODO do we want to support vpacks in here too?
3715 int (*strcmp_funct) (const char* str1, const char* str2);
3716 int left, right, middle;
3719 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3721 // Look for the file (binary search)
3723 right = pak->numfiles - 1;
3724 while (left <= right)
3728 middle = (left + right) / 2;
3729 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3735 // If we're too far in the list
3742 // we found the requested pack but it is not registered quake
3750 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3753 unsigned char *filedata;
3754 fs_offset_t filesize;
3755 if (filesizepointer)
3756 *filesizepointer = 0;
3757 if (!filename || !*filename)
3759 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3762 if (filesizepointer)
3763 *filesizepointer = filesize;
3764 crc = CRC_Block(filedata, filesize);
3770 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3773 unsigned char *out = NULL;
3777 #ifndef LINK_TO_ZLIB
3782 memset(&strm, 0, sizeof(strm));
3783 strm.zalloc = Z_NULL;
3784 strm.zfree = Z_NULL;
3785 strm.opaque = Z_NULL;
3788 level = Z_DEFAULT_COMPRESSION;
3790 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3792 Con_Printf("FS_Deflate: deflate init error!\n");
3796 strm.next_in = (unsigned char*)data;
3797 strm.avail_in = size;
3799 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3802 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3803 qz_deflateEnd(&strm);
3807 strm.next_out = tmp;
3808 strm.avail_out = size;
3810 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3812 Con_Printf("FS_Deflate: deflate failed!\n");
3813 qz_deflateEnd(&strm);
3818 if(qz_deflateEnd(&strm) != Z_OK)
3820 Con_Printf("FS_Deflate: deflateEnd failed\n");
3825 if(strm.total_out >= size)
3827 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3832 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3835 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3841 *deflated_size = (size_t)strm.total_out;
3843 memcpy(out, tmp, strm.total_out);
3849 static void AssertBufsize(sizebuf_t *buf, int length)
3851 if(buf->cursize + length > buf->maxsize)
3853 int oldsize = buf->maxsize;
3854 unsigned char *olddata;
3855 olddata = buf->data;
3856 buf->maxsize += length;
3857 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3860 memcpy(buf->data, olddata, oldsize);
3866 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3870 unsigned char *out = NULL;
3871 unsigned char tmp[2048];
3876 #ifndef LINK_TO_ZLIB
3881 memset(&outbuf, 0, sizeof(outbuf));
3882 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3883 outbuf.maxsize = sizeof(tmp);
3885 memset(&strm, 0, sizeof(strm));
3886 strm.zalloc = Z_NULL;
3887 strm.zfree = Z_NULL;
3888 strm.opaque = Z_NULL;
3890 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3892 Con_Printf("FS_Inflate: inflate init error!\n");
3893 Mem_Free(outbuf.data);
3897 strm.next_in = (unsigned char*)data;
3898 strm.avail_in = size;
3902 strm.next_out = tmp;
3903 strm.avail_out = sizeof(tmp);
3904 ret = qz_inflate(&strm, Z_NO_FLUSH);
3905 // it either returns Z_OK on progress, Z_STREAM_END on end
3913 case Z_STREAM_ERROR:
3914 Con_Print("FS_Inflate: stream error!\n");
3917 Con_Print("FS_Inflate: data error!\n");
3920 Con_Print("FS_Inflate: mem error!\n");
3923 Con_Print("FS_Inflate: buf error!\n");
3926 Con_Print("FS_Inflate: unknown error!\n");
3930 if(ret != Z_OK && ret != Z_STREAM_END)
3932 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3933 Mem_Free(outbuf.data);
3934 qz_inflateEnd(&strm);
3937 have = sizeof(tmp) - strm.avail_out;
3938 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3939 SZ_Write(&outbuf, tmp, have);
3940 } while(ret != Z_STREAM_END);
3942 qz_inflateEnd(&strm);
3944 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3947 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3948 Mem_Free(outbuf.data);
3952 memcpy(out, outbuf.data, outbuf.cursize);
3953 Mem_Free(outbuf.data);
3956 *inflated_size = (size_t)outbuf.cursize;