4 Copyright (C) 2003-2006 Mathieu Olivier
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 See the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to:
20 Free Software Foundation, Inc.
21 59 Temple Place - Suite 330
22 Boston, MA 02111-1307, USA
26 // include SDL for IPHONEOS code
27 # include <TargetConditionals.h>
42 # include <sys/stat.h>
51 // Win32 requires us to add O_BINARY, but the other OSes don't have it
56 // In case the system doesn't support the O_NONBLOCK flag
61 // largefile support for Win32
64 # define lseek _lseeki64
68 // suppress deprecated warnings
69 # include <sys/stat.h>
74 # define unlink _unlink
78 /** \page fs File System
80 All of Quake's data access is through a hierchal file system, but the contents
81 of the file system can be transparently merged from several sources.
83 The "base directory" is the path to the directory holding the quake.exe and
84 all game directories. The sys_* files pass this to host_init in
85 quakeparms_t->basedir. This can be overridden with the "-basedir" command
86 line parm to allow code debugging in a different directory. The base
87 directory is only used during filesystem initialization.
89 The "game directory" is the first tree on the search path and directory that
90 all generated files (savegames, screenshots, demos, config files) will be
91 saved to. This can be overridden with the "-game" command line parameter.
92 The game directory can never be changed while quake is executing. This is a
93 precaution against having a malicious server instruct clients to write files
94 over areas they shouldn't.
100 =============================================================================
104 =============================================================================
107 // Magic numbers of a ZIP file (big-endian format)
108 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
109 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
110 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
112 // Other constants for ZIP files
113 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
114 #define ZIP_END_CDIR_SIZE 22
115 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
116 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
121 #define qz_inflate inflate
122 #define qz_inflateEnd inflateEnd
123 #define qz_inflateInit2_ inflateInit2_
124 #define qz_inflateReset inflateReset
125 #define qz_deflateInit2_ deflateInit2_
126 #define qz_deflateEnd deflateEnd
127 #define qz_deflate deflate
128 #define Z_MEMLEVEL_DEFAULT 8
131 // Zlib constants (from zlib.h)
132 #define Z_SYNC_FLUSH 2
135 #define Z_STREAM_END 1
136 #define Z_STREAM_ERROR (-2)
137 #define Z_DATA_ERROR (-3)
138 #define Z_MEM_ERROR (-4)
139 #define Z_BUF_ERROR (-5)
140 #define ZLIB_VERSION "1.2.3"
144 #define Z_MEMLEVEL_DEFAULT 8
147 #define Z_DEFAULT_COMPRESSION (-1)
149 #define Z_SYNC_FLUSH 2
150 #define Z_FULL_FLUSH 3
153 // Uncomment the following line if the zlib DLL you have still uses
154 // the 1.1.x series calling convention on Win32 (WINAPI)
155 //#define ZLIB_USES_WINAPI
159 =============================================================================
163 =============================================================================
166 /*! Zlib stream (from zlib.h)
167 * \warning: some pointers we don't use directly have
168 * been cast to "void*" for a matter of simplicity
172 unsigned char *next_in; ///< next input byte
173 unsigned int avail_in; ///< number of bytes available at next_in
174 unsigned long total_in; ///< total nb of input bytes read so far
176 unsigned char *next_out; ///< next output byte should be put there
177 unsigned int avail_out; ///< remaining free space at next_out
178 unsigned long total_out; ///< total nb of bytes output so far
180 char *msg; ///< last error message, NULL if no error
181 void *state; ///< not visible by applications
183 void *zalloc; ///< used to allocate the internal state
184 void *zfree; ///< used to free the internal state
185 void *opaque; ///< private data object passed to zalloc and zfree
187 int data_type; ///< best guess about the data type: ascii or binary
188 unsigned long adler; ///< adler32 value of the uncompressed data
189 unsigned long reserved; ///< reserved for future use
194 /// inside a package (PAK or PK3)
195 #define QFILE_FLAG_PACKED (1 << 0)
196 /// file is compressed using the deflate algorithm (PK3 only)
197 #define QFILE_FLAG_DEFLATED (1 << 1)
198 /// file is actually already loaded data
199 #define QFILE_FLAG_DATA (1 << 2)
200 /// real file will be removed on close
201 #define QFILE_FLAG_REMOVE (1 << 3)
203 #define FILE_BUFF_SIZE 2048
207 size_t comp_length; ///< length of the compressed file
208 size_t in_ind, in_len; ///< input buffer current index and length
209 size_t in_position; ///< position in the compressed file
210 unsigned char input [FILE_BUFF_SIZE];
216 int handle; ///< file descriptor
217 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
218 fs_offset_t position; ///< current position in the file
219 fs_offset_t offset; ///< offset into the package (0 if external file)
220 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
223 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
224 unsigned char buff [FILE_BUFF_SIZE];
226 ztoolkit_t* ztk; ///< For zipped files.
228 const unsigned char *data; ///< For data files.
230 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
234 // ------ PK3 files on disk ------ //
236 // You can get the complete ZIP format description from PKWARE website
238 typedef struct pk3_endOfCentralDir_s
240 unsigned int signature;
241 unsigned short disknum;
242 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
243 unsigned short localentries; ///< number of entries in the central directory on this disk
244 unsigned short nbentries; ///< total number of entries in the central directory on this disk
245 unsigned int cdir_size; ///< size of the central directory
246 unsigned int cdir_offset; ///< with respect to the starting disk number
247 unsigned short comment_size;
248 fs_offset_t prepended_garbage;
249 } pk3_endOfCentralDir_t;
252 // ------ PAK files on disk ------ //
253 typedef struct dpackfile_s
256 int filepos, filelen;
259 typedef struct dpackheader_s
267 /*! \name Packages in memory
270 /// the offset in packfile_t is the true contents offset
271 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
272 /// file compressed using the deflate algorithm
273 #define PACKFILE_FLAG_DEFLATED (1 << 1)
274 /// file is a symbolic link
275 #define PACKFILE_FLAG_SYMLINK (1 << 2)
277 typedef struct packfile_s
279 char name [MAX_QPATH];
282 fs_offset_t packsize; ///< size in the package
283 fs_offset_t realsize; ///< real file size (uncompressed)
286 typedef struct pack_s
288 char filename [MAX_OSPATH];
289 char shortname [MAX_QPATH];
291 int ignorecase; ///< PK3 ignores case
298 /// Search paths for files (including packages)
299 typedef struct searchpath_s
301 // only one of filename / pack will be used
302 char filename[MAX_OSPATH];
304 struct searchpath_s *next;
309 =============================================================================
313 =============================================================================
318 void FS_Which_f(void);
320 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
321 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
322 fs_offset_t offset, fs_offset_t packsize,
323 fs_offset_t realsize, int flags);
327 =============================================================================
331 =============================================================================
334 mempool_t *fs_mempool;
336 searchpath_t *fs_searchpaths = NULL;
337 const char *const fs_checkgamedir_missing = "missing";
339 #define MAX_FILES_IN_PACK 65536
341 char fs_userdir[MAX_OSPATH];
342 char fs_gamedir[MAX_OSPATH];
343 char fs_basedir[MAX_OSPATH];
344 static pack_t *fs_selfpack = NULL;
346 // list of active game directories (empty if not running a mod)
347 int fs_numgamedirs = 0;
348 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
350 // list of all gamedirs with modinfo.txt
351 gamedir_t *fs_all_gamedirs = NULL;
352 int fs_all_gamedirs_count = 0;
354 cvar_t scr_screenshot_name = {CVAR_NORESETTODEFAULTS, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
355 cvar_t fs_empty_files_in_pack_mark_deletions = {0, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
356 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
360 =============================================================================
362 PRIVATE FUNCTIONS - PK3 HANDLING
364 =============================================================================
368 // Functions exported from zlib
369 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
370 # define ZEXPORT WINAPI
375 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
376 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
377 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
378 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
379 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
380 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
381 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
384 #define qz_inflateInit2(strm, windowBits) \
385 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
386 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
387 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
390 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
392 static dllfunction_t zlibfuncs[] =
394 {"inflate", (void **) &qz_inflate},
395 {"inflateEnd", (void **) &qz_inflateEnd},
396 {"inflateInit2_", (void **) &qz_inflateInit2_},
397 {"inflateReset", (void **) &qz_inflateReset},
398 {"deflateInit2_", (void **) &qz_deflateInit2_},
399 {"deflateEnd", (void **) &qz_deflateEnd},
400 {"deflate", (void **) &qz_deflate},
404 /// Handle for Zlib DLL
405 static dllhandle_t zlib_dll = NULL;
409 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
410 static dllfunction_t shfolderfuncs[] =
412 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
415 static const char* shfolderdllnames [] =
417 "shfolder.dll", // IE 4, or Win NT and higher
420 static dllhandle_t shfolder_dll = NULL;
422 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};
423 #define qREFKNOWNFOLDERID const GUID *
424 #define qKF_FLAG_CREATE 0x8000
425 #define qKF_FLAG_NO_ALIAS 0x1000
426 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
427 static dllfunction_t shell32funcs[] =
429 {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
432 static const char* shell32dllnames [] =
434 "shell32.dll", // Vista and higher
437 static dllhandle_t shell32_dll = NULL;
439 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
440 static void (WINAPI *qCoUninitialize)(void);
441 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
442 static dllfunction_t ole32funcs[] =
444 {"CoInitializeEx", (void **) &qCoInitializeEx},
445 {"CoUninitialize", (void **) &qCoUninitialize},
446 {"CoTaskMemFree", (void **) &qCoTaskMemFree},
449 static const char* ole32dllnames [] =
451 "ole32.dll", // 2000 and higher
454 static dllhandle_t ole32_dll = NULL;
464 void PK3_CloseLibrary (void)
467 Sys_UnloadLibrary (&zlib_dll);
476 Try to load the Zlib DLL
479 qboolean PK3_OpenLibrary (void)
484 const char* dllnames [] =
487 # ifdef ZLIB_USES_WINAPI
493 #elif defined(MACOSX)
507 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
515 See if zlib is available
518 qboolean FS_HasZlib(void)
523 PK3_OpenLibrary(); // to be safe
524 return (zlib_dll != 0);
530 PK3_GetEndOfCentralDir
532 Extract the end of the central directory from a PK3 package
535 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
537 fs_offset_t filesize, maxsize;
538 unsigned char *buffer, *ptr;
541 // Get the package size
542 filesize = lseek (packhandle, 0, SEEK_END);
543 if (filesize < ZIP_END_CDIR_SIZE)
546 // Load the end of the file in memory
547 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
550 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
551 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
552 lseek (packhandle, filesize - maxsize, SEEK_SET);
553 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
559 // Look for the end of central dir signature around the end of the file
560 maxsize -= ZIP_END_CDIR_SIZE;
561 ptr = &buffer[maxsize];
563 while (BuffBigLong (ptr) != ZIP_END_HEADER)
575 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
576 eocd->signature = LittleLong (eocd->signature);
577 eocd->disknum = LittleShort (eocd->disknum);
578 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
579 eocd->localentries = LittleShort (eocd->localentries);
580 eocd->nbentries = LittleShort (eocd->nbentries);
581 eocd->cdir_size = LittleLong (eocd->cdir_size);
582 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
583 eocd->comment_size = LittleShort (eocd->comment_size);
584 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
585 eocd->cdir_offset += eocd->prepended_garbage;
597 Extract the file list from a PK3 file
600 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
602 unsigned char *central_dir, *ptr;
604 fs_offset_t remaining;
606 // Load the central directory in memory
607 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
608 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
609 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
611 Mem_Free (central_dir);
615 // Extract the files properties
616 // The parsing is done "by hand" because some fields have variable sizes and
617 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
618 remaining = eocd->cdir_size;
621 for (ind = 0; ind < eocd->nbentries; ind++)
623 fs_offset_t namesize, count;
625 // Checking the remaining size
626 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
628 Mem_Free (central_dir);
631 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
634 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
636 Mem_Free (central_dir);
640 namesize = BuffLittleShort (&ptr[28]); // filename length
642 // Check encryption, compression, and attributes
643 // 1st uint8 : general purpose bit flag
644 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
646 // LordHavoc: bit 3 would be a problem if we were scanning the archive
647 // but is not a problem in the central directory where the values are
650 // bit 3 seems to always be set by the standard Mac OSX zip maker
652 // 2nd uint8 : external file attributes
653 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
654 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
656 // Still enough bytes for the name?
657 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
659 Mem_Free (central_dir);
663 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
664 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
666 char filename [sizeof (pack->files[0].name)];
667 fs_offset_t offset, packsize, realsize;
670 // Extract the name (strip it if necessary)
671 namesize = min(namesize, (int)sizeof (filename) - 1);
672 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
673 filename[namesize] = '\0';
675 if (BuffLittleShort (&ptr[10]))
676 flags = PACKFILE_FLAG_DEFLATED;
679 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
680 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
681 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
683 switch(ptr[5]) // C_VERSION_MADE_BY_1
688 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
689 // can't use S_ISLNK here, as this has to compile on non-UNIX too
690 flags |= PACKFILE_FLAG_SYMLINK;
694 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
698 // Skip the name, additionnal field, and comment
699 // 1er uint16 : extra field length
700 // 2eme uint16 : file comment length
701 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
702 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
706 // If the package is empty, central_dir is NULL here
707 if (central_dir != NULL)
708 Mem_Free (central_dir);
709 return pack->numfiles;
717 Create a package entry associated with a PK3 file
720 pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
722 pk3_endOfCentralDir_t eocd;
726 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
729 Con_Printf ("%s is not a PK3 file\n", packfile);
734 // Multi-volume ZIP archives are NOT allowed
735 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
737 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
742 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
743 // since eocd.nbentries is an unsigned 16 bits integer
744 #if MAX_FILES_IN_PACK < 65535
745 if (eocd.nbentries > MAX_FILES_IN_PACK)
747 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
753 // Create a package structure in memory
754 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
755 pack->ignorecase = true; // PK3 ignores case
756 strlcpy (pack->filename, packfile, sizeof (pack->filename));
757 pack->handle = packhandle;
758 pack->numfiles = eocd.nbentries;
759 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
761 real_nb_files = PK3_BuildFileList (pack, &eocd);
762 if (real_nb_files < 0)
764 Con_Printf ("%s is not a valid PK3 file\n", packfile);
770 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
773 pack_t *FS_LoadPackPK3 (const char *packfile)
776 packhandle = FS_SysOpenFD (packfile, "rb", false);
779 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
785 PK3_GetTrueFileOffset
787 Find where the true file data offset is
790 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
792 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
796 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
799 // Load the local file description
800 lseek (pack->handle, pfile->offset, SEEK_SET);
801 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
802 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
804 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
808 // Skip name and extra field
809 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
811 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
817 =============================================================================
819 OTHER PRIVATE FUNCTIONS
821 =============================================================================
829 Add a file to the list of files contained into a package
832 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
833 fs_offset_t offset, fs_offset_t packsize,
834 fs_offset_t realsize, int flags)
836 int (*strcmp_funct) (const char* str1, const char* str2);
837 int left, right, middle;
840 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
842 // Look for the slot we should put that file into (binary search)
844 right = pack->numfiles - 1;
845 while (left <= right)
849 middle = (left + right) / 2;
850 diff = strcmp_funct (pack->files[middle].name, name);
852 // If we found the file, there's a problem
854 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
856 // If we're too far in the list
863 // We have to move the right of the list by one slot to free the one we need
864 pfile = &pack->files[left];
865 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
868 strlcpy (pfile->name, name, sizeof (pfile->name));
869 pfile->offset = offset;
870 pfile->packsize = packsize;
871 pfile->realsize = realsize;
872 pfile->flags = flags;
882 Only used for FS_OpenRealFile.
885 void FS_CreatePath (char *path)
889 for (ofs = path+1 ; *ofs ; ofs++)
891 if (*ofs == '/' || *ofs == '\\')
893 // create the directory
909 void FS_Path_f (void)
913 Con_Print("Current search path:\n");
914 for (s=fs_searchpaths ; s ; s=s->next)
919 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
921 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
924 Con_Printf("%s\n", s->filename);
934 /*! Takes an explicit (not game tree related) path to a pak file.
935 *Loads the header and directory, adding the files at the beginning
936 *of the list so they override previous pack files.
938 pack_t *FS_LoadPackPAK (const char *packfile)
940 dpackheader_t header;
946 packhandle = FS_SysOpenFD(packfile, "rb", false);
949 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
951 Con_Printf ("%s is not a packfile\n", packfile);
955 if (memcmp(header.id, "PACK", 4))
957 Con_Printf ("%s is not a packfile\n", packfile);
961 header.dirofs = LittleLong (header.dirofs);
962 header.dirlen = LittleLong (header.dirlen);
964 if (header.dirlen % sizeof(dpackfile_t))
966 Con_Printf ("%s has an invalid directory size\n", packfile);
971 numpackfiles = header.dirlen / sizeof(dpackfile_t);
973 if (numpackfiles > MAX_FILES_IN_PACK)
975 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
980 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
981 lseek (packhandle, header.dirofs, SEEK_SET);
982 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
984 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
990 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
991 pack->ignorecase = false; // PAK is case sensitive
992 strlcpy (pack->filename, packfile, sizeof (pack->filename));
993 pack->handle = packhandle;
995 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
997 // parse the directory
998 for (i = 0;i < numpackfiles;i++)
1000 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1001 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1003 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1008 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1013 ====================
1016 Create a package entry associated with a directory file
1017 ====================
1019 pack_t *FS_LoadPackVirtual (const char *dirname)
1022 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1024 pack->ignorecase = false;
1025 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1027 pack->numfiles = -1;
1029 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1038 /*! Adds the given pack to the search path.
1039 * The pack type is autodetected by the file extension.
1041 * Returns true if the file was successfully added to the
1042 * search path or if it was already included.
1044 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1045 * plain directories.
1048 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1050 searchpath_t *search;
1052 const char *ext = FS_FileExtension(pakfile);
1055 for(search = fs_searchpaths; search; search = search->next)
1057 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1060 *already_loaded = true;
1061 return true; // already loaded
1066 *already_loaded = false;
1068 if(!strcasecmp(ext, "pk3dir"))
1069 pak = FS_LoadPackVirtual (pakfile);
1070 else if(!strcasecmp(ext, "pak"))
1071 pak = FS_LoadPackPAK (pakfile);
1072 else if(!strcasecmp(ext, "pk3"))
1073 pak = FS_LoadPackPK3 (pakfile);
1075 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1079 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1081 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1084 // find the first item whose next one is a pack or NULL
1085 searchpath_t *insertion_point = 0;
1086 if(fs_searchpaths && !fs_searchpaths->pack)
1088 insertion_point = fs_searchpaths;
1091 if(!insertion_point->next)
1093 if(insertion_point->next->pack)
1095 insertion_point = insertion_point->next;
1098 // If insertion_point is NULL, this means that either there is no
1099 // item in the list yet, or that the very first item is a pack. In
1100 // that case, we want to insert at the beginning...
1101 if(!insertion_point)
1103 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1104 search->next = fs_searchpaths;
1105 fs_searchpaths = search;
1108 // otherwise we want to append directly after insertion_point.
1110 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1111 search->next = insertion_point->next;
1112 insertion_point->next = search;
1117 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1118 search->next = fs_searchpaths;
1119 fs_searchpaths = search;
1124 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1125 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1126 // same goes for the name inside the pack structure
1127 l = strlen(pak->shortname);
1129 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1130 pak->shortname[l - 3] = 0;
1131 l = strlen(pak->filename);
1133 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1134 pak->filename[l - 3] = 0;
1140 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1151 /*! Adds the given pack to the search path and searches for it in the game path.
1152 * The pack type is autodetected by the file extension.
1154 * Returns true if the file was successfully added to the
1155 * search path or if it was already included.
1157 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1158 * plain directories.
1160 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1162 char fullpath[MAX_OSPATH];
1164 searchpath_t *search;
1167 *already_loaded = false;
1169 // then find the real name...
1170 search = FS_FindFile(pakfile, &index, true);
1171 if(!search || search->pack)
1173 Con_Printf("could not find pak \"%s\"\n", pakfile);
1177 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1179 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1187 Sets fs_gamedir, adds the directory to the head of the path,
1188 then loads and adds pak1.pak pak2.pak ...
1191 void FS_AddGameDirectory (const char *dir)
1195 searchpath_t *search;
1197 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1199 stringlistinit(&list);
1200 listdirectory(&list, "", dir);
1201 stringlistsort(&list, false);
1203 // add any PAK package in the directory
1204 for (i = 0;i < list.numstrings;i++)
1206 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1208 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1212 // add any PK3 package in the directory
1213 for (i = 0;i < list.numstrings;i++)
1215 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1217 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1221 stringlistfreecontents(&list);
1223 // Add the directory to the search path
1224 // (unpacked files have the priority over packed files)
1225 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1226 strlcpy (search->filename, dir, sizeof (search->filename));
1227 search->next = fs_searchpaths;
1228 fs_searchpaths = search;
1237 void FS_AddGameHierarchy (const char *dir)
1239 // Add the common game directory
1240 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1243 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1252 const char *FS_FileExtension (const char *in)
1254 const char *separator, *backslash, *colon, *dot;
1256 separator = strrchr(in, '/');
1257 backslash = strrchr(in, '\\');
1258 if (!separator || separator < backslash)
1259 separator = backslash;
1260 colon = strrchr(in, ':');
1261 if (!separator || separator < colon)
1264 dot = strrchr(in, '.');
1265 if (dot == NULL || (separator && (dot < separator)))
1277 const char *FS_FileWithoutPath (const char *in)
1279 const char *separator, *backslash, *colon;
1281 separator = strrchr(in, '/');
1282 backslash = strrchr(in, '\\');
1283 if (!separator || separator < backslash)
1284 separator = backslash;
1285 colon = strrchr(in, ':');
1286 if (!separator || separator < colon)
1288 return separator ? separator + 1 : in;
1297 void FS_ClearSearchPath (void)
1299 // unload all packs and directory information, close all pack files
1300 // (if a qfile is still reading a pack it won't be harmed because it used
1301 // dup() to get its own handle already)
1302 while (fs_searchpaths)
1304 searchpath_t *search = fs_searchpaths;
1305 fs_searchpaths = search->next;
1306 if (search->pack && search->pack != fs_selfpack)
1308 if(!search->pack->vpack)
1311 close(search->pack->handle);
1312 // free any memory associated with it
1313 if (search->pack->files)
1314 Mem_Free(search->pack->files);
1316 Mem_Free(search->pack);
1322 static void FS_AddSelfPack(void)
1326 searchpath_t *search;
1327 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1328 search->next = fs_searchpaths;
1329 search->pack = fs_selfpack;
1330 fs_searchpaths = search;
1340 void FS_Rescan (void)
1343 qboolean fs_modified = false;
1344 qboolean reset = false;
1345 char gamedirbuf[MAX_INPUTLINE];
1349 FS_ClearSearchPath();
1351 // automatically activate gamemode for the gamedirs specified
1353 COM_ChangeGameTypeForGameDirs();
1355 // add the game-specific paths
1356 // gamedirname1 (typically id1)
1357 FS_AddGameHierarchy (gamedirname1);
1358 // update the com_modname (used for server info)
1359 if (gamedirname2 && gamedirname2[0])
1360 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1362 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1364 // add the game-specific path, if any
1365 // (only used for mission packs and the like, which should set fs_modified)
1366 if (gamedirname2 && gamedirname2[0])
1369 FS_AddGameHierarchy (gamedirname2);
1373 // Adds basedir/gamedir as an override game
1374 // LordHavoc: now supports multiple -game directories
1375 // set the com_modname (reported in server info)
1377 for (i = 0;i < fs_numgamedirs;i++)
1380 FS_AddGameHierarchy (fs_gamedirs[i]);
1381 // update the com_modname (used server info)
1382 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1384 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1386 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1388 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1390 // add back the selfpack as new first item
1393 // set the default screenshot name to either the mod name or the
1394 // gamemode screenshot name
1395 if (strcmp(com_modname, gamedirname1))
1396 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1398 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1400 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1401 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1403 // If "-condebug" is in the command line, remove the previous log file
1404 if (COM_CheckParm ("-condebug") != 0)
1405 unlink (va("%s/qconsole.log", fs_gamedir));
1407 // look for the pop.lmp file and set registered to true if it is found
1408 if (FS_FileExists("gfx/pop.lmp"))
1409 Cvar_Set ("registered", "1");
1415 if (!registered.integer)
1418 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1420 Con_Print("Playing shareware version.\n");
1423 Con_Print("Playing registered version.\n");
1425 case GAME_STEELSTORM:
1426 if (registered.integer)
1427 Con_Print("Playing registered version.\n");
1429 Con_Print("Playing shareware version.\n");
1435 // unload all wads so that future queries will return the new data
1439 void FS_Rescan_f(void)
1449 extern void Host_SaveConfig (void);
1450 extern void Host_LoadConfig_f (void);
1451 extern qboolean vid_opened;
1452 extern void VID_Stop(void);
1453 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1458 if (fs_numgamedirs == numgamedirs)
1460 for (i = 0;i < numgamedirs;i++)
1461 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1463 if (i == numgamedirs)
1464 return true; // already using this set of gamedirs, do nothing
1467 if (numgamedirs > MAX_GAMEDIRS)
1470 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1471 return false; // too many gamedirs
1474 for (i = 0;i < numgamedirs;i++)
1476 // if string is nasty, reject it
1477 p = FS_CheckGameDir(gamedirs[i]);
1481 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1482 return false; // nasty gamedirs
1484 if(p == fs_checkgamedir_missing && failmissing)
1487 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1488 return false; // missing gamedirs
1494 fs_numgamedirs = numgamedirs;
1495 for (i = 0;i < fs_numgamedirs;i++)
1496 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1498 // reinitialize filesystem to detect the new paks
1501 if (cls.demoplayback)
1507 // unload all sounds so they will be reloaded from the new files as needed
1508 S_UnloadAllSounds_f();
1510 // close down the video subsystem, it will start up again when the config finishes...
1514 // restart the video subsystem after the config is executed
1515 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1525 void FS_GameDir_f (void)
1529 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1533 Con_Printf("gamedirs active:");
1534 for (i = 0;i < fs_numgamedirs;i++)
1535 Con_Printf(" %s", fs_gamedirs[i]);
1540 numgamedirs = Cmd_Argc() - 1;
1541 if (numgamedirs > MAX_GAMEDIRS)
1543 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1547 for (i = 0;i < numgamedirs;i++)
1548 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1550 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1552 // actually, changing during game would work fine, but would be stupid
1553 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1557 // halt demo playback to close the file
1560 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1563 static const char *FS_SysCheckGameDir(const char *gamedir)
1565 static char buf[8192];
1571 stringlistinit(&list);
1572 listdirectory(&list, gamedir, "");
1573 success = list.numstrings > 0;
1574 stringlistfreecontents(&list);
1578 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1581 n = FS_Read (f, buf, sizeof(buf) - 1);
1601 const char *FS_CheckGameDir(const char *gamedir)
1605 if (FS_CheckNastyPath(gamedir, true))
1608 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1613 // get description from basedir
1614 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1622 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1626 return fs_checkgamedir_missing;
1629 static void FS_ListGameDirs(void)
1631 stringlist_t list, list2;
1635 fs_all_gamedirs_count = 0;
1637 Mem_Free(fs_all_gamedirs);
1639 stringlistinit(&list);
1640 listdirectory(&list, va("%s/", fs_basedir), "");
1641 listdirectory(&list, va("%s/", fs_userdir), "");
1642 stringlistsort(&list, false);
1644 stringlistinit(&list2);
1645 for(i = 0; i < list.numstrings; ++i)
1648 if(!strcmp(list.strings[i-1], list.strings[i]))
1650 info = FS_CheckGameDir(list.strings[i]);
1653 if(info == fs_checkgamedir_missing)
1657 stringlistappend(&list2, list.strings[i]);
1659 stringlistfreecontents(&list);
1661 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1662 for(i = 0; i < list2.numstrings; ++i)
1664 info = FS_CheckGameDir(list2.strings[i]);
1665 // all this cannot happen any more, but better be safe than sorry
1668 if(info == fs_checkgamedir_missing)
1672 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1673 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1674 ++fs_all_gamedirs_count;
1680 #pragma comment(lib, "shell32.lib")
1690 void FS_Init_SelfPack (void)
1693 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1696 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1702 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1705 const char **new_argv;
1707 int args_left = 256;
1708 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1711 new_argv[0] = "dummy";
1716 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1719 while(COM_ParseToken_Console(&p))
1723 q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1724 strlcpy(q, com_token, strlen(com_token) + 1);
1725 new_argv[com_argc + i] = q;
1728 new_argv[i+com_argc] = NULL;
1729 com_argv = new_argv;
1730 com_argc = com_argc + i;
1737 int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1739 #if defined(__IPHONEOS__)
1740 if (userdirmode == USERDIRMODE_HOME)
1742 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1743 // fs_userdir stores configurations to the Documents folder of the app
1744 strlcpy(userdir, maxlength, "../Documents/");
1749 #elif defined(WIN32)
1751 #if _MSC_VER >= 1400
1754 TCHAR mydocsdir[MAX_PATH + 1];
1755 wchar_t *savedgamesdirw;
1756 char savedgamesdir[MAX_OSPATH];
1764 case USERDIRMODE_NOHOME:
1765 strlcpy(userdir, fs_basedir, userdirsize);
1767 case USERDIRMODE_MYGAMES:
1769 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1771 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1773 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1776 #if _MSC_VER >= 1400
1777 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1780 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1785 homedir = getenv("USERPROFILE");
1788 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1793 case USERDIRMODE_SAVEDGAMES:
1795 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1797 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1798 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1800 savedgamesdir[0] = 0;
1801 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1804 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1806 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1809 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1811 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1812 #if _MSC_VER >= 1400
1813 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1815 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1817 qCoTaskMemFree(savedgamesdirw);
1820 if (savedgamesdir[0])
1822 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1836 case USERDIRMODE_NOHOME:
1837 strlcpy(userdir, fs_basedir, userdirsize);
1839 case USERDIRMODE_HOME:
1840 homedir = getenv("HOME");
1843 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1847 case USERDIRMODE_SAVEDGAMES:
1848 homedir = getenv("HOME");
1852 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1854 // the XDG say some files would need to go in:
1855 // XDG_CONFIG_HOME (or ~/.config/%s/)
1856 // XDG_DATA_HOME (or ~/.local/share/%s/)
1857 // XDG_CACHE_HOME (or ~/.cache/%s/)
1858 // and also search the following global locations if defined:
1859 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1860 // XDG_DATA_DIRS (normally /usr/share/%s/)
1861 // this would be too complicated...
1872 // historical behavior...
1873 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1874 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
1877 // see if we can write to this path (note: won't create path)
1879 // no access() here, we must try to open the file for appending
1880 fd = Sys_OpenFD(va("%s%s/config.cfg", userdir, gamedirname1), "a", false);
1884 // on Unix, we don't need to ACTUALLY attempt to open the file
1885 if(access(va("%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1892 return 1; // good choice - the path exists and is writable
1896 if (userdirmode == USERDIRMODE_NOHOME)
1897 return -1; // path usually already exists, we lack permissions
1899 return 0; // probably good - failed to write but maybe we need to create path
1918 // Overrides the system supplied base directory (under GAMENAME)
1919 // 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)
1920 i = COM_CheckParm ("-basedir");
1921 if (i && i < com_argc-1)
1923 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1924 i = (int)strlen (fs_basedir);
1925 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1926 fs_basedir[i-1] = 0;
1930 // If the base directory is explicitly defined by the compilation process
1931 #ifdef DP_FS_BASEDIR
1932 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1933 #elif defined(MACOSX)
1934 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1935 if (strstr(com_argv[0], ".app/"))
1938 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1939 split = strstr(fs_basedir, ".app/");
1942 struct stat statresult;
1943 // truncate to just after the .app/
1945 // see if gamedir exists in Resources
1946 if (stat(va("%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1948 // found gamedir inside Resources, use it
1949 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1953 // no gamedir found in Resources, gamedir is probably
1954 // outside the .app, remove .app part of path
1955 while (split > fs_basedir && *split != '/')
1964 // make sure the appending of a path separator won't create an unterminated string
1965 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1966 // add a path separator to the end of the basedir if it lacks one
1967 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1968 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1970 // Add the personal game directory
1971 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1972 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1973 else if (COM_CheckParm("-nohome"))
1974 *fs_userdir = 0; // user wants roaming installation, no userdir
1978 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1979 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1980 int userdirstatus[USERDIRMODE_COUNT];
1982 // historical behavior...
1983 if (!strcmp(gamedirname1, "id1"))
1984 preferreduserdirmode = USERDIRMODE_NOHOME;
1986 // check what limitations the user wants to impose
1987 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
1988 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
1989 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
1990 // gather the status of the possible userdirs
1991 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
1993 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
1994 if (userdirstatus[dirmode] == 1)
1995 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
1996 else if (userdirstatus[dirmode] == 0)
1997 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
1999 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2001 // some games may prefer writing to basedir, but if write fails we
2002 // have to search for a real userdir...
2003 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2004 preferreduserdirmode = highestuserdirmode;
2005 // check for an existing userdir and continue using it if possible...
2006 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2007 if (userdirstatus[dirmode] == 1)
2009 // if no existing userdir found, make a new one...
2010 if (dirmode == 0 && preferreduserdirmode > 0)
2011 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2012 if (userdirstatus[dirmode] >= 0)
2014 // and finally, we picked one...
2015 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2016 Con_DPrintf("userdir %i is the winner\n", dirmode);
2019 // if userdir equal to basedir, clear it to avoid confusion later
2020 if (!strcmp(fs_basedir, fs_userdir))
2025 p = FS_CheckGameDir(gamedirname1);
2026 if(!p || p == fs_checkgamedir_missing)
2027 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2031 p = FS_CheckGameDir(gamedirname2);
2032 if(!p || p == fs_checkgamedir_missing)
2033 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2037 // Adds basedir/gamedir as an override game
2038 // LordHavoc: now supports multiple -game directories
2039 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2043 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2046 p = FS_CheckGameDir(com_argv[i]);
2048 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2049 if(p == fs_checkgamedir_missing)
2050 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2051 // add the gamedir to the list of active gamedirs
2052 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2057 // generate the searchpath
2061 void FS_Init_Commands(void)
2063 Cvar_RegisterVariable (&scr_screenshot_name);
2064 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2065 Cvar_RegisterVariable (&cvar_fs_gamedir);
2067 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2068 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2069 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2070 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2071 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2072 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2080 void FS_Shutdown (void)
2082 // close all pack files and such
2083 // (hopefully there aren't any other open files, but they'll be cleaned up
2084 // by the OS anyway)
2085 FS_ClearSearchPath();
2086 Mem_FreePool (&fs_mempool);
2089 Sys_UnloadLibrary (&shfolder_dll);
2090 Sys_UnloadLibrary (&shell32_dll);
2091 Sys_UnloadLibrary (&ole32_dll);
2095 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2100 qboolean dolock = false;
2102 // Parse the mode string
2111 opt = O_CREAT | O_TRUNC;
2115 opt = O_CREAT | O_APPEND;
2118 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2121 for (ind = 1; mode[ind] != '\0'; ind++)
2135 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2136 filepath, mode, mode[ind]);
2144 # if _MSC_VER >= 1400
2145 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2147 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2150 handle = open (filepath, mod | opt, 0666);
2151 if(handle >= 0 && dolock)
2154 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2155 l.l_whence = SEEK_SET;
2158 if(fcntl(handle, F_SETLK, &l) == -1)
2170 ====================
2173 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2174 ====================
2176 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2180 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2182 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2183 if (file->handle < 0)
2189 file->filename = Mem_strdup(fs_mempool, filepath);
2191 file->real_length = lseek (file->handle, 0, SEEK_END);
2193 // For files opened in append mode, we start at the end of the file
2195 file->position = file->real_length;
2197 lseek (file->handle, 0, SEEK_SET);
2207 Open a packed file using its package file descriptor
2210 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2216 pfile = &pack->files[pack_ind];
2218 // If we don't have the true offset, get it now
2219 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2220 if (!PK3_GetTrueFileOffset (pfile, pack))
2223 #ifndef LINK_TO_ZLIB
2224 // No Zlib DLL = no compressed files
2225 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2227 Con_Printf("WARNING: can't open the compressed file %s\n"
2228 "You need the Zlib DLL to use compressed files\n",
2234 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2235 // the dup() call to avoid having to close the dup_handle on error here
2236 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2238 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2239 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2243 dup_handle = dup (pack->handle);
2246 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2250 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2251 memset (file, 0, sizeof (*file));
2252 file->handle = dup_handle;
2253 file->flags = QFILE_FLAG_PACKED;
2254 file->real_length = pfile->realsize;
2255 file->offset = pfile->offset;
2259 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2263 file->flags |= QFILE_FLAG_DEFLATED;
2265 // We need some more variables
2266 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2268 ztk->comp_length = pfile->packsize;
2270 // Initialize zlib stream
2271 ztk->zstream.next_in = ztk->input;
2272 ztk->zstream.avail_in = 0;
2274 /* From Zlib's "unzip.c":
2276 * windowBits is passed < 0 to tell that there is no zlib header.
2277 * Note that in this case inflate *requires* an extra "dummy" byte
2278 * after the compressed stream in order to complete decompression and
2279 * return Z_STREAM_END.
2280 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2281 * size of both compressed and uncompressed data
2283 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2285 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2291 ztk->zstream.next_out = file->buff;
2292 ztk->zstream.avail_out = sizeof (file->buff);
2301 ====================
2304 Return true if the path should be rejected due to one of the following:
2305 1: path elements that are non-portable
2306 2: path elements that would allow access to files outside the game directory,
2307 or are just not a good idea for a mod to be using.
2308 ====================
2310 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2312 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2316 // Windows: don't allow \ in filenames (windows-only), period.
2317 // (on Windows \ is a directory separator, but / is also supported)
2318 if (strstr(path, "\\"))
2319 return 1; // non-portable
2321 // Mac: don't allow Mac-only filenames - : is a directory separator
2322 // instead of /, but we rely on / working already, so there's no reason to
2323 // support a Mac-only path
2324 // Amiga and Windows: : tries to go to root of drive
2325 if (strstr(path, ":"))
2326 return 1; // non-portable attempt to go to root of drive
2328 // Amiga: // is parent directory
2329 if (strstr(path, "//"))
2330 return 1; // non-portable attempt to go to parent directory
2332 // all: don't allow going to parent directory (../ or /../)
2333 if (strstr(path, ".."))
2334 return 2; // attempt to go outside the game directory
2336 // Windows and UNIXes: don't allow absolute paths
2338 return 2; // attempt to go outside the game directory
2340 // 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
2341 if (strchr(path, '.'))
2345 // gamedir is entirely path elements, so simply forbid . entirely
2348 if (strchr(path, '.') < strrchr(path, '/'))
2349 return 2; // possible attempt to go outside the game directory
2352 // all: forbid trailing slash on gamedir
2353 if (isgamedir && path[strlen(path)-1] == '/')
2356 // all: forbid leading dot on any filename for any reason
2357 if (strstr(path, "/."))
2358 return 2; // attempt to go outside the game directory
2360 // after all these checks we're pretty sure it's a / separated filename
2361 // and won't do much if any harm
2367 ====================
2370 Look for a file in the packages and in the filesystem
2372 Return the searchpath where the file was found (or NULL)
2373 and the file index in the package if relevant
2374 ====================
2376 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2378 searchpath_t *search;
2381 // search through the path, one element at a time
2382 for (search = fs_searchpaths;search;search = search->next)
2384 // is the element a pak file?
2385 if (search->pack && !search->pack->vpack)
2387 int (*strcmp_funct) (const char* str1, const char* str2);
2388 int left, right, middle;
2391 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2393 // Look for the file (binary search)
2395 right = pak->numfiles - 1;
2396 while (left <= right)
2400 middle = (left + right) / 2;
2401 diff = strcmp_funct (pak->files[middle].name, name);
2406 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2408 // yes, but the first one is empty so we treat it as not being there
2409 if (!quiet && developer_extra.integer)
2410 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2417 if (!quiet && developer_extra.integer)
2418 Con_DPrintf("FS_FindFile: %s in %s\n",
2419 pak->files[middle].name, pak->filename);
2426 // If we're too far in the list
2435 char netpath[MAX_OSPATH];
2436 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2437 if (FS_SysFileExists (netpath))
2439 if (!quiet && developer_extra.integer)
2440 Con_DPrintf("FS_FindFile: %s\n", netpath);
2449 if (!quiet && developer_extra.integer)
2450 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2462 Look for a file in the search paths and open it in read-only mode
2465 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2467 searchpath_t *search;
2470 search = FS_FindFile (filename, &pack_ind, quiet);
2476 // Found in the filesystem?
2479 // this works with vpacks, so we are fine
2480 char path [MAX_OSPATH];
2481 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2482 return FS_SysOpen (path, "rb", nonblocking);
2485 // So, we found it in a package...
2487 // Is it a PK3 symlink?
2488 // TODO also handle directory symlinks by parsing the whole structure...
2489 // but heck, file symlinks are good enough for now
2490 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2492 if(symlinkLevels <= 0)
2494 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2499 char linkbuf[MAX_QPATH];
2501 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2502 const char *mergeslash;
2507 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2513 // Now combine the paths...
2514 mergeslash = strrchr(filename, '/');
2515 mergestart = linkbuf;
2517 mergeslash = filename;
2518 while(!strncmp(mergestart, "../", 3))
2521 while(mergeslash > filename)
2524 if(*mergeslash == '/')
2528 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2529 if(mergeslash == filename)
2531 // Either mergeslash == filename, then we just replace the name (done below)
2535 // Or, we append the name after mergeslash;
2536 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2537 int spaceNeeded = mergeslash - filename + 1;
2538 int spaceRemoved = mergestart - linkbuf;
2539 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2541 Con_DPrintf("symlink: too long path rejected\n");
2544 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2545 memcpy(linkbuf, filename, spaceNeeded);
2546 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2547 mergestart = linkbuf;
2549 if (!quiet && developer_loading.integer)
2550 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2551 if(FS_CheckNastyPath (mergestart, false))
2553 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2556 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2560 return FS_OpenPackedFile (search->pack, pack_ind);
2565 =============================================================================
2567 MAIN PUBLIC FUNCTIONS
2569 =============================================================================
2573 ====================
2576 Open a file in the userpath. The syntax is the same as fopen
2577 Used for savegame scanning in menu, and all file writing.
2578 ====================
2580 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2582 char real_path [MAX_OSPATH];
2584 if (FS_CheckNastyPath(filepath, false))
2586 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2590 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2592 // If the file is opened in "write", "append", or "read/write" mode,
2593 // create directories up to the file.
2594 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2595 FS_CreatePath (real_path);
2596 return FS_SysOpen (real_path, mode, false);
2601 ====================
2604 Open a file. The syntax is the same as fopen
2605 ====================
2607 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2609 if (FS_CheckNastyPath(filepath, false))
2611 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2615 return FS_OpenReadFile (filepath, quiet, false, 16);
2620 ====================
2623 Open a file. The syntax is the same as fopen
2624 ====================
2626 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2629 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2630 memset (file, 0, sizeof (*file));
2631 file->flags = QFILE_FLAG_DATA;
2633 file->real_length = size;
2639 ====================
2643 ====================
2645 int FS_Close (qfile_t* file)
2647 if(file->flags & QFILE_FLAG_DATA)
2653 if (close (file->handle))
2658 if (file->flags & QFILE_FLAG_REMOVE)
2659 remove(file->filename);
2661 Mem_Free((void *) file->filename);
2666 qz_inflateEnd (&file->ztk->zstream);
2667 Mem_Free (file->ztk);
2674 void FS_RemoveOnClose(qfile_t* file)
2676 file->flags |= QFILE_FLAG_REMOVE;
2680 ====================
2683 Write "datasize" bytes into a file
2684 ====================
2686 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2690 // If necessary, seek to the exact file position we're supposed to be
2691 if (file->buff_ind != file->buff_len)
2692 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2694 // Purge cached data
2697 // Write the buffer and update the position
2698 result = write (file->handle, data, (fs_offset_t)datasize);
2699 file->position = lseek (file->handle, 0, SEEK_CUR);
2700 if (file->real_length < file->position)
2701 file->real_length = file->position;
2711 ====================
2714 Read up to "buffersize" bytes from a file
2715 ====================
2717 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2719 fs_offset_t count, done;
2721 if (buffersize == 0)
2724 // Get rid of the ungetc character
2725 if (file->ungetc != EOF)
2727 ((char*)buffer)[0] = file->ungetc;
2735 if(file->flags & QFILE_FLAG_DATA)
2737 size_t left = file->real_length - file->position;
2738 if(buffersize > left)
2740 memcpy(buffer, file->data + file->position, buffersize);
2741 file->position += buffersize;
2745 // First, we copy as many bytes as we can from "buff"
2746 if (file->buff_ind < file->buff_len)
2748 count = file->buff_len - file->buff_ind;
2749 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2751 memcpy (buffer, &file->buff[file->buff_ind], count);
2752 file->buff_ind += count;
2754 buffersize -= count;
2755 if (buffersize == 0)
2759 // NOTE: at this point, the read buffer is always empty
2761 // If the file isn't compressed
2762 if (! (file->flags & QFILE_FLAG_DEFLATED))
2766 // We must take care to not read after the end of the file
2767 count = file->real_length - file->position;
2769 // If we have a lot of data to get, put them directly into "buffer"
2770 if (buffersize > sizeof (file->buff) / 2)
2772 if (count > (fs_offset_t)buffersize)
2773 count = (fs_offset_t)buffersize;
2774 lseek (file->handle, file->offset + file->position, SEEK_SET);
2775 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2779 file->position += nb;
2781 // Purge cached data
2787 if (count > (fs_offset_t)sizeof (file->buff))
2788 count = (fs_offset_t)sizeof (file->buff);
2789 lseek (file->handle, file->offset + file->position, SEEK_SET);
2790 nb = read (file->handle, file->buff, count);
2793 file->buff_len = nb;
2794 file->position += nb;
2796 // Copy the requested data in "buffer" (as much as we can)
2797 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2798 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2799 file->buff_ind = count;
2807 // If the file is compressed, it's more complicated...
2808 // We cycle through a few operations until we have read enough data
2809 while (buffersize > 0)
2811 ztoolkit_t *ztk = file->ztk;
2814 // NOTE: at this point, the read buffer is always empty
2816 // If "input" is also empty, we need to refill it
2817 if (ztk->in_ind == ztk->in_len)
2819 // If we are at the end of the file
2820 if (file->position == file->real_length)
2823 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2824 if (count > (fs_offset_t)sizeof (ztk->input))
2825 count = (fs_offset_t)sizeof (ztk->input);
2826 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2827 if (read (file->handle, ztk->input, count) != count)
2829 Con_Printf ("FS_Read: unexpected end of file\n");
2834 ztk->in_len = count;
2835 ztk->in_position += count;
2838 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2839 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2841 // Now that we are sure we have compressed data available, we need to determine
2842 // if it's better to inflate it in "file->buff" or directly in "buffer"
2844 // Inflate the data in "file->buff"
2845 if (buffersize < sizeof (file->buff) / 2)
2847 ztk->zstream.next_out = file->buff;
2848 ztk->zstream.avail_out = sizeof (file->buff);
2849 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2850 if (error != Z_OK && error != Z_STREAM_END)
2852 Con_Printf ("FS_Read: Can't inflate file\n");
2855 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2857 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2858 file->position += file->buff_len;
2860 // Copy the requested data in "buffer" (as much as we can)
2861 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2862 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2863 file->buff_ind = count;
2866 // Else, we inflate directly in "buffer"
2869 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2870 ztk->zstream.avail_out = (unsigned int)buffersize;
2871 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2872 if (error != Z_OK && error != Z_STREAM_END)
2874 Con_Printf ("FS_Read: Can't inflate file\n");
2877 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2879 // How much data did it inflate?
2880 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2881 file->position += count;
2883 // Purge cached data
2888 buffersize -= count;
2896 ====================
2899 Print a string into a file
2900 ====================
2902 int FS_Print (qfile_t* file, const char *msg)
2904 return (int)FS_Write (file, msg, strlen (msg));
2908 ====================
2911 Print a string into a file
2912 ====================
2914 int FS_Printf(qfile_t* file, const char* format, ...)
2919 va_start (args, format);
2920 result = FS_VPrintf (file, format, args);
2928 ====================
2931 Print a string into a file
2932 ====================
2934 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2937 fs_offset_t buff_size = MAX_INPUTLINE;
2942 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2943 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2944 if (len >= 0 && len < buff_size)
2946 Mem_Free (tempbuff);
2950 len = write (file->handle, tempbuff, len);
2951 Mem_Free (tempbuff);
2958 ====================
2961 Get the next character of a file
2962 ====================
2964 int FS_Getc (qfile_t* file)
2968 if (FS_Read (file, &c, 1) != 1)
2976 ====================
2979 Put a character back into the read buffer (only supports one character!)
2980 ====================
2982 int FS_UnGetc (qfile_t* file, unsigned char c)
2984 // If there's already a character waiting to be read
2985 if (file->ungetc != EOF)
2994 ====================
2997 Move the position index in a file
2998 ====================
3000 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3003 unsigned char* buffer;
3004 fs_offset_t buffersize;
3006 // Compute the file offset
3010 offset += file->position - file->buff_len + file->buff_ind;
3017 offset += file->real_length;
3023 if (offset < 0 || offset > file->real_length)
3026 if(file->flags & QFILE_FLAG_DATA)
3028 file->position = offset;
3032 // If we have the data in our read buffer, we don't need to actually seek
3033 if (file->position - file->buff_len <= offset && offset <= file->position)
3035 file->buff_ind = offset + file->buff_len - file->position;
3039 // Purge cached data
3042 // Unpacked or uncompressed files can seek directly
3043 if (! (file->flags & QFILE_FLAG_DEFLATED))
3045 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3047 file->position = offset;
3051 // Seeking in compressed files is more a hack than anything else,
3052 // but we need to support it, so here we go.
3055 // If we have to go back in the file, we need to restart from the beginning
3056 if (offset <= file->position)
3060 ztk->in_position = 0;
3062 lseek (file->handle, file->offset, SEEK_SET);
3064 // Reset the Zlib stream
3065 ztk->zstream.next_in = ztk->input;
3066 ztk->zstream.avail_in = 0;
3067 qz_inflateReset (&ztk->zstream);
3070 // We need a big buffer to force inflating into it directly
3071 buffersize = 2 * sizeof (file->buff);
3072 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3074 // Skip all data until we reach the requested offset
3075 while (offset > file->position)
3077 fs_offset_t diff = offset - file->position;
3078 fs_offset_t count, len;
3080 count = (diff > buffersize) ? buffersize : diff;
3081 len = FS_Read (file, buffer, count);
3095 ====================
3098 Give the current position in a file
3099 ====================
3101 fs_offset_t FS_Tell (qfile_t* file)
3103 return file->position - file->buff_len + file->buff_ind;
3108 ====================
3111 Give the total size of a file
3112 ====================
3114 fs_offset_t FS_FileSize (qfile_t* file)
3116 return file->real_length;
3121 ====================
3124 Erases any buffered input or output data
3125 ====================
3127 void FS_Purge (qfile_t* file)
3139 Filename are relative to the quake directory.
3140 Always appends a 0 byte.
3143 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3146 unsigned char *buf = NULL;
3147 fs_offset_t filesize = 0;
3149 file = FS_OpenVirtualFile(path, quiet);
3152 filesize = file->real_length;
3155 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3160 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3161 buf[filesize] = '\0';
3162 FS_Read (file, buf, filesize);
3164 if (developer_loadfile.integer)
3165 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3168 if (filesizepointer)
3169 *filesizepointer = filesize;
3178 The filename will be prefixed by the current game directory
3181 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3185 fs_offset_t lentotal;
3187 file = FS_OpenRealFile(filename, "wb", false);
3190 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3195 for(i = 0; i < count; ++i)
3197 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3198 for(i = 0; i < count; ++i)
3199 FS_Write (file, data[i], len[i]);
3204 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3206 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3211 =============================================================================
3213 OTHERS PUBLIC FUNCTIONS
3215 =============================================================================
3223 void FS_StripExtension (const char *in, char *out, size_t size_out)
3231 while ((currentchar = *in) && size_out > 1)
3233 if (currentchar == '.')
3235 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3237 *out++ = currentchar;
3253 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3257 // if path doesn't have a .EXT, append extension
3258 // (extension should include the .)
3259 src = path + strlen(path) - 1;
3261 while (*src != '/' && src != path)
3264 return; // it has an extension
3268 strlcat (path, extension, size_path);
3276 Look for a file in the packages and in the filesystem
3279 int FS_FileType (const char *filename)
3281 searchpath_t *search;
3282 char fullpath[MAX_OSPATH];
3284 search = FS_FindFile (filename, NULL, true);
3286 return FS_FILETYPE_NONE;
3288 if(search->pack && !search->pack->vpack)
3289 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3291 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3292 return FS_SysFileType(fullpath);
3300 Look for a file in the packages and in the filesystem
3303 qboolean FS_FileExists (const char *filename)
3305 return (FS_FindFile (filename, NULL, true) != NULL);
3313 Look for a file in the filesystem only
3316 int FS_SysFileType (const char *path)
3319 // Sajt - some older sdks are missing this define
3320 # ifndef INVALID_FILE_ATTRIBUTES
3321 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3324 DWORD result = GetFileAttributes(path);
3326 if(result == INVALID_FILE_ATTRIBUTES)
3327 return FS_FILETYPE_NONE;
3329 if(result & FILE_ATTRIBUTE_DIRECTORY)
3330 return FS_FILETYPE_DIRECTORY;
3332 return FS_FILETYPE_FILE;
3336 if (stat (path,&buf) == -1)
3337 return FS_FILETYPE_NONE;
3340 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3342 if(S_ISDIR(buf.st_mode))
3343 return FS_FILETYPE_DIRECTORY;
3345 return FS_FILETYPE_FILE;
3349 qboolean FS_SysFileExists (const char *path)
3351 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3354 void FS_mkdir (const char *path)
3367 Allocate and fill a search structure with information on matching filenames.
3370 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3373 searchpath_t *searchpath;
3375 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3376 stringlist_t resultlist;
3377 stringlist_t dirlist;
3378 const char *slash, *backslash, *colon, *separator;
3380 char temp[MAX_OSPATH];
3382 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3387 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3391 stringlistinit(&resultlist);
3392 stringlistinit(&dirlist);
3394 slash = strrchr(pattern, '/');
3395 backslash = strrchr(pattern, '\\');
3396 colon = strrchr(pattern, ':');
3397 separator = max(slash, backslash);
3398 separator = max(separator, colon);
3399 basepathlength = separator ? (separator + 1 - pattern) : 0;
3400 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3402 memcpy(basepath, pattern, basepathlength);
3403 basepath[basepathlength] = 0;
3405 // search through the path, one element at a time
3406 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3408 // is the element a pak file?
3409 if (searchpath->pack && !searchpath->pack->vpack)
3411 // look through all the pak file elements
3412 pak = searchpath->pack;
3413 for (i = 0;i < pak->numfiles;i++)
3415 strlcpy(temp, pak->files[i].name, sizeof(temp));
3418 if (matchpattern(temp, (char *)pattern, true))
3420 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3421 if (!strcmp(resultlist.strings[resultlistindex], temp))
3423 if (resultlistindex == resultlist.numstrings)
3425 stringlistappend(&resultlist, temp);
3426 if (!quiet && developer_loading.integer)
3427 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3430 // strip off one path element at a time until empty
3431 // this way directories are added to the listing if they match the pattern
3432 slash = strrchr(temp, '/');
3433 backslash = strrchr(temp, '\\');
3434 colon = strrchr(temp, ':');
3436 if (separator < slash)
3438 if (separator < backslash)
3439 separator = backslash;
3440 if (separator < colon)
3442 *((char *)separator) = 0;
3448 stringlist_t matchedSet, foundSet;
3449 const char *start = pattern;
3451 stringlistinit(&matchedSet);
3452 stringlistinit(&foundSet);
3453 // add a first entry to the set
3454 stringlistappend(&matchedSet, "");
3455 // iterate through pattern's path
3458 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3459 char subpath[MAX_OSPATH];
3460 char subpattern[MAX_OSPATH];
3462 // find the next wildcard
3463 wildcard = strchr(start, '?');
3464 asterisk = strchr(start, '*');
3465 if (asterisk && (!wildcard || asterisk < wildcard))
3467 wildcard = asterisk;
3472 nextseparator = strchr( wildcard, '/' );
3476 nextseparator = NULL;
3479 if( !nextseparator ) {
3480 nextseparator = start + strlen( start );
3483 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3484 // copy everything up except nextseperator
3485 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3486 // find the last '/' before the wildcard
3487 prevseparator = strrchr( subpattern, '/' );
3489 prevseparator = subpattern;
3492 // copy everything from start to the previous including the '/' (before the wildcard)
3493 // everything up to start is already included in the path of matchedSet's entries
3494 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3496 // for each entry in matchedSet try to open the subdirectories specified in subpath
3497 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3498 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3499 strlcat( temp, subpath, sizeof(temp) );
3500 listdirectory( &foundSet, searchpath->filename, temp );
3502 if( dirlistindex == 0 ) {
3505 // reset the current result set
3506 stringlistfreecontents( &matchedSet );
3507 // match against the pattern
3508 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3509 const char *direntry = foundSet.strings[ dirlistindex ];
3510 if (matchpattern(direntry, subpattern, true)) {
3511 stringlistappend( &matchedSet, direntry );
3514 stringlistfreecontents( &foundSet );
3516 start = nextseparator;
3519 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3521 const char *temp = matchedSet.strings[dirlistindex];
3522 if (matchpattern(temp, (char *)pattern, true))
3524 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3525 if (!strcmp(resultlist.strings[resultlistindex], temp))
3527 if (resultlistindex == resultlist.numstrings)
3529 stringlistappend(&resultlist, temp);
3530 if (!quiet && developer_loading.integer)
3531 Con_Printf("SearchDirFile: %s\n", temp);
3535 stringlistfreecontents( &matchedSet );
3539 if (resultlist.numstrings)
3541 stringlistsort(&resultlist, true);
3542 numfiles = resultlist.numstrings;
3544 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3545 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3546 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3547 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3548 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3549 search->numfilenames = (int)numfiles;
3552 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3555 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3556 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3557 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3559 numchars += (int)textlen;
3562 stringlistfreecontents(&resultlist);
3568 void FS_FreeSearch(fssearch_t *search)
3573 extern int con_linewidth;
3574 int FS_ListDirectory(const char *pattern, int oneperline)
3583 char linebuf[MAX_INPUTLINE];
3585 search = FS_Search(pattern, true, true);
3588 numfiles = search->numfilenames;
3591 // FIXME: the names could be added to one column list and then
3592 // gradually shifted into the next column if they fit, and then the
3593 // next to make a compact variable width listing but it's a lot more
3595 // find width for columns
3597 for (i = 0;i < numfiles;i++)
3599 l = (int)strlen(search->filenames[i]);
3600 if (columnwidth < l)
3603 // count the spacing character
3605 // calculate number of columns
3606 numcolumns = con_linewidth / columnwidth;
3607 // don't bother with the column printing if it's only one column
3608 if (numcolumns >= 2)
3610 numlines = (numfiles + numcolumns - 1) / numcolumns;
3611 for (i = 0;i < numlines;i++)
3614 for (k = 0;k < numcolumns;k++)
3616 l = i * numcolumns + k;
3619 name = search->filenames[l];
3620 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3621 linebuf[linebufpos++] = name[j];
3622 // space out name unless it's the last on the line
3623 if (k + 1 < numcolumns && l + 1 < numfiles)
3624 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3625 linebuf[linebufpos++] = ' ';
3628 linebuf[linebufpos] = 0;
3629 Con_Printf("%s\n", linebuf);
3636 for (i = 0;i < numfiles;i++)
3637 Con_Printf("%s\n", search->filenames[i]);
3638 FS_FreeSearch(search);
3639 return (int)numfiles;
3642 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3644 const char *pattern;
3645 if (Cmd_Argc() >= 3)
3647 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3650 if (Cmd_Argc() == 2)
3651 pattern = Cmd_Argv(1);
3654 if (!FS_ListDirectory(pattern, oneperline))
3655 Con_Print("No files found.\n");
3660 FS_ListDirectoryCmd("dir", true);
3665 FS_ListDirectoryCmd("ls", false);
3668 void FS_Which_f(void)
3670 const char *filename;
3673 if (Cmd_Argc() != 2)
3675 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3678 filename = Cmd_Argv(1);
3679 sp = FS_FindFile(filename, &index, true);
3681 Con_Printf("%s isn't anywhere\n", filename);
3687 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3689 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3692 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3696 const char *FS_WhichPack(const char *filename)
3699 searchpath_t *sp = FS_FindFile(filename, &index, true);
3701 return sp->pack->shortname;
3707 ====================
3708 FS_IsRegisteredQuakePack
3710 Look for a proof of purchase file file in the requested package
3712 If it is found, this file should NOT be downloaded.
3713 ====================
3715 qboolean FS_IsRegisteredQuakePack(const char *name)
3717 searchpath_t *search;
3720 // search through the path, one element at a time
3721 for (search = fs_searchpaths;search;search = search->next)
3723 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3724 // TODO do we want to support vpacks in here too?
3726 int (*strcmp_funct) (const char* str1, const char* str2);
3727 int left, right, middle;
3730 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3732 // Look for the file (binary search)
3734 right = pak->numfiles - 1;
3735 while (left <= right)
3739 middle = (left + right) / 2;
3740 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3746 // If we're too far in the list
3753 // we found the requested pack but it is not registered quake
3761 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3764 unsigned char *filedata;
3765 fs_offset_t filesize;
3766 if (filesizepointer)
3767 *filesizepointer = 0;
3768 if (!filename || !*filename)
3770 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3773 if (filesizepointer)
3774 *filesizepointer = filesize;
3775 crc = CRC_Block(filedata, filesize);
3781 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3784 unsigned char *out = NULL;
3788 #ifndef LINK_TO_ZLIB
3793 memset(&strm, 0, sizeof(strm));
3794 strm.zalloc = Z_NULL;
3795 strm.zfree = Z_NULL;
3796 strm.opaque = Z_NULL;
3799 level = Z_DEFAULT_COMPRESSION;
3801 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3803 Con_Printf("FS_Deflate: deflate init error!\n");
3807 strm.next_in = (unsigned char*)data;
3808 strm.avail_in = size;
3810 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3813 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3814 qz_deflateEnd(&strm);
3818 strm.next_out = tmp;
3819 strm.avail_out = size;
3821 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3823 Con_Printf("FS_Deflate: deflate failed!\n");
3824 qz_deflateEnd(&strm);
3829 if(qz_deflateEnd(&strm) != Z_OK)
3831 Con_Printf("FS_Deflate: deflateEnd failed\n");
3836 if(strm.total_out >= size)
3838 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3843 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3846 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3852 *deflated_size = (size_t)strm.total_out;
3854 memcpy(out, tmp, strm.total_out);
3860 static void AssertBufsize(sizebuf_t *buf, int length)
3862 if(buf->cursize + length > buf->maxsize)
3864 int oldsize = buf->maxsize;
3865 unsigned char *olddata;
3866 olddata = buf->data;
3867 buf->maxsize += length;
3868 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3871 memcpy(buf->data, olddata, oldsize);
3877 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3881 unsigned char *out = NULL;
3882 unsigned char tmp[2048];
3887 #ifndef LINK_TO_ZLIB
3892 memset(&outbuf, 0, sizeof(outbuf));
3893 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3894 outbuf.maxsize = sizeof(tmp);
3896 memset(&strm, 0, sizeof(strm));
3897 strm.zalloc = Z_NULL;
3898 strm.zfree = Z_NULL;
3899 strm.opaque = Z_NULL;
3901 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3903 Con_Printf("FS_Inflate: inflate init error!\n");
3904 Mem_Free(outbuf.data);
3908 strm.next_in = (unsigned char*)data;
3909 strm.avail_in = size;
3913 strm.next_out = tmp;
3914 strm.avail_out = sizeof(tmp);
3915 ret = qz_inflate(&strm, Z_NO_FLUSH);
3916 // it either returns Z_OK on progress, Z_STREAM_END on end
3924 case Z_STREAM_ERROR:
3925 Con_Print("FS_Inflate: stream error!\n");
3928 Con_Print("FS_Inflate: data error!\n");
3931 Con_Print("FS_Inflate: mem error!\n");
3934 Con_Print("FS_Inflate: buf error!\n");
3937 Con_Print("FS_Inflate: unknown error!\n");
3941 if(ret != Z_OK && ret != Z_STREAM_END)
3943 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3944 Mem_Free(outbuf.data);
3945 qz_inflateEnd(&strm);
3948 have = sizeof(tmp) - strm.avail_out;
3949 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3950 SZ_Write(&outbuf, tmp, have);
3951 } while(ret != Z_STREAM_END);
3953 qz_inflateEnd(&strm);
3955 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3958 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3959 Mem_Free(outbuf.data);
3963 memcpy(out, outbuf.data, outbuf.cursize);
3964 Mem_Free(outbuf.data);
3967 *inflated_size = (size_t)outbuf.cursize;