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>
40 # include <sys/stat.h>
44 # include <sys/stat.h>
54 // Win32 requires us to add O_BINARY, but the other OSes don't have it
59 // In case the system doesn't support the O_NONBLOCK flag
64 // largefile support for Win32
67 # define lseek _lseeki64
70 // suppress deprecated warnings
75 # define unlink _unlink
79 /** \page fs File System
81 All of Quake's data access is through a hierchal file system, but the contents
82 of the file system can be transparently merged from several sources.
84 The "base directory" is the path to the directory holding the quake.exe and
85 all game directories. The sys_* files pass this to host_init in
86 quakeparms_t->basedir. This can be overridden with the "-basedir" command
87 line parm to allow code debugging in a different directory. The base
88 directory is only used during filesystem initialization.
90 The "game directory" is the first tree on the search path and directory that
91 all generated files (savegames, screenshots, demos, config files) will be
92 saved to. This can be overridden with the "-game" command line parameter.
93 The game directory can never be changed while quake is executing. This is a
94 precaution against having a malicious server instruct clients to write files
95 over areas they shouldn't.
101 =============================================================================
105 =============================================================================
108 // Magic numbers of a ZIP file (big-endian format)
109 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
110 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
111 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
113 // Other constants for ZIP files
114 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
115 #define ZIP_END_CDIR_SIZE 22
116 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
117 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
122 #define qz_inflate inflate
123 #define qz_inflateEnd inflateEnd
124 #define qz_inflateInit2_ inflateInit2_
125 #define qz_inflateReset inflateReset
126 #define qz_deflateInit2_ deflateInit2_
127 #define qz_deflateEnd deflateEnd
128 #define qz_deflate deflate
129 #define Z_MEMLEVEL_DEFAULT 8
132 // Zlib constants (from zlib.h)
133 #define Z_SYNC_FLUSH 2
136 #define Z_STREAM_END 1
137 #define Z_STREAM_ERROR (-2)
138 #define Z_DATA_ERROR (-3)
139 #define Z_MEM_ERROR (-4)
140 #define Z_BUF_ERROR (-5)
141 #define ZLIB_VERSION "1.2.3"
145 #define Z_MEMLEVEL_DEFAULT 8
148 #define Z_DEFAULT_COMPRESSION (-1)
150 #define Z_SYNC_FLUSH 2
151 #define Z_FULL_FLUSH 3
154 // Uncomment the following line if the zlib DLL you have still uses
155 // the 1.1.x series calling convention on Win32 (WINAPI)
156 //#define ZLIB_USES_WINAPI
160 =============================================================================
164 =============================================================================
167 /*! Zlib stream (from zlib.h)
168 * \warning: some pointers we don't use directly have
169 * been cast to "void*" for a matter of simplicity
173 unsigned char *next_in; ///< next input byte
174 unsigned int avail_in; ///< number of bytes available at next_in
175 unsigned long total_in; ///< total nb of input bytes read so far
177 unsigned char *next_out; ///< next output byte should be put there
178 unsigned int avail_out; ///< remaining free space at next_out
179 unsigned long total_out; ///< total nb of bytes output so far
181 char *msg; ///< last error message, NULL if no error
182 void *state; ///< not visible by applications
184 void *zalloc; ///< used to allocate the internal state
185 void *zfree; ///< used to free the internal state
186 void *opaque; ///< private data object passed to zalloc and zfree
188 int data_type; ///< best guess about the data type: ascii or binary
189 unsigned long adler; ///< adler32 value of the uncompressed data
190 unsigned long reserved; ///< reserved for future use
195 /// inside a package (PAK or PK3)
196 #define QFILE_FLAG_PACKED (1 << 0)
197 /// file is compressed using the deflate algorithm (PK3 only)
198 #define QFILE_FLAG_DEFLATED (1 << 1)
199 /// file is actually already loaded data
200 #define QFILE_FLAG_DATA (1 << 2)
201 /// real file will be removed on close
202 #define QFILE_FLAG_REMOVE (1 << 3)
204 #define FILE_BUFF_SIZE 2048
208 size_t comp_length; ///< length of the compressed file
209 size_t in_ind, in_len; ///< input buffer current index and length
210 size_t in_position; ///< position in the compressed file
211 unsigned char input [FILE_BUFF_SIZE];
217 int handle; ///< file descriptor
218 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
219 fs_offset_t position; ///< current position in the file
220 fs_offset_t offset; ///< offset into the package (0 if external file)
221 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
224 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
225 unsigned char buff [FILE_BUFF_SIZE];
227 ztoolkit_t* ztk; ///< For zipped files.
229 const unsigned char *data; ///< For data files.
231 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
235 // ------ PK3 files on disk ------ //
237 // You can get the complete ZIP format description from PKWARE website
239 typedef struct pk3_endOfCentralDir_s
241 unsigned int signature;
242 unsigned short disknum;
243 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
244 unsigned short localentries; ///< number of entries in the central directory on this disk
245 unsigned short nbentries; ///< total number of entries in the central directory on this disk
246 unsigned int cdir_size; ///< size of the central directory
247 unsigned int cdir_offset; ///< with respect to the starting disk number
248 unsigned short comment_size;
249 fs_offset_t prepended_garbage;
250 } pk3_endOfCentralDir_t;
253 // ------ PAK files on disk ------ //
254 typedef struct dpackfile_s
257 int filepos, filelen;
260 typedef struct dpackheader_s
268 /*! \name Packages in memory
271 /// the offset in packfile_t is the true contents offset
272 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
273 /// file compressed using the deflate algorithm
274 #define PACKFILE_FLAG_DEFLATED (1 << 1)
275 /// file is a symbolic link
276 #define PACKFILE_FLAG_SYMLINK (1 << 2)
278 typedef struct packfile_s
280 char name [MAX_QPATH];
283 fs_offset_t packsize; ///< size in the package
284 fs_offset_t realsize; ///< real file size (uncompressed)
287 typedef struct pack_s
289 char filename [MAX_OSPATH];
290 char shortname [MAX_QPATH];
292 int ignorecase; ///< PK3 ignores case
299 /// Search paths for files (including packages)
300 typedef struct searchpath_s
302 // only one of filename / pack will be used
303 char filename[MAX_OSPATH];
305 struct searchpath_s *next;
310 =============================================================================
314 =============================================================================
319 void FS_Which_f(void);
321 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
322 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
323 fs_offset_t offset, fs_offset_t packsize,
324 fs_offset_t realsize, int flags);
328 =============================================================================
332 =============================================================================
335 mempool_t *fs_mempool;
336 void *fs_mutex = NULL;
338 searchpath_t *fs_searchpaths = NULL;
339 const char *const fs_checkgamedir_missing = "missing";
341 #define MAX_FILES_IN_PACK 65536
343 char fs_userdir[MAX_OSPATH];
344 char fs_gamedir[MAX_OSPATH];
345 char fs_basedir[MAX_OSPATH];
346 static pack_t *fs_selfpack = NULL;
348 // list of active game directories (empty if not running a mod)
349 int fs_numgamedirs = 0;
350 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
352 // list of all gamedirs with modinfo.txt
353 gamedir_t *fs_all_gamedirs = NULL;
354 int fs_all_gamedirs_count = 0;
356 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)"};
357 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"};
358 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
362 =============================================================================
364 PRIVATE FUNCTIONS - PK3 HANDLING
366 =============================================================================
370 // Functions exported from zlib
371 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
372 # define ZEXPORT WINAPI
377 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
378 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
379 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
380 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
381 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
382 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
383 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
386 #define qz_inflateInit2(strm, windowBits) \
387 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
388 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
389 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
392 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
394 static dllfunction_t zlibfuncs[] =
396 {"inflate", (void **) &qz_inflate},
397 {"inflateEnd", (void **) &qz_inflateEnd},
398 {"inflateInit2_", (void **) &qz_inflateInit2_},
399 {"inflateReset", (void **) &qz_inflateReset},
400 {"deflateInit2_", (void **) &qz_deflateInit2_},
401 {"deflateEnd", (void **) &qz_deflateEnd},
402 {"deflate", (void **) &qz_deflate},
406 /// Handle for Zlib DLL
407 static dllhandle_t zlib_dll = NULL;
411 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
412 static dllfunction_t shfolderfuncs[] =
414 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
417 static const char* shfolderdllnames [] =
419 "shfolder.dll", // IE 4, or Win NT and higher
422 static dllhandle_t shfolder_dll = NULL;
424 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
425 #define qREFKNOWNFOLDERID const GUID *
426 #define qKF_FLAG_CREATE 0x8000
427 #define qKF_FLAG_NO_ALIAS 0x1000
428 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
429 static dllfunction_t shell32funcs[] =
431 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
434 static const char* shell32dllnames [] =
436 "shell32.dll", // Vista and higher
439 static dllhandle_t shell32_dll = NULL;
441 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
442 static void (WINAPI *qCoUninitialize)(void);
443 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
444 static dllfunction_t ole32funcs[] =
446 {"CoInitializeEx", (void **) &qCoInitializeEx},
447 {"CoUninitialize", (void **) &qCoUninitialize},
448 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
451 static const char* ole32dllnames [] =
453 "ole32.dll", // 2000 and higher
456 static dllhandle_t ole32_dll = NULL;
466 static void PK3_CloseLibrary (void)
469 Sys_UnloadLibrary (&zlib_dll);
478 Try to load the Zlib DLL
481 static qboolean PK3_OpenLibrary (void)
486 const char* dllnames [] =
489 # ifdef ZLIB_USES_WINAPI
495 #elif defined(MACOSX)
509 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
517 See if zlib is available
520 qboolean FS_HasZlib(void)
525 PK3_OpenLibrary(); // to be safe
526 return (zlib_dll != 0);
532 PK3_GetEndOfCentralDir
534 Extract the end of the central directory from a PK3 package
537 static qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
539 fs_offset_t filesize, maxsize;
540 unsigned char *buffer, *ptr;
543 // Get the package size
544 filesize = lseek (packhandle, 0, SEEK_END);
545 if (filesize < ZIP_END_CDIR_SIZE)
548 // Load the end of the file in memory
549 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
552 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
553 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
554 lseek (packhandle, filesize - maxsize, SEEK_SET);
555 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
561 // Look for the end of central dir signature around the end of the file
562 maxsize -= ZIP_END_CDIR_SIZE;
563 ptr = &buffer[maxsize];
565 while (BuffBigLong (ptr) != ZIP_END_HEADER)
577 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
578 eocd->signature = LittleLong (eocd->signature);
579 eocd->disknum = LittleShort (eocd->disknum);
580 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
581 eocd->localentries = LittleShort (eocd->localentries);
582 eocd->nbentries = LittleShort (eocd->nbentries);
583 eocd->cdir_size = LittleLong (eocd->cdir_size);
584 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
585 eocd->comment_size = LittleShort (eocd->comment_size);
586 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
587 eocd->cdir_offset += eocd->prepended_garbage;
599 Extract the file list from a PK3 file
602 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
604 unsigned char *central_dir, *ptr;
606 fs_offset_t remaining;
608 // Load the central directory in memory
609 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
610 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
611 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
613 Mem_Free (central_dir);
617 // Extract the files properties
618 // The parsing is done "by hand" because some fields have variable sizes and
619 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
620 remaining = eocd->cdir_size;
623 for (ind = 0; ind < eocd->nbentries; ind++)
625 fs_offset_t namesize, count;
627 // Checking the remaining size
628 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
630 Mem_Free (central_dir);
633 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
636 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
638 Mem_Free (central_dir);
642 namesize = BuffLittleShort (&ptr[28]); // filename length
644 // Check encryption, compression, and attributes
645 // 1st uint8 : general purpose bit flag
646 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
648 // LordHavoc: bit 3 would be a problem if we were scanning the archive
649 // but is not a problem in the central directory where the values are
652 // bit 3 seems to always be set by the standard Mac OSX zip maker
654 // 2nd uint8 : external file attributes
655 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
656 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
658 // Still enough bytes for the name?
659 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
661 Mem_Free (central_dir);
665 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
666 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
668 char filename [sizeof (pack->files[0].name)];
669 fs_offset_t offset, packsize, realsize;
672 // Extract the name (strip it if necessary)
673 namesize = min(namesize, (int)sizeof (filename) - 1);
674 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
675 filename[namesize] = '\0';
677 if (BuffLittleShort (&ptr[10]))
678 flags = PACKFILE_FLAG_DEFLATED;
681 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
682 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
683 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
685 switch(ptr[5]) // C_VERSION_MADE_BY_1
690 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
691 // can't use S_ISLNK here, as this has to compile on non-UNIX too
692 flags |= PACKFILE_FLAG_SYMLINK;
696 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
700 // Skip the name, additionnal field, and comment
701 // 1er uint16 : extra field length
702 // 2eme uint16 : file comment length
703 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
704 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
708 // If the package is empty, central_dir is NULL here
709 if (central_dir != NULL)
710 Mem_Free (central_dir);
711 return pack->numfiles;
719 Create a package entry associated with a PK3 file
722 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
724 pk3_endOfCentralDir_t eocd;
728 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
731 Con_Printf ("%s is not a PK3 file\n", packfile);
736 // Multi-volume ZIP archives are NOT allowed
737 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
739 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
744 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
745 // since eocd.nbentries is an unsigned 16 bits integer
746 #if MAX_FILES_IN_PACK < 65535
747 if (eocd.nbentries > MAX_FILES_IN_PACK)
749 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
755 // Create a package structure in memory
756 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
757 pack->ignorecase = true; // PK3 ignores case
758 strlcpy (pack->filename, packfile, sizeof (pack->filename));
759 pack->handle = packhandle;
760 pack->numfiles = eocd.nbentries;
761 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
763 real_nb_files = PK3_BuildFileList (pack, &eocd);
764 if (real_nb_files < 0)
766 Con_Printf ("%s is not a valid PK3 file\n", packfile);
772 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
775 static pack_t *FS_LoadPackPK3 (const char *packfile)
778 packhandle = FS_SysOpenFD (packfile, "rb", false);
781 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
787 PK3_GetTrueFileOffset
789 Find where the true file data offset is
792 static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
794 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
798 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
801 // Load the local file description
802 lseek (pack->handle, pfile->offset, SEEK_SET);
803 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
804 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
806 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
810 // Skip name and extra field
811 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
813 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
819 =============================================================================
821 OTHER PRIVATE FUNCTIONS
823 =============================================================================
831 Add a file to the list of files contained into a package
834 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
835 fs_offset_t offset, fs_offset_t packsize,
836 fs_offset_t realsize, int flags)
838 int (*strcmp_funct) (const char* str1, const char* str2);
839 int left, right, middle;
842 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
844 // Look for the slot we should put that file into (binary search)
846 right = pack->numfiles - 1;
847 while (left <= right)
851 middle = (left + right) / 2;
852 diff = strcmp_funct (pack->files[middle].name, name);
854 // If we found the file, there's a problem
856 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
858 // If we're too far in the list
865 // We have to move the right of the list by one slot to free the one we need
866 pfile = &pack->files[left];
867 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
870 strlcpy (pfile->name, name, sizeof (pfile->name));
871 pfile->offset = offset;
872 pfile->packsize = packsize;
873 pfile->realsize = realsize;
874 pfile->flags = flags;
884 Only used for FS_OpenRealFile.
887 void FS_CreatePath (char *path)
891 for (ofs = path+1 ; *ofs ; ofs++)
893 if (*ofs == '/' || *ofs == '\\')
895 // create the directory
911 static void FS_Path_f (void)
915 Con_Print("Current search path:\n");
916 for (s=fs_searchpaths ; s ; s=s->next)
921 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
923 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
926 Con_Printf("%s\n", s->filename);
936 /*! Takes an explicit (not game tree related) path to a pak file.
937 *Loads the header and directory, adding the files at the beginning
938 *of the list so they override previous pack files.
940 static pack_t *FS_LoadPackPAK (const char *packfile)
942 dpackheader_t header;
948 packhandle = FS_SysOpenFD(packfile, "rb", false);
951 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
953 Con_Printf ("%s is not a packfile\n", packfile);
957 if (memcmp(header.id, "PACK", 4))
959 Con_Printf ("%s is not a packfile\n", packfile);
963 header.dirofs = LittleLong (header.dirofs);
964 header.dirlen = LittleLong (header.dirlen);
966 if (header.dirlen % sizeof(dpackfile_t))
968 Con_Printf ("%s has an invalid directory size\n", packfile);
973 numpackfiles = header.dirlen / sizeof(dpackfile_t);
975 if (numpackfiles > MAX_FILES_IN_PACK)
977 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
982 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
983 lseek (packhandle, header.dirofs, SEEK_SET);
984 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
986 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
992 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
993 pack->ignorecase = false; // PAK is case sensitive
994 strlcpy (pack->filename, packfile, sizeof (pack->filename));
995 pack->handle = packhandle;
997 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
999 // parse the directory
1000 for (i = 0;i < numpackfiles;i++)
1002 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1003 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1005 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1010 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1015 ====================
1018 Create a package entry associated with a directory file
1019 ====================
1021 static pack_t *FS_LoadPackVirtual (const char *dirname)
1024 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1026 pack->ignorecase = false;
1027 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1029 pack->numfiles = -1;
1031 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1040 /*! Adds the given pack to the search path.
1041 * The pack type is autodetected by the file extension.
1043 * Returns true if the file was successfully added to the
1044 * search path or if it was already included.
1046 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1047 * plain directories.
1050 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1052 searchpath_t *search;
1054 const char *ext = FS_FileExtension(pakfile);
1057 for(search = fs_searchpaths; search; search = search->next)
1059 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1062 *already_loaded = true;
1063 return true; // already loaded
1068 *already_loaded = false;
1070 if(!strcasecmp(ext, "pk3dir"))
1071 pak = FS_LoadPackVirtual (pakfile);
1072 else if(!strcasecmp(ext, "pak"))
1073 pak = FS_LoadPackPAK (pakfile);
1074 else if(!strcasecmp(ext, "pk3"))
1075 pak = FS_LoadPackPK3 (pakfile);
1077 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1081 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1083 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1086 // find the first item whose next one is a pack or NULL
1087 searchpath_t *insertion_point = 0;
1088 if(fs_searchpaths && !fs_searchpaths->pack)
1090 insertion_point = fs_searchpaths;
1093 if(!insertion_point->next)
1095 if(insertion_point->next->pack)
1097 insertion_point = insertion_point->next;
1100 // If insertion_point is NULL, this means that either there is no
1101 // item in the list yet, or that the very first item is a pack. In
1102 // that case, we want to insert at the beginning...
1103 if(!insertion_point)
1105 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1106 search->next = fs_searchpaths;
1107 fs_searchpaths = search;
1110 // otherwise we want to append directly after insertion_point.
1112 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1113 search->next = insertion_point->next;
1114 insertion_point->next = search;
1119 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1120 search->next = fs_searchpaths;
1121 fs_searchpaths = search;
1126 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1127 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1128 // same goes for the name inside the pack structure
1129 l = strlen(pak->shortname);
1131 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1132 pak->shortname[l - 3] = 0;
1133 l = strlen(pak->filename);
1135 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1136 pak->filename[l - 3] = 0;
1142 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1153 /*! Adds the given pack to the search path and searches for it in the game path.
1154 * The pack type is autodetected by the file extension.
1156 * Returns true if the file was successfully added to the
1157 * search path or if it was already included.
1159 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1160 * plain directories.
1162 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1164 char fullpath[MAX_OSPATH];
1166 searchpath_t *search;
1169 *already_loaded = false;
1171 // then find the real name...
1172 search = FS_FindFile(pakfile, &index, true);
1173 if(!search || search->pack)
1175 Con_Printf("could not find pak \"%s\"\n", pakfile);
1179 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1181 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1189 Sets fs_gamedir, adds the directory to the head of the path,
1190 then loads and adds pak1.pak pak2.pak ...
1193 static void FS_AddGameDirectory (const char *dir)
1197 searchpath_t *search;
1199 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1201 stringlistinit(&list);
1202 listdirectory(&list, "", dir);
1203 stringlistsort(&list, false);
1205 // add any PAK package in the directory
1206 for (i = 0;i < list.numstrings;i++)
1208 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1210 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1214 // add any PK3 package in the directory
1215 for (i = 0;i < list.numstrings;i++)
1217 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1219 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1223 stringlistfreecontents(&list);
1225 // Add the directory to the search path
1226 // (unpacked files have the priority over packed files)
1227 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1228 strlcpy (search->filename, dir, sizeof (search->filename));
1229 search->next = fs_searchpaths;
1230 fs_searchpaths = search;
1239 static void FS_AddGameHierarchy (const char *dir)
1242 // Add the common game directory
1243 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1246 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1255 const char *FS_FileExtension (const char *in)
1257 const char *separator, *backslash, *colon, *dot;
1259 separator = strrchr(in, '/');
1260 backslash = strrchr(in, '\\');
1261 if (!separator || separator < backslash)
1262 separator = backslash;
1263 colon = strrchr(in, ':');
1264 if (!separator || separator < colon)
1267 dot = strrchr(in, '.');
1268 if (dot == NULL || (separator && (dot < separator)))
1280 const char *FS_FileWithoutPath (const char *in)
1282 const char *separator, *backslash, *colon;
1284 separator = strrchr(in, '/');
1285 backslash = strrchr(in, '\\');
1286 if (!separator || separator < backslash)
1287 separator = backslash;
1288 colon = strrchr(in, ':');
1289 if (!separator || separator < colon)
1291 return separator ? separator + 1 : in;
1300 static void FS_ClearSearchPath (void)
1302 // unload all packs and directory information, close all pack files
1303 // (if a qfile is still reading a pack it won't be harmed because it used
1304 // dup() to get its own handle already)
1305 while (fs_searchpaths)
1307 searchpath_t *search = fs_searchpaths;
1308 fs_searchpaths = search->next;
1309 if (search->pack && search->pack != fs_selfpack)
1311 if(!search->pack->vpack)
1314 close(search->pack->handle);
1315 // free any memory associated with it
1316 if (search->pack->files)
1317 Mem_Free(search->pack->files);
1319 Mem_Free(search->pack);
1325 static void FS_AddSelfPack(void)
1329 searchpath_t *search;
1330 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1331 search->next = fs_searchpaths;
1332 search->pack = fs_selfpack;
1333 fs_searchpaths = search;
1343 void FS_Rescan (void)
1346 qboolean fs_modified = false;
1347 qboolean reset = false;
1348 char gamedirbuf[MAX_INPUTLINE];
1353 FS_ClearSearchPath();
1355 // automatically activate gamemode for the gamedirs specified
1357 COM_ChangeGameTypeForGameDirs();
1359 // add the game-specific paths
1360 // gamedirname1 (typically id1)
1361 FS_AddGameHierarchy (gamedirname1);
1362 // update the com_modname (used for server info)
1363 if (gamedirname2 && gamedirname2[0])
1364 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1366 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1368 // add the game-specific path, if any
1369 // (only used for mission packs and the like, which should set fs_modified)
1370 if (gamedirname2 && gamedirname2[0])
1373 FS_AddGameHierarchy (gamedirname2);
1377 // Adds basedir/gamedir as an override game
1378 // LordHavoc: now supports multiple -game directories
1379 // set the com_modname (reported in server info)
1381 for (i = 0;i < fs_numgamedirs;i++)
1384 FS_AddGameHierarchy (fs_gamedirs[i]);
1385 // update the com_modname (used server info)
1386 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1388 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1390 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1392 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1394 // add back the selfpack as new first item
1397 // set the default screenshot name to either the mod name or the
1398 // gamemode screenshot name
1399 if (strcmp(com_modname, gamedirname1))
1400 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1402 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1404 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1405 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1407 // If "-condebug" is in the command line, remove the previous log file
1408 if (COM_CheckParm ("-condebug") != 0)
1409 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1411 // look for the pop.lmp file and set registered to true if it is found
1412 if (FS_FileExists("gfx/pop.lmp"))
1413 Cvar_Set ("registered", "1");
1419 if (!registered.integer)
1422 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1424 Con_Print("Playing shareware version.\n");
1427 Con_Print("Playing registered version.\n");
1429 case GAME_STEELSTORM:
1430 if (registered.integer)
1431 Con_Print("Playing registered version.\n");
1433 Con_Print("Playing shareware version.\n");
1439 // unload all wads so that future queries will return the new data
1443 static void FS_Rescan_f(void)
1453 extern qboolean vid_opened;
1454 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1459 if (fs_numgamedirs == numgamedirs)
1461 for (i = 0;i < numgamedirs;i++)
1462 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1464 if (i == numgamedirs)
1465 return true; // already using this set of gamedirs, do nothing
1468 if (numgamedirs > MAX_GAMEDIRS)
1471 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1472 return false; // too many gamedirs
1475 for (i = 0;i < numgamedirs;i++)
1477 // if string is nasty, reject it
1478 p = FS_CheckGameDir(gamedirs[i]);
1482 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1483 return false; // nasty gamedirs
1485 if(p == fs_checkgamedir_missing && failmissing)
1488 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1489 return false; // missing gamedirs
1495 fs_numgamedirs = numgamedirs;
1496 for (i = 0;i < fs_numgamedirs;i++)
1497 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1499 // reinitialize filesystem to detect the new paks
1502 if (cls.demoplayback)
1508 // unload all sounds so they will be reloaded from the new files as needed
1509 S_UnloadAllSounds_f();
1511 // close down the video subsystem, it will start up again when the config finishes...
1515 // restart the video subsystem after the config is executed
1516 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1526 static void FS_GameDir_f (void)
1530 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1534 Con_Printf("gamedirs active:");
1535 for (i = 0;i < fs_numgamedirs;i++)
1536 Con_Printf(" %s", fs_gamedirs[i]);
1541 numgamedirs = Cmd_Argc() - 1;
1542 if (numgamedirs > MAX_GAMEDIRS)
1544 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1548 for (i = 0;i < numgamedirs;i++)
1549 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1551 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1553 // actually, changing during game would work fine, but would be stupid
1554 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1558 // halt demo playback to close the file
1561 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1564 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1572 stringlistinit(&list);
1573 listdirectory(&list, gamedir, "");
1574 success = list.numstrings > 0;
1575 stringlistfreecontents(&list);
1579 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1582 n = FS_Read (f, buf, buflength - 1);
1602 const char *FS_CheckGameDir(const char *gamedir)
1608 if (FS_CheckNastyPath(gamedir, true))
1611 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1616 // get description from basedir
1617 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1625 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1629 return fs_checkgamedir_missing;
1632 static void FS_ListGameDirs(void)
1634 stringlist_t list, list2;
1639 fs_all_gamedirs_count = 0;
1641 Mem_Free(fs_all_gamedirs);
1643 stringlistinit(&list);
1644 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1645 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1646 stringlistsort(&list, false);
1648 stringlistinit(&list2);
1649 for(i = 0; i < list.numstrings; ++i)
1652 if(!strcmp(list.strings[i-1], list.strings[i]))
1654 info = FS_CheckGameDir(list.strings[i]);
1657 if(info == fs_checkgamedir_missing)
1661 stringlistappend(&list2, list.strings[i]);
1663 stringlistfreecontents(&list);
1665 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1666 for(i = 0; i < list2.numstrings; ++i)
1668 info = FS_CheckGameDir(list2.strings[i]);
1669 // all this cannot happen any more, but better be safe than sorry
1672 if(info == fs_checkgamedir_missing)
1676 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1677 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1678 ++fs_all_gamedirs_count;
1684 #pragma comment(lib, "shell32.lib")
1694 void FS_Init_SelfPack (void)
1697 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1700 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1706 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1709 const char **new_argv;
1711 int args_left = 256;
1712 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1715 new_argv[0] = "dummy";
1720 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1723 while(COM_ParseToken_Console(&p))
1725 size_t sz = strlen(com_token) + 1; // shut up clang
1728 q = (char *)Mem_Alloc(fs_mempool, sz);
1729 strlcpy(q, com_token, sz);
1730 new_argv[com_argc + i] = q;
1733 new_argv[i+com_argc] = NULL;
1734 com_argv = new_argv;
1735 com_argc = com_argc + i;
1742 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1744 #if defined(__IPHONEOS__)
1745 if (userdirmode == USERDIRMODE_HOME)
1747 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1748 // fs_userdir stores configurations to the Documents folder of the app
1749 strlcpy(userdir, maxlength, "../Documents/");
1754 #elif defined(WIN32)
1756 #if _MSC_VER >= 1400
1759 TCHAR mydocsdir[MAX_PATH + 1];
1760 wchar_t *savedgamesdirw;
1761 char savedgamesdir[MAX_OSPATH];
1770 case USERDIRMODE_NOHOME:
1771 strlcpy(userdir, fs_basedir, userdirsize);
1773 case USERDIRMODE_MYGAMES:
1775 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1777 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1779 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1782 #if _MSC_VER >= 1400
1783 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1786 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1791 homedir = getenv("USERPROFILE");
1794 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1799 case USERDIRMODE_SAVEDGAMES:
1801 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1803 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1804 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1806 savedgamesdir[0] = 0;
1807 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1810 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1812 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1815 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1817 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1818 #if _MSC_VER >= 1400
1819 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1821 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1823 qCoTaskMemFree(savedgamesdirw);
1826 if (savedgamesdir[0])
1828 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1843 case USERDIRMODE_NOHOME:
1844 strlcpy(userdir, fs_basedir, userdirsize);
1846 case USERDIRMODE_HOME:
1847 homedir = getenv("HOME");
1850 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1854 case USERDIRMODE_SAVEDGAMES:
1855 homedir = getenv("HOME");
1859 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1861 // the XDG say some files would need to go in:
1862 // XDG_CONFIG_HOME (or ~/.config/%s/)
1863 // XDG_DATA_HOME (or ~/.local/share/%s/)
1864 // XDG_CACHE_HOME (or ~/.cache/%s/)
1865 // and also search the following global locations if defined:
1866 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1867 // XDG_DATA_DIRS (normally /usr/share/%s/)
1868 // this would be too complicated...
1879 // historical behavior...
1880 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1881 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
1884 // see if we can write to this path (note: won't create path)
1886 // no access() here, we must try to open the file for appending
1887 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1891 // on Unix, we don't need to ACTUALLY attempt to open the file
1892 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1899 return 1; // good choice - the path exists and is writable
1903 if (userdirmode == USERDIRMODE_NOHOME)
1904 return -1; // path usually already exists, we lack permissions
1906 return 0; // probably good - failed to write but maybe we need to create path
1925 // Overrides the system supplied base directory (under GAMENAME)
1926 // 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)
1927 i = COM_CheckParm ("-basedir");
1928 if (i && i < com_argc-1)
1930 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1931 i = (int)strlen (fs_basedir);
1932 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1933 fs_basedir[i-1] = 0;
1937 // If the base directory is explicitly defined by the compilation process
1938 #ifdef DP_FS_BASEDIR
1939 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1940 #elif defined(MACOSX)
1941 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1942 if (strstr(com_argv[0], ".app/"))
1945 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1946 split = strstr(fs_basedir, ".app/");
1949 struct stat statresult;
1951 // truncate to just after the .app/
1953 // see if gamedir exists in Resources
1954 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1956 // found gamedir inside Resources, use it
1957 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1961 // no gamedir found in Resources, gamedir is probably
1962 // outside the .app, remove .app part of path
1963 while (split > fs_basedir && *split != '/')
1972 // make sure the appending of a path separator won't create an unterminated string
1973 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1974 // add a path separator to the end of the basedir if it lacks one
1975 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1976 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1978 // Add the personal game directory
1979 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1980 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1981 else if (COM_CheckParm("-nohome"))
1982 *fs_userdir = 0; // user wants roaming installation, no userdir
1986 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1987 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1988 int userdirstatus[USERDIRMODE_COUNT];
1990 // historical behavior...
1991 if (!strcmp(gamedirname1, "id1"))
1992 preferreduserdirmode = USERDIRMODE_NOHOME;
1994 // check what limitations the user wants to impose
1995 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
1996 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
1997 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
1998 // gather the status of the possible userdirs
1999 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2001 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2002 if (userdirstatus[dirmode] == 1)
2003 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2004 else if (userdirstatus[dirmode] == 0)
2005 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2007 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2009 // some games may prefer writing to basedir, but if write fails we
2010 // have to search for a real userdir...
2011 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2012 preferreduserdirmode = highestuserdirmode;
2013 // check for an existing userdir and continue using it if possible...
2014 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2015 if (userdirstatus[dirmode] == 1)
2017 // if no existing userdir found, make a new one...
2018 if (dirmode == 0 && preferreduserdirmode > 0)
2019 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2020 if (userdirstatus[dirmode] >= 0)
2022 // and finally, we picked one...
2023 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2024 Con_DPrintf("userdir %i is the winner\n", dirmode);
2027 // if userdir equal to basedir, clear it to avoid confusion later
2028 if (!strcmp(fs_basedir, fs_userdir))
2033 p = FS_CheckGameDir(gamedirname1);
2034 if(!p || p == fs_checkgamedir_missing)
2035 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2039 p = FS_CheckGameDir(gamedirname2);
2040 if(!p || p == fs_checkgamedir_missing)
2041 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2045 // Adds basedir/gamedir as an override game
2046 // LordHavoc: now supports multiple -game directories
2047 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2051 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2054 p = FS_CheckGameDir(com_argv[i]);
2056 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2057 if(p == fs_checkgamedir_missing)
2058 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2059 // add the gamedir to the list of active gamedirs
2060 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2065 // generate the searchpath
2068 if (Thread_HasThreads())
2069 fs_mutex = Thread_CreateMutex();
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);
2098 PK3_CloseLibrary ();
2101 Sys_UnloadLibrary (&shfolder_dll);
2102 Sys_UnloadLibrary (&shell32_dll);
2103 Sys_UnloadLibrary (&ole32_dll);
2107 Thread_DestroyMutex(fs_mutex);
2110 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2115 qboolean dolock = false;
2117 // Parse the mode string
2126 opt = O_CREAT | O_TRUNC;
2130 opt = O_CREAT | O_APPEND;
2133 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2136 for (ind = 1; mode[ind] != '\0'; ind++)
2150 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2151 filepath, mode, mode[ind]);
2158 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2162 # if _MSC_VER >= 1400
2163 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2165 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2168 handle = open (filepath, mod | opt, 0666);
2169 if(handle >= 0 && dolock)
2172 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2173 l.l_whence = SEEK_SET;
2176 if(fcntl(handle, F_SETLK, &l) == -1)
2188 ====================
2191 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2192 ====================
2194 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2198 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2200 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2201 if (file->handle < 0)
2207 file->filename = Mem_strdup(fs_mempool, filepath);
2209 file->real_length = lseek (file->handle, 0, SEEK_END);
2211 // For files opened in append mode, we start at the end of the file
2213 file->position = file->real_length;
2215 lseek (file->handle, 0, SEEK_SET);
2225 Open a packed file using its package file descriptor
2228 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2234 pfile = &pack->files[pack_ind];
2236 // If we don't have the true offset, get it now
2237 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2238 if (!PK3_GetTrueFileOffset (pfile, pack))
2241 #ifndef LINK_TO_ZLIB
2242 // No Zlib DLL = no compressed files
2243 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2245 Con_Printf("WARNING: can't open the compressed file %s\n"
2246 "You need the Zlib DLL to use compressed files\n",
2252 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2253 // the dup() call to avoid having to close the dup_handle on error here
2254 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2256 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2257 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2261 dup_handle = dup (pack->handle);
2264 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2268 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2269 memset (file, 0, sizeof (*file));
2270 file->handle = dup_handle;
2271 file->flags = QFILE_FLAG_PACKED;
2272 file->real_length = pfile->realsize;
2273 file->offset = pfile->offset;
2277 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2281 file->flags |= QFILE_FLAG_DEFLATED;
2283 // We need some more variables
2284 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2286 ztk->comp_length = pfile->packsize;
2288 // Initialize zlib stream
2289 ztk->zstream.next_in = ztk->input;
2290 ztk->zstream.avail_in = 0;
2292 /* From Zlib's "unzip.c":
2294 * windowBits is passed < 0 to tell that there is no zlib header.
2295 * Note that in this case inflate *requires* an extra "dummy" byte
2296 * after the compressed stream in order to complete decompression and
2297 * return Z_STREAM_END.
2298 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2299 * size of both compressed and uncompressed data
2301 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2303 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2309 ztk->zstream.next_out = file->buff;
2310 ztk->zstream.avail_out = sizeof (file->buff);
2319 ====================
2322 Return true if the path should be rejected due to one of the following:
2323 1: path elements that are non-portable
2324 2: path elements that would allow access to files outside the game directory,
2325 or are just not a good idea for a mod to be using.
2326 ====================
2328 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2330 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2334 // Windows: don't allow \ in filenames (windows-only), period.
2335 // (on Windows \ is a directory separator, but / is also supported)
2336 if (strstr(path, "\\"))
2337 return 1; // non-portable
2339 // Mac: don't allow Mac-only filenames - : is a directory separator
2340 // instead of /, but we rely on / working already, so there's no reason to
2341 // support a Mac-only path
2342 // Amiga and Windows: : tries to go to root of drive
2343 if (strstr(path, ":"))
2344 return 1; // non-portable attempt to go to root of drive
2346 // Amiga: // is parent directory
2347 if (strstr(path, "//"))
2348 return 1; // non-portable attempt to go to parent directory
2350 // all: don't allow going to parent directory (../ or /../)
2351 if (strstr(path, ".."))
2352 return 2; // attempt to go outside the game directory
2354 // Windows and UNIXes: don't allow absolute paths
2356 return 2; // attempt to go outside the game directory
2358 // 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
2359 if (strchr(path, '.'))
2363 // gamedir is entirely path elements, so simply forbid . entirely
2366 if (strchr(path, '.') < strrchr(path, '/'))
2367 return 2; // possible attempt to go outside the game directory
2370 // all: forbid trailing slash on gamedir
2371 if (isgamedir && path[strlen(path)-1] == '/')
2374 // all: forbid leading dot on any filename for any reason
2375 if (strstr(path, "/."))
2376 return 2; // attempt to go outside the game directory
2378 // after all these checks we're pretty sure it's a / separated filename
2379 // and won't do much if any harm
2385 ====================
2388 Look for a file in the packages and in the filesystem
2390 Return the searchpath where the file was found (or NULL)
2391 and the file index in the package if relevant
2392 ====================
2394 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2396 searchpath_t *search;
2399 // search through the path, one element at a time
2400 for (search = fs_searchpaths;search;search = search->next)
2402 // is the element a pak file?
2403 if (search->pack && !search->pack->vpack)
2405 int (*strcmp_funct) (const char* str1, const char* str2);
2406 int left, right, middle;
2409 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2411 // Look for the file (binary search)
2413 right = pak->numfiles - 1;
2414 while (left <= right)
2418 middle = (left + right) / 2;
2419 diff = strcmp_funct (pak->files[middle].name, name);
2424 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2426 // yes, but the first one is empty so we treat it as not being there
2427 if (!quiet && developer_extra.integer)
2428 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2435 if (!quiet && developer_extra.integer)
2436 Con_DPrintf("FS_FindFile: %s in %s\n",
2437 pak->files[middle].name, pak->filename);
2444 // If we're too far in the list
2453 char netpath[MAX_OSPATH];
2454 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2455 if (FS_SysFileExists (netpath))
2457 if (!quiet && developer_extra.integer)
2458 Con_DPrintf("FS_FindFile: %s\n", netpath);
2467 if (!quiet && developer_extra.integer)
2468 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2480 Look for a file in the search paths and open it in read-only mode
2483 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2485 searchpath_t *search;
2488 search = FS_FindFile (filename, &pack_ind, quiet);
2494 // Found in the filesystem?
2497 // this works with vpacks, so we are fine
2498 char path [MAX_OSPATH];
2499 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2500 return FS_SysOpen (path, "rb", nonblocking);
2503 // So, we found it in a package...
2505 // Is it a PK3 symlink?
2506 // TODO also handle directory symlinks by parsing the whole structure...
2507 // but heck, file symlinks are good enough for now
2508 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2510 if(symlinkLevels <= 0)
2512 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2517 char linkbuf[MAX_QPATH];
2519 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2520 const char *mergeslash;
2525 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2531 // Now combine the paths...
2532 mergeslash = strrchr(filename, '/');
2533 mergestart = linkbuf;
2535 mergeslash = filename;
2536 while(!strncmp(mergestart, "../", 3))
2539 while(mergeslash > filename)
2542 if(*mergeslash == '/')
2546 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2547 if(mergeslash == filename)
2549 // Either mergeslash == filename, then we just replace the name (done below)
2553 // Or, we append the name after mergeslash;
2554 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2555 int spaceNeeded = mergeslash - filename + 1;
2556 int spaceRemoved = mergestart - linkbuf;
2557 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2559 Con_DPrintf("symlink: too long path rejected\n");
2562 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2563 memcpy(linkbuf, filename, spaceNeeded);
2564 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2565 mergestart = linkbuf;
2567 if (!quiet && developer_loading.integer)
2568 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2569 if(FS_CheckNastyPath (mergestart, false))
2571 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2574 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2578 return FS_OpenPackedFile (search->pack, pack_ind);
2583 =============================================================================
2585 MAIN PUBLIC FUNCTIONS
2587 =============================================================================
2591 ====================
2594 Open a file in the userpath. The syntax is the same as fopen
2595 Used for savegame scanning in menu, and all file writing.
2596 ====================
2598 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2600 char real_path [MAX_OSPATH];
2602 if (FS_CheckNastyPath(filepath, false))
2604 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2608 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2610 // If the file is opened in "write", "append", or "read/write" mode,
2611 // create directories up to the file.
2612 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2613 FS_CreatePath (real_path);
2614 return FS_SysOpen (real_path, mode, false);
2619 ====================
2622 Open a file. The syntax is the same as fopen
2623 ====================
2625 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2627 qfile_t *result = NULL;
2628 if (FS_CheckNastyPath(filepath, false))
2630 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2634 if (fs_mutex) Thread_LockMutex(fs_mutex);
2635 result = FS_OpenReadFile (filepath, quiet, false, 16);
2636 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2642 ====================
2645 Open a file. The syntax is the same as fopen
2646 ====================
2648 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2651 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2652 memset (file, 0, sizeof (*file));
2653 file->flags = QFILE_FLAG_DATA;
2655 file->real_length = size;
2661 ====================
2665 ====================
2667 int FS_Close (qfile_t* file)
2669 if(file->flags & QFILE_FLAG_DATA)
2675 if (close (file->handle))
2680 if (file->flags & QFILE_FLAG_REMOVE)
2681 remove(file->filename);
2683 Mem_Free((void *) file->filename);
2688 qz_inflateEnd (&file->ztk->zstream);
2689 Mem_Free (file->ztk);
2696 void FS_RemoveOnClose(qfile_t* file)
2698 file->flags |= QFILE_FLAG_REMOVE;
2702 ====================
2705 Write "datasize" bytes into a file
2706 ====================
2708 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2712 // If necessary, seek to the exact file position we're supposed to be
2713 if (file->buff_ind != file->buff_len)
2714 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2716 // Purge cached data
2719 // Write the buffer and update the position
2720 result = write (file->handle, data, (fs_offset_t)datasize);
2721 file->position = lseek (file->handle, 0, SEEK_CUR);
2722 if (file->real_length < file->position)
2723 file->real_length = file->position;
2733 ====================
2736 Read up to "buffersize" bytes from a file
2737 ====================
2739 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2741 fs_offset_t count, done;
2743 if (buffersize == 0)
2746 // Get rid of the ungetc character
2747 if (file->ungetc != EOF)
2749 ((char*)buffer)[0] = file->ungetc;
2757 if(file->flags & QFILE_FLAG_DATA)
2759 size_t left = file->real_length - file->position;
2760 if(buffersize > left)
2762 memcpy(buffer, file->data + file->position, buffersize);
2763 file->position += buffersize;
2767 // First, we copy as many bytes as we can from "buff"
2768 if (file->buff_ind < file->buff_len)
2770 count = file->buff_len - file->buff_ind;
2771 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2773 memcpy (buffer, &file->buff[file->buff_ind], count);
2774 file->buff_ind += count;
2776 buffersize -= count;
2777 if (buffersize == 0)
2781 // NOTE: at this point, the read buffer is always empty
2783 // If the file isn't compressed
2784 if (! (file->flags & QFILE_FLAG_DEFLATED))
2788 // We must take care to not read after the end of the file
2789 count = file->real_length - file->position;
2791 // If we have a lot of data to get, put them directly into "buffer"
2792 if (buffersize > sizeof (file->buff) / 2)
2794 if (count > (fs_offset_t)buffersize)
2795 count = (fs_offset_t)buffersize;
2796 lseek (file->handle, file->offset + file->position, SEEK_SET);
2797 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2801 file->position += nb;
2803 // Purge cached data
2809 if (count > (fs_offset_t)sizeof (file->buff))
2810 count = (fs_offset_t)sizeof (file->buff);
2811 lseek (file->handle, file->offset + file->position, SEEK_SET);
2812 nb = read (file->handle, file->buff, count);
2815 file->buff_len = nb;
2816 file->position += nb;
2818 // Copy the requested data in "buffer" (as much as we can)
2819 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2820 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2821 file->buff_ind = count;
2829 // If the file is compressed, it's more complicated...
2830 // We cycle through a few operations until we have read enough data
2831 while (buffersize > 0)
2833 ztoolkit_t *ztk = file->ztk;
2836 // NOTE: at this point, the read buffer is always empty
2838 // If "input" is also empty, we need to refill it
2839 if (ztk->in_ind == ztk->in_len)
2841 // If we are at the end of the file
2842 if (file->position == file->real_length)
2845 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2846 if (count > (fs_offset_t)sizeof (ztk->input))
2847 count = (fs_offset_t)sizeof (ztk->input);
2848 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2849 if (read (file->handle, ztk->input, count) != count)
2851 Con_Printf ("FS_Read: unexpected end of file\n");
2856 ztk->in_len = count;
2857 ztk->in_position += count;
2860 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2861 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2863 // Now that we are sure we have compressed data available, we need to determine
2864 // if it's better to inflate it in "file->buff" or directly in "buffer"
2866 // Inflate the data in "file->buff"
2867 if (buffersize < sizeof (file->buff) / 2)
2869 ztk->zstream.next_out = file->buff;
2870 ztk->zstream.avail_out = sizeof (file->buff);
2871 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2872 if (error != Z_OK && error != Z_STREAM_END)
2874 Con_Printf ("FS_Read: Can't inflate file\n");
2877 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2879 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2880 file->position += file->buff_len;
2882 // Copy the requested data in "buffer" (as much as we can)
2883 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2884 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2885 file->buff_ind = count;
2888 // Else, we inflate directly in "buffer"
2891 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2892 ztk->zstream.avail_out = (unsigned int)buffersize;
2893 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2894 if (error != Z_OK && error != Z_STREAM_END)
2896 Con_Printf ("FS_Read: Can't inflate file\n");
2899 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2901 // How much data did it inflate?
2902 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2903 file->position += count;
2905 // Purge cached data
2910 buffersize -= count;
2918 ====================
2921 Print a string into a file
2922 ====================
2924 int FS_Print (qfile_t* file, const char *msg)
2926 return (int)FS_Write (file, msg, strlen (msg));
2930 ====================
2933 Print a string into a file
2934 ====================
2936 int FS_Printf(qfile_t* file, const char* format, ...)
2941 va_start (args, format);
2942 result = FS_VPrintf (file, format, args);
2950 ====================
2953 Print a string into a file
2954 ====================
2956 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2959 fs_offset_t buff_size = MAX_INPUTLINE;
2964 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2965 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2966 if (len >= 0 && len < buff_size)
2968 Mem_Free (tempbuff);
2972 len = write (file->handle, tempbuff, len);
2973 Mem_Free (tempbuff);
2980 ====================
2983 Get the next character of a file
2984 ====================
2986 int FS_Getc (qfile_t* file)
2990 if (FS_Read (file, &c, 1) != 1)
2998 ====================
3001 Put a character back into the read buffer (only supports one character!)
3002 ====================
3004 int FS_UnGetc (qfile_t* file, unsigned char c)
3006 // If there's already a character waiting to be read
3007 if (file->ungetc != EOF)
3016 ====================
3019 Move the position index in a file
3020 ====================
3022 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3025 unsigned char* buffer;
3026 fs_offset_t buffersize;
3028 // Compute the file offset
3032 offset += file->position - file->buff_len + file->buff_ind;
3039 offset += file->real_length;
3045 if (offset < 0 || offset > file->real_length)
3048 if(file->flags & QFILE_FLAG_DATA)
3050 file->position = offset;
3054 // If we have the data in our read buffer, we don't need to actually seek
3055 if (file->position - file->buff_len <= offset && offset <= file->position)
3057 file->buff_ind = offset + file->buff_len - file->position;
3061 // Purge cached data
3064 // Unpacked or uncompressed files can seek directly
3065 if (! (file->flags & QFILE_FLAG_DEFLATED))
3067 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3069 file->position = offset;
3073 // Seeking in compressed files is more a hack than anything else,
3074 // but we need to support it, so here we go.
3077 // If we have to go back in the file, we need to restart from the beginning
3078 if (offset <= file->position)
3082 ztk->in_position = 0;
3084 lseek (file->handle, file->offset, SEEK_SET);
3086 // Reset the Zlib stream
3087 ztk->zstream.next_in = ztk->input;
3088 ztk->zstream.avail_in = 0;
3089 qz_inflateReset (&ztk->zstream);
3092 // We need a big buffer to force inflating into it directly
3093 buffersize = 2 * sizeof (file->buff);
3094 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3096 // Skip all data until we reach the requested offset
3097 while (offset > file->position)
3099 fs_offset_t diff = offset - file->position;
3100 fs_offset_t count, len;
3102 count = (diff > buffersize) ? buffersize : diff;
3103 len = FS_Read (file, buffer, count);
3117 ====================
3120 Give the current position in a file
3121 ====================
3123 fs_offset_t FS_Tell (qfile_t* file)
3125 return file->position - file->buff_len + file->buff_ind;
3130 ====================
3133 Give the total size of a file
3134 ====================
3136 fs_offset_t FS_FileSize (qfile_t* file)
3138 return file->real_length;
3143 ====================
3146 Erases any buffered input or output data
3147 ====================
3149 void FS_Purge (qfile_t* file)
3161 Filename are relative to the quake directory.
3162 Always appends a 0 byte.
3165 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3168 unsigned char *buf = NULL;
3169 fs_offset_t filesize = 0;
3171 file = FS_OpenVirtualFile(path, quiet);
3174 filesize = file->real_length;
3177 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3182 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3183 buf[filesize] = '\0';
3184 FS_Read (file, buf, filesize);
3186 if (developer_loadfile.integer)
3187 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3190 if (filesizepointer)
3191 *filesizepointer = filesize;
3200 The filename will be prefixed by the current game directory
3203 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3207 fs_offset_t lentotal;
3209 file = FS_OpenRealFile(filename, "wb", false);
3212 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3217 for(i = 0; i < count; ++i)
3219 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3220 for(i = 0; i < count; ++i)
3221 FS_Write (file, data[i], len[i]);
3226 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3228 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3233 =============================================================================
3235 OTHERS PUBLIC FUNCTIONS
3237 =============================================================================
3245 void FS_StripExtension (const char *in, char *out, size_t size_out)
3253 while ((currentchar = *in) && size_out > 1)
3255 if (currentchar == '.')
3257 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3259 *out++ = currentchar;
3275 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3279 // if path doesn't have a .EXT, append extension
3280 // (extension should include the .)
3281 src = path + strlen(path) - 1;
3283 while (*src != '/' && src != path)
3286 return; // it has an extension
3290 strlcat (path, extension, size_path);
3298 Look for a file in the packages and in the filesystem
3301 int FS_FileType (const char *filename)
3303 searchpath_t *search;
3304 char fullpath[MAX_OSPATH];
3306 search = FS_FindFile (filename, NULL, true);
3308 return FS_FILETYPE_NONE;
3310 if(search->pack && !search->pack->vpack)
3311 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3313 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3314 return FS_SysFileType(fullpath);
3322 Look for a file in the packages and in the filesystem
3325 qboolean FS_FileExists (const char *filename)
3327 return (FS_FindFile (filename, NULL, true) != NULL);
3335 Look for a file in the filesystem only
3338 int FS_SysFileType (const char *path)
3341 // Sajt - some older sdks are missing this define
3342 # ifndef INVALID_FILE_ATTRIBUTES
3343 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3346 DWORD result = GetFileAttributes(path);
3348 if(result == INVALID_FILE_ATTRIBUTES)
3349 return FS_FILETYPE_NONE;
3351 if(result & FILE_ATTRIBUTE_DIRECTORY)
3352 return FS_FILETYPE_DIRECTORY;
3354 return FS_FILETYPE_FILE;
3358 if (stat (path,&buf) == -1)
3359 return FS_FILETYPE_NONE;
3362 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3364 if(S_ISDIR(buf.st_mode))
3365 return FS_FILETYPE_DIRECTORY;
3367 return FS_FILETYPE_FILE;
3371 qboolean FS_SysFileExists (const char *path)
3373 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3376 void FS_mkdir (const char *path)
3378 if(COM_CheckParm("-readonly"))
3392 Allocate and fill a search structure with information on matching filenames.
3395 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3398 searchpath_t *searchpath;
3400 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3401 stringlist_t resultlist;
3402 stringlist_t dirlist;
3403 const char *slash, *backslash, *colon, *separator;
3405 char temp[MAX_OSPATH];
3407 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3412 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3416 stringlistinit(&resultlist);
3417 stringlistinit(&dirlist);
3419 slash = strrchr(pattern, '/');
3420 backslash = strrchr(pattern, '\\');
3421 colon = strrchr(pattern, ':');
3422 separator = max(slash, backslash);
3423 separator = max(separator, colon);
3424 basepathlength = separator ? (separator + 1 - pattern) : 0;
3425 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3427 memcpy(basepath, pattern, basepathlength);
3428 basepath[basepathlength] = 0;
3430 // search through the path, one element at a time
3431 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3433 // is the element a pak file?
3434 if (searchpath->pack && !searchpath->pack->vpack)
3436 // look through all the pak file elements
3437 pak = searchpath->pack;
3438 for (i = 0;i < pak->numfiles;i++)
3440 strlcpy(temp, pak->files[i].name, sizeof(temp));
3443 if (matchpattern(temp, (char *)pattern, true))
3445 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3446 if (!strcmp(resultlist.strings[resultlistindex], temp))
3448 if (resultlistindex == resultlist.numstrings)
3450 stringlistappend(&resultlist, temp);
3451 if (!quiet && developer_loading.integer)
3452 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3455 // strip off one path element at a time until empty
3456 // this way directories are added to the listing if they match the pattern
3457 slash = strrchr(temp, '/');
3458 backslash = strrchr(temp, '\\');
3459 colon = strrchr(temp, ':');
3461 if (separator < slash)
3463 if (separator < backslash)
3464 separator = backslash;
3465 if (separator < colon)
3467 *((char *)separator) = 0;
3473 stringlist_t matchedSet, foundSet;
3474 const char *start = pattern;
3476 stringlistinit(&matchedSet);
3477 stringlistinit(&foundSet);
3478 // add a first entry to the set
3479 stringlistappend(&matchedSet, "");
3480 // iterate through pattern's path
3483 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3484 char subpath[MAX_OSPATH];
3485 char subpattern[MAX_OSPATH];
3487 // find the next wildcard
3488 wildcard = strchr(start, '?');
3489 asterisk = strchr(start, '*');
3490 if (asterisk && (!wildcard || asterisk < wildcard))
3492 wildcard = asterisk;
3497 nextseparator = strchr( wildcard, '/' );
3501 nextseparator = NULL;
3504 if( !nextseparator ) {
3505 nextseparator = start + strlen( start );
3508 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3509 // copy everything up except nextseperator
3510 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3511 // find the last '/' before the wildcard
3512 prevseparator = strrchr( subpattern, '/' );
3514 prevseparator = subpattern;
3517 // copy everything from start to the previous including the '/' (before the wildcard)
3518 // everything up to start is already included in the path of matchedSet's entries
3519 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3521 // for each entry in matchedSet try to open the subdirectories specified in subpath
3522 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3523 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3524 strlcat( temp, subpath, sizeof(temp) );
3525 listdirectory( &foundSet, searchpath->filename, temp );
3527 if( dirlistindex == 0 ) {
3530 // reset the current result set
3531 stringlistfreecontents( &matchedSet );
3532 // match against the pattern
3533 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3534 const char *direntry = foundSet.strings[ dirlistindex ];
3535 if (matchpattern(direntry, subpattern, true)) {
3536 stringlistappend( &matchedSet, direntry );
3539 stringlistfreecontents( &foundSet );
3541 start = nextseparator;
3544 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3546 const char *temp = matchedSet.strings[dirlistindex];
3547 if (matchpattern(temp, (char *)pattern, true))
3549 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3550 if (!strcmp(resultlist.strings[resultlistindex], temp))
3552 if (resultlistindex == resultlist.numstrings)
3554 stringlistappend(&resultlist, temp);
3555 if (!quiet && developer_loading.integer)
3556 Con_Printf("SearchDirFile: %s\n", temp);
3560 stringlistfreecontents( &matchedSet );
3564 if (resultlist.numstrings)
3566 stringlistsort(&resultlist, true);
3567 numfiles = resultlist.numstrings;
3569 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3570 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3571 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3572 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3573 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3574 search->numfilenames = (int)numfiles;
3577 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3580 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3581 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3582 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3584 numchars += (int)textlen;
3587 stringlistfreecontents(&resultlist);
3593 void FS_FreeSearch(fssearch_t *search)
3598 extern int con_linewidth;
3599 static int FS_ListDirectory(const char *pattern, int oneperline)
3608 char linebuf[MAX_INPUTLINE];
3610 search = FS_Search(pattern, true, true);
3613 numfiles = search->numfilenames;
3616 // FIXME: the names could be added to one column list and then
3617 // gradually shifted into the next column if they fit, and then the
3618 // next to make a compact variable width listing but it's a lot more
3620 // find width for columns
3622 for (i = 0;i < numfiles;i++)
3624 l = (int)strlen(search->filenames[i]);
3625 if (columnwidth < l)
3628 // count the spacing character
3630 // calculate number of columns
3631 numcolumns = con_linewidth / columnwidth;
3632 // don't bother with the column printing if it's only one column
3633 if (numcolumns >= 2)
3635 numlines = (numfiles + numcolumns - 1) / numcolumns;
3636 for (i = 0;i < numlines;i++)
3639 for (k = 0;k < numcolumns;k++)
3641 l = i * numcolumns + k;
3644 name = search->filenames[l];
3645 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3646 linebuf[linebufpos++] = name[j];
3647 // space out name unless it's the last on the line
3648 if (k + 1 < numcolumns && l + 1 < numfiles)
3649 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3650 linebuf[linebufpos++] = ' ';
3653 linebuf[linebufpos] = 0;
3654 Con_Printf("%s\n", linebuf);
3661 for (i = 0;i < numfiles;i++)
3662 Con_Printf("%s\n", search->filenames[i]);
3663 FS_FreeSearch(search);
3664 return (int)numfiles;
3667 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3669 const char *pattern;
3670 if (Cmd_Argc() >= 3)
3672 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3675 if (Cmd_Argc() == 2)
3676 pattern = Cmd_Argv(1);
3679 if (!FS_ListDirectory(pattern, oneperline))
3680 Con_Print("No files found.\n");
3685 FS_ListDirectoryCmd("dir", true);
3690 FS_ListDirectoryCmd("ls", false);
3693 void FS_Which_f(void)
3695 const char *filename;
3698 if (Cmd_Argc() != 2)
3700 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3703 filename = Cmd_Argv(1);
3704 sp = FS_FindFile(filename, &index, true);
3706 Con_Printf("%s isn't anywhere\n", filename);
3712 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3714 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3717 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3721 const char *FS_WhichPack(const char *filename)
3724 searchpath_t *sp = FS_FindFile(filename, &index, true);
3726 return sp->pack->shortname;
3732 ====================
3733 FS_IsRegisteredQuakePack
3735 Look for a proof of purchase file file in the requested package
3737 If it is found, this file should NOT be downloaded.
3738 ====================
3740 qboolean FS_IsRegisteredQuakePack(const char *name)
3742 searchpath_t *search;
3745 // search through the path, one element at a time
3746 for (search = fs_searchpaths;search;search = search->next)
3748 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3749 // TODO do we want to support vpacks in here too?
3751 int (*strcmp_funct) (const char* str1, const char* str2);
3752 int left, right, middle;
3755 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3757 // Look for the file (binary search)
3759 right = pak->numfiles - 1;
3760 while (left <= right)
3764 middle = (left + right) / 2;
3765 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3771 // If we're too far in the list
3778 // we found the requested pack but it is not registered quake
3786 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3789 unsigned char *filedata;
3790 fs_offset_t filesize;
3791 if (filesizepointer)
3792 *filesizepointer = 0;
3793 if (!filename || !*filename)
3795 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3798 if (filesizepointer)
3799 *filesizepointer = filesize;
3800 crc = CRC_Block(filedata, filesize);
3806 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3809 unsigned char *out = NULL;
3813 #ifndef LINK_TO_ZLIB
3818 memset(&strm, 0, sizeof(strm));
3819 strm.zalloc = Z_NULL;
3820 strm.zfree = Z_NULL;
3821 strm.opaque = Z_NULL;
3824 level = Z_DEFAULT_COMPRESSION;
3826 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3828 Con_Printf("FS_Deflate: deflate init error!\n");
3832 strm.next_in = (unsigned char*)data;
3833 strm.avail_in = size;
3835 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3838 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3839 qz_deflateEnd(&strm);
3843 strm.next_out = tmp;
3844 strm.avail_out = size;
3846 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3848 Con_Printf("FS_Deflate: deflate failed!\n");
3849 qz_deflateEnd(&strm);
3854 if(qz_deflateEnd(&strm) != Z_OK)
3856 Con_Printf("FS_Deflate: deflateEnd failed\n");
3861 if(strm.total_out >= size)
3863 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3868 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3871 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3877 *deflated_size = (size_t)strm.total_out;
3879 memcpy(out, tmp, strm.total_out);
3885 static void AssertBufsize(sizebuf_t *buf, int length)
3887 if(buf->cursize + length > buf->maxsize)
3889 int oldsize = buf->maxsize;
3890 unsigned char *olddata;
3891 olddata = buf->data;
3892 buf->maxsize += length;
3893 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3896 memcpy(buf->data, olddata, oldsize);
3902 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3906 unsigned char *out = NULL;
3907 unsigned char tmp[2048];
3912 #ifndef LINK_TO_ZLIB
3917 memset(&outbuf, 0, sizeof(outbuf));
3918 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3919 outbuf.maxsize = sizeof(tmp);
3921 memset(&strm, 0, sizeof(strm));
3922 strm.zalloc = Z_NULL;
3923 strm.zfree = Z_NULL;
3924 strm.opaque = Z_NULL;
3926 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3928 Con_Printf("FS_Inflate: inflate init error!\n");
3929 Mem_Free(outbuf.data);
3933 strm.next_in = (unsigned char*)data;
3934 strm.avail_in = size;
3938 strm.next_out = tmp;
3939 strm.avail_out = sizeof(tmp);
3940 ret = qz_inflate(&strm, Z_NO_FLUSH);
3941 // it either returns Z_OK on progress, Z_STREAM_END on end
3949 case Z_STREAM_ERROR:
3950 Con_Print("FS_Inflate: stream error!\n");
3953 Con_Print("FS_Inflate: data error!\n");
3956 Con_Print("FS_Inflate: mem error!\n");
3959 Con_Print("FS_Inflate: buf error!\n");
3962 Con_Print("FS_Inflate: unknown error!\n");
3966 if(ret != Z_OK && ret != Z_STREAM_END)
3968 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3969 Mem_Free(outbuf.data);
3970 qz_inflateEnd(&strm);
3973 have = sizeof(tmp) - strm.avail_out;
3974 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3975 SZ_Write(&outbuf, tmp, have);
3976 } while(ret != Z_STREAM_END);
3978 qz_inflateEnd(&strm);
3980 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3983 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3984 Mem_Free(outbuf.data);
3988 memcpy(out, outbuf.data, outbuf.cursize);
3989 Mem_Free(outbuf.data);
3992 *inflated_size = (size_t)outbuf.cursize;