4 Copyright (C) 2003-2006 Mathieu Olivier
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 See the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to:
20 Free Software Foundation, Inc.
21 59 Temple Place - Suite 330
22 Boston, MA 02111-1307, USA
26 // include SDL for IPHONEOS code
27 # include <TargetConditionals.h>
42 # include <sys/stat.h>
52 // Win32 requires us to add O_BINARY, but the other OSes don't have it
57 // In case the system doesn't support the O_NONBLOCK flag
62 // largefile support for Win32
65 # define lseek _lseeki64
69 // suppress deprecated warnings
70 # include <sys/stat.h>
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)
779 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
781 packhandle = open (packfile, O_RDONLY | O_BINARY);
785 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
791 PK3_GetTrueFileOffset
793 Find where the true file data offset is
796 static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
798 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
802 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
805 // Load the local file description
806 lseek (pack->handle, pfile->offset, SEEK_SET);
807 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
808 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
810 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
814 // Skip name and extra field
815 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
817 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
823 =============================================================================
825 OTHER PRIVATE FUNCTIONS
827 =============================================================================
835 Add a file to the list of files contained into a package
838 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
839 fs_offset_t offset, fs_offset_t packsize,
840 fs_offset_t realsize, int flags)
842 int (*strcmp_funct) (const char* str1, const char* str2);
843 int left, right, middle;
846 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
848 // Look for the slot we should put that file into (binary search)
850 right = pack->numfiles - 1;
851 while (left <= right)
855 middle = (left + right) / 2;
856 diff = strcmp_funct (pack->files[middle].name, name);
858 // If we found the file, there's a problem
860 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
862 // If we're too far in the list
869 // We have to move the right of the list by one slot to free the one we need
870 pfile = &pack->files[left];
871 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
874 strlcpy (pfile->name, name, sizeof (pfile->name));
875 pfile->offset = offset;
876 pfile->packsize = packsize;
877 pfile->realsize = realsize;
878 pfile->flags = flags;
888 Only used for FS_OpenRealFile.
891 void FS_CreatePath (char *path)
895 for (ofs = path+1 ; *ofs ; ofs++)
897 if (*ofs == '/' || *ofs == '\\')
899 // create the directory
915 static void FS_Path_f (void)
919 Con_Print("Current search path:\n");
920 for (s=fs_searchpaths ; s ; s=s->next)
925 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
927 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
930 Con_Printf("%s\n", s->filename);
940 /*! Takes an explicit (not game tree related) path to a pak file.
941 *Loads the header and directory, adding the files at the beginning
942 *of the list so they override previous pack files.
944 static pack_t *FS_LoadPackPAK (const char *packfile)
946 dpackheader_t header;
953 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
955 packhandle = open (packfile, O_RDONLY | O_BINARY);
959 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
961 Con_Printf ("%s is not a packfile\n", packfile);
965 if (memcmp(header.id, "PACK", 4))
967 Con_Printf ("%s is not a packfile\n", packfile);
971 header.dirofs = LittleLong (header.dirofs);
972 header.dirlen = LittleLong (header.dirlen);
974 if (header.dirlen % sizeof(dpackfile_t))
976 Con_Printf ("%s has an invalid directory size\n", packfile);
981 numpackfiles = header.dirlen / sizeof(dpackfile_t);
983 if (numpackfiles > MAX_FILES_IN_PACK)
985 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
990 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
991 lseek (packhandle, header.dirofs, SEEK_SET);
992 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
994 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1000 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1001 pack->ignorecase = false; // PAK is case sensitive
1002 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1003 pack->handle = packhandle;
1005 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1007 // parse the directory
1008 for (i = 0;i < numpackfiles;i++)
1010 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1011 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1013 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1018 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1023 ====================
1026 Create a package entry associated with a directory file
1027 ====================
1029 static pack_t *FS_LoadPackVirtual (const char *dirname)
1032 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1034 pack->ignorecase = false;
1035 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1037 pack->numfiles = -1;
1039 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1048 /*! Adds the given pack to the search path.
1049 * The pack type is autodetected by the file extension.
1051 * Returns true if the file was successfully added to the
1052 * search path or if it was already included.
1054 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1055 * plain directories.
1058 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1060 searchpath_t *search;
1062 const char *ext = FS_FileExtension(pakfile);
1065 for(search = fs_searchpaths; search; search = search->next)
1067 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1070 *already_loaded = true;
1071 return true; // already loaded
1076 *already_loaded = false;
1078 if(!strcasecmp(ext, "pk3dir"))
1079 pak = FS_LoadPackVirtual (pakfile);
1080 else if(!strcasecmp(ext, "pak"))
1081 pak = FS_LoadPackPAK (pakfile);
1082 else if(!strcasecmp(ext, "pk3"))
1083 pak = FS_LoadPackPK3 (pakfile);
1085 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1089 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1091 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1094 // find the first item whose next one is a pack or NULL
1095 searchpath_t *insertion_point = 0;
1096 if(fs_searchpaths && !fs_searchpaths->pack)
1098 insertion_point = fs_searchpaths;
1101 if(!insertion_point->next)
1103 if(insertion_point->next->pack)
1105 insertion_point = insertion_point->next;
1108 // If insertion_point is NULL, this means that either there is no
1109 // item in the list yet, or that the very first item is a pack. In
1110 // that case, we want to insert at the beginning...
1111 if(!insertion_point)
1113 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1114 search->next = fs_searchpaths;
1115 fs_searchpaths = search;
1118 // otherwise we want to append directly after insertion_point.
1120 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1121 search->next = insertion_point->next;
1122 insertion_point->next = search;
1127 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1128 search->next = fs_searchpaths;
1129 fs_searchpaths = search;
1134 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1135 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1136 // same goes for the name inside the pack structure
1137 l = strlen(pak->shortname);
1139 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1140 pak->shortname[l - 3] = 0;
1141 l = strlen(pak->filename);
1143 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1144 pak->filename[l - 3] = 0;
1150 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1161 /*! Adds the given pack to the search path and searches for it in the game path.
1162 * The pack type is autodetected by the file extension.
1164 * Returns true if the file was successfully added to the
1165 * search path or if it was already included.
1167 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1168 * plain directories.
1170 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1172 char fullpath[MAX_OSPATH];
1174 searchpath_t *search;
1177 *already_loaded = false;
1179 // then find the real name...
1180 search = FS_FindFile(pakfile, &index, true);
1181 if(!search || search->pack)
1183 Con_Printf("could not find pak \"%s\"\n", pakfile);
1187 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1189 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1197 Sets fs_gamedir, adds the directory to the head of the path,
1198 then loads and adds pak1.pak pak2.pak ...
1201 static void FS_AddGameDirectory (const char *dir)
1205 searchpath_t *search;
1207 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1209 stringlistinit(&list);
1210 listdirectory(&list, "", dir);
1211 stringlistsort(&list, false);
1213 // add any PAK package in the directory
1214 for (i = 0;i < list.numstrings;i++)
1216 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1218 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1222 // add any PK3 package in the directory
1223 for (i = 0;i < list.numstrings;i++)
1225 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1227 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1231 stringlistfreecontents(&list);
1233 // Add the directory to the search path
1234 // (unpacked files have the priority over packed files)
1235 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1236 strlcpy (search->filename, dir, sizeof (search->filename));
1237 search->next = fs_searchpaths;
1238 fs_searchpaths = search;
1247 static void FS_AddGameHierarchy (const char *dir)
1250 // Add the common game directory
1251 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1254 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1263 const char *FS_FileExtension (const char *in)
1265 const char *separator, *backslash, *colon, *dot;
1267 separator = strrchr(in, '/');
1268 backslash = strrchr(in, '\\');
1269 if (!separator || separator < backslash)
1270 separator = backslash;
1271 colon = strrchr(in, ':');
1272 if (!separator || separator < colon)
1275 dot = strrchr(in, '.');
1276 if (dot == NULL || (separator && (dot < separator)))
1288 const char *FS_FileWithoutPath (const char *in)
1290 const char *separator, *backslash, *colon;
1292 separator = strrchr(in, '/');
1293 backslash = strrchr(in, '\\');
1294 if (!separator || separator < backslash)
1295 separator = backslash;
1296 colon = strrchr(in, ':');
1297 if (!separator || separator < colon)
1299 return separator ? separator + 1 : in;
1308 static void FS_ClearSearchPath (void)
1310 // unload all packs and directory information, close all pack files
1311 // (if a qfile is still reading a pack it won't be harmed because it used
1312 // dup() to get its own handle already)
1313 while (fs_searchpaths)
1315 searchpath_t *search = fs_searchpaths;
1316 fs_searchpaths = search->next;
1317 if (search->pack && search->pack != fs_selfpack)
1319 if(!search->pack->vpack)
1322 close(search->pack->handle);
1323 // free any memory associated with it
1324 if (search->pack->files)
1325 Mem_Free(search->pack->files);
1327 Mem_Free(search->pack);
1333 static void FS_AddSelfPack(void)
1337 searchpath_t *search;
1338 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1339 search->next = fs_searchpaths;
1340 search->pack = fs_selfpack;
1341 fs_searchpaths = search;
1351 void FS_Rescan (void)
1354 qboolean fs_modified = false;
1355 qboolean reset = false;
1356 char gamedirbuf[MAX_INPUTLINE];
1361 FS_ClearSearchPath();
1363 // automatically activate gamemode for the gamedirs specified
1365 COM_ChangeGameTypeForGameDirs();
1367 // add the game-specific paths
1368 // gamedirname1 (typically id1)
1369 FS_AddGameHierarchy (gamedirname1);
1370 // update the com_modname (used for server info)
1371 if (gamedirname2 && gamedirname2[0])
1372 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1374 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1376 // add the game-specific path, if any
1377 // (only used for mission packs and the like, which should set fs_modified)
1378 if (gamedirname2 && gamedirname2[0])
1381 FS_AddGameHierarchy (gamedirname2);
1385 // Adds basedir/gamedir as an override game
1386 // LordHavoc: now supports multiple -game directories
1387 // set the com_modname (reported in server info)
1389 for (i = 0;i < fs_numgamedirs;i++)
1392 FS_AddGameHierarchy (fs_gamedirs[i]);
1393 // update the com_modname (used server info)
1394 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1396 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1398 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1400 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1402 // add back the selfpack as new first item
1405 // set the default screenshot name to either the mod name or the
1406 // gamemode screenshot name
1407 if (strcmp(com_modname, gamedirname1))
1408 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1410 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1412 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1413 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1415 // If "-condebug" is in the command line, remove the previous log file
1416 if (COM_CheckParm ("-condebug") != 0)
1417 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1419 // look for the pop.lmp file and set registered to true if it is found
1420 if (FS_FileExists("gfx/pop.lmp"))
1421 Cvar_Set ("registered", "1");
1427 if (!registered.integer)
1430 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1432 Con_Print("Playing shareware version.\n");
1435 Con_Print("Playing registered version.\n");
1437 case GAME_STEELSTORM:
1438 if (registered.integer)
1439 Con_Print("Playing registered version.\n");
1441 Con_Print("Playing shareware version.\n");
1447 // unload all wads so that future queries will return the new data
1451 static void FS_Rescan_f(void)
1461 extern qboolean vid_opened;
1462 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1467 if (fs_numgamedirs == numgamedirs)
1469 for (i = 0;i < numgamedirs;i++)
1470 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1472 if (i == numgamedirs)
1473 return true; // already using this set of gamedirs, do nothing
1476 if (numgamedirs > MAX_GAMEDIRS)
1479 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1480 return false; // too many gamedirs
1483 for (i = 0;i < numgamedirs;i++)
1485 // if string is nasty, reject it
1486 p = FS_CheckGameDir(gamedirs[i]);
1490 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1491 return false; // nasty gamedirs
1493 if(p == fs_checkgamedir_missing && failmissing)
1496 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1497 return false; // missing gamedirs
1503 fs_numgamedirs = numgamedirs;
1504 for (i = 0;i < fs_numgamedirs;i++)
1505 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1507 // reinitialize filesystem to detect the new paks
1510 if (cls.demoplayback)
1516 // unload all sounds so they will be reloaded from the new files as needed
1517 S_UnloadAllSounds_f();
1519 // close down the video subsystem, it will start up again when the config finishes...
1523 // restart the video subsystem after the config is executed
1524 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1534 static void FS_GameDir_f (void)
1538 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1542 Con_Printf("gamedirs active:");
1543 for (i = 0;i < fs_numgamedirs;i++)
1544 Con_Printf(" %s", fs_gamedirs[i]);
1549 numgamedirs = Cmd_Argc() - 1;
1550 if (numgamedirs > MAX_GAMEDIRS)
1552 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1556 for (i = 0;i < numgamedirs;i++)
1557 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1559 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1561 // actually, changing during game would work fine, but would be stupid
1562 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1566 // halt demo playback to close the file
1569 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1572 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1580 stringlistinit(&list);
1581 listdirectory(&list, gamedir, "");
1582 success = list.numstrings > 0;
1583 stringlistfreecontents(&list);
1587 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1590 n = FS_Read (f, buf, buflength - 1);
1610 const char *FS_CheckGameDir(const char *gamedir)
1616 if (FS_CheckNastyPath(gamedir, true))
1619 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1624 // get description from basedir
1625 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1633 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1637 return fs_checkgamedir_missing;
1640 static void FS_ListGameDirs(void)
1642 stringlist_t list, list2;
1647 fs_all_gamedirs_count = 0;
1649 Mem_Free(fs_all_gamedirs);
1651 stringlistinit(&list);
1652 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1653 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1654 stringlistsort(&list, false);
1656 stringlistinit(&list2);
1657 for(i = 0; i < list.numstrings; ++i)
1660 if(!strcmp(list.strings[i-1], list.strings[i]))
1662 info = FS_CheckGameDir(list.strings[i]);
1665 if(info == fs_checkgamedir_missing)
1669 stringlistappend(&list2, list.strings[i]);
1671 stringlistfreecontents(&list);
1673 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1674 for(i = 0; i < list2.numstrings; ++i)
1676 info = FS_CheckGameDir(list2.strings[i]);
1677 // all this cannot happen any more, but better be safe than sorry
1680 if(info == fs_checkgamedir_missing)
1684 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1685 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1686 ++fs_all_gamedirs_count;
1692 #pragma comment(lib, "shell32.lib")
1702 void FS_Init_SelfPack (void)
1705 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1708 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1714 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1717 const char **new_argv;
1719 int args_left = 256;
1720 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1723 new_argv[0] = "dummy";
1728 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1731 while(COM_ParseToken_Console(&p))
1735 q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1736 strlcpy(q, com_token, strlen(com_token) + 1);
1737 new_argv[com_argc + i] = q;
1740 new_argv[i+com_argc] = NULL;
1741 com_argv = new_argv;
1742 com_argc = com_argc + i;
1749 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1751 #if defined(__IPHONEOS__)
1752 if (userdirmode == USERDIRMODE_HOME)
1754 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1755 // fs_userdir stores configurations to the Documents folder of the app
1756 strlcpy(userdir, maxlength, "../Documents/");
1761 #elif defined(WIN32)
1763 #if _MSC_VER >= 1400
1766 TCHAR mydocsdir[MAX_PATH + 1];
1767 wchar_t *savedgamesdirw;
1768 char savedgamesdir[MAX_OSPATH];
1777 case USERDIRMODE_NOHOME:
1778 strlcpy(userdir, fs_basedir, userdirsize);
1780 case USERDIRMODE_MYGAMES:
1782 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1784 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1786 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1789 #if _MSC_VER >= 1400
1790 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1793 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1798 homedir = getenv("USERPROFILE");
1801 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1806 case USERDIRMODE_SAVEDGAMES:
1808 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1810 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1811 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1813 savedgamesdir[0] = 0;
1814 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1817 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1819 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1822 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1824 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1825 #if _MSC_VER >= 1400
1826 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1828 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1830 qCoTaskMemFree(savedgamesdirw);
1833 if (savedgamesdir[0])
1835 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1850 case USERDIRMODE_NOHOME:
1851 strlcpy(userdir, fs_basedir, userdirsize);
1853 case USERDIRMODE_HOME:
1854 homedir = getenv("HOME");
1857 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1861 case USERDIRMODE_SAVEDGAMES:
1862 homedir = getenv("HOME");
1866 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1868 // the XDG say some files would need to go in:
1869 // XDG_CONFIG_HOME (or ~/.config/%s/)
1870 // XDG_DATA_HOME (or ~/.local/share/%s/)
1871 // XDG_CACHE_HOME (or ~/.cache/%s/)
1872 // and also search the following global locations if defined:
1873 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1874 // XDG_DATA_DIRS (normally /usr/share/%s/)
1875 // this would be too complicated...
1886 // historical behavior...
1887 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1888 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
1891 // see if we can write to this path (note: won't create path)
1893 # if _MSC_VER >= 1400
1894 _sopen_s(&fd, va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
1896 fd = open (va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1901 // on Unix, we don't need to ACTUALLY attempt to open the file
1902 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1909 return 1; // good choice - the path exists and is writable
1913 if (userdirmode == USERDIRMODE_NOHOME)
1914 return -1; // path usually already exists, we lack permissions
1916 return 0; // probably good - failed to write but maybe we need to create path
1935 // Overrides the system supplied base directory (under GAMENAME)
1936 // 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)
1937 i = COM_CheckParm ("-basedir");
1938 if (i && i < com_argc-1)
1940 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1941 i = (int)strlen (fs_basedir);
1942 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1943 fs_basedir[i-1] = 0;
1947 // If the base directory is explicitly defined by the compilation process
1948 #ifdef DP_FS_BASEDIR
1949 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1950 #elif defined(MACOSX)
1951 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1952 if (strstr(com_argv[0], ".app/"))
1955 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1956 split = strstr(fs_basedir, ".app/");
1959 struct stat statresult;
1960 // truncate to just after the .app/
1962 // see if gamedir exists in Resources
1963 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1965 // found gamedir inside Resources, use it
1966 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1970 // no gamedir found in Resources, gamedir is probably
1971 // outside the .app, remove .app part of path
1972 while (split > fs_basedir && *split != '/')
1981 // make sure the appending of a path separator won't create an unterminated string
1982 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1983 // add a path separator to the end of the basedir if it lacks one
1984 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1985 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1987 // Add the personal game directory
1988 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1989 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1990 else if (COM_CheckParm("-nohome"))
1991 *fs_userdir = 0; // user wants roaming installation, no userdir
1995 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1996 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1997 int userdirstatus[USERDIRMODE_COUNT];
1999 // historical behavior...
2000 if (!strcmp(gamedirname1, "id1"))
2001 preferreduserdirmode = USERDIRMODE_NOHOME;
2003 // check what limitations the user wants to impose
2004 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2005 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2006 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2007 // gather the status of the possible userdirs
2008 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2010 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2011 if (userdirstatus[dirmode] == 1)
2012 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2013 else if (userdirstatus[dirmode] == 0)
2014 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2016 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2018 // some games may prefer writing to basedir, but if write fails we
2019 // have to search for a real userdir...
2020 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2021 preferreduserdirmode = highestuserdirmode;
2022 // check for an existing userdir and continue using it if possible...
2023 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2024 if (userdirstatus[dirmode] == 1)
2026 // if no existing userdir found, make a new one...
2027 if (dirmode == 0 && preferreduserdirmode > 0)
2028 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2029 if (userdirstatus[dirmode] >= 0)
2031 // and finally, we picked one...
2032 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2033 Con_DPrintf("userdir %i is the winner\n", dirmode);
2036 // if userdir equal to basedir, clear it to avoid confusion later
2037 if (!strcmp(fs_basedir, fs_userdir))
2042 p = FS_CheckGameDir(gamedirname1);
2043 if(!p || p == fs_checkgamedir_missing)
2044 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2048 p = FS_CheckGameDir(gamedirname2);
2049 if(!p || p == fs_checkgamedir_missing)
2050 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2054 // Adds basedir/gamedir as an override game
2055 // LordHavoc: now supports multiple -game directories
2056 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2060 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2063 p = FS_CheckGameDir(com_argv[i]);
2065 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2066 if(p == fs_checkgamedir_missing)
2067 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2068 // add the gamedir to the list of active gamedirs
2069 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2074 // generate the searchpath
2077 if (Thread_HasThreads())
2078 fs_mutex = Thread_CreateMutex();
2081 void FS_Init_Commands(void)
2083 Cvar_RegisterVariable (&scr_screenshot_name);
2084 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2085 Cvar_RegisterVariable (&cvar_fs_gamedir);
2087 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2088 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2089 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2090 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2091 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2092 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2100 void FS_Shutdown (void)
2102 // close all pack files and such
2103 // (hopefully there aren't any other open files, but they'll be cleaned up
2104 // by the OS anyway)
2105 FS_ClearSearchPath();
2106 Mem_FreePool (&fs_mempool);
2107 PK3_CloseLibrary ();
2110 Sys_UnloadLibrary (&shfolder_dll);
2111 Sys_UnloadLibrary (&shell32_dll);
2112 Sys_UnloadLibrary (&ole32_dll);
2116 Thread_DestroyMutex(fs_mutex);
2119 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2125 // Parse the mode string
2134 opt = O_CREAT | O_TRUNC;
2138 opt = O_CREAT | O_APPEND;
2141 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2144 for (ind = 1; mode[ind] != '\0'; ind++)
2155 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2156 filepath, mode, mode[ind]);
2163 #if _MSC_VER >= 1400
2164 _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
2166 handle = open (filepath, mod | opt, 0666);
2172 ====================
2175 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2176 ====================
2178 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2182 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2184 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2185 if (file->handle < 0)
2191 file->filename = Mem_strdup(fs_mempool, filepath);
2193 file->real_length = lseek (file->handle, 0, SEEK_END);
2195 // For files opened in append mode, we start at the end of the file
2197 file->position = file->real_length;
2199 lseek (file->handle, 0, SEEK_SET);
2209 Open a packed file using its package file descriptor
2212 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2218 pfile = &pack->files[pack_ind];
2220 // If we don't have the true offset, get it now
2221 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2222 if (!PK3_GetTrueFileOffset (pfile, pack))
2225 #ifndef LINK_TO_ZLIB
2226 // No Zlib DLL = no compressed files
2227 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2229 Con_Printf("WARNING: can't open the compressed file %s\n"
2230 "You need the Zlib DLL to use compressed files\n",
2236 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2237 // the dup() call to avoid having to close the dup_handle on error here
2238 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2240 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2241 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2245 dup_handle = dup (pack->handle);
2248 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2252 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2253 memset (file, 0, sizeof (*file));
2254 file->handle = dup_handle;
2255 file->flags = QFILE_FLAG_PACKED;
2256 file->real_length = pfile->realsize;
2257 file->offset = pfile->offset;
2261 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2265 file->flags |= QFILE_FLAG_DEFLATED;
2267 // We need some more variables
2268 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2270 ztk->comp_length = pfile->packsize;
2272 // Initialize zlib stream
2273 ztk->zstream.next_in = ztk->input;
2274 ztk->zstream.avail_in = 0;
2276 /* From Zlib's "unzip.c":
2278 * windowBits is passed < 0 to tell that there is no zlib header.
2279 * Note that in this case inflate *requires* an extra "dummy" byte
2280 * after the compressed stream in order to complete decompression and
2281 * return Z_STREAM_END.
2282 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2283 * size of both compressed and uncompressed data
2285 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2287 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2293 ztk->zstream.next_out = file->buff;
2294 ztk->zstream.avail_out = sizeof (file->buff);
2303 ====================
2306 Return true if the path should be rejected due to one of the following:
2307 1: path elements that are non-portable
2308 2: path elements that would allow access to files outside the game directory,
2309 or are just not a good idea for a mod to be using.
2310 ====================
2312 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2314 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2318 // Windows: don't allow \ in filenames (windows-only), period.
2319 // (on Windows \ is a directory separator, but / is also supported)
2320 if (strstr(path, "\\"))
2321 return 1; // non-portable
2323 // Mac: don't allow Mac-only filenames - : is a directory separator
2324 // instead of /, but we rely on / working already, so there's no reason to
2325 // support a Mac-only path
2326 // Amiga and Windows: : tries to go to root of drive
2327 if (strstr(path, ":"))
2328 return 1; // non-portable attempt to go to root of drive
2330 // Amiga: // is parent directory
2331 if (strstr(path, "//"))
2332 return 1; // non-portable attempt to go to parent directory
2334 // all: don't allow going to parent directory (../ or /../)
2335 if (strstr(path, ".."))
2336 return 2; // attempt to go outside the game directory
2338 // Windows and UNIXes: don't allow absolute paths
2340 return 2; // attempt to go outside the game directory
2342 // 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
2343 if (strchr(path, '.'))
2347 // gamedir is entirely path elements, so simply forbid . entirely
2350 if (strchr(path, '.') < strrchr(path, '/'))
2351 return 2; // possible attempt to go outside the game directory
2354 // all: forbid trailing slash on gamedir
2355 if (isgamedir && path[strlen(path)-1] == '/')
2358 // all: forbid leading dot on any filename for any reason
2359 if (strstr(path, "/."))
2360 return 2; // attempt to go outside the game directory
2362 // after all these checks we're pretty sure it's a / separated filename
2363 // and won't do much if any harm
2369 ====================
2372 Look for a file in the packages and in the filesystem
2374 Return the searchpath where the file was found (or NULL)
2375 and the file index in the package if relevant
2376 ====================
2378 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2380 searchpath_t *search;
2383 // search through the path, one element at a time
2384 for (search = fs_searchpaths;search;search = search->next)
2386 // is the element a pak file?
2387 if (search->pack && !search->pack->vpack)
2389 int (*strcmp_funct) (const char* str1, const char* str2);
2390 int left, right, middle;
2393 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2395 // Look for the file (binary search)
2397 right = pak->numfiles - 1;
2398 while (left <= right)
2402 middle = (left + right) / 2;
2403 diff = strcmp_funct (pak->files[middle].name, name);
2408 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2410 // yes, but the first one is empty so we treat it as not being there
2411 if (!quiet && developer_extra.integer)
2412 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2419 if (!quiet && developer_extra.integer)
2420 Con_DPrintf("FS_FindFile: %s in %s\n",
2421 pak->files[middle].name, pak->filename);
2428 // If we're too far in the list
2437 char netpath[MAX_OSPATH];
2438 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2439 if (FS_SysFileExists (netpath))
2441 if (!quiet && developer_extra.integer)
2442 Con_DPrintf("FS_FindFile: %s\n", netpath);
2451 if (!quiet && developer_extra.integer)
2452 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2464 Look for a file in the search paths and open it in read-only mode
2467 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2469 searchpath_t *search;
2472 search = FS_FindFile (filename, &pack_ind, quiet);
2478 // Found in the filesystem?
2481 // this works with vpacks, so we are fine
2482 char path [MAX_OSPATH];
2483 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2484 return FS_SysOpen (path, "rb", nonblocking);
2487 // So, we found it in a package...
2489 // Is it a PK3 symlink?
2490 // TODO also handle directory symlinks by parsing the whole structure...
2491 // but heck, file symlinks are good enough for now
2492 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2494 if(symlinkLevels <= 0)
2496 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2501 char linkbuf[MAX_QPATH];
2503 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2504 const char *mergeslash;
2509 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2515 // Now combine the paths...
2516 mergeslash = strrchr(filename, '/');
2517 mergestart = linkbuf;
2519 mergeslash = filename;
2520 while(!strncmp(mergestart, "../", 3))
2523 while(mergeslash > filename)
2526 if(*mergeslash == '/')
2530 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2531 if(mergeslash == filename)
2533 // Either mergeslash == filename, then we just replace the name (done below)
2537 // Or, we append the name after mergeslash;
2538 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2539 int spaceNeeded = mergeslash - filename + 1;
2540 int spaceRemoved = mergestart - linkbuf;
2541 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2543 Con_DPrintf("symlink: too long path rejected\n");
2546 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2547 memcpy(linkbuf, filename, spaceNeeded);
2548 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2549 mergestart = linkbuf;
2551 if (!quiet && developer_loading.integer)
2552 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2553 if(FS_CheckNastyPath (mergestart, false))
2555 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2558 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2562 return FS_OpenPackedFile (search->pack, pack_ind);
2567 =============================================================================
2569 MAIN PUBLIC FUNCTIONS
2571 =============================================================================
2575 ====================
2578 Open a file in the userpath. The syntax is the same as fopen
2579 Used for savegame scanning in menu, and all file writing.
2580 ====================
2582 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2584 char real_path [MAX_OSPATH];
2586 if (FS_CheckNastyPath(filepath, false))
2588 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2592 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2594 // If the file is opened in "write", "append", or "read/write" mode,
2595 // create directories up to the file.
2596 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2597 FS_CreatePath (real_path);
2598 return FS_SysOpen (real_path, mode, false);
2603 ====================
2606 Open a file. The syntax is the same as fopen
2607 ====================
2609 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2611 qfile_t *result = NULL;
2612 if (FS_CheckNastyPath(filepath, false))
2614 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2618 if (fs_mutex) Thread_LockMutex(fs_mutex);
2619 result = FS_OpenReadFile (filepath, quiet, false, 16);
2620 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2626 ====================
2629 Open a file. The syntax is the same as fopen
2630 ====================
2632 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2635 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2636 memset (file, 0, sizeof (*file));
2637 file->flags = QFILE_FLAG_DATA;
2639 file->real_length = size;
2645 ====================
2649 ====================
2651 int FS_Close (qfile_t* file)
2653 if(file->flags & QFILE_FLAG_DATA)
2659 if (close (file->handle))
2664 if (file->flags & QFILE_FLAG_REMOVE)
2665 remove(file->filename);
2667 Mem_Free((void *) file->filename);
2672 qz_inflateEnd (&file->ztk->zstream);
2673 Mem_Free (file->ztk);
2680 void FS_RemoveOnClose(qfile_t* file)
2682 file->flags |= QFILE_FLAG_REMOVE;
2686 ====================
2689 Write "datasize" bytes into a file
2690 ====================
2692 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2696 // If necessary, seek to the exact file position we're supposed to be
2697 if (file->buff_ind != file->buff_len)
2698 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2700 // Purge cached data
2703 // Write the buffer and update the position
2704 result = write (file->handle, data, (fs_offset_t)datasize);
2705 file->position = lseek (file->handle, 0, SEEK_CUR);
2706 if (file->real_length < file->position)
2707 file->real_length = file->position;
2717 ====================
2720 Read up to "buffersize" bytes from a file
2721 ====================
2723 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2725 fs_offset_t count, done;
2727 if (buffersize == 0)
2730 // Get rid of the ungetc character
2731 if (file->ungetc != EOF)
2733 ((char*)buffer)[0] = file->ungetc;
2741 if(file->flags & QFILE_FLAG_DATA)
2743 size_t left = file->real_length - file->position;
2744 if(buffersize > left)
2746 memcpy(buffer, file->data + file->position, buffersize);
2747 file->position += buffersize;
2751 // First, we copy as many bytes as we can from "buff"
2752 if (file->buff_ind < file->buff_len)
2754 count = file->buff_len - file->buff_ind;
2755 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2757 memcpy (buffer, &file->buff[file->buff_ind], count);
2758 file->buff_ind += count;
2760 buffersize -= count;
2761 if (buffersize == 0)
2765 // NOTE: at this point, the read buffer is always empty
2767 // If the file isn't compressed
2768 if (! (file->flags & QFILE_FLAG_DEFLATED))
2772 // We must take care to not read after the end of the file
2773 count = file->real_length - file->position;
2775 // If we have a lot of data to get, put them directly into "buffer"
2776 if (buffersize > sizeof (file->buff) / 2)
2778 if (count > (fs_offset_t)buffersize)
2779 count = (fs_offset_t)buffersize;
2780 lseek (file->handle, file->offset + file->position, SEEK_SET);
2781 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2785 file->position += nb;
2787 // Purge cached data
2793 if (count > (fs_offset_t)sizeof (file->buff))
2794 count = (fs_offset_t)sizeof (file->buff);
2795 lseek (file->handle, file->offset + file->position, SEEK_SET);
2796 nb = read (file->handle, file->buff, count);
2799 file->buff_len = nb;
2800 file->position += nb;
2802 // Copy the requested data in "buffer" (as much as we can)
2803 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2804 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2805 file->buff_ind = count;
2813 // If the file is compressed, it's more complicated...
2814 // We cycle through a few operations until we have read enough data
2815 while (buffersize > 0)
2817 ztoolkit_t *ztk = file->ztk;
2820 // NOTE: at this point, the read buffer is always empty
2822 // If "input" is also empty, we need to refill it
2823 if (ztk->in_ind == ztk->in_len)
2825 // If we are at the end of the file
2826 if (file->position == file->real_length)
2829 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2830 if (count > (fs_offset_t)sizeof (ztk->input))
2831 count = (fs_offset_t)sizeof (ztk->input);
2832 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2833 if (read (file->handle, ztk->input, count) != count)
2835 Con_Printf ("FS_Read: unexpected end of file\n");
2840 ztk->in_len = count;
2841 ztk->in_position += count;
2844 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2845 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2847 // Now that we are sure we have compressed data available, we need to determine
2848 // if it's better to inflate it in "file->buff" or directly in "buffer"
2850 // Inflate the data in "file->buff"
2851 if (buffersize < sizeof (file->buff) / 2)
2853 ztk->zstream.next_out = file->buff;
2854 ztk->zstream.avail_out = sizeof (file->buff);
2855 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2856 if (error != Z_OK && error != Z_STREAM_END)
2858 Con_Printf ("FS_Read: Can't inflate file\n");
2861 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2863 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2864 file->position += file->buff_len;
2866 // Copy the requested data in "buffer" (as much as we can)
2867 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2868 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2869 file->buff_ind = count;
2872 // Else, we inflate directly in "buffer"
2875 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2876 ztk->zstream.avail_out = (unsigned int)buffersize;
2877 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2878 if (error != Z_OK && error != Z_STREAM_END)
2880 Con_Printf ("FS_Read: Can't inflate file\n");
2883 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2885 // How much data did it inflate?
2886 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2887 file->position += count;
2889 // Purge cached data
2894 buffersize -= count;
2902 ====================
2905 Print a string into a file
2906 ====================
2908 int FS_Print (qfile_t* file, const char *msg)
2910 return (int)FS_Write (file, msg, strlen (msg));
2914 ====================
2917 Print a string into a file
2918 ====================
2920 int FS_Printf(qfile_t* file, const char* format, ...)
2925 va_start (args, format);
2926 result = FS_VPrintf (file, format, args);
2934 ====================
2937 Print a string into a file
2938 ====================
2940 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2943 fs_offset_t buff_size = MAX_INPUTLINE;
2948 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2949 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2950 if (len >= 0 && len < buff_size)
2952 Mem_Free (tempbuff);
2956 len = write (file->handle, tempbuff, len);
2957 Mem_Free (tempbuff);
2964 ====================
2967 Get the next character of a file
2968 ====================
2970 int FS_Getc (qfile_t* file)
2974 if (FS_Read (file, &c, 1) != 1)
2982 ====================
2985 Put a character back into the read buffer (only supports one character!)
2986 ====================
2988 int FS_UnGetc (qfile_t* file, unsigned char c)
2990 // If there's already a character waiting to be read
2991 if (file->ungetc != EOF)
3000 ====================
3003 Move the position index in a file
3004 ====================
3006 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3009 unsigned char* buffer;
3010 fs_offset_t buffersize;
3012 // Compute the file offset
3016 offset += file->position - file->buff_len + file->buff_ind;
3023 offset += file->real_length;
3029 if (offset < 0 || offset > file->real_length)
3032 if(file->flags & QFILE_FLAG_DATA)
3034 file->position = offset;
3038 // If we have the data in our read buffer, we don't need to actually seek
3039 if (file->position - file->buff_len <= offset && offset <= file->position)
3041 file->buff_ind = offset + file->buff_len - file->position;
3045 // Purge cached data
3048 // Unpacked or uncompressed files can seek directly
3049 if (! (file->flags & QFILE_FLAG_DEFLATED))
3051 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3053 file->position = offset;
3057 // Seeking in compressed files is more a hack than anything else,
3058 // but we need to support it, so here we go.
3061 // If we have to go back in the file, we need to restart from the beginning
3062 if (offset <= file->position)
3066 ztk->in_position = 0;
3068 lseek (file->handle, file->offset, SEEK_SET);
3070 // Reset the Zlib stream
3071 ztk->zstream.next_in = ztk->input;
3072 ztk->zstream.avail_in = 0;
3073 qz_inflateReset (&ztk->zstream);
3076 // We need a big buffer to force inflating into it directly
3077 buffersize = 2 * sizeof (file->buff);
3078 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3080 // Skip all data until we reach the requested offset
3081 while (offset > file->position)
3083 fs_offset_t diff = offset - file->position;
3084 fs_offset_t count, len;
3086 count = (diff > buffersize) ? buffersize : diff;
3087 len = FS_Read (file, buffer, count);
3101 ====================
3104 Give the current position in a file
3105 ====================
3107 fs_offset_t FS_Tell (qfile_t* file)
3109 return file->position - file->buff_len + file->buff_ind;
3114 ====================
3117 Give the total size of a file
3118 ====================
3120 fs_offset_t FS_FileSize (qfile_t* file)
3122 return file->real_length;
3127 ====================
3130 Erases any buffered input or output data
3131 ====================
3133 void FS_Purge (qfile_t* file)
3145 Filename are relative to the quake directory.
3146 Always appends a 0 byte.
3149 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3152 unsigned char *buf = NULL;
3153 fs_offset_t filesize = 0;
3155 file = FS_OpenVirtualFile(path, quiet);
3158 filesize = file->real_length;
3161 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3166 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3167 buf[filesize] = '\0';
3168 FS_Read (file, buf, filesize);
3170 if (developer_loadfile.integer)
3171 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3174 if (filesizepointer)
3175 *filesizepointer = filesize;
3184 The filename will be prefixed by the current game directory
3187 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3191 fs_offset_t lentotal;
3193 file = FS_OpenRealFile(filename, "wb", false);
3196 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3201 for(i = 0; i < count; ++i)
3203 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3204 for(i = 0; i < count; ++i)
3205 FS_Write (file, data[i], len[i]);
3210 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3212 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3217 =============================================================================
3219 OTHERS PUBLIC FUNCTIONS
3221 =============================================================================
3229 void FS_StripExtension (const char *in, char *out, size_t size_out)
3237 while ((currentchar = *in) && size_out > 1)
3239 if (currentchar == '.')
3241 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3243 *out++ = currentchar;
3259 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3263 // if path doesn't have a .EXT, append extension
3264 // (extension should include the .)
3265 src = path + strlen(path) - 1;
3267 while (*src != '/' && src != path)
3270 return; // it has an extension
3274 strlcat (path, extension, size_path);
3282 Look for a file in the packages and in the filesystem
3285 int FS_FileType (const char *filename)
3287 searchpath_t *search;
3288 char fullpath[MAX_OSPATH];
3290 search = FS_FindFile (filename, NULL, true);
3292 return FS_FILETYPE_NONE;
3294 if(search->pack && !search->pack->vpack)
3295 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3297 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3298 return FS_SysFileType(fullpath);
3306 Look for a file in the packages and in the filesystem
3309 qboolean FS_FileExists (const char *filename)
3311 return (FS_FindFile (filename, NULL, true) != NULL);
3319 Look for a file in the filesystem only
3322 int FS_SysFileType (const char *path)
3325 // Sajt - some older sdks are missing this define
3326 # ifndef INVALID_FILE_ATTRIBUTES
3327 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3330 DWORD result = GetFileAttributes(path);
3332 if(result == INVALID_FILE_ATTRIBUTES)
3333 return FS_FILETYPE_NONE;
3335 if(result & FILE_ATTRIBUTE_DIRECTORY)
3336 return FS_FILETYPE_DIRECTORY;
3338 return FS_FILETYPE_FILE;
3342 if (stat (path,&buf) == -1)
3343 return FS_FILETYPE_NONE;
3346 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3348 if(S_ISDIR(buf.st_mode))
3349 return FS_FILETYPE_DIRECTORY;
3351 return FS_FILETYPE_FILE;
3355 qboolean FS_SysFileExists (const char *path)
3357 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3360 void FS_mkdir (const char *path)
3373 Allocate and fill a search structure with information on matching filenames.
3376 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3379 searchpath_t *searchpath;
3381 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3382 stringlist_t resultlist;
3383 stringlist_t dirlist;
3384 const char *slash, *backslash, *colon, *separator;
3386 char temp[MAX_OSPATH];
3388 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3393 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3397 stringlistinit(&resultlist);
3398 stringlistinit(&dirlist);
3400 slash = strrchr(pattern, '/');
3401 backslash = strrchr(pattern, '\\');
3402 colon = strrchr(pattern, ':');
3403 separator = max(slash, backslash);
3404 separator = max(separator, colon);
3405 basepathlength = separator ? (separator + 1 - pattern) : 0;
3406 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3408 memcpy(basepath, pattern, basepathlength);
3409 basepath[basepathlength] = 0;
3411 // search through the path, one element at a time
3412 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3414 // is the element a pak file?
3415 if (searchpath->pack && !searchpath->pack->vpack)
3417 // look through all the pak file elements
3418 pak = searchpath->pack;
3419 for (i = 0;i < pak->numfiles;i++)
3421 strlcpy(temp, pak->files[i].name, sizeof(temp));
3424 if (matchpattern(temp, (char *)pattern, true))
3426 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3427 if (!strcmp(resultlist.strings[resultlistindex], temp))
3429 if (resultlistindex == resultlist.numstrings)
3431 stringlistappend(&resultlist, temp);
3432 if (!quiet && developer_loading.integer)
3433 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3436 // strip off one path element at a time until empty
3437 // this way directories are added to the listing if they match the pattern
3438 slash = strrchr(temp, '/');
3439 backslash = strrchr(temp, '\\');
3440 colon = strrchr(temp, ':');
3442 if (separator < slash)
3444 if (separator < backslash)
3445 separator = backslash;
3446 if (separator < colon)
3448 *((char *)separator) = 0;
3454 stringlist_t matchedSet, foundSet;
3455 const char *start = pattern;
3457 stringlistinit(&matchedSet);
3458 stringlistinit(&foundSet);
3459 // add a first entry to the set
3460 stringlistappend(&matchedSet, "");
3461 // iterate through pattern's path
3464 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3465 char subpath[MAX_OSPATH];
3466 char subpattern[MAX_OSPATH];
3468 // find the next wildcard
3469 wildcard = strchr(start, '?');
3470 asterisk = strchr(start, '*');
3471 if (asterisk && (!wildcard || asterisk < wildcard))
3473 wildcard = asterisk;
3478 nextseparator = strchr( wildcard, '/' );
3482 nextseparator = NULL;
3485 if( !nextseparator ) {
3486 nextseparator = start + strlen( start );
3489 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3490 // copy everything up except nextseperator
3491 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3492 // find the last '/' before the wildcard
3493 prevseparator = strrchr( subpattern, '/' );
3495 prevseparator = subpattern;
3498 // copy everything from start to the previous including the '/' (before the wildcard)
3499 // everything up to start is already included in the path of matchedSet's entries
3500 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3502 // for each entry in matchedSet try to open the subdirectories specified in subpath
3503 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3504 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3505 strlcat( temp, subpath, sizeof(temp) );
3506 listdirectory( &foundSet, searchpath->filename, temp );
3508 if( dirlistindex == 0 ) {
3511 // reset the current result set
3512 stringlistfreecontents( &matchedSet );
3513 // match against the pattern
3514 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3515 const char *direntry = foundSet.strings[ dirlistindex ];
3516 if (matchpattern(direntry, subpattern, true)) {
3517 stringlistappend( &matchedSet, direntry );
3520 stringlistfreecontents( &foundSet );
3522 start = nextseparator;
3525 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3527 const char *temp = matchedSet.strings[dirlistindex];
3528 if (matchpattern(temp, (char *)pattern, true))
3530 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3531 if (!strcmp(resultlist.strings[resultlistindex], temp))
3533 if (resultlistindex == resultlist.numstrings)
3535 stringlistappend(&resultlist, temp);
3536 if (!quiet && developer_loading.integer)
3537 Con_Printf("SearchDirFile: %s\n", temp);
3541 stringlistfreecontents( &matchedSet );
3545 if (resultlist.numstrings)
3547 stringlistsort(&resultlist, true);
3548 numfiles = resultlist.numstrings;
3550 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3551 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3552 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3553 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3554 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3555 search->numfilenames = (int)numfiles;
3558 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3561 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3562 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3563 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3565 numchars += (int)textlen;
3568 stringlistfreecontents(&resultlist);
3574 void FS_FreeSearch(fssearch_t *search)
3579 extern int con_linewidth;
3580 static int FS_ListDirectory(const char *pattern, int oneperline)
3589 char linebuf[MAX_INPUTLINE];
3591 search = FS_Search(pattern, true, true);
3594 numfiles = search->numfilenames;
3597 // FIXME: the names could be added to one column list and then
3598 // gradually shifted into the next column if they fit, and then the
3599 // next to make a compact variable width listing but it's a lot more
3601 // find width for columns
3603 for (i = 0;i < numfiles;i++)
3605 l = (int)strlen(search->filenames[i]);
3606 if (columnwidth < l)
3609 // count the spacing character
3611 // calculate number of columns
3612 numcolumns = con_linewidth / columnwidth;
3613 // don't bother with the column printing if it's only one column
3614 if (numcolumns >= 2)
3616 numlines = (numfiles + numcolumns - 1) / numcolumns;
3617 for (i = 0;i < numlines;i++)
3620 for (k = 0;k < numcolumns;k++)
3622 l = i * numcolumns + k;
3625 name = search->filenames[l];
3626 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3627 linebuf[linebufpos++] = name[j];
3628 // space out name unless it's the last on the line
3629 if (k + 1 < numcolumns && l + 1 < numfiles)
3630 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3631 linebuf[linebufpos++] = ' ';
3634 linebuf[linebufpos] = 0;
3635 Con_Printf("%s\n", linebuf);
3642 for (i = 0;i < numfiles;i++)
3643 Con_Printf("%s\n", search->filenames[i]);
3644 FS_FreeSearch(search);
3645 return (int)numfiles;
3648 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3650 const char *pattern;
3651 if (Cmd_Argc() >= 3)
3653 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3656 if (Cmd_Argc() == 2)
3657 pattern = Cmd_Argv(1);
3660 if (!FS_ListDirectory(pattern, oneperline))
3661 Con_Print("No files found.\n");
3666 FS_ListDirectoryCmd("dir", true);
3671 FS_ListDirectoryCmd("ls", false);
3674 void FS_Which_f(void)
3676 const char *filename;
3679 if (Cmd_Argc() != 2)
3681 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3684 filename = Cmd_Argv(1);
3685 sp = FS_FindFile(filename, &index, true);
3687 Con_Printf("%s isn't anywhere\n", filename);
3693 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3695 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3698 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3702 const char *FS_WhichPack(const char *filename)
3705 searchpath_t *sp = FS_FindFile(filename, &index, true);
3707 return sp->pack->shortname;
3713 ====================
3714 FS_IsRegisteredQuakePack
3716 Look for a proof of purchase file file in the requested package
3718 If it is found, this file should NOT be downloaded.
3719 ====================
3721 qboolean FS_IsRegisteredQuakePack(const char *name)
3723 searchpath_t *search;
3726 // search through the path, one element at a time
3727 for (search = fs_searchpaths;search;search = search->next)
3729 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3730 // TODO do we want to support vpacks in here too?
3732 int (*strcmp_funct) (const char* str1, const char* str2);
3733 int left, right, middle;
3736 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3738 // Look for the file (binary search)
3740 right = pak->numfiles - 1;
3741 while (left <= right)
3745 middle = (left + right) / 2;
3746 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3752 // If we're too far in the list
3759 // we found the requested pack but it is not registered quake
3767 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3770 unsigned char *filedata;
3771 fs_offset_t filesize;
3772 if (filesizepointer)
3773 *filesizepointer = 0;
3774 if (!filename || !*filename)
3776 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3779 if (filesizepointer)
3780 *filesizepointer = filesize;
3781 crc = CRC_Block(filedata, filesize);
3787 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3790 unsigned char *out = NULL;
3794 #ifndef LINK_TO_ZLIB
3799 memset(&strm, 0, sizeof(strm));
3800 strm.zalloc = Z_NULL;
3801 strm.zfree = Z_NULL;
3802 strm.opaque = Z_NULL;
3805 level = Z_DEFAULT_COMPRESSION;
3807 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3809 Con_Printf("FS_Deflate: deflate init error!\n");
3813 strm.next_in = (unsigned char*)data;
3814 strm.avail_in = size;
3816 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3819 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3820 qz_deflateEnd(&strm);
3824 strm.next_out = tmp;
3825 strm.avail_out = size;
3827 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3829 Con_Printf("FS_Deflate: deflate failed!\n");
3830 qz_deflateEnd(&strm);
3835 if(qz_deflateEnd(&strm) != Z_OK)
3837 Con_Printf("FS_Deflate: deflateEnd failed\n");
3842 if(strm.total_out >= size)
3844 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3849 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3852 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3858 *deflated_size = (size_t)strm.total_out;
3860 memcpy(out, tmp, strm.total_out);
3866 static void AssertBufsize(sizebuf_t *buf, int length)
3868 if(buf->cursize + length > buf->maxsize)
3870 int oldsize = buf->maxsize;
3871 unsigned char *olddata;
3872 olddata = buf->data;
3873 buf->maxsize += length;
3874 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3877 memcpy(buf->data, olddata, oldsize);
3883 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3887 unsigned char *out = NULL;
3888 unsigned char tmp[2048];
3893 #ifndef LINK_TO_ZLIB
3898 memset(&outbuf, 0, sizeof(outbuf));
3899 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3900 outbuf.maxsize = sizeof(tmp);
3902 memset(&strm, 0, sizeof(strm));
3903 strm.zalloc = Z_NULL;
3904 strm.zfree = Z_NULL;
3905 strm.opaque = Z_NULL;
3907 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3909 Con_Printf("FS_Inflate: inflate init error!\n");
3910 Mem_Free(outbuf.data);
3914 strm.next_in = (unsigned char*)data;
3915 strm.avail_in = size;
3919 strm.next_out = tmp;
3920 strm.avail_out = sizeof(tmp);
3921 ret = qz_inflate(&strm, Z_NO_FLUSH);
3922 // it either returns Z_OK on progress, Z_STREAM_END on end
3930 case Z_STREAM_ERROR:
3931 Con_Print("FS_Inflate: stream error!\n");
3934 Con_Print("FS_Inflate: data error!\n");
3937 Con_Print("FS_Inflate: mem error!\n");
3940 Con_Print("FS_Inflate: buf error!\n");
3943 Con_Print("FS_Inflate: unknown error!\n");
3947 if(ret != Z_OK && ret != Z_STREAM_END)
3949 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3950 Mem_Free(outbuf.data);
3951 qz_inflateEnd(&strm);
3954 have = sizeof(tmp) - strm.avail_out;
3955 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3956 SZ_Write(&outbuf, tmp, have);
3957 } while(ret != Z_STREAM_END);
3959 qz_inflateEnd(&strm);
3961 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3964 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3965 Mem_Free(outbuf.data);
3969 memcpy(out, outbuf.data, outbuf.cursize);
3970 Mem_Free(outbuf.data);
3973 *inflated_size = (size_t)outbuf.cursize;