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 = true; // PAK is sensitive in Quake1 but insensitive in Quake2
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);
1076 else if(!strcasecmp(ext, "obb")) // android apk expansion
1077 pak = FS_LoadPackPK3 (pakfile);
1079 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1083 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1085 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1088 // find the first item whose next one is a pack or NULL
1089 searchpath_t *insertion_point = 0;
1090 if(fs_searchpaths && !fs_searchpaths->pack)
1092 insertion_point = fs_searchpaths;
1095 if(!insertion_point->next)
1097 if(insertion_point->next->pack)
1099 insertion_point = insertion_point->next;
1102 // If insertion_point is NULL, this means that either there is no
1103 // item in the list yet, or that the very first item is a pack. In
1104 // that case, we want to insert at the beginning...
1105 if(!insertion_point)
1107 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1108 search->next = fs_searchpaths;
1109 fs_searchpaths = search;
1112 // otherwise we want to append directly after insertion_point.
1114 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1115 search->next = insertion_point->next;
1116 insertion_point->next = search;
1121 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1122 search->next = fs_searchpaths;
1123 fs_searchpaths = search;
1128 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1129 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1130 // same goes for the name inside the pack structure
1131 l = strlen(pak->shortname);
1133 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1134 pak->shortname[l - 3] = 0;
1135 l = strlen(pak->filename);
1137 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1138 pak->filename[l - 3] = 0;
1144 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1155 /*! Adds the given pack to the search path and searches for it in the game path.
1156 * The pack type is autodetected by the file extension.
1158 * Returns true if the file was successfully added to the
1159 * search path or if it was already included.
1161 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1162 * plain directories.
1164 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1166 char fullpath[MAX_OSPATH];
1168 searchpath_t *search;
1171 *already_loaded = false;
1173 // then find the real name...
1174 search = FS_FindFile(pakfile, &index, true);
1175 if(!search || search->pack)
1177 Con_Printf("could not find pak \"%s\"\n", pakfile);
1181 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1183 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1191 Sets fs_gamedir, adds the directory to the head of the path,
1192 then loads and adds pak1.pak pak2.pak ...
1195 static void FS_AddGameDirectory (const char *dir)
1199 searchpath_t *search;
1201 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1203 stringlistinit(&list);
1204 listdirectory(&list, "", dir);
1205 stringlistsort(&list, false);
1207 // add any PAK package in the directory
1208 for (i = 0;i < list.numstrings;i++)
1210 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1212 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1216 // add any PK3 package in the directory
1217 for (i = 0;i < list.numstrings;i++)
1219 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1221 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1225 stringlistfreecontents(&list);
1227 // Add the directory to the search path
1228 // (unpacked files have the priority over packed files)
1229 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1230 strlcpy (search->filename, dir, sizeof (search->filename));
1231 search->next = fs_searchpaths;
1232 fs_searchpaths = search;
1241 static void FS_AddGameHierarchy (const char *dir)
1244 // Add the common game directory
1245 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1248 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1257 const char *FS_FileExtension (const char *in)
1259 const char *separator, *backslash, *colon, *dot;
1261 separator = strrchr(in, '/');
1262 backslash = strrchr(in, '\\');
1263 if (!separator || separator < backslash)
1264 separator = backslash;
1265 colon = strrchr(in, ':');
1266 if (!separator || separator < colon)
1269 dot = strrchr(in, '.');
1270 if (dot == NULL || (separator && (dot < separator)))
1282 const char *FS_FileWithoutPath (const char *in)
1284 const char *separator, *backslash, *colon;
1286 separator = strrchr(in, '/');
1287 backslash = strrchr(in, '\\');
1288 if (!separator || separator < backslash)
1289 separator = backslash;
1290 colon = strrchr(in, ':');
1291 if (!separator || separator < colon)
1293 return separator ? separator + 1 : in;
1302 static void FS_ClearSearchPath (void)
1304 // unload all packs and directory information, close all pack files
1305 // (if a qfile is still reading a pack it won't be harmed because it used
1306 // dup() to get its own handle already)
1307 while (fs_searchpaths)
1309 searchpath_t *search = fs_searchpaths;
1310 fs_searchpaths = search->next;
1311 if (search->pack && search->pack != fs_selfpack)
1313 if(!search->pack->vpack)
1316 close(search->pack->handle);
1317 // free any memory associated with it
1318 if (search->pack->files)
1319 Mem_Free(search->pack->files);
1321 Mem_Free(search->pack);
1327 static void FS_AddSelfPack(void)
1331 searchpath_t *search;
1332 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1333 search->next = fs_searchpaths;
1334 search->pack = fs_selfpack;
1335 fs_searchpaths = search;
1345 void FS_Rescan (void)
1348 qboolean fs_modified = false;
1349 qboolean reset = false;
1350 char gamedirbuf[MAX_INPUTLINE];
1355 FS_ClearSearchPath();
1357 // automatically activate gamemode for the gamedirs specified
1359 COM_ChangeGameTypeForGameDirs();
1361 // add the game-specific paths
1362 // gamedirname1 (typically id1)
1363 FS_AddGameHierarchy (gamedirname1);
1364 // update the com_modname (used for server info)
1365 if (gamedirname2 && gamedirname2[0])
1366 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1368 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1370 // add the game-specific path, if any
1371 // (only used for mission packs and the like, which should set fs_modified)
1372 if (gamedirname2 && gamedirname2[0])
1375 FS_AddGameHierarchy (gamedirname2);
1379 // Adds basedir/gamedir as an override game
1380 // LordHavoc: now supports multiple -game directories
1381 // set the com_modname (reported in server info)
1383 for (i = 0;i < fs_numgamedirs;i++)
1386 FS_AddGameHierarchy (fs_gamedirs[i]);
1387 // update the com_modname (used server info)
1388 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1390 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1392 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1394 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1396 // add back the selfpack as new first item
1399 // set the default screenshot name to either the mod name or the
1400 // gamemode screenshot name
1401 if (strcmp(com_modname, gamedirname1))
1402 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1404 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1406 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1407 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1409 // If "-condebug" is in the command line, remove the previous log file
1410 if (COM_CheckParm ("-condebug") != 0)
1411 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1413 // look for the pop.lmp file and set registered to true if it is found
1414 if (FS_FileExists("gfx/pop.lmp"))
1415 Cvar_Set ("registered", "1");
1421 if (!registered.integer)
1424 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1426 Con_Print("Playing shareware version.\n");
1429 Con_Print("Playing registered version.\n");
1431 case GAME_STEELSTORM:
1432 if (registered.integer)
1433 Con_Print("Playing registered version.\n");
1435 Con_Print("Playing shareware version.\n");
1441 // unload all wads so that future queries will return the new data
1445 static void FS_Rescan_f(void)
1455 extern qboolean vid_opened;
1456 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1461 if (fs_numgamedirs == numgamedirs)
1463 for (i = 0;i < numgamedirs;i++)
1464 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1466 if (i == numgamedirs)
1467 return true; // already using this set of gamedirs, do nothing
1470 if (numgamedirs > MAX_GAMEDIRS)
1473 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1474 return false; // too many gamedirs
1477 for (i = 0;i < numgamedirs;i++)
1479 // if string is nasty, reject it
1480 p = FS_CheckGameDir(gamedirs[i]);
1484 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1485 return false; // nasty gamedirs
1487 if(p == fs_checkgamedir_missing && failmissing)
1490 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1491 return false; // missing gamedirs
1497 fs_numgamedirs = numgamedirs;
1498 for (i = 0;i < fs_numgamedirs;i++)
1499 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1501 // reinitialize filesystem to detect the new paks
1504 if (cls.demoplayback)
1510 // unload all sounds so they will be reloaded from the new files as needed
1511 S_UnloadAllSounds_f();
1513 // close down the video subsystem, it will start up again when the config finishes...
1517 // restart the video subsystem after the config is executed
1518 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1528 static void FS_GameDir_f (void)
1532 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1536 Con_Printf("gamedirs active:");
1537 for (i = 0;i < fs_numgamedirs;i++)
1538 Con_Printf(" %s", fs_gamedirs[i]);
1543 numgamedirs = Cmd_Argc() - 1;
1544 if (numgamedirs > MAX_GAMEDIRS)
1546 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1550 for (i = 0;i < numgamedirs;i++)
1551 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1553 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1555 // actually, changing during game would work fine, but would be stupid
1556 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1560 // halt demo playback to close the file
1563 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1566 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1574 stringlistinit(&list);
1575 listdirectory(&list, gamedir, "");
1576 success = list.numstrings > 0;
1577 stringlistfreecontents(&list);
1581 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1584 n = FS_Read (f, buf, buflength - 1);
1604 const char *FS_CheckGameDir(const char *gamedir)
1610 if (FS_CheckNastyPath(gamedir, true))
1613 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1618 // get description from basedir
1619 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1627 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1631 return fs_checkgamedir_missing;
1634 static void FS_ListGameDirs(void)
1636 stringlist_t list, list2;
1641 fs_all_gamedirs_count = 0;
1643 Mem_Free(fs_all_gamedirs);
1645 stringlistinit(&list);
1646 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1647 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1648 stringlistsort(&list, false);
1650 stringlistinit(&list2);
1651 for(i = 0; i < list.numstrings; ++i)
1654 if(!strcmp(list.strings[i-1], list.strings[i]))
1656 info = FS_CheckGameDir(list.strings[i]);
1659 if(info == fs_checkgamedir_missing)
1663 stringlistappend(&list2, list.strings[i]);
1665 stringlistfreecontents(&list);
1667 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1668 for(i = 0; i < list2.numstrings; ++i)
1670 info = FS_CheckGameDir(list2.strings[i]);
1671 // all this cannot happen any more, but better be safe than sorry
1674 if(info == fs_checkgamedir_missing)
1678 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1679 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1680 ++fs_all_gamedirs_count;
1686 #pragma comment(lib, "shell32.lib")
1696 void FS_Init_SelfPack (void)
1699 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1702 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1708 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1711 const char **new_argv;
1713 int args_left = 256;
1714 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1717 new_argv[0] = "dummy";
1722 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1725 while(COM_ParseToken_Console(&p))
1727 size_t sz = strlen(com_token) + 1; // shut up clang
1730 q = (char *)Mem_Alloc(fs_mempool, sz);
1731 strlcpy(q, com_token, sz);
1732 new_argv[com_argc + i] = q;
1735 new_argv[i+com_argc] = NULL;
1736 com_argv = new_argv;
1737 com_argc = com_argc + i;
1744 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1746 #if defined(__IPHONEOS__)
1747 if (userdirmode == USERDIRMODE_HOME)
1749 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1750 // fs_userdir stores configurations to the Documents folder of the app
1751 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1756 #elif defined(WIN32)
1758 #if _MSC_VER >= 1400
1761 TCHAR mydocsdir[MAX_PATH + 1];
1762 wchar_t *savedgamesdirw;
1763 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);
1845 case USERDIRMODE_NOHOME:
1846 strlcpy(userdir, fs_basedir, userdirsize);
1848 case USERDIRMODE_HOME:
1849 homedir = getenv("HOME");
1852 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1856 case USERDIRMODE_SAVEDGAMES:
1857 homedir = getenv("HOME");
1861 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1863 // the XDG say some files would need to go in:
1864 // XDG_CONFIG_HOME (or ~/.config/%s/)
1865 // XDG_DATA_HOME (or ~/.local/share/%s/)
1866 // XDG_CACHE_HOME (or ~/.cache/%s/)
1867 // and also search the following global locations if defined:
1868 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1869 // XDG_DATA_DIRS (normally /usr/share/%s/)
1870 // this would be too complicated...
1880 #if !defined(__IPHONEOS__)
1883 // historical behavior...
1884 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1885 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
1888 // see if we can write to this path (note: won't create path)
1890 // no access() here, we must try to open the file for appending
1891 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1895 // on Unix, we don't need to ACTUALLY attempt to open the file
1896 if(access(va(vabuf, sizeof(vabuf), "%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
1930 // Overrides the system supplied base directory (under GAMENAME)
1931 // 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)
1932 i = COM_CheckParm ("-basedir");
1933 if (i && i < com_argc-1)
1935 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1936 i = (int)strlen (fs_basedir);
1937 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1938 fs_basedir[i-1] = 0;
1942 // If the base directory is explicitly defined by the compilation process
1943 #ifdef DP_FS_BASEDIR
1944 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1945 #elif defined(__ANDROID__)
1946 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
1947 #elif defined(MACOSX)
1948 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1949 if (strstr(com_argv[0], ".app/"))
1952 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1953 split = strstr(fs_basedir, ".app/");
1956 struct stat statresult;
1958 // truncate to just after the .app/
1960 // see if gamedir exists in Resources
1961 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1963 // found gamedir inside Resources, use it
1964 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1968 // no gamedir found in Resources, gamedir is probably
1969 // outside the .app, remove .app part of path
1970 while (split > fs_basedir && *split != '/')
1979 // make sure the appending of a path separator won't create an unterminated string
1980 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1981 // add a path separator to the end of the basedir if it lacks one
1982 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1983 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1985 // Add the personal game directory
1986 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1987 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1988 else if (COM_CheckParm("-nohome"))
1989 *fs_userdir = 0; // user wants roaming installation, no userdir
1993 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1994 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1995 int userdirstatus[USERDIRMODE_COUNT];
1997 // historical behavior...
1998 if (!strcmp(gamedirname1, "id1"))
1999 preferreduserdirmode = USERDIRMODE_NOHOME;
2001 // check what limitations the user wants to impose
2002 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2003 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2004 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2005 // gather the status of the possible userdirs
2006 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2008 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2009 if (userdirstatus[dirmode] == 1)
2010 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2011 else if (userdirstatus[dirmode] == 0)
2012 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2014 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2016 // some games may prefer writing to basedir, but if write fails we
2017 // have to search for a real userdir...
2018 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2019 preferreduserdirmode = highestuserdirmode;
2020 // check for an existing userdir and continue using it if possible...
2021 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2022 if (userdirstatus[dirmode] == 1)
2024 // if no existing userdir found, make a new one...
2025 if (dirmode == 0 && preferreduserdirmode > 0)
2026 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2027 if (userdirstatus[dirmode] >= 0)
2029 // and finally, we picked one...
2030 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2031 Con_DPrintf("userdir %i is the winner\n", dirmode);
2034 // if userdir equal to basedir, clear it to avoid confusion later
2035 if (!strcmp(fs_basedir, fs_userdir))
2040 p = FS_CheckGameDir(gamedirname1);
2041 if(!p || p == fs_checkgamedir_missing)
2042 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2046 p = FS_CheckGameDir(gamedirname2);
2047 if(!p || p == fs_checkgamedir_missing)
2048 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2052 // Adds basedir/gamedir as an override game
2053 // LordHavoc: now supports multiple -game directories
2054 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2058 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2061 p = FS_CheckGameDir(com_argv[i]);
2063 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2064 if(p == fs_checkgamedir_missing)
2065 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2066 // add the gamedir to the list of active gamedirs
2067 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2072 // generate the searchpath
2075 if (Thread_HasThreads())
2076 fs_mutex = Thread_CreateMutex();
2079 void FS_Init_Commands(void)
2081 Cvar_RegisterVariable (&scr_screenshot_name);
2082 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2083 Cvar_RegisterVariable (&cvar_fs_gamedir);
2085 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2086 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2087 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2088 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2089 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2090 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2098 void FS_Shutdown (void)
2100 // close all pack files and such
2101 // (hopefully there aren't any other open files, but they'll be cleaned up
2102 // by the OS anyway)
2103 FS_ClearSearchPath();
2104 Mem_FreePool (&fs_mempool);
2105 PK3_CloseLibrary ();
2108 Sys_UnloadLibrary (&shfolder_dll);
2109 Sys_UnloadLibrary (&shell32_dll);
2110 Sys_UnloadLibrary (&ole32_dll);
2114 Thread_DestroyMutex(fs_mutex);
2117 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2122 qboolean dolock = false;
2124 // Parse the mode string
2133 opt = O_CREAT | O_TRUNC;
2137 opt = O_CREAT | O_APPEND;
2140 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2143 for (ind = 1; mode[ind] != '\0'; ind++)
2157 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2158 filepath, mode, mode[ind]);
2165 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2169 # if _MSC_VER >= 1400
2170 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2172 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2175 handle = open (filepath, mod | opt, 0666);
2176 if(handle >= 0 && dolock)
2179 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2180 l.l_whence = SEEK_SET;
2183 if(fcntl(handle, F_SETLK, &l) == -1)
2195 ====================
2198 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2199 ====================
2201 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2205 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2207 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2208 if (file->handle < 0)
2214 file->filename = Mem_strdup(fs_mempool, filepath);
2216 file->real_length = lseek (file->handle, 0, SEEK_END);
2218 // For files opened in append mode, we start at the end of the file
2220 file->position = file->real_length;
2222 lseek (file->handle, 0, SEEK_SET);
2232 Open a packed file using its package file descriptor
2235 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2241 pfile = &pack->files[pack_ind];
2243 // If we don't have the true offset, get it now
2244 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2245 if (!PK3_GetTrueFileOffset (pfile, pack))
2248 #ifndef LINK_TO_ZLIB
2249 // No Zlib DLL = no compressed files
2250 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2252 Con_Printf("WARNING: can't open the compressed file %s\n"
2253 "You need the Zlib DLL to use compressed files\n",
2259 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2260 // the dup() call to avoid having to close the dup_handle on error here
2261 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2263 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2264 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2268 dup_handle = dup (pack->handle);
2271 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2275 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2276 memset (file, 0, sizeof (*file));
2277 file->handle = dup_handle;
2278 file->flags = QFILE_FLAG_PACKED;
2279 file->real_length = pfile->realsize;
2280 file->offset = pfile->offset;
2284 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2288 file->flags |= QFILE_FLAG_DEFLATED;
2290 // We need some more variables
2291 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2293 ztk->comp_length = pfile->packsize;
2295 // Initialize zlib stream
2296 ztk->zstream.next_in = ztk->input;
2297 ztk->zstream.avail_in = 0;
2299 /* From Zlib's "unzip.c":
2301 * windowBits is passed < 0 to tell that there is no zlib header.
2302 * Note that in this case inflate *requires* an extra "dummy" byte
2303 * after the compressed stream in order to complete decompression and
2304 * return Z_STREAM_END.
2305 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2306 * size of both compressed and uncompressed data
2308 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2310 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2316 ztk->zstream.next_out = file->buff;
2317 ztk->zstream.avail_out = sizeof (file->buff);
2326 ====================
2329 Return true if the path should be rejected due to one of the following:
2330 1: path elements that are non-portable
2331 2: path elements that would allow access to files outside the game directory,
2332 or are just not a good idea for a mod to be using.
2333 ====================
2335 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2337 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2341 // Windows: don't allow \ in filenames (windows-only), period.
2342 // (on Windows \ is a directory separator, but / is also supported)
2343 if (strstr(path, "\\"))
2344 return 1; // non-portable
2346 // Mac: don't allow Mac-only filenames - : is a directory separator
2347 // instead of /, but we rely on / working already, so there's no reason to
2348 // support a Mac-only path
2349 // Amiga and Windows: : tries to go to root of drive
2350 if (strstr(path, ":"))
2351 return 1; // non-portable attempt to go to root of drive
2353 // Amiga: // is parent directory
2354 if (strstr(path, "//"))
2355 return 1; // non-portable attempt to go to parent directory
2357 // all: don't allow going to parent directory (../ or /../)
2358 if (strstr(path, ".."))
2359 return 2; // attempt to go outside the game directory
2361 // Windows and UNIXes: don't allow absolute paths
2363 return 2; // attempt to go outside the game directory
2365 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2366 if (strstr(path, "./"))
2367 return 2; // possible attempt to go outside the game directory
2369 // all: forbid trailing slash on gamedir
2370 if (isgamedir && path[strlen(path)-1] == '/')
2373 // all: forbid leading dot on any filename for any reason
2374 if (strstr(path, "/."))
2375 return 2; // attempt to go outside the game directory
2377 // after all these checks we're pretty sure it's a / separated filename
2378 // and won't do much if any harm
2384 ====================
2387 Look for a file in the packages and in the filesystem
2389 Return the searchpath where the file was found (or NULL)
2390 and the file index in the package if relevant
2391 ====================
2393 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2395 searchpath_t *search;
2398 // search through the path, one element at a time
2399 for (search = fs_searchpaths;search;search = search->next)
2401 // is the element a pak file?
2402 if (search->pack && !search->pack->vpack)
2404 int (*strcmp_funct) (const char* str1, const char* str2);
2405 int left, right, middle;
2408 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2410 // Look for the file (binary search)
2412 right = pak->numfiles - 1;
2413 while (left <= right)
2417 middle = (left + right) / 2;
2418 diff = strcmp_funct (pak->files[middle].name, name);
2423 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2425 // yes, but the first one is empty so we treat it as not being there
2426 if (!quiet && developer_extra.integer)
2427 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2434 if (!quiet && developer_extra.integer)
2435 Con_DPrintf("FS_FindFile: %s in %s\n",
2436 pak->files[middle].name, pak->filename);
2443 // If we're too far in the list
2452 char netpath[MAX_OSPATH];
2453 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2454 if (FS_SysFileExists (netpath))
2456 if (!quiet && developer_extra.integer)
2457 Con_DPrintf("FS_FindFile: %s\n", netpath);
2466 if (!quiet && developer_extra.integer)
2467 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2479 Look for a file in the search paths and open it in read-only mode
2482 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2484 searchpath_t *search;
2487 search = FS_FindFile (filename, &pack_ind, quiet);
2493 // Found in the filesystem?
2496 // this works with vpacks, so we are fine
2497 char path [MAX_OSPATH];
2498 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2499 return FS_SysOpen (path, "rb", nonblocking);
2502 // So, we found it in a package...
2504 // Is it a PK3 symlink?
2505 // TODO also handle directory symlinks by parsing the whole structure...
2506 // but heck, file symlinks are good enough for now
2507 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2509 if(symlinkLevels <= 0)
2511 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2516 char linkbuf[MAX_QPATH];
2518 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2519 const char *mergeslash;
2524 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2530 // Now combine the paths...
2531 mergeslash = strrchr(filename, '/');
2532 mergestart = linkbuf;
2534 mergeslash = filename;
2535 while(!strncmp(mergestart, "../", 3))
2538 while(mergeslash > filename)
2541 if(*mergeslash == '/')
2545 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2546 if(mergeslash == filename)
2548 // Either mergeslash == filename, then we just replace the name (done below)
2552 // Or, we append the name after mergeslash;
2553 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2554 int spaceNeeded = mergeslash - filename + 1;
2555 int spaceRemoved = mergestart - linkbuf;
2556 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2558 Con_DPrintf("symlink: too long path rejected\n");
2561 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2562 memcpy(linkbuf, filename, spaceNeeded);
2563 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2564 mergestart = linkbuf;
2566 if (!quiet && developer_loading.integer)
2567 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2568 if(FS_CheckNastyPath (mergestart, false))
2570 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2573 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2577 return FS_OpenPackedFile (search->pack, pack_ind);
2582 =============================================================================
2584 MAIN PUBLIC FUNCTIONS
2586 =============================================================================
2590 ====================
2593 Open a file in the userpath. The syntax is the same as fopen
2594 Used for savegame scanning in menu, and all file writing.
2595 ====================
2597 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2599 char real_path [MAX_OSPATH];
2601 if (FS_CheckNastyPath(filepath, false))
2603 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2607 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2609 // If the file is opened in "write", "append", or "read/write" mode,
2610 // create directories up to the file.
2611 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2612 FS_CreatePath (real_path);
2613 return FS_SysOpen (real_path, mode, false);
2618 ====================
2621 Open a file. The syntax is the same as fopen
2622 ====================
2624 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2626 qfile_t *result = NULL;
2627 if (FS_CheckNastyPath(filepath, false))
2629 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2633 if (fs_mutex) Thread_LockMutex(fs_mutex);
2634 result = FS_OpenReadFile (filepath, quiet, false, 16);
2635 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2641 ====================
2644 Open a file. The syntax is the same as fopen
2645 ====================
2647 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2650 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2651 memset (file, 0, sizeof (*file));
2652 file->flags = QFILE_FLAG_DATA;
2654 file->real_length = size;
2660 ====================
2664 ====================
2666 int FS_Close (qfile_t* file)
2668 if(file->flags & QFILE_FLAG_DATA)
2674 if (close (file->handle))
2679 if (file->flags & QFILE_FLAG_REMOVE)
2680 remove(file->filename);
2682 Mem_Free((void *) file->filename);
2687 qz_inflateEnd (&file->ztk->zstream);
2688 Mem_Free (file->ztk);
2695 void FS_RemoveOnClose(qfile_t* file)
2697 file->flags |= QFILE_FLAG_REMOVE;
2701 ====================
2704 Write "datasize" bytes into a file
2705 ====================
2707 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2709 fs_offset_t written = 0;
2711 // If necessary, seek to the exact file position we're supposed to be
2712 if (file->buff_ind != file->buff_len)
2713 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2715 // Purge cached data
2718 // Write the buffer and update the position
2719 // LordHavoc: to hush a warning about passing size_t to an unsigned int parameter on Win64 we do this as multiple writes if the size would be too big for an integer (we never write that big in one go, but it's a theory)
2720 while (written < (fs_offset_t)datasize)
2722 // figure out how much to write in one chunk
2723 fs_offset_t maxchunk = 1<<30; // 1 GiB
2724 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2725 int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
2726 // if at least some was written, add it to our accumulator
2729 // if the result is not what we expected, consider the write to be incomplete
2730 if (result != chunk)
2733 file->position = lseek (file->handle, 0, SEEK_CUR);
2734 if (file->real_length < file->position)
2735 file->real_length = file->position;
2737 // note that this will never be less than 0 even if the write failed
2743 ====================
2746 Read up to "buffersize" bytes from a file
2747 ====================
2749 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2751 fs_offset_t count, done;
2753 if (buffersize == 0)
2756 // Get rid of the ungetc character
2757 if (file->ungetc != EOF)
2759 ((char*)buffer)[0] = file->ungetc;
2767 if(file->flags & QFILE_FLAG_DATA)
2769 size_t left = file->real_length - file->position;
2770 if(buffersize > left)
2772 memcpy(buffer, file->data + file->position, buffersize);
2773 file->position += buffersize;
2777 // First, we copy as many bytes as we can from "buff"
2778 if (file->buff_ind < file->buff_len)
2780 count = file->buff_len - file->buff_ind;
2781 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2783 memcpy (buffer, &file->buff[file->buff_ind], count);
2784 file->buff_ind += count;
2786 buffersize -= count;
2787 if (buffersize == 0)
2791 // NOTE: at this point, the read buffer is always empty
2793 // If the file isn't compressed
2794 if (! (file->flags & QFILE_FLAG_DEFLATED))
2798 // We must take care to not read after the end of the file
2799 count = file->real_length - file->position;
2801 // If we have a lot of data to get, put them directly into "buffer"
2802 if (buffersize > sizeof (file->buff) / 2)
2804 if (count > (fs_offset_t)buffersize)
2805 count = (fs_offset_t)buffersize;
2806 lseek (file->handle, file->offset + file->position, SEEK_SET);
2807 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2811 file->position += nb;
2813 // Purge cached data
2819 if (count > (fs_offset_t)sizeof (file->buff))
2820 count = (fs_offset_t)sizeof (file->buff);
2821 lseek (file->handle, file->offset + file->position, SEEK_SET);
2822 nb = read (file->handle, file->buff, count);
2825 file->buff_len = nb;
2826 file->position += nb;
2828 // Copy the requested data in "buffer" (as much as we can)
2829 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2830 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2831 file->buff_ind = count;
2839 // If the file is compressed, it's more complicated...
2840 // We cycle through a few operations until we have read enough data
2841 while (buffersize > 0)
2843 ztoolkit_t *ztk = file->ztk;
2846 // NOTE: at this point, the read buffer is always empty
2848 // If "input" is also empty, we need to refill it
2849 if (ztk->in_ind == ztk->in_len)
2851 // If we are at the end of the file
2852 if (file->position == file->real_length)
2855 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2856 if (count > (fs_offset_t)sizeof (ztk->input))
2857 count = (fs_offset_t)sizeof (ztk->input);
2858 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2859 if (read (file->handle, ztk->input, count) != count)
2861 Con_Printf ("FS_Read: unexpected end of file\n");
2866 ztk->in_len = count;
2867 ztk->in_position += count;
2870 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2871 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2873 // Now that we are sure we have compressed data available, we need to determine
2874 // if it's better to inflate it in "file->buff" or directly in "buffer"
2876 // Inflate the data in "file->buff"
2877 if (buffersize < sizeof (file->buff) / 2)
2879 ztk->zstream.next_out = file->buff;
2880 ztk->zstream.avail_out = sizeof (file->buff);
2881 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2882 if (error != Z_OK && error != Z_STREAM_END)
2884 Con_Printf ("FS_Read: Can't inflate file\n");
2887 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2889 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2890 file->position += file->buff_len;
2892 // Copy the requested data in "buffer" (as much as we can)
2893 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2894 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2895 file->buff_ind = count;
2898 // Else, we inflate directly in "buffer"
2901 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2902 ztk->zstream.avail_out = (unsigned int)buffersize;
2903 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2904 if (error != Z_OK && error != Z_STREAM_END)
2906 Con_Printf ("FS_Read: Can't inflate file\n");
2909 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2911 // How much data did it inflate?
2912 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2913 file->position += count;
2915 // Purge cached data
2920 buffersize -= count;
2928 ====================
2931 Print a string into a file
2932 ====================
2934 int FS_Print (qfile_t* file, const char *msg)
2936 return (int)FS_Write (file, msg, strlen (msg));
2940 ====================
2943 Print a string into a file
2944 ====================
2946 int FS_Printf(qfile_t* file, const char* format, ...)
2951 va_start (args, format);
2952 result = FS_VPrintf (file, format, args);
2960 ====================
2963 Print a string into a file
2964 ====================
2966 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2969 fs_offset_t buff_size = MAX_INPUTLINE;
2974 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2975 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2976 if (len >= 0 && len < buff_size)
2978 Mem_Free (tempbuff);
2982 len = write (file->handle, tempbuff, len);
2983 Mem_Free (tempbuff);
2990 ====================
2993 Get the next character of a file
2994 ====================
2996 int FS_Getc (qfile_t* file)
3000 if (FS_Read (file, &c, 1) != 1)
3008 ====================
3011 Put a character back into the read buffer (only supports one character!)
3012 ====================
3014 int FS_UnGetc (qfile_t* file, unsigned char c)
3016 // If there's already a character waiting to be read
3017 if (file->ungetc != EOF)
3026 ====================
3029 Move the position index in a file
3030 ====================
3032 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3035 unsigned char* buffer;
3036 fs_offset_t buffersize;
3038 // Compute the file offset
3042 offset += file->position - file->buff_len + file->buff_ind;
3049 offset += file->real_length;
3055 if (offset < 0 || offset > file->real_length)
3058 if(file->flags & QFILE_FLAG_DATA)
3060 file->position = offset;
3064 // If we have the data in our read buffer, we don't need to actually seek
3065 if (file->position - file->buff_len <= offset && offset <= file->position)
3067 file->buff_ind = offset + file->buff_len - file->position;
3071 // Purge cached data
3074 // Unpacked or uncompressed files can seek directly
3075 if (! (file->flags & QFILE_FLAG_DEFLATED))
3077 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3079 file->position = offset;
3083 // Seeking in compressed files is more a hack than anything else,
3084 // but we need to support it, so here we go.
3087 // If we have to go back in the file, we need to restart from the beginning
3088 if (offset <= file->position)
3092 ztk->in_position = 0;
3094 lseek (file->handle, file->offset, SEEK_SET);
3096 // Reset the Zlib stream
3097 ztk->zstream.next_in = ztk->input;
3098 ztk->zstream.avail_in = 0;
3099 qz_inflateReset (&ztk->zstream);
3102 // We need a big buffer to force inflating into it directly
3103 buffersize = 2 * sizeof (file->buff);
3104 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3106 // Skip all data until we reach the requested offset
3107 while (offset > file->position)
3109 fs_offset_t diff = offset - file->position;
3110 fs_offset_t count, len;
3112 count = (diff > buffersize) ? buffersize : diff;
3113 len = FS_Read (file, buffer, count);
3127 ====================
3130 Give the current position in a file
3131 ====================
3133 fs_offset_t FS_Tell (qfile_t* file)
3135 return file->position - file->buff_len + file->buff_ind;
3140 ====================
3143 Give the total size of a file
3144 ====================
3146 fs_offset_t FS_FileSize (qfile_t* file)
3148 return file->real_length;
3153 ====================
3156 Erases any buffered input or output data
3157 ====================
3159 void FS_Purge (qfile_t* file)
3171 Filename are relative to the quake directory.
3172 Always appends a 0 byte.
3175 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3178 unsigned char *buf = NULL;
3179 fs_offset_t filesize = 0;
3181 file = FS_OpenVirtualFile(path, quiet);
3184 filesize = file->real_length;
3187 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3192 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3193 buf[filesize] = '\0';
3194 FS_Read (file, buf, filesize);
3196 if (developer_loadfile.integer)
3197 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3200 if (filesizepointer)
3201 *filesizepointer = filesize;
3210 The filename will be prefixed by the current game directory
3213 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3217 fs_offset_t lentotal;
3219 file = FS_OpenRealFile(filename, "wb", false);
3222 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3227 for(i = 0; i < count; ++i)
3229 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3230 for(i = 0; i < count; ++i)
3231 FS_Write (file, data[i], len[i]);
3236 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3238 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3243 =============================================================================
3245 OTHERS PUBLIC FUNCTIONS
3247 =============================================================================
3255 void FS_StripExtension (const char *in, char *out, size_t size_out)
3263 while ((currentchar = *in) && size_out > 1)
3265 if (currentchar == '.')
3267 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3269 *out++ = currentchar;
3285 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3289 // if path doesn't have a .EXT, append extension
3290 // (extension should include the .)
3291 src = path + strlen(path) - 1;
3293 while (*src != '/' && src != path)
3296 return; // it has an extension
3300 strlcat (path, extension, size_path);
3308 Look for a file in the packages and in the filesystem
3311 int FS_FileType (const char *filename)
3313 searchpath_t *search;
3314 char fullpath[MAX_OSPATH];
3316 search = FS_FindFile (filename, NULL, true);
3318 return FS_FILETYPE_NONE;
3320 if(search->pack && !search->pack->vpack)
3321 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3323 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3324 return FS_SysFileType(fullpath);
3332 Look for a file in the packages and in the filesystem
3335 qboolean FS_FileExists (const char *filename)
3337 return (FS_FindFile (filename, NULL, true) != NULL);
3345 Look for a file in the filesystem only
3348 int FS_SysFileType (const char *path)
3351 // Sajt - some older sdks are missing this define
3352 # ifndef INVALID_FILE_ATTRIBUTES
3353 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3356 DWORD result = GetFileAttributes(path);
3358 if(result == INVALID_FILE_ATTRIBUTES)
3359 return FS_FILETYPE_NONE;
3361 if(result & FILE_ATTRIBUTE_DIRECTORY)
3362 return FS_FILETYPE_DIRECTORY;
3364 return FS_FILETYPE_FILE;
3368 if (stat (path,&buf) == -1)
3369 return FS_FILETYPE_NONE;
3372 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3374 if(S_ISDIR(buf.st_mode))
3375 return FS_FILETYPE_DIRECTORY;
3377 return FS_FILETYPE_FILE;
3381 qboolean FS_SysFileExists (const char *path)
3383 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3386 void FS_mkdir (const char *path)
3388 if(COM_CheckParm("-readonly"))
3402 Allocate and fill a search structure with information on matching filenames.
3405 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3408 searchpath_t *searchpath;
3410 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3411 stringlist_t resultlist;
3412 stringlist_t dirlist;
3413 const char *slash, *backslash, *colon, *separator;
3415 char temp[MAX_OSPATH];
3417 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3422 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3426 stringlistinit(&resultlist);
3427 stringlistinit(&dirlist);
3429 slash = strrchr(pattern, '/');
3430 backslash = strrchr(pattern, '\\');
3431 colon = strrchr(pattern, ':');
3432 separator = max(slash, backslash);
3433 separator = max(separator, colon);
3434 basepathlength = separator ? (separator + 1 - pattern) : 0;
3435 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3437 memcpy(basepath, pattern, basepathlength);
3438 basepath[basepathlength] = 0;
3440 // search through the path, one element at a time
3441 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3443 // is the element a pak file?
3444 if (searchpath->pack && !searchpath->pack->vpack)
3446 // look through all the pak file elements
3447 pak = searchpath->pack;
3448 for (i = 0;i < pak->numfiles;i++)
3450 strlcpy(temp, pak->files[i].name, sizeof(temp));
3453 if (matchpattern(temp, (char *)pattern, true))
3455 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3456 if (!strcmp(resultlist.strings[resultlistindex], temp))
3458 if (resultlistindex == resultlist.numstrings)
3460 stringlistappend(&resultlist, temp);
3461 if (!quiet && developer_loading.integer)
3462 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3465 // strip off one path element at a time until empty
3466 // this way directories are added to the listing if they match the pattern
3467 slash = strrchr(temp, '/');
3468 backslash = strrchr(temp, '\\');
3469 colon = strrchr(temp, ':');
3471 if (separator < slash)
3473 if (separator < backslash)
3474 separator = backslash;
3475 if (separator < colon)
3477 *((char *)separator) = 0;
3483 stringlist_t matchedSet, foundSet;
3484 const char *start = pattern;
3486 stringlistinit(&matchedSet);
3487 stringlistinit(&foundSet);
3488 // add a first entry to the set
3489 stringlistappend(&matchedSet, "");
3490 // iterate through pattern's path
3493 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3494 char subpath[MAX_OSPATH];
3495 char subpattern[MAX_OSPATH];
3497 // find the next wildcard
3498 wildcard = strchr(start, '?');
3499 asterisk = strchr(start, '*');
3500 if (asterisk && (!wildcard || asterisk < wildcard))
3502 wildcard = asterisk;
3507 nextseparator = strchr( wildcard, '/' );
3511 nextseparator = NULL;
3514 if( !nextseparator ) {
3515 nextseparator = start + strlen( start );
3518 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3519 // copy everything up except nextseperator
3520 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3521 // find the last '/' before the wildcard
3522 prevseparator = strrchr( subpattern, '/' );
3524 prevseparator = subpattern;
3527 // copy everything from start to the previous including the '/' (before the wildcard)
3528 // everything up to start is already included in the path of matchedSet's entries
3529 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3531 // for each entry in matchedSet try to open the subdirectories specified in subpath
3532 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3533 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3534 strlcat( temp, subpath, sizeof(temp) );
3535 listdirectory( &foundSet, searchpath->filename, temp );
3537 if( dirlistindex == 0 ) {
3540 // reset the current result set
3541 stringlistfreecontents( &matchedSet );
3542 // match against the pattern
3543 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3544 const char *direntry = foundSet.strings[ dirlistindex ];
3545 if (matchpattern(direntry, subpattern, true)) {
3546 stringlistappend( &matchedSet, direntry );
3549 stringlistfreecontents( &foundSet );
3551 start = nextseparator;
3554 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3556 const char *temp = matchedSet.strings[dirlistindex];
3557 if (matchpattern(temp, (char *)pattern, true))
3559 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3560 if (!strcmp(resultlist.strings[resultlistindex], temp))
3562 if (resultlistindex == resultlist.numstrings)
3564 stringlistappend(&resultlist, temp);
3565 if (!quiet && developer_loading.integer)
3566 Con_Printf("SearchDirFile: %s\n", temp);
3570 stringlistfreecontents( &matchedSet );
3574 if (resultlist.numstrings)
3576 stringlistsort(&resultlist, true);
3577 numfiles = resultlist.numstrings;
3579 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3580 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3581 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3582 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3583 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3584 search->numfilenames = (int)numfiles;
3587 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3590 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3591 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3592 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3594 numchars += (int)textlen;
3597 stringlistfreecontents(&resultlist);
3603 void FS_FreeSearch(fssearch_t *search)
3608 extern int con_linewidth;
3609 static int FS_ListDirectory(const char *pattern, int oneperline)
3618 char linebuf[MAX_INPUTLINE];
3620 search = FS_Search(pattern, true, true);
3623 numfiles = search->numfilenames;
3626 // FIXME: the names could be added to one column list and then
3627 // gradually shifted into the next column if they fit, and then the
3628 // next to make a compact variable width listing but it's a lot more
3630 // find width for columns
3632 for (i = 0;i < numfiles;i++)
3634 l = (int)strlen(search->filenames[i]);
3635 if (columnwidth < l)
3638 // count the spacing character
3640 // calculate number of columns
3641 numcolumns = con_linewidth / columnwidth;
3642 // don't bother with the column printing if it's only one column
3643 if (numcolumns >= 2)
3645 numlines = (numfiles + numcolumns - 1) / numcolumns;
3646 for (i = 0;i < numlines;i++)
3649 for (k = 0;k < numcolumns;k++)
3651 l = i * numcolumns + k;
3654 name = search->filenames[l];
3655 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3656 linebuf[linebufpos++] = name[j];
3657 // space out name unless it's the last on the line
3658 if (k + 1 < numcolumns && l + 1 < numfiles)
3659 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3660 linebuf[linebufpos++] = ' ';
3663 linebuf[linebufpos] = 0;
3664 Con_Printf("%s\n", linebuf);
3671 for (i = 0;i < numfiles;i++)
3672 Con_Printf("%s\n", search->filenames[i]);
3673 FS_FreeSearch(search);
3674 return (int)numfiles;
3677 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3679 const char *pattern;
3680 if (Cmd_Argc() >= 3)
3682 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3685 if (Cmd_Argc() == 2)
3686 pattern = Cmd_Argv(1);
3689 if (!FS_ListDirectory(pattern, oneperline))
3690 Con_Print("No files found.\n");
3695 FS_ListDirectoryCmd("dir", true);
3700 FS_ListDirectoryCmd("ls", false);
3703 void FS_Which_f(void)
3705 const char *filename;
3708 if (Cmd_Argc() != 2)
3710 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3713 filename = Cmd_Argv(1);
3714 sp = FS_FindFile(filename, &index, true);
3716 Con_Printf("%s isn't anywhere\n", filename);
3722 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3724 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3727 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3731 const char *FS_WhichPack(const char *filename)
3734 searchpath_t *sp = FS_FindFile(filename, &index, true);
3736 return sp->pack->shortname;
3744 ====================
3745 FS_IsRegisteredQuakePack
3747 Look for a proof of purchase file file in the requested package
3749 If it is found, this file should NOT be downloaded.
3750 ====================
3752 qboolean FS_IsRegisteredQuakePack(const char *name)
3754 searchpath_t *search;
3757 // search through the path, one element at a time
3758 for (search = fs_searchpaths;search;search = search->next)
3760 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3761 // TODO do we want to support vpacks in here too?
3763 int (*strcmp_funct) (const char* str1, const char* str2);
3764 int left, right, middle;
3767 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3769 // Look for the file (binary search)
3771 right = pak->numfiles - 1;
3772 while (left <= right)
3776 middle = (left + right) / 2;
3777 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3783 // If we're too far in the list
3790 // we found the requested pack but it is not registered quake
3798 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3801 unsigned char *filedata;
3802 fs_offset_t filesize;
3803 if (filesizepointer)
3804 *filesizepointer = 0;
3805 if (!filename || !*filename)
3807 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3810 if (filesizepointer)
3811 *filesizepointer = filesize;
3812 crc = CRC_Block(filedata, filesize);
3818 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3821 unsigned char *out = NULL;
3825 #ifndef LINK_TO_ZLIB
3830 memset(&strm, 0, sizeof(strm));
3831 strm.zalloc = Z_NULL;
3832 strm.zfree = Z_NULL;
3833 strm.opaque = Z_NULL;
3836 level = Z_DEFAULT_COMPRESSION;
3838 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3840 Con_Printf("FS_Deflate: deflate init error!\n");
3844 strm.next_in = (unsigned char*)data;
3845 strm.avail_in = (unsigned int)size;
3847 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3850 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3851 qz_deflateEnd(&strm);
3855 strm.next_out = tmp;
3856 strm.avail_out = (unsigned int)size;
3858 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3860 Con_Printf("FS_Deflate: deflate failed!\n");
3861 qz_deflateEnd(&strm);
3866 if(qz_deflateEnd(&strm) != Z_OK)
3868 Con_Printf("FS_Deflate: deflateEnd failed\n");
3873 if(strm.total_out >= size)
3875 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3880 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3883 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3889 *deflated_size = (size_t)strm.total_out;
3891 memcpy(out, tmp, strm.total_out);
3897 static void AssertBufsize(sizebuf_t *buf, int length)
3899 if(buf->cursize + length > buf->maxsize)
3901 int oldsize = buf->maxsize;
3902 unsigned char *olddata;
3903 olddata = buf->data;
3904 buf->maxsize += length;
3905 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3908 memcpy(buf->data, olddata, oldsize);
3914 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3918 unsigned char *out = NULL;
3919 unsigned char tmp[2048];
3924 #ifndef LINK_TO_ZLIB
3929 memset(&outbuf, 0, sizeof(outbuf));
3930 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3931 outbuf.maxsize = sizeof(tmp);
3933 memset(&strm, 0, sizeof(strm));
3934 strm.zalloc = Z_NULL;
3935 strm.zfree = Z_NULL;
3936 strm.opaque = Z_NULL;
3938 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3940 Con_Printf("FS_Inflate: inflate init error!\n");
3941 Mem_Free(outbuf.data);
3945 strm.next_in = (unsigned char*)data;
3946 strm.avail_in = (unsigned int)size;
3950 strm.next_out = tmp;
3951 strm.avail_out = sizeof(tmp);
3952 ret = qz_inflate(&strm, Z_NO_FLUSH);
3953 // it either returns Z_OK on progress, Z_STREAM_END on end
3961 case Z_STREAM_ERROR:
3962 Con_Print("FS_Inflate: stream error!\n");
3965 Con_Print("FS_Inflate: data error!\n");
3968 Con_Print("FS_Inflate: mem error!\n");
3971 Con_Print("FS_Inflate: buf error!\n");
3974 Con_Print("FS_Inflate: unknown error!\n");
3978 if(ret != Z_OK && ret != Z_STREAM_END)
3980 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3981 Mem_Free(outbuf.data);
3982 qz_inflateEnd(&strm);
3985 have = sizeof(tmp) - strm.avail_out;
3986 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3987 SZ_Write(&outbuf, tmp, have);
3988 } while(ret != Z_STREAM_END);
3990 qz_inflateEnd(&strm);
3992 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3995 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3996 Mem_Free(outbuf.data);
4000 memcpy(out, outbuf.data, outbuf.cursize);
4001 Mem_Free(outbuf.data);
4004 *inflated_size = (size_t)outbuf.cursize;