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
32 # include <sys/stat.h>
36 # include <sys/stat.h>
43 // include SDL for IPHONEOS code
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
68 // suppress deprecated warnings
73 # define unlink _unlink
77 /** \page fs File System
79 All of Quake's data access is through a hierchal file system, but the contents
80 of the file system can be transparently merged from several sources.
82 The "base directory" is the path to the directory holding the quake.exe and
83 all game directories. The sys_* files pass this to host_init in
84 quakeparms_t->basedir. This can be overridden with the "-basedir" command
85 line parm to allow code debugging in a different directory. The base
86 directory is only used during filesystem initialization.
88 The "game directory" is the first tree on the search path and directory that
89 all generated files (savegames, screenshots, demos, config files) will be
90 saved to. This can be overridden with the "-game" command line parameter.
91 The game directory can never be changed while quake is executing. This is a
92 precaution against having a malicious server instruct clients to write files
93 over areas they shouldn't.
99 =============================================================================
103 =============================================================================
106 // Magic numbers of a ZIP file (big-endian format)
107 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
108 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
109 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
111 // Other constants for ZIP files
112 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
113 #define ZIP_END_CDIR_SIZE 22
114 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
115 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
120 #define qz_inflate inflate
121 #define qz_inflateEnd inflateEnd
122 #define qz_inflateInit2_ inflateInit2_
123 #define qz_inflateReset inflateReset
124 #define qz_deflateInit2_ deflateInit2_
125 #define qz_deflateEnd deflateEnd
126 #define qz_deflate deflate
127 #define Z_MEMLEVEL_DEFAULT 8
130 // Zlib constants (from zlib.h)
131 #define Z_SYNC_FLUSH 2
134 #define Z_STREAM_END 1
135 #define Z_STREAM_ERROR (-2)
136 #define Z_DATA_ERROR (-3)
137 #define Z_MEM_ERROR (-4)
138 #define Z_BUF_ERROR (-5)
139 #define ZLIB_VERSION "1.2.3"
143 #define Z_MEMLEVEL_DEFAULT 8
146 #define Z_DEFAULT_COMPRESSION (-1)
148 #define Z_SYNC_FLUSH 2
149 #define Z_FULL_FLUSH 3
152 // Uncomment the following line if the zlib DLL you have still uses
153 // the 1.1.x series calling convention on Win32 (WINAPI)
154 //#define ZLIB_USES_WINAPI
158 =============================================================================
162 =============================================================================
165 /*! Zlib stream (from zlib.h)
166 * \warning: some pointers we don't use directly have
167 * been cast to "void*" for a matter of simplicity
171 unsigned char *next_in; ///< next input byte
172 unsigned int avail_in; ///< number of bytes available at next_in
173 unsigned long total_in; ///< total nb of input bytes read so far
175 unsigned char *next_out; ///< next output byte should be put there
176 unsigned int avail_out; ///< remaining free space at next_out
177 unsigned long total_out; ///< total nb of bytes output so far
179 char *msg; ///< last error message, NULL if no error
180 void *state; ///< not visible by applications
182 void *zalloc; ///< used to allocate the internal state
183 void *zfree; ///< used to free the internal state
184 void *opaque; ///< private data object passed to zalloc and zfree
186 int data_type; ///< best guess about the data type: ascii or binary
187 unsigned long adler; ///< adler32 value of the uncompressed data
188 unsigned long reserved; ///< reserved for future use
193 /// inside a package (PAK or PK3)
194 #define QFILE_FLAG_PACKED (1 << 0)
195 /// file is compressed using the deflate algorithm (PK3 only)
196 #define QFILE_FLAG_DEFLATED (1 << 1)
197 /// file is actually already loaded data
198 #define QFILE_FLAG_DATA (1 << 2)
199 /// real file will be removed on close
200 #define QFILE_FLAG_REMOVE (1 << 3)
202 #define FILE_BUFF_SIZE 2048
206 size_t comp_length; ///< length of the compressed file
207 size_t in_ind, in_len; ///< input buffer current index and length
208 size_t in_position; ///< position in the compressed file
209 unsigned char input [FILE_BUFF_SIZE];
215 int handle; ///< file descriptor
216 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
217 fs_offset_t position; ///< current position in the file
218 fs_offset_t offset; ///< offset into the package (0 if external file)
219 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
222 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
223 unsigned char buff [FILE_BUFF_SIZE];
225 ztoolkit_t* ztk; ///< For zipped files.
227 const unsigned char *data; ///< For data files.
229 const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
233 // ------ PK3 files on disk ------ //
235 // You can get the complete ZIP format description from PKWARE website
237 typedef struct pk3_endOfCentralDir_s
239 unsigned int signature;
240 unsigned short disknum;
241 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
242 unsigned short localentries; ///< number of entries in the central directory on this disk
243 unsigned short nbentries; ///< total number of entries in the central directory on this disk
244 unsigned int cdir_size; ///< size of the central directory
245 unsigned int cdir_offset; ///< with respect to the starting disk number
246 unsigned short comment_size;
247 fs_offset_t prepended_garbage;
248 } pk3_endOfCentralDir_t;
251 // ------ PAK files on disk ------ //
252 typedef struct dpackfile_s
255 int filepos, filelen;
258 typedef struct dpackheader_s
266 /*! \name Packages in memory
269 /// the offset in packfile_t is the true contents offset
270 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
271 /// file compressed using the deflate algorithm
272 #define PACKFILE_FLAG_DEFLATED (1 << 1)
273 /// file is a symbolic link
274 #define PACKFILE_FLAG_SYMLINK (1 << 2)
276 typedef struct packfile_s
278 char name [MAX_QPATH];
281 fs_offset_t packsize; ///< size in the package
282 fs_offset_t realsize; ///< real file size (uncompressed)
285 typedef struct pack_s
287 char filename [MAX_OSPATH];
288 char shortname [MAX_QPATH];
290 int ignorecase; ///< PK3 ignores case
297 /// Search paths for files (including packages)
298 typedef struct searchpath_s
300 // only one of filename / pack will be used
301 char filename[MAX_OSPATH];
303 struct searchpath_s *next;
308 =============================================================================
312 =============================================================================
317 void FS_Which_f(void);
319 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
320 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
321 fs_offset_t offset, fs_offset_t packsize,
322 fs_offset_t realsize, int flags);
326 =============================================================================
330 =============================================================================
333 mempool_t *fs_mempool;
334 void *fs_mutex = NULL;
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 static void PK3_CloseLibrary (void)
467 Sys_UnloadLibrary (&zlib_dll);
476 Try to load the Zlib DLL
479 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 = true; // PAK is sensitive in Quake1 but insensitive in Quake2
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 static 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);
1074 else if(!strcasecmp(ext, "obb")) // android apk expansion
1075 pak = FS_LoadPackPK3 (pakfile);
1077 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1081 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1083 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1086 // find the first item whose next one is a pack or NULL
1087 searchpath_t *insertion_point = 0;
1088 if(fs_searchpaths && !fs_searchpaths->pack)
1090 insertion_point = fs_searchpaths;
1093 if(!insertion_point->next)
1095 if(insertion_point->next->pack)
1097 insertion_point = insertion_point->next;
1100 // If insertion_point is NULL, this means that either there is no
1101 // item in the list yet, or that the very first item is a pack. In
1102 // that case, we want to insert at the beginning...
1103 if(!insertion_point)
1105 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1106 search->next = fs_searchpaths;
1107 fs_searchpaths = search;
1110 // otherwise we want to append directly after insertion_point.
1112 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1113 search->next = insertion_point->next;
1114 insertion_point->next = search;
1119 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1120 search->next = fs_searchpaths;
1121 fs_searchpaths = search;
1126 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1127 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1128 // same goes for the name inside the pack structure
1129 l = strlen(pak->shortname);
1131 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1132 pak->shortname[l - 3] = 0;
1133 l = strlen(pak->filename);
1135 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1136 pak->filename[l - 3] = 0;
1142 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1153 /*! Adds the given pack to the search path and searches for it in the game path.
1154 * The pack type is autodetected by the file extension.
1156 * Returns true if the file was successfully added to the
1157 * search path or if it was already included.
1159 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1160 * plain directories.
1162 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1164 char fullpath[MAX_OSPATH];
1166 searchpath_t *search;
1169 *already_loaded = false;
1171 // then find the real name...
1172 search = FS_FindFile(pakfile, &index, true);
1173 if(!search || search->pack)
1175 Con_Printf("could not find pak \"%s\"\n", pakfile);
1179 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1181 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1189 Sets fs_gamedir, adds the directory to the head of the path,
1190 then loads and adds pak1.pak pak2.pak ...
1193 static void FS_AddGameDirectory (const char *dir)
1197 searchpath_t *search;
1199 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1201 stringlistinit(&list);
1202 listdirectory(&list, "", dir);
1203 stringlistsort(&list, false);
1205 // add any PAK package in the directory
1206 for (i = 0;i < list.numstrings;i++)
1208 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1210 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1214 // add any PK3 package in the directory
1215 for (i = 0;i < list.numstrings;i++)
1217 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1219 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1223 stringlistfreecontents(&list);
1225 // Add the directory to the search path
1226 // (unpacked files have the priority over packed files)
1227 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1228 strlcpy (search->filename, dir, sizeof (search->filename));
1229 search->next = fs_searchpaths;
1230 fs_searchpaths = search;
1239 static void FS_AddGameHierarchy (const char *dir)
1242 // Add the common game directory
1243 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1246 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1255 const char *FS_FileExtension (const char *in)
1257 const char *separator, *backslash, *colon, *dot;
1259 separator = strrchr(in, '/');
1260 backslash = strrchr(in, '\\');
1261 if (!separator || separator < backslash)
1262 separator = backslash;
1263 colon = strrchr(in, ':');
1264 if (!separator || separator < colon)
1267 dot = strrchr(in, '.');
1268 if (dot == NULL || (separator && (dot < separator)))
1280 const char *FS_FileWithoutPath (const char *in)
1282 const char *separator, *backslash, *colon;
1284 separator = strrchr(in, '/');
1285 backslash = strrchr(in, '\\');
1286 if (!separator || separator < backslash)
1287 separator = backslash;
1288 colon = strrchr(in, ':');
1289 if (!separator || separator < colon)
1291 return separator ? separator + 1 : in;
1300 static void FS_ClearSearchPath (void)
1302 // unload all packs and directory information, close all pack files
1303 // (if a qfile is still reading a pack it won't be harmed because it used
1304 // dup() to get its own handle already)
1305 while (fs_searchpaths)
1307 searchpath_t *search = fs_searchpaths;
1308 fs_searchpaths = search->next;
1309 if (search->pack && search->pack != fs_selfpack)
1311 if(!search->pack->vpack)
1314 close(search->pack->handle);
1315 // free any memory associated with it
1316 if (search->pack->files)
1317 Mem_Free(search->pack->files);
1319 Mem_Free(search->pack);
1325 static void FS_AddSelfPack(void)
1329 searchpath_t *search;
1330 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1331 search->next = fs_searchpaths;
1332 search->pack = fs_selfpack;
1333 fs_searchpaths = search;
1343 void FS_Rescan (void)
1346 qboolean fs_modified = false;
1347 qboolean reset = false;
1348 char gamedirbuf[MAX_INPUTLINE];
1353 FS_ClearSearchPath();
1355 // automatically activate gamemode for the gamedirs specified
1357 COM_ChangeGameTypeForGameDirs();
1359 // add the game-specific paths
1360 // gamedirname1 (typically id1)
1361 FS_AddGameHierarchy (gamedirname1);
1362 // update the com_modname (used for server info)
1363 if (gamedirname2 && gamedirname2[0])
1364 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1366 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1368 // add the game-specific path, if any
1369 // (only used for mission packs and the like, which should set fs_modified)
1370 if (gamedirname2 && gamedirname2[0])
1373 FS_AddGameHierarchy (gamedirname2);
1377 // Adds basedir/gamedir as an override game
1378 // LordHavoc: now supports multiple -game directories
1379 // set the com_modname (reported in server info)
1381 for (i = 0;i < fs_numgamedirs;i++)
1384 FS_AddGameHierarchy (fs_gamedirs[i]);
1385 // update the com_modname (used server info)
1386 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1388 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1390 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1392 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1394 // add back the selfpack as new first item
1397 // set the default screenshot name to either the mod name or the
1398 // gamemode screenshot name
1399 if (strcmp(com_modname, gamedirname1))
1400 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1402 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1404 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1405 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1407 // If "-condebug" is in the command line, remove the previous log file
1408 if (COM_CheckParm ("-condebug") != 0)
1409 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1411 // look for the pop.lmp file and set registered to true if it is found
1412 if (FS_FileExists("gfx/pop.lmp"))
1413 Cvar_Set ("registered", "1");
1419 if (!registered.integer)
1422 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1424 Con_Print("Playing shareware version.\n");
1427 Con_Print("Playing registered version.\n");
1429 case GAME_STEELSTORM:
1430 if (registered.integer)
1431 Con_Print("Playing registered version.\n");
1433 Con_Print("Playing shareware version.\n");
1439 // unload all wads so that future queries will return the new data
1443 static void FS_Rescan_f(void)
1453 extern qboolean vid_opened;
1454 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1459 if (fs_numgamedirs == numgamedirs)
1461 for (i = 0;i < numgamedirs;i++)
1462 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1464 if (i == numgamedirs)
1465 return true; // already using this set of gamedirs, do nothing
1468 if (numgamedirs > MAX_GAMEDIRS)
1471 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1472 return false; // too many gamedirs
1475 for (i = 0;i < numgamedirs;i++)
1477 // if string is nasty, reject it
1478 p = FS_CheckGameDir(gamedirs[i]);
1482 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1483 return false; // nasty gamedirs
1485 if(p == fs_checkgamedir_missing && failmissing)
1488 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1489 return false; // missing gamedirs
1495 fs_numgamedirs = numgamedirs;
1496 for (i = 0;i < fs_numgamedirs;i++)
1497 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1499 // reinitialize filesystem to detect the new paks
1502 if (cls.demoplayback)
1508 // unload all sounds so they will be reloaded from the new files as needed
1509 S_UnloadAllSounds_f();
1511 // close down the video subsystem, it will start up again when the config finishes...
1515 // restart the video subsystem after the config is executed
1516 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1526 static void FS_GameDir_f (void)
1530 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1534 Con_Printf("gamedirs active:");
1535 for (i = 0;i < fs_numgamedirs;i++)
1536 Con_Printf(" %s", fs_gamedirs[i]);
1541 numgamedirs = Cmd_Argc() - 1;
1542 if (numgamedirs > MAX_GAMEDIRS)
1544 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1548 for (i = 0;i < numgamedirs;i++)
1549 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1551 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1553 // actually, changing during game would work fine, but would be stupid
1554 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1558 // halt demo playback to close the file
1561 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1564 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1572 stringlistinit(&list);
1573 listdirectory(&list, gamedir, "");
1574 success = list.numstrings > 0;
1575 stringlistfreecontents(&list);
1579 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1582 n = FS_Read (f, buf, buflength - 1);
1602 const char *FS_CheckGameDir(const char *gamedir)
1608 if (FS_CheckNastyPath(gamedir, true))
1611 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1616 // get description from basedir
1617 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1625 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1629 return fs_checkgamedir_missing;
1632 static void FS_ListGameDirs(void)
1634 stringlist_t list, list2;
1639 fs_all_gamedirs_count = 0;
1641 Mem_Free(fs_all_gamedirs);
1643 stringlistinit(&list);
1644 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1645 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1646 stringlistsort(&list, false);
1648 stringlistinit(&list2);
1649 for(i = 0; i < list.numstrings; ++i)
1652 if(!strcmp(list.strings[i-1], list.strings[i]))
1654 info = FS_CheckGameDir(list.strings[i]);
1657 if(info == fs_checkgamedir_missing)
1661 stringlistappend(&list2, list.strings[i]);
1663 stringlistfreecontents(&list);
1665 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1666 for(i = 0; i < list2.numstrings; ++i)
1668 info = FS_CheckGameDir(list2.strings[i]);
1669 // all this cannot happen any more, but better be safe than sorry
1672 if(info == fs_checkgamedir_missing)
1676 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1677 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1678 ++fs_all_gamedirs_count;
1684 #pragma comment(lib, "shell32.lib")
1694 void FS_Init_SelfPack (void)
1697 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1700 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1706 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1709 const char **new_argv;
1711 int args_left = 256;
1712 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1715 new_argv[0] = "dummy";
1720 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1723 while(COM_ParseToken_Console(&p))
1725 size_t sz = strlen(com_token) + 1; // shut up clang
1728 q = (char *)Mem_Alloc(fs_mempool, sz);
1729 strlcpy(q, com_token, sz);
1730 new_argv[com_argc + i] = q;
1733 new_argv[i+com_argc] = NULL;
1734 com_argv = new_argv;
1735 com_argc = com_argc + i;
1742 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1744 #if defined(__IPHONEOS__)
1745 if (userdirmode == USERDIRMODE_HOME)
1747 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1748 // fs_userdir stores configurations to the Documents folder of the app
1749 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1754 #elif defined(WIN32)
1756 #if _MSC_VER >= 1400
1759 TCHAR mydocsdir[MAX_PATH + 1];
1760 wchar_t *savedgamesdirw;
1761 char savedgamesdir[MAX_OSPATH];
1770 case USERDIRMODE_NOHOME:
1771 strlcpy(userdir, fs_basedir, userdirsize);
1773 case USERDIRMODE_MYGAMES:
1775 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1777 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1779 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1782 #if _MSC_VER >= 1400
1783 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1786 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1791 homedir = getenv("USERPROFILE");
1794 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1799 case USERDIRMODE_SAVEDGAMES:
1801 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1803 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1804 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1806 savedgamesdir[0] = 0;
1807 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1810 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1812 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1815 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1817 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1818 #if _MSC_VER >= 1400
1819 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1821 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1823 qCoTaskMemFree(savedgamesdirw);
1826 if (savedgamesdir[0])
1828 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1843 case USERDIRMODE_NOHOME:
1844 strlcpy(userdir, fs_basedir, userdirsize);
1846 case USERDIRMODE_HOME:
1847 homedir = getenv("HOME");
1850 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1854 case USERDIRMODE_SAVEDGAMES:
1855 homedir = getenv("HOME");
1859 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1861 // the XDG say some files would need to go in:
1862 // XDG_CONFIG_HOME (or ~/.config/%s/)
1863 // XDG_DATA_HOME (or ~/.local/share/%s/)
1864 // XDG_CACHE_HOME (or ~/.cache/%s/)
1865 // and also search the following global locations if defined:
1866 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1867 // XDG_DATA_DIRS (normally /usr/share/%s/)
1868 // this would be too complicated...
1878 #if !defined(__IPHONEOS__)
1881 // historical behavior...
1882 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1883 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
1886 // see if we can write to this path (note: won't create path)
1888 // no access() here, we must try to open the file for appending
1889 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1893 // on Unix, we don't need to ACTUALLY attempt to open the file
1894 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1901 return 1; // good choice - the path exists and is writable
1905 if (userdirmode == USERDIRMODE_NOHOME)
1906 return -1; // path usually already exists, we lack permissions
1908 return 0; // probably good - failed to write but maybe we need to create path
1928 // Overrides the system supplied base directory (under GAMENAME)
1929 // 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)
1930 i = COM_CheckParm ("-basedir");
1931 if (i && i < com_argc-1)
1933 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1934 i = (int)strlen (fs_basedir);
1935 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1936 fs_basedir[i-1] = 0;
1940 // If the base directory is explicitly defined by the compilation process
1941 #ifdef DP_FS_BASEDIR
1942 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1943 #elif defined(__ANDROID__)
1944 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
1945 #elif defined(MACOSX)
1946 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1947 if (strstr(com_argv[0], ".app/"))
1950 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1951 split = strstr(fs_basedir, ".app/");
1954 struct stat statresult;
1956 // truncate to just after the .app/
1958 // see if gamedir exists in Resources
1959 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1961 // found gamedir inside Resources, use it
1962 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1966 // no gamedir found in Resources, gamedir is probably
1967 // outside the .app, remove .app part of path
1968 while (split > fs_basedir && *split != '/')
1977 // make sure the appending of a path separator won't create an unterminated string
1978 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1979 // add a path separator to the end of the basedir if it lacks one
1980 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1981 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1983 // Add the personal game directory
1984 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1985 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1986 else if (COM_CheckParm("-nohome"))
1987 *fs_userdir = 0; // user wants roaming installation, no userdir
1991 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1992 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1993 int userdirstatus[USERDIRMODE_COUNT];
1995 // historical behavior...
1996 if (!strcmp(gamedirname1, "id1"))
1997 preferreduserdirmode = USERDIRMODE_NOHOME;
1999 // check what limitations the user wants to impose
2000 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2001 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2002 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2003 // gather the status of the possible userdirs
2004 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2006 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2007 if (userdirstatus[dirmode] == 1)
2008 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2009 else if (userdirstatus[dirmode] == 0)
2010 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2012 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2014 // some games may prefer writing to basedir, but if write fails we
2015 // have to search for a real userdir...
2016 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2017 preferreduserdirmode = highestuserdirmode;
2018 // check for an existing userdir and continue using it if possible...
2019 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2020 if (userdirstatus[dirmode] == 1)
2022 // if no existing userdir found, make a new one...
2023 if (dirmode == 0 && preferreduserdirmode > 0)
2024 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2025 if (userdirstatus[dirmode] >= 0)
2027 // and finally, we picked one...
2028 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2029 Con_DPrintf("userdir %i is the winner\n", dirmode);
2032 // if userdir equal to basedir, clear it to avoid confusion later
2033 if (!strcmp(fs_basedir, fs_userdir))
2038 p = FS_CheckGameDir(gamedirname1);
2039 if(!p || p == fs_checkgamedir_missing)
2040 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2044 p = FS_CheckGameDir(gamedirname2);
2045 if(!p || p == fs_checkgamedir_missing)
2046 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2050 // Adds basedir/gamedir as an override game
2051 // LordHavoc: now supports multiple -game directories
2052 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2056 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2059 p = FS_CheckGameDir(com_argv[i]);
2061 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2062 if(p == fs_checkgamedir_missing)
2063 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2064 // add the gamedir to the list of active gamedirs
2065 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2070 // generate the searchpath
2073 if (Thread_HasThreads())
2074 fs_mutex = Thread_CreateMutex();
2077 void FS_Init_Commands(void)
2079 Cvar_RegisterVariable (&scr_screenshot_name);
2080 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2081 Cvar_RegisterVariable (&cvar_fs_gamedir);
2083 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2084 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2085 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2086 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2087 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2088 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2096 void FS_Shutdown (void)
2098 // close all pack files and such
2099 // (hopefully there aren't any other open files, but they'll be cleaned up
2100 // by the OS anyway)
2101 FS_ClearSearchPath();
2102 Mem_FreePool (&fs_mempool);
2103 PK3_CloseLibrary ();
2106 Sys_UnloadLibrary (&shfolder_dll);
2107 Sys_UnloadLibrary (&shell32_dll);
2108 Sys_UnloadLibrary (&ole32_dll);
2112 Thread_DestroyMutex(fs_mutex);
2115 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2120 qboolean dolock = false;
2122 // Parse the mode string
2131 opt = O_CREAT | O_TRUNC;
2135 opt = O_CREAT | O_APPEND;
2138 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2141 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(COM_CheckParm("-readonly") && mod != O_RDONLY)
2167 # if _MSC_VER >= 1400
2168 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2170 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2173 handle = open (filepath, mod | opt, 0666);
2174 if(handle >= 0 && dolock)
2177 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2178 l.l_whence = SEEK_SET;
2181 if(fcntl(handle, F_SETLK, &l) == -1)
2193 ====================
2196 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2197 ====================
2199 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2203 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2205 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2206 if (file->handle < 0)
2212 file->filename = Mem_strdup(fs_mempool, filepath);
2214 file->real_length = lseek (file->handle, 0, SEEK_END);
2216 // For files opened in append mode, we start at the end of the file
2218 file->position = file->real_length;
2220 lseek (file->handle, 0, SEEK_SET);
2230 Open a packed file using its package file descriptor
2233 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2239 pfile = &pack->files[pack_ind];
2241 // If we don't have the true offset, get it now
2242 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2243 if (!PK3_GetTrueFileOffset (pfile, pack))
2246 #ifndef LINK_TO_ZLIB
2247 // No Zlib DLL = no compressed files
2248 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2250 Con_Printf("WARNING: can't open the compressed file %s\n"
2251 "You need the Zlib DLL to use compressed files\n",
2257 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2258 // the dup() call to avoid having to close the dup_handle on error here
2259 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2261 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2262 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2266 dup_handle = dup (pack->handle);
2269 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2273 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2274 memset (file, 0, sizeof (*file));
2275 file->handle = dup_handle;
2276 file->flags = QFILE_FLAG_PACKED;
2277 file->real_length = pfile->realsize;
2278 file->offset = pfile->offset;
2282 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2286 file->flags |= QFILE_FLAG_DEFLATED;
2288 // We need some more variables
2289 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2291 ztk->comp_length = pfile->packsize;
2293 // Initialize zlib stream
2294 ztk->zstream.next_in = ztk->input;
2295 ztk->zstream.avail_in = 0;
2297 /* From Zlib's "unzip.c":
2299 * windowBits is passed < 0 to tell that there is no zlib header.
2300 * Note that in this case inflate *requires* an extra "dummy" byte
2301 * after the compressed stream in order to complete decompression and
2302 * return Z_STREAM_END.
2303 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2304 * size of both compressed and uncompressed data
2306 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2308 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2314 ztk->zstream.next_out = file->buff;
2315 ztk->zstream.avail_out = sizeof (file->buff);
2324 ====================
2327 Return true if the path should be rejected due to one of the following:
2328 1: path elements that are non-portable
2329 2: path elements that would allow access to files outside the game directory,
2330 or are just not a good idea for a mod to be using.
2331 ====================
2333 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2335 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2339 // Windows: don't allow \ in filenames (windows-only), period.
2340 // (on Windows \ is a directory separator, but / is also supported)
2341 if (strstr(path, "\\"))
2342 return 1; // non-portable
2344 // Mac: don't allow Mac-only filenames - : is a directory separator
2345 // instead of /, but we rely on / working already, so there's no reason to
2346 // support a Mac-only path
2347 // Amiga and Windows: : tries to go to root of drive
2348 if (strstr(path, ":"))
2349 return 1; // non-portable attempt to go to root of drive
2351 // Amiga: // is parent directory
2352 if (strstr(path, "//"))
2353 return 1; // non-portable attempt to go to parent directory
2355 // all: don't allow going to parent directory (../ or /../)
2356 if (strstr(path, ".."))
2357 return 2; // attempt to go outside the game directory
2359 // Windows and UNIXes: don't allow absolute paths
2361 return 2; // attempt to go outside the game directory
2363 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2364 if (strstr(path, "./"))
2365 return 2; // possible attempt to go outside the game directory
2367 // all: forbid trailing slash on gamedir
2368 if (isgamedir && path[strlen(path)-1] == '/')
2371 // all: forbid leading dot on any filename for any reason
2372 if (strstr(path, "/."))
2373 return 2; // attempt to go outside the game directory
2375 // after all these checks we're pretty sure it's a / separated filename
2376 // and won't do much if any harm
2382 ====================
2385 Look for a file in the packages and in the filesystem
2387 Return the searchpath where the file was found (or NULL)
2388 and the file index in the package if relevant
2389 ====================
2391 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2393 searchpath_t *search;
2396 // search through the path, one element at a time
2397 for (search = fs_searchpaths;search;search = search->next)
2399 // is the element a pak file?
2400 if (search->pack && !search->pack->vpack)
2402 int (*strcmp_funct) (const char* str1, const char* str2);
2403 int left, right, middle;
2406 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2408 // Look for the file (binary search)
2410 right = pak->numfiles - 1;
2411 while (left <= right)
2415 middle = (left + right) / 2;
2416 diff = strcmp_funct (pak->files[middle].name, name);
2421 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2423 // yes, but the first one is empty so we treat it as not being there
2424 if (!quiet && developer_extra.integer)
2425 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2432 if (!quiet && developer_extra.integer)
2433 Con_DPrintf("FS_FindFile: %s in %s\n",
2434 pak->files[middle].name, pak->filename);
2441 // If we're too far in the list
2450 char netpath[MAX_OSPATH];
2451 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2452 if (FS_SysFileExists (netpath))
2454 if (!quiet && developer_extra.integer)
2455 Con_DPrintf("FS_FindFile: %s\n", netpath);
2464 if (!quiet && developer_extra.integer)
2465 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2477 Look for a file in the search paths and open it in read-only mode
2480 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2482 searchpath_t *search;
2485 search = FS_FindFile (filename, &pack_ind, quiet);
2491 // Found in the filesystem?
2494 // this works with vpacks, so we are fine
2495 char path [MAX_OSPATH];
2496 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2497 return FS_SysOpen (path, "rb", nonblocking);
2500 // So, we found it in a package...
2502 // Is it a PK3 symlink?
2503 // TODO also handle directory symlinks by parsing the whole structure...
2504 // but heck, file symlinks are good enough for now
2505 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2507 if(symlinkLevels <= 0)
2509 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2514 char linkbuf[MAX_QPATH];
2516 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2517 const char *mergeslash;
2522 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2528 // Now combine the paths...
2529 mergeslash = strrchr(filename, '/');
2530 mergestart = linkbuf;
2532 mergeslash = filename;
2533 while(!strncmp(mergestart, "../", 3))
2536 while(mergeslash > filename)
2539 if(*mergeslash == '/')
2543 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2544 if(mergeslash == filename)
2546 // Either mergeslash == filename, then we just replace the name (done below)
2550 // Or, we append the name after mergeslash;
2551 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2552 int spaceNeeded = mergeslash - filename + 1;
2553 int spaceRemoved = mergestart - linkbuf;
2554 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2556 Con_DPrintf("symlink: too long path rejected\n");
2559 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2560 memcpy(linkbuf, filename, spaceNeeded);
2561 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2562 mergestart = linkbuf;
2564 if (!quiet && developer_loading.integer)
2565 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2566 if(FS_CheckNastyPath (mergestart, false))
2568 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2571 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2575 return FS_OpenPackedFile (search->pack, pack_ind);
2580 =============================================================================
2582 MAIN PUBLIC FUNCTIONS
2584 =============================================================================
2588 ====================
2591 Open a file in the userpath. The syntax is the same as fopen
2592 Used for savegame scanning in menu, and all file writing.
2593 ====================
2595 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2597 char real_path [MAX_OSPATH];
2599 if (FS_CheckNastyPath(filepath, false))
2601 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2605 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2607 // If the file is opened in "write", "append", or "read/write" mode,
2608 // create directories up to the file.
2609 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2610 FS_CreatePath (real_path);
2611 return FS_SysOpen (real_path, mode, false);
2616 ====================
2619 Open a file. The syntax is the same as fopen
2620 ====================
2622 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2624 qfile_t *result = NULL;
2625 if (FS_CheckNastyPath(filepath, false))
2627 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2631 if (fs_mutex) Thread_LockMutex(fs_mutex);
2632 result = FS_OpenReadFile (filepath, quiet, false, 16);
2633 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2639 ====================
2642 Open a file. The syntax is the same as fopen
2643 ====================
2645 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2648 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2649 memset (file, 0, sizeof (*file));
2650 file->flags = QFILE_FLAG_DATA;
2652 file->real_length = size;
2658 ====================
2662 ====================
2664 int FS_Close (qfile_t* file)
2666 if(file->flags & QFILE_FLAG_DATA)
2672 if (close (file->handle))
2677 if (file->flags & QFILE_FLAG_REMOVE)
2678 remove(file->filename);
2680 Mem_Free((void *) file->filename);
2685 qz_inflateEnd (&file->ztk->zstream);
2686 Mem_Free (file->ztk);
2693 void FS_RemoveOnClose(qfile_t* file)
2695 file->flags |= QFILE_FLAG_REMOVE;
2699 ====================
2702 Write "datasize" bytes into a file
2703 ====================
2705 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2707 fs_offset_t written = 0;
2709 // If necessary, seek to the exact file position we're supposed to be
2710 if (file->buff_ind != file->buff_len)
2711 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2713 // Purge cached data
2716 // Write the buffer and update the position
2717 // LordHavoc: to hush a warning about passing size_t to an unsigned int parameter on Win64 we do this as multiple writes if the size would be too big for an integer (we never write that big in one go, but it's a theory)
2718 while (written < (fs_offset_t)datasize)
2720 // figure out how much to write in one chunk
2721 fs_offset_t maxchunk = 1<<30; // 1 GiB
2722 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2723 int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
2724 // if at least some was written, add it to our accumulator
2727 // if the result is not what we expected, consider the write to be incomplete
2728 if (result != chunk)
2731 file->position = lseek (file->handle, 0, SEEK_CUR);
2732 if (file->real_length < file->position)
2733 file->real_length = file->position;
2735 // note that this will never be less than 0 even if the write failed
2741 ====================
2744 Read up to "buffersize" bytes from a file
2745 ====================
2747 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2749 fs_offset_t count, done;
2751 if (buffersize == 0)
2754 // Get rid of the ungetc character
2755 if (file->ungetc != EOF)
2757 ((char*)buffer)[0] = file->ungetc;
2765 if(file->flags & QFILE_FLAG_DATA)
2767 size_t left = file->real_length - file->position;
2768 if(buffersize > left)
2770 memcpy(buffer, file->data + file->position, buffersize);
2771 file->position += buffersize;
2775 // First, we copy as many bytes as we can from "buff"
2776 if (file->buff_ind < file->buff_len)
2778 count = file->buff_len - file->buff_ind;
2779 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2781 memcpy (buffer, &file->buff[file->buff_ind], count);
2782 file->buff_ind += count;
2784 buffersize -= count;
2785 if (buffersize == 0)
2789 // NOTE: at this point, the read buffer is always empty
2791 // If the file isn't compressed
2792 if (! (file->flags & QFILE_FLAG_DEFLATED))
2796 // We must take care to not read after the end of the file
2797 count = file->real_length - file->position;
2799 // If we have a lot of data to get, put them directly into "buffer"
2800 if (buffersize > sizeof (file->buff) / 2)
2802 if (count > (fs_offset_t)buffersize)
2803 count = (fs_offset_t)buffersize;
2804 lseek (file->handle, file->offset + file->position, SEEK_SET);
2805 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2809 file->position += nb;
2811 // Purge cached data
2817 if (count > (fs_offset_t)sizeof (file->buff))
2818 count = (fs_offset_t)sizeof (file->buff);
2819 lseek (file->handle, file->offset + file->position, SEEK_SET);
2820 nb = read (file->handle, file->buff, count);
2823 file->buff_len = nb;
2824 file->position += nb;
2826 // Copy the requested data in "buffer" (as much as we can)
2827 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2828 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2829 file->buff_ind = count;
2837 // If the file is compressed, it's more complicated...
2838 // We cycle through a few operations until we have read enough data
2839 while (buffersize > 0)
2841 ztoolkit_t *ztk = file->ztk;
2844 // NOTE: at this point, the read buffer is always empty
2846 // If "input" is also empty, we need to refill it
2847 if (ztk->in_ind == ztk->in_len)
2849 // If we are at the end of the file
2850 if (file->position == file->real_length)
2853 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2854 if (count > (fs_offset_t)sizeof (ztk->input))
2855 count = (fs_offset_t)sizeof (ztk->input);
2856 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2857 if (read (file->handle, ztk->input, count) != count)
2859 Con_Printf ("FS_Read: unexpected end of file\n");
2864 ztk->in_len = count;
2865 ztk->in_position += count;
2868 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2869 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2871 // Now that we are sure we have compressed data available, we need to determine
2872 // if it's better to inflate it in "file->buff" or directly in "buffer"
2874 // Inflate the data in "file->buff"
2875 if (buffersize < sizeof (file->buff) / 2)
2877 ztk->zstream.next_out = file->buff;
2878 ztk->zstream.avail_out = sizeof (file->buff);
2879 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2880 if (error != Z_OK && error != Z_STREAM_END)
2882 Con_Printf ("FS_Read: Can't inflate file\n");
2885 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2887 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2888 file->position += file->buff_len;
2890 // Copy the requested data in "buffer" (as much as we can)
2891 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2892 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2893 file->buff_ind = count;
2896 // Else, we inflate directly in "buffer"
2899 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2900 ztk->zstream.avail_out = (unsigned int)buffersize;
2901 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2902 if (error != Z_OK && error != Z_STREAM_END)
2904 Con_Printf ("FS_Read: Can't inflate file\n");
2907 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2909 // How much data did it inflate?
2910 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2911 file->position += count;
2913 // Purge cached data
2918 buffersize -= count;
2926 ====================
2929 Print a string into a file
2930 ====================
2932 int FS_Print (qfile_t* file, const char *msg)
2934 return (int)FS_Write (file, msg, strlen (msg));
2938 ====================
2941 Print a string into a file
2942 ====================
2944 int FS_Printf(qfile_t* file, const char* format, ...)
2949 va_start (args, format);
2950 result = FS_VPrintf (file, format, args);
2958 ====================
2961 Print a string into a file
2962 ====================
2964 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2967 fs_offset_t buff_size = MAX_INPUTLINE;
2972 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2973 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2974 if (len >= 0 && len < buff_size)
2976 Mem_Free (tempbuff);
2980 len = write (file->handle, tempbuff, len);
2981 Mem_Free (tempbuff);
2988 ====================
2991 Get the next character of a file
2992 ====================
2994 int FS_Getc (qfile_t* file)
2998 if (FS_Read (file, &c, 1) != 1)
3006 ====================
3009 Put a character back into the read buffer (only supports one character!)
3010 ====================
3012 int FS_UnGetc (qfile_t* file, unsigned char c)
3014 // If there's already a character waiting to be read
3015 if (file->ungetc != EOF)
3024 ====================
3027 Move the position index in a file
3028 ====================
3030 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3033 unsigned char* buffer;
3034 fs_offset_t buffersize;
3036 // Compute the file offset
3040 offset += file->position - file->buff_len + file->buff_ind;
3047 offset += file->real_length;
3053 if (offset < 0 || offset > file->real_length)
3056 if(file->flags & QFILE_FLAG_DATA)
3058 file->position = offset;
3062 // If we have the data in our read buffer, we don't need to actually seek
3063 if (file->position - file->buff_len <= offset && offset <= file->position)
3065 file->buff_ind = offset + file->buff_len - file->position;
3069 // Purge cached data
3072 // Unpacked or uncompressed files can seek directly
3073 if (! (file->flags & QFILE_FLAG_DEFLATED))
3075 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3077 file->position = offset;
3081 // Seeking in compressed files is more a hack than anything else,
3082 // but we need to support it, so here we go.
3085 // If we have to go back in the file, we need to restart from the beginning
3086 if (offset <= file->position)
3090 ztk->in_position = 0;
3092 lseek (file->handle, file->offset, SEEK_SET);
3094 // Reset the Zlib stream
3095 ztk->zstream.next_in = ztk->input;
3096 ztk->zstream.avail_in = 0;
3097 qz_inflateReset (&ztk->zstream);
3100 // We need a big buffer to force inflating into it directly
3101 buffersize = 2 * sizeof (file->buff);
3102 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3104 // Skip all data until we reach the requested offset
3105 while (offset > file->position)
3107 fs_offset_t diff = offset - file->position;
3108 fs_offset_t count, len;
3110 count = (diff > buffersize) ? buffersize : diff;
3111 len = FS_Read (file, buffer, count);
3125 ====================
3128 Give the current position in a file
3129 ====================
3131 fs_offset_t FS_Tell (qfile_t* file)
3133 return file->position - file->buff_len + file->buff_ind;
3138 ====================
3141 Give the total size of a file
3142 ====================
3144 fs_offset_t FS_FileSize (qfile_t* file)
3146 return file->real_length;
3151 ====================
3154 Erases any buffered input or output data
3155 ====================
3157 void FS_Purge (qfile_t* file)
3169 Filename are relative to the quake directory.
3170 Always appends a 0 byte.
3173 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3176 unsigned char *buf = NULL;
3177 fs_offset_t filesize = 0;
3179 file = FS_OpenVirtualFile(path, quiet);
3182 filesize = file->real_length;
3185 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3190 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3191 buf[filesize] = '\0';
3192 FS_Read (file, buf, filesize);
3194 if (developer_loadfile.integer)
3195 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3198 if (filesizepointer)
3199 *filesizepointer = filesize;
3208 The filename will be prefixed by the current game directory
3211 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3215 fs_offset_t lentotal;
3217 file = FS_OpenRealFile(filename, "wb", false);
3220 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3225 for(i = 0; i < count; ++i)
3227 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3228 for(i = 0; i < count; ++i)
3229 FS_Write (file, data[i], len[i]);
3234 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3236 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3241 =============================================================================
3243 OTHERS PUBLIC FUNCTIONS
3245 =============================================================================
3253 void FS_StripExtension (const char *in, char *out, size_t size_out)
3261 while ((currentchar = *in) && size_out > 1)
3263 if (currentchar == '.')
3265 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3267 *out++ = currentchar;
3283 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3287 // if path doesn't have a .EXT, append extension
3288 // (extension should include the .)
3289 src = path + strlen(path) - 1;
3291 while (*src != '/' && src != path)
3294 return; // it has an extension
3298 strlcat (path, extension, size_path);
3306 Look for a file in the packages and in the filesystem
3309 int FS_FileType (const char *filename)
3311 searchpath_t *search;
3312 char fullpath[MAX_OSPATH];
3314 search = FS_FindFile (filename, NULL, true);
3316 return FS_FILETYPE_NONE;
3318 if(search->pack && !search->pack->vpack)
3319 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3321 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3322 return FS_SysFileType(fullpath);
3330 Look for a file in the packages and in the filesystem
3333 qboolean FS_FileExists (const char *filename)
3335 return (FS_FindFile (filename, NULL, true) != NULL);
3343 Look for a file in the filesystem only
3346 int FS_SysFileType (const char *path)
3349 // Sajt - some older sdks are missing this define
3350 # ifndef INVALID_FILE_ATTRIBUTES
3351 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3354 DWORD result = GetFileAttributes(path);
3356 if(result == INVALID_FILE_ATTRIBUTES)
3357 return FS_FILETYPE_NONE;
3359 if(result & FILE_ATTRIBUTE_DIRECTORY)
3360 return FS_FILETYPE_DIRECTORY;
3362 return FS_FILETYPE_FILE;
3366 if (stat (path,&buf) == -1)
3367 return FS_FILETYPE_NONE;
3370 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3372 if(S_ISDIR(buf.st_mode))
3373 return FS_FILETYPE_DIRECTORY;
3375 return FS_FILETYPE_FILE;
3379 qboolean FS_SysFileExists (const char *path)
3381 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3384 void FS_mkdir (const char *path)
3386 if(COM_CheckParm("-readonly"))
3400 Allocate and fill a search structure with information on matching filenames.
3403 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3406 searchpath_t *searchpath;
3408 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3409 stringlist_t resultlist;
3410 stringlist_t dirlist;
3411 const char *slash, *backslash, *colon, *separator;
3413 char temp[MAX_OSPATH];
3415 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3420 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3424 stringlistinit(&resultlist);
3425 stringlistinit(&dirlist);
3427 slash = strrchr(pattern, '/');
3428 backslash = strrchr(pattern, '\\');
3429 colon = strrchr(pattern, ':');
3430 separator = max(slash, backslash);
3431 separator = max(separator, colon);
3432 basepathlength = separator ? (separator + 1 - pattern) : 0;
3433 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3435 memcpy(basepath, pattern, basepathlength);
3436 basepath[basepathlength] = 0;
3438 // search through the path, one element at a time
3439 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3441 // is the element a pak file?
3442 if (searchpath->pack && !searchpath->pack->vpack)
3444 // look through all the pak file elements
3445 pak = searchpath->pack;
3446 for (i = 0;i < pak->numfiles;i++)
3448 strlcpy(temp, pak->files[i].name, sizeof(temp));
3451 if (matchpattern(temp, (char *)pattern, true))
3453 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3454 if (!strcmp(resultlist.strings[resultlistindex], temp))
3456 if (resultlistindex == resultlist.numstrings)
3458 stringlistappend(&resultlist, temp);
3459 if (!quiet && developer_loading.integer)
3460 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3463 // strip off one path element at a time until empty
3464 // this way directories are added to the listing if they match the pattern
3465 slash = strrchr(temp, '/');
3466 backslash = strrchr(temp, '\\');
3467 colon = strrchr(temp, ':');
3469 if (separator < slash)
3471 if (separator < backslash)
3472 separator = backslash;
3473 if (separator < colon)
3475 *((char *)separator) = 0;
3481 stringlist_t matchedSet, foundSet;
3482 const char *start = pattern;
3484 stringlistinit(&matchedSet);
3485 stringlistinit(&foundSet);
3486 // add a first entry to the set
3487 stringlistappend(&matchedSet, "");
3488 // iterate through pattern's path
3491 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3492 char subpath[MAX_OSPATH];
3493 char subpattern[MAX_OSPATH];
3495 // find the next wildcard
3496 wildcard = strchr(start, '?');
3497 asterisk = strchr(start, '*');
3498 if (asterisk && (!wildcard || asterisk < wildcard))
3500 wildcard = asterisk;
3505 nextseparator = strchr( wildcard, '/' );
3509 nextseparator = NULL;
3512 if( !nextseparator ) {
3513 nextseparator = start + strlen( start );
3516 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3517 // copy everything up except nextseperator
3518 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3519 // find the last '/' before the wildcard
3520 prevseparator = strrchr( subpattern, '/' );
3522 prevseparator = subpattern;
3525 // copy everything from start to the previous including the '/' (before the wildcard)
3526 // everything up to start is already included in the path of matchedSet's entries
3527 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3529 // for each entry in matchedSet try to open the subdirectories specified in subpath
3530 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3531 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3532 strlcat( temp, subpath, sizeof(temp) );
3533 listdirectory( &foundSet, searchpath->filename, temp );
3535 if( dirlistindex == 0 ) {
3538 // reset the current result set
3539 stringlistfreecontents( &matchedSet );
3540 // match against the pattern
3541 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3542 const char *direntry = foundSet.strings[ dirlistindex ];
3543 if (matchpattern(direntry, subpattern, true)) {
3544 stringlistappend( &matchedSet, direntry );
3547 stringlistfreecontents( &foundSet );
3549 start = nextseparator;
3552 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3554 const char *temp = matchedSet.strings[dirlistindex];
3555 if (matchpattern(temp, (char *)pattern, true))
3557 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3558 if (!strcmp(resultlist.strings[resultlistindex], temp))
3560 if (resultlistindex == resultlist.numstrings)
3562 stringlistappend(&resultlist, temp);
3563 if (!quiet && developer_loading.integer)
3564 Con_Printf("SearchDirFile: %s\n", temp);
3568 stringlistfreecontents( &matchedSet );
3572 if (resultlist.numstrings)
3574 stringlistsort(&resultlist, true);
3575 numfiles = resultlist.numstrings;
3577 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3578 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3579 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3580 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3581 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3582 search->numfilenames = (int)numfiles;
3585 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3588 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3589 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3590 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3592 numchars += (int)textlen;
3595 stringlistfreecontents(&resultlist);
3601 void FS_FreeSearch(fssearch_t *search)
3606 extern int con_linewidth;
3607 static int FS_ListDirectory(const char *pattern, int oneperline)
3616 char linebuf[MAX_INPUTLINE];
3618 search = FS_Search(pattern, true, true);
3621 numfiles = search->numfilenames;
3624 // FIXME: the names could be added to one column list and then
3625 // gradually shifted into the next column if they fit, and then the
3626 // next to make a compact variable width listing but it's a lot more
3628 // find width for columns
3630 for (i = 0;i < numfiles;i++)
3632 l = (int)strlen(search->filenames[i]);
3633 if (columnwidth < l)
3636 // count the spacing character
3638 // calculate number of columns
3639 numcolumns = con_linewidth / columnwidth;
3640 // don't bother with the column printing if it's only one column
3641 if (numcolumns >= 2)
3643 numlines = (numfiles + numcolumns - 1) / numcolumns;
3644 for (i = 0;i < numlines;i++)
3647 for (k = 0;k < numcolumns;k++)
3649 l = i * numcolumns + k;
3652 name = search->filenames[l];
3653 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3654 linebuf[linebufpos++] = name[j];
3655 // space out name unless it's the last on the line
3656 if (k + 1 < numcolumns && l + 1 < numfiles)
3657 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3658 linebuf[linebufpos++] = ' ';
3661 linebuf[linebufpos] = 0;
3662 Con_Printf("%s\n", linebuf);
3669 for (i = 0;i < numfiles;i++)
3670 Con_Printf("%s\n", search->filenames[i]);
3671 FS_FreeSearch(search);
3672 return (int)numfiles;
3675 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3677 const char *pattern;
3678 if (Cmd_Argc() >= 3)
3680 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3683 if (Cmd_Argc() == 2)
3684 pattern = Cmd_Argv(1);
3687 if (!FS_ListDirectory(pattern, oneperline))
3688 Con_Print("No files found.\n");
3693 FS_ListDirectoryCmd("dir", true);
3698 FS_ListDirectoryCmd("ls", false);
3701 void FS_Which_f(void)
3703 const char *filename;
3706 if (Cmd_Argc() != 2)
3708 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3711 filename = Cmd_Argv(1);
3712 sp = FS_FindFile(filename, &index, true);
3714 Con_Printf("%s isn't anywhere\n", filename);
3720 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3722 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3725 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3729 const char *FS_WhichPack(const char *filename)
3732 searchpath_t *sp = FS_FindFile(filename, &index, true);
3734 return sp->pack->shortname;
3742 ====================
3743 FS_IsRegisteredQuakePack
3745 Look for a proof of purchase file file in the requested package
3747 If it is found, this file should NOT be downloaded.
3748 ====================
3750 qboolean FS_IsRegisteredQuakePack(const char *name)
3752 searchpath_t *search;
3755 // search through the path, one element at a time
3756 for (search = fs_searchpaths;search;search = search->next)
3758 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3759 // TODO do we want to support vpacks in here too?
3761 int (*strcmp_funct) (const char* str1, const char* str2);
3762 int left, right, middle;
3765 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3767 // Look for the file (binary search)
3769 right = pak->numfiles - 1;
3770 while (left <= right)
3774 middle = (left + right) / 2;
3775 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3781 // If we're too far in the list
3788 // we found the requested pack but it is not registered quake
3796 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3799 unsigned char *filedata;
3800 fs_offset_t filesize;
3801 if (filesizepointer)
3802 *filesizepointer = 0;
3803 if (!filename || !*filename)
3805 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3808 if (filesizepointer)
3809 *filesizepointer = filesize;
3810 crc = CRC_Block(filedata, filesize);
3816 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3819 unsigned char *out = NULL;
3823 #ifndef LINK_TO_ZLIB
3828 memset(&strm, 0, sizeof(strm));
3829 strm.zalloc = Z_NULL;
3830 strm.zfree = Z_NULL;
3831 strm.opaque = Z_NULL;
3834 level = Z_DEFAULT_COMPRESSION;
3836 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3838 Con_Printf("FS_Deflate: deflate init error!\n");
3842 strm.next_in = (unsigned char*)data;
3843 strm.avail_in = (unsigned int)size;
3845 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3848 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3849 qz_deflateEnd(&strm);
3853 strm.next_out = tmp;
3854 strm.avail_out = (unsigned int)size;
3856 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3858 Con_Printf("FS_Deflate: deflate failed!\n");
3859 qz_deflateEnd(&strm);
3864 if(qz_deflateEnd(&strm) != Z_OK)
3866 Con_Printf("FS_Deflate: deflateEnd failed\n");
3871 if(strm.total_out >= size)
3873 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3878 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3881 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3887 *deflated_size = (size_t)strm.total_out;
3889 memcpy(out, tmp, strm.total_out);
3895 static void AssertBufsize(sizebuf_t *buf, int length)
3897 if(buf->cursize + length > buf->maxsize)
3899 int oldsize = buf->maxsize;
3900 unsigned char *olddata;
3901 olddata = buf->data;
3902 buf->maxsize += length;
3903 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3906 memcpy(buf->data, olddata, oldsize);
3912 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3916 unsigned char *out = NULL;
3917 unsigned char tmp[2048];
3922 #ifndef LINK_TO_ZLIB
3927 memset(&outbuf, 0, sizeof(outbuf));
3928 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3929 outbuf.maxsize = sizeof(tmp);
3931 memset(&strm, 0, sizeof(strm));
3932 strm.zalloc = Z_NULL;
3933 strm.zfree = Z_NULL;
3934 strm.opaque = Z_NULL;
3936 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3938 Con_Printf("FS_Inflate: inflate init error!\n");
3939 Mem_Free(outbuf.data);
3943 strm.next_in = (unsigned char*)data;
3944 strm.avail_in = (unsigned int)size;
3948 strm.next_out = tmp;
3949 strm.avail_out = sizeof(tmp);
3950 ret = qz_inflate(&strm, Z_NO_FLUSH);
3951 // it either returns Z_OK on progress, Z_STREAM_END on end
3959 case Z_STREAM_ERROR:
3960 Con_Print("FS_Inflate: stream error!\n");
3963 Con_Print("FS_Inflate: data error!\n");
3966 Con_Print("FS_Inflate: mem error!\n");
3969 Con_Print("FS_Inflate: buf error!\n");
3972 Con_Print("FS_Inflate: unknown error!\n");
3976 if(ret != Z_OK && ret != Z_STREAM_END)
3978 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3979 Mem_Free(outbuf.data);
3980 qz_inflateEnd(&strm);
3983 have = sizeof(tmp) - strm.avail_out;
3984 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3985 SZ_Write(&outbuf, tmp, have);
3986 } while(ret != Z_STREAM_END);
3988 qz_inflateEnd(&strm);
3990 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3993 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3994 Mem_Free(outbuf.data);
3998 memcpy(out, outbuf.data, outbuf.cursize);
3999 Mem_Free(outbuf.data);
4002 *inflated_size = (size_t)outbuf.cursize;