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;
590 eocd->cdir_size < 0 || eocd->cdir_size > filesize ||
591 eocd->cdir_offset < 0 || eocd->cdir_offset >= filesize ||
592 eocd->cdir_offset + eocd->cdir_size > filesize
595 // Obviously invalid central directory.
607 Extract the file list from a PK3 file
610 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
612 unsigned char *central_dir, *ptr;
614 fs_offset_t remaining;
616 // Load the central directory in memory
617 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
618 if (lseek (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
620 Mem_Free (central_dir);
623 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
625 Mem_Free (central_dir);
629 // Extract the files properties
630 // The parsing is done "by hand" because some fields have variable sizes and
631 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
632 remaining = eocd->cdir_size;
635 for (ind = 0; ind < eocd->nbentries; ind++)
637 fs_offset_t namesize, count;
639 // Checking the remaining size
640 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
642 Mem_Free (central_dir);
645 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
648 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
650 Mem_Free (central_dir);
654 namesize = BuffLittleShort (&ptr[28]); // filename length
656 // Check encryption, compression, and attributes
657 // 1st uint8 : general purpose bit flag
658 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
660 // LordHavoc: bit 3 would be a problem if we were scanning the archive
661 // but is not a problem in the central directory where the values are
664 // bit 3 seems to always be set by the standard Mac OSX zip maker
666 // 2nd uint8 : external file attributes
667 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
668 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
670 // Still enough bytes for the name?
671 if (namesize < 0 || remaining < namesize || namesize >= (int)sizeof (*pack->files))
673 Mem_Free (central_dir);
677 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
678 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
680 char filename [sizeof (pack->files[0].name)];
681 fs_offset_t offset, packsize, realsize;
684 // Extract the name (strip it if necessary)
685 namesize = min(namesize, (int)sizeof (filename) - 1);
686 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
687 filename[namesize] = '\0';
689 if (BuffLittleShort (&ptr[10]))
690 flags = PACKFILE_FLAG_DEFLATED;
693 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
694 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
695 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
697 switch(ptr[5]) // C_VERSION_MADE_BY_1
702 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
703 // can't use S_ISLNK here, as this has to compile on non-UNIX too
704 flags |= PACKFILE_FLAG_SYMLINK;
708 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
712 // Skip the name, additionnal field, and comment
713 // 1er uint16 : extra field length
714 // 2eme uint16 : file comment length
715 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
716 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
720 // If the package is empty, central_dir is NULL here
721 if (central_dir != NULL)
722 Mem_Free (central_dir);
723 return pack->numfiles;
731 Create a package entry associated with a PK3 file
734 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
736 pk3_endOfCentralDir_t eocd;
740 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
743 Con_Printf ("%s is not a PK3 file\n", packfile);
748 // Multi-volume ZIP archives are NOT allowed
749 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
751 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
756 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
757 // since eocd.nbentries is an unsigned 16 bits integer
758 #if MAX_FILES_IN_PACK < 65535
759 if (eocd.nbentries > MAX_FILES_IN_PACK)
761 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
767 // Create a package structure in memory
768 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
769 pack->ignorecase = true; // PK3 ignores case
770 strlcpy (pack->filename, packfile, sizeof (pack->filename));
771 pack->handle = packhandle;
772 pack->numfiles = eocd.nbentries;
773 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
775 real_nb_files = PK3_BuildFileList (pack, &eocd);
776 if (real_nb_files < 0)
778 Con_Printf ("%s is not a valid PK3 file\n", packfile);
784 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
787 static pack_t *FS_LoadPackPK3 (const char *packfile)
790 packhandle = FS_SysOpenFD (packfile, "rb", false);
793 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
799 PK3_GetTrueFileOffset
801 Find where the true file data offset is
804 static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
806 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
810 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
813 // Load the local file description
814 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
816 Con_Printf ("Can't seek in package %s\n", pack->filename);
819 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
820 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
822 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
826 // Skip name and extra field
827 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
829 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
835 =============================================================================
837 OTHER PRIVATE FUNCTIONS
839 =============================================================================
847 Add a file to the list of files contained into a package
850 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
851 fs_offset_t offset, fs_offset_t packsize,
852 fs_offset_t realsize, int flags)
854 int (*strcmp_funct) (const char* str1, const char* str2);
855 int left, right, middle;
858 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
860 // Look for the slot we should put that file into (binary search)
862 right = pack->numfiles - 1;
863 while (left <= right)
867 middle = (left + right) / 2;
868 diff = strcmp_funct (pack->files[middle].name, name);
870 // If we found the file, there's a problem
872 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
874 // If we're too far in the list
881 // We have to move the right of the list by one slot to free the one we need
882 pfile = &pack->files[left];
883 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
886 strlcpy (pfile->name, name, sizeof (pfile->name));
887 pfile->offset = offset;
888 pfile->packsize = packsize;
889 pfile->realsize = realsize;
890 pfile->flags = flags;
900 Only used for FS_OpenRealFile.
903 void FS_CreatePath (char *path)
907 for (ofs = path+1 ; *ofs ; ofs++)
909 if (*ofs == '/' || *ofs == '\\')
911 // create the directory
927 static void FS_Path_f (void)
931 Con_Print("Current search path:\n");
932 for (s=fs_searchpaths ; s ; s=s->next)
937 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
939 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
942 Con_Printf("%s\n", s->filename);
952 /*! Takes an explicit (not game tree related) path to a pak file.
953 *Loads the header and directory, adding the files at the beginning
954 *of the list so they override previous pack files.
956 static pack_t *FS_LoadPackPAK (const char *packfile)
958 dpackheader_t header;
964 packhandle = FS_SysOpenFD(packfile, "rb", false);
967 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
969 Con_Printf ("%s is not a packfile\n", packfile);
973 if (memcmp(header.id, "PACK", 4))
975 Con_Printf ("%s is not a packfile\n", packfile);
979 header.dirofs = LittleLong (header.dirofs);
980 header.dirlen = LittleLong (header.dirlen);
982 if (header.dirlen % sizeof(dpackfile_t))
984 Con_Printf ("%s has an invalid directory size\n", packfile);
989 numpackfiles = header.dirlen / sizeof(dpackfile_t);
991 if (numpackfiles > MAX_FILES_IN_PACK)
993 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
998 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
999 lseek (packhandle, header.dirofs, SEEK_SET);
1000 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
1002 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1008 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1009 pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
1010 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1011 pack->handle = packhandle;
1013 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1015 // parse the directory
1016 for (i = 0;i < numpackfiles;i++)
1018 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1019 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1021 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1026 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1031 ====================
1034 Create a package entry associated with a directory file
1035 ====================
1037 static pack_t *FS_LoadPackVirtual (const char *dirname)
1040 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1042 pack->ignorecase = false;
1043 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1045 pack->numfiles = -1;
1047 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1056 /*! Adds the given pack to the search path.
1057 * The pack type is autodetected by the file extension.
1059 * Returns true if the file was successfully added to the
1060 * search path or if it was already included.
1062 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1063 * plain directories.
1066 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1068 searchpath_t *search;
1070 const char *ext = FS_FileExtension(pakfile);
1073 for(search = fs_searchpaths; search; search = search->next)
1075 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1078 *already_loaded = true;
1079 return true; // already loaded
1084 *already_loaded = false;
1086 if(!strcasecmp(ext, "pk3dir"))
1087 pak = FS_LoadPackVirtual (pakfile);
1088 else if(!strcasecmp(ext, "pak"))
1089 pak = FS_LoadPackPAK (pakfile);
1090 else if(!strcasecmp(ext, "pk3"))
1091 pak = FS_LoadPackPK3 (pakfile);
1092 else if(!strcasecmp(ext, "obb")) // android apk expansion
1093 pak = FS_LoadPackPK3 (pakfile);
1095 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1099 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1101 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1104 // find the first item whose next one is a pack or NULL
1105 searchpath_t *insertion_point = 0;
1106 if(fs_searchpaths && !fs_searchpaths->pack)
1108 insertion_point = fs_searchpaths;
1111 if(!insertion_point->next)
1113 if(insertion_point->next->pack)
1115 insertion_point = insertion_point->next;
1118 // If insertion_point is NULL, this means that either there is no
1119 // item in the list yet, or that the very first item is a pack. In
1120 // that case, we want to insert at the beginning...
1121 if(!insertion_point)
1123 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1124 search->next = fs_searchpaths;
1125 fs_searchpaths = search;
1128 // otherwise we want to append directly after insertion_point.
1130 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1131 search->next = insertion_point->next;
1132 insertion_point->next = search;
1137 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1138 search->next = fs_searchpaths;
1139 fs_searchpaths = search;
1144 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1145 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1146 // same goes for the name inside the pack structure
1147 l = strlen(pak->shortname);
1149 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1150 pak->shortname[l - 3] = 0;
1151 l = strlen(pak->filename);
1153 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1154 pak->filename[l - 3] = 0;
1160 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1171 /*! Adds the given pack to the search path and searches for it in the game path.
1172 * The pack type is autodetected by the file extension.
1174 * Returns true if the file was successfully added to the
1175 * search path or if it was already included.
1177 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1178 * plain directories.
1180 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1182 char fullpath[MAX_OSPATH];
1184 searchpath_t *search;
1187 *already_loaded = false;
1189 // then find the real name...
1190 search = FS_FindFile(pakfile, &index, true);
1191 if(!search || search->pack)
1193 Con_Printf("could not find pak \"%s\"\n", pakfile);
1197 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1199 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1207 Sets fs_gamedir, adds the directory to the head of the path,
1208 then loads and adds pak1.pak pak2.pak ...
1211 static void FS_AddGameDirectory (const char *dir)
1215 searchpath_t *search;
1217 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1219 stringlistinit(&list);
1220 listdirectory(&list, "", dir);
1221 stringlistsort(&list, false);
1223 // add any PAK package in the directory
1224 for (i = 0;i < list.numstrings;i++)
1226 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1228 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1232 // add any PK3 package in the directory
1233 for (i = 0;i < list.numstrings;i++)
1235 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1237 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1241 stringlistfreecontents(&list);
1243 // Add the directory to the search path
1244 // (unpacked files have the priority over packed files)
1245 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1246 strlcpy (search->filename, dir, sizeof (search->filename));
1247 search->next = fs_searchpaths;
1248 fs_searchpaths = search;
1257 static void FS_AddGameHierarchy (const char *dir)
1260 // Add the common game directory
1261 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1264 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1273 const char *FS_FileExtension (const char *in)
1275 const char *separator, *backslash, *colon, *dot;
1277 separator = strrchr(in, '/');
1278 backslash = strrchr(in, '\\');
1279 if (!separator || separator < backslash)
1280 separator = backslash;
1281 colon = strrchr(in, ':');
1282 if (!separator || separator < colon)
1285 dot = strrchr(in, '.');
1286 if (dot == NULL || (separator && (dot < separator)))
1298 const char *FS_FileWithoutPath (const char *in)
1300 const char *separator, *backslash, *colon;
1302 separator = strrchr(in, '/');
1303 backslash = strrchr(in, '\\');
1304 if (!separator || separator < backslash)
1305 separator = backslash;
1306 colon = strrchr(in, ':');
1307 if (!separator || separator < colon)
1309 return separator ? separator + 1 : in;
1318 static void FS_ClearSearchPath (void)
1320 // unload all packs and directory information, close all pack files
1321 // (if a qfile is still reading a pack it won't be harmed because it used
1322 // dup() to get its own handle already)
1323 while (fs_searchpaths)
1325 searchpath_t *search = fs_searchpaths;
1326 fs_searchpaths = search->next;
1327 if (search->pack && search->pack != fs_selfpack)
1329 if(!search->pack->vpack)
1332 close(search->pack->handle);
1333 // free any memory associated with it
1334 if (search->pack->files)
1335 Mem_Free(search->pack->files);
1337 Mem_Free(search->pack);
1343 static void FS_AddSelfPack(void)
1347 searchpath_t *search;
1348 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1349 search->next = fs_searchpaths;
1350 search->pack = fs_selfpack;
1351 fs_searchpaths = search;
1361 void FS_Rescan (void)
1364 qboolean fs_modified = false;
1365 qboolean reset = false;
1366 char gamedirbuf[MAX_INPUTLINE];
1371 FS_ClearSearchPath();
1373 // automatically activate gamemode for the gamedirs specified
1375 COM_ChangeGameTypeForGameDirs();
1377 // add the game-specific paths
1378 // gamedirname1 (typically id1)
1379 FS_AddGameHierarchy (gamedirname1);
1380 // update the com_modname (used for server info)
1381 if (gamedirname2 && gamedirname2[0])
1382 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1384 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1386 // add the game-specific path, if any
1387 // (only used for mission packs and the like, which should set fs_modified)
1388 if (gamedirname2 && gamedirname2[0])
1391 FS_AddGameHierarchy (gamedirname2);
1395 // Adds basedir/gamedir as an override game
1396 // LordHavoc: now supports multiple -game directories
1397 // set the com_modname (reported in server info)
1399 for (i = 0;i < fs_numgamedirs;i++)
1402 FS_AddGameHierarchy (fs_gamedirs[i]);
1403 // update the com_modname (used server info)
1404 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1406 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1408 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1410 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1412 // add back the selfpack as new first item
1415 // set the default screenshot name to either the mod name or the
1416 // gamemode screenshot name
1417 if (strcmp(com_modname, gamedirname1))
1418 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1420 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1422 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1423 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1425 // If "-condebug" is in the command line, remove the previous log file
1426 if (COM_CheckParm ("-condebug") != 0)
1427 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1429 // look for the pop.lmp file and set registered to true if it is found
1430 if (FS_FileExists("gfx/pop.lmp"))
1431 Cvar_Set ("registered", "1");
1437 if (!registered.integer)
1440 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1442 Con_Print("Playing shareware version.\n");
1445 Con_Print("Playing registered version.\n");
1447 case GAME_STEELSTORM:
1448 if (registered.integer)
1449 Con_Print("Playing registered version.\n");
1451 Con_Print("Playing shareware version.\n");
1457 // unload all wads so that future queries will return the new data
1461 static void FS_Rescan_f(void)
1471 extern qboolean vid_opened;
1472 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1477 if (fs_numgamedirs == numgamedirs)
1479 for (i = 0;i < numgamedirs;i++)
1480 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1482 if (i == numgamedirs)
1483 return true; // already using this set of gamedirs, do nothing
1486 if (numgamedirs > MAX_GAMEDIRS)
1489 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1490 return false; // too many gamedirs
1493 for (i = 0;i < numgamedirs;i++)
1495 // if string is nasty, reject it
1496 p = FS_CheckGameDir(gamedirs[i]);
1500 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1501 return false; // nasty gamedirs
1503 if(p == fs_checkgamedir_missing && failmissing)
1506 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1507 return false; // missing gamedirs
1513 fs_numgamedirs = numgamedirs;
1514 for (i = 0;i < fs_numgamedirs;i++)
1515 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1517 // reinitialize filesystem to detect the new paks
1520 if (cls.demoplayback)
1526 // unload all sounds so they will be reloaded from the new files as needed
1527 S_UnloadAllSounds_f();
1529 // close down the video subsystem, it will start up again when the config finishes...
1533 // restart the video subsystem after the config is executed
1534 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1544 static void FS_GameDir_f (void)
1548 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1552 Con_Printf("gamedirs active:");
1553 for (i = 0;i < fs_numgamedirs;i++)
1554 Con_Printf(" %s", fs_gamedirs[i]);
1559 numgamedirs = Cmd_Argc() - 1;
1560 if (numgamedirs > MAX_GAMEDIRS)
1562 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1566 for (i = 0;i < numgamedirs;i++)
1567 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1569 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1571 // actually, changing during game would work fine, but would be stupid
1572 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1576 // halt demo playback to close the file
1579 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1582 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1590 stringlistinit(&list);
1591 listdirectory(&list, gamedir, "");
1592 success = list.numstrings > 0;
1593 stringlistfreecontents(&list);
1597 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1600 n = FS_Read (f, buf, buflength - 1);
1620 const char *FS_CheckGameDir(const char *gamedir)
1626 if (FS_CheckNastyPath(gamedir, true))
1629 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1634 // get description from basedir
1635 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1643 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1647 return fs_checkgamedir_missing;
1650 static void FS_ListGameDirs(void)
1652 stringlist_t list, list2;
1657 fs_all_gamedirs_count = 0;
1659 Mem_Free(fs_all_gamedirs);
1661 stringlistinit(&list);
1662 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1663 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1664 stringlistsort(&list, false);
1666 stringlistinit(&list2);
1667 for(i = 0; i < list.numstrings; ++i)
1670 if(!strcmp(list.strings[i-1], list.strings[i]))
1672 info = FS_CheckGameDir(list.strings[i]);
1675 if(info == fs_checkgamedir_missing)
1679 stringlistappend(&list2, list.strings[i]);
1681 stringlistfreecontents(&list);
1683 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1684 for(i = 0; i < list2.numstrings; ++i)
1686 info = FS_CheckGameDir(list2.strings[i]);
1687 // all this cannot happen any more, but better be safe than sorry
1690 if(info == fs_checkgamedir_missing)
1694 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1695 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1696 ++fs_all_gamedirs_count;
1702 #pragma comment(lib, "shell32.lib")
1712 void FS_Init_SelfPack (void)
1715 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1718 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1724 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1727 const char **new_argv;
1729 int args_left = 256;
1730 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1733 new_argv[0] = "dummy";
1738 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1741 while(COM_ParseToken_Console(&p))
1743 size_t sz = strlen(com_token) + 1; // shut up clang
1746 q = (char *)Mem_Alloc(fs_mempool, sz);
1747 strlcpy(q, com_token, sz);
1748 new_argv[com_argc + i] = q;
1751 new_argv[i+com_argc] = NULL;
1752 com_argv = new_argv;
1753 com_argc = com_argc + i;
1760 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1762 #if defined(__IPHONEOS__)
1763 if (userdirmode == USERDIRMODE_HOME)
1765 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1766 // fs_userdir stores configurations to the Documents folder of the app
1767 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1772 #elif defined(WIN32)
1774 #if _MSC_VER >= 1400
1777 TCHAR mydocsdir[MAX_PATH + 1];
1778 wchar_t *savedgamesdirw;
1779 char savedgamesdir[MAX_OSPATH];
1788 case USERDIRMODE_NOHOME:
1789 strlcpy(userdir, fs_basedir, userdirsize);
1791 case USERDIRMODE_MYGAMES:
1793 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1795 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1797 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1800 #if _MSC_VER >= 1400
1801 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1804 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1809 homedir = getenv("USERPROFILE");
1812 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1817 case USERDIRMODE_SAVEDGAMES:
1819 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1821 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1822 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1824 savedgamesdir[0] = 0;
1825 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1828 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1830 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1833 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1835 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1836 #if _MSC_VER >= 1400
1837 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1839 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1841 qCoTaskMemFree(savedgamesdirw);
1844 if (savedgamesdir[0])
1846 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1861 case USERDIRMODE_NOHOME:
1862 strlcpy(userdir, fs_basedir, userdirsize);
1864 case USERDIRMODE_HOME:
1865 homedir = getenv("HOME");
1868 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1872 case USERDIRMODE_SAVEDGAMES:
1873 homedir = getenv("HOME");
1877 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1879 // the XDG say some files would need to go in:
1880 // XDG_CONFIG_HOME (or ~/.config/%s/)
1881 // XDG_DATA_HOME (or ~/.local/share/%s/)
1882 // XDG_CACHE_HOME (or ~/.cache/%s/)
1883 // and also search the following global locations if defined:
1884 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1885 // XDG_DATA_DIRS (normally /usr/share/%s/)
1886 // this would be too complicated...
1896 #if !defined(__IPHONEOS__)
1899 // historical behavior...
1900 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1901 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
1904 // see if we can write to this path (note: won't create path)
1906 // no access() here, we must try to open the file for appending
1907 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1911 // on Unix, we don't need to ACTUALLY attempt to open the file
1912 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1919 return 1; // good choice - the path exists and is writable
1923 if (userdirmode == USERDIRMODE_NOHOME)
1924 return -1; // path usually already exists, we lack permissions
1926 return 0; // probably good - failed to write but maybe we need to create path
1946 // Overrides the system supplied base directory (under GAMENAME)
1947 // 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)
1948 i = COM_CheckParm ("-basedir");
1949 if (i && i < com_argc-1)
1951 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1952 i = (int)strlen (fs_basedir);
1953 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1954 fs_basedir[i-1] = 0;
1958 // If the base directory is explicitly defined by the compilation process
1959 #ifdef DP_FS_BASEDIR
1960 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1961 #elif defined(__ANDROID__)
1962 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
1963 #elif defined(MACOSX)
1964 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1965 if (strstr(com_argv[0], ".app/"))
1968 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1969 split = strstr(fs_basedir, ".app/");
1972 struct stat statresult;
1974 // truncate to just after the .app/
1976 // see if gamedir exists in Resources
1977 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1979 // found gamedir inside Resources, use it
1980 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1984 // no gamedir found in Resources, gamedir is probably
1985 // outside the .app, remove .app part of path
1986 while (split > fs_basedir && *split != '/')
1995 // make sure the appending of a path separator won't create an unterminated string
1996 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1997 // add a path separator to the end of the basedir if it lacks one
1998 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1999 strlcat(fs_basedir, "/", sizeof(fs_basedir));
2001 // Add the personal game directory
2002 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
2003 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
2004 else if (COM_CheckParm("-nohome"))
2005 *fs_userdir = 0; // user wants roaming installation, no userdir
2009 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2010 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2011 int userdirstatus[USERDIRMODE_COUNT];
2013 // historical behavior...
2014 if (!strcmp(gamedirname1, "id1"))
2015 preferreduserdirmode = USERDIRMODE_NOHOME;
2017 // check what limitations the user wants to impose
2018 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2019 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2020 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2021 // gather the status of the possible userdirs
2022 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2024 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2025 if (userdirstatus[dirmode] == 1)
2026 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2027 else if (userdirstatus[dirmode] == 0)
2028 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2030 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2032 // some games may prefer writing to basedir, but if write fails we
2033 // have to search for a real userdir...
2034 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2035 preferreduserdirmode = highestuserdirmode;
2036 // check for an existing userdir and continue using it if possible...
2037 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2038 if (userdirstatus[dirmode] == 1)
2040 // if no existing userdir found, make a new one...
2041 if (dirmode == 0 && preferreduserdirmode > 0)
2042 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2043 if (userdirstatus[dirmode] >= 0)
2045 // and finally, we picked one...
2046 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2047 Con_DPrintf("userdir %i is the winner\n", dirmode);
2050 // if userdir equal to basedir, clear it to avoid confusion later
2051 if (!strcmp(fs_basedir, fs_userdir))
2056 p = FS_CheckGameDir(gamedirname1);
2057 if(!p || p == fs_checkgamedir_missing)
2058 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2062 p = FS_CheckGameDir(gamedirname2);
2063 if(!p || p == fs_checkgamedir_missing)
2064 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2068 // Adds basedir/gamedir as an override game
2069 // LordHavoc: now supports multiple -game directories
2070 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2074 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2077 p = FS_CheckGameDir(com_argv[i]);
2079 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2080 if(p == fs_checkgamedir_missing)
2081 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2082 // add the gamedir to the list of active gamedirs
2083 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2088 // generate the searchpath
2091 if (Thread_HasThreads())
2092 fs_mutex = Thread_CreateMutex();
2095 void FS_Init_Commands(void)
2097 Cvar_RegisterVariable (&scr_screenshot_name);
2098 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2099 Cvar_RegisterVariable (&cvar_fs_gamedir);
2101 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2102 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2103 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2104 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2105 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2106 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2114 void FS_Shutdown (void)
2116 // close all pack files and such
2117 // (hopefully there aren't any other open files, but they'll be cleaned up
2118 // by the OS anyway)
2119 FS_ClearSearchPath();
2120 Mem_FreePool (&fs_mempool);
2121 PK3_CloseLibrary ();
2124 Sys_UnloadLibrary (&shfolder_dll);
2125 Sys_UnloadLibrary (&shell32_dll);
2126 Sys_UnloadLibrary (&ole32_dll);
2130 Thread_DestroyMutex(fs_mutex);
2133 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2138 qboolean dolock = false;
2140 // Parse the mode string
2149 opt = O_CREAT | O_TRUNC;
2153 opt = O_CREAT | O_APPEND;
2156 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2159 for (ind = 1; mode[ind] != '\0'; ind++)
2173 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2174 filepath, mode, mode[ind]);
2181 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2185 # if _MSC_VER >= 1400
2186 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2188 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2191 handle = open (filepath, mod | opt, 0666);
2192 if(handle >= 0 && dolock)
2195 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2196 l.l_whence = SEEK_SET;
2199 if(fcntl(handle, F_SETLK, &l) == -1)
2211 ====================
2214 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2215 ====================
2217 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2221 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2223 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2224 if (file->handle < 0)
2230 file->filename = Mem_strdup(fs_mempool, filepath);
2232 file->real_length = lseek (file->handle, 0, SEEK_END);
2234 // For files opened in append mode, we start at the end of the file
2236 file->position = file->real_length;
2238 lseek (file->handle, 0, SEEK_SET);
2248 Open a packed file using its package file descriptor
2251 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2257 pfile = &pack->files[pack_ind];
2259 // If we don't have the true offset, get it now
2260 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2261 if (!PK3_GetTrueFileOffset (pfile, pack))
2264 #ifndef LINK_TO_ZLIB
2265 // No Zlib DLL = no compressed files
2266 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2268 Con_Printf("WARNING: can't open the compressed file %s\n"
2269 "You need the Zlib DLL to use compressed files\n",
2275 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2276 // the dup() call to avoid having to close the dup_handle on error here
2277 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2279 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2280 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2284 dup_handle = dup (pack->handle);
2287 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2291 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2292 memset (file, 0, sizeof (*file));
2293 file->handle = dup_handle;
2294 file->flags = QFILE_FLAG_PACKED;
2295 file->real_length = pfile->realsize;
2296 file->offset = pfile->offset;
2300 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2304 file->flags |= QFILE_FLAG_DEFLATED;
2306 // We need some more variables
2307 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2309 ztk->comp_length = pfile->packsize;
2311 // Initialize zlib stream
2312 ztk->zstream.next_in = ztk->input;
2313 ztk->zstream.avail_in = 0;
2315 /* From Zlib's "unzip.c":
2317 * windowBits is passed < 0 to tell that there is no zlib header.
2318 * Note that in this case inflate *requires* an extra "dummy" byte
2319 * after the compressed stream in order to complete decompression and
2320 * return Z_STREAM_END.
2321 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2322 * size of both compressed and uncompressed data
2324 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2326 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2332 ztk->zstream.next_out = file->buff;
2333 ztk->zstream.avail_out = sizeof (file->buff);
2342 ====================
2345 Return true if the path should be rejected due to one of the following:
2346 1: path elements that are non-portable
2347 2: path elements that would allow access to files outside the game directory,
2348 or are just not a good idea for a mod to be using.
2349 ====================
2351 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2353 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2357 // Windows: don't allow \ in filenames (windows-only), period.
2358 // (on Windows \ is a directory separator, but / is also supported)
2359 if (strstr(path, "\\"))
2360 return 1; // non-portable
2362 // Mac: don't allow Mac-only filenames - : is a directory separator
2363 // instead of /, but we rely on / working already, so there's no reason to
2364 // support a Mac-only path
2365 // Amiga and Windows: : tries to go to root of drive
2366 if (strstr(path, ":"))
2367 return 1; // non-portable attempt to go to root of drive
2369 // Amiga: // is parent directory
2370 if (strstr(path, "//"))
2371 return 1; // non-portable attempt to go to parent directory
2373 // all: don't allow going to parent directory (../ or /../)
2374 if (strstr(path, ".."))
2375 return 2; // attempt to go outside the game directory
2377 // Windows and UNIXes: don't allow absolute paths
2379 return 2; // attempt to go outside the game directory
2381 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2382 if (strstr(path, "./"))
2383 return 2; // possible attempt to go outside the game directory
2385 // all: forbid trailing slash on gamedir
2386 if (isgamedir && path[strlen(path)-1] == '/')
2389 // all: forbid leading dot on any filename for any reason
2390 if (strstr(path, "/."))
2391 return 2; // attempt to go outside the game directory
2393 // after all these checks we're pretty sure it's a / separated filename
2394 // and won't do much if any harm
2400 ====================
2403 Look for a file in the packages and in the filesystem
2405 Return the searchpath where the file was found (or NULL)
2406 and the file index in the package if relevant
2407 ====================
2409 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2411 searchpath_t *search;
2414 // search through the path, one element at a time
2415 for (search = fs_searchpaths;search;search = search->next)
2417 // is the element a pak file?
2418 if (search->pack && !search->pack->vpack)
2420 int (*strcmp_funct) (const char* str1, const char* str2);
2421 int left, right, middle;
2424 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2426 // Look for the file (binary search)
2428 right = pak->numfiles - 1;
2429 while (left <= right)
2433 middle = (left + right) / 2;
2434 diff = strcmp_funct (pak->files[middle].name, name);
2439 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2441 // yes, but the first one is empty so we treat it as not being there
2442 if (!quiet && developer_extra.integer)
2443 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2450 if (!quiet && developer_extra.integer)
2451 Con_DPrintf("FS_FindFile: %s in %s\n",
2452 pak->files[middle].name, pak->filename);
2459 // If we're too far in the list
2468 char netpath[MAX_OSPATH];
2469 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2470 if (FS_SysFileExists (netpath))
2472 if (!quiet && developer_extra.integer)
2473 Con_DPrintf("FS_FindFile: %s\n", netpath);
2482 if (!quiet && developer_extra.integer)
2483 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2495 Look for a file in the search paths and open it in read-only mode
2498 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2500 searchpath_t *search;
2503 search = FS_FindFile (filename, &pack_ind, quiet);
2509 // Found in the filesystem?
2512 // this works with vpacks, so we are fine
2513 char path [MAX_OSPATH];
2514 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2515 return FS_SysOpen (path, "rb", nonblocking);
2518 // So, we found it in a package...
2520 // Is it a PK3 symlink?
2521 // TODO also handle directory symlinks by parsing the whole structure...
2522 // but heck, file symlinks are good enough for now
2523 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2525 if(symlinkLevels <= 0)
2527 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2532 char linkbuf[MAX_QPATH];
2534 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2535 const char *mergeslash;
2540 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2546 // Now combine the paths...
2547 mergeslash = strrchr(filename, '/');
2548 mergestart = linkbuf;
2550 mergeslash = filename;
2551 while(!strncmp(mergestart, "../", 3))
2554 while(mergeslash > filename)
2557 if(*mergeslash == '/')
2561 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2562 if(mergeslash == filename)
2564 // Either mergeslash == filename, then we just replace the name (done below)
2568 // Or, we append the name after mergeslash;
2569 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2570 int spaceNeeded = mergeslash - filename + 1;
2571 int spaceRemoved = mergestart - linkbuf;
2572 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2574 Con_DPrintf("symlink: too long path rejected\n");
2577 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2578 memcpy(linkbuf, filename, spaceNeeded);
2579 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2580 mergestart = linkbuf;
2582 if (!quiet && developer_loading.integer)
2583 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2584 if(FS_CheckNastyPath (mergestart, false))
2586 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2589 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2593 return FS_OpenPackedFile (search->pack, pack_ind);
2598 =============================================================================
2600 MAIN PUBLIC FUNCTIONS
2602 =============================================================================
2606 ====================
2609 Open a file in the userpath. The syntax is the same as fopen
2610 Used for savegame scanning in menu, and all file writing.
2611 ====================
2613 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2615 char real_path [MAX_OSPATH];
2617 if (FS_CheckNastyPath(filepath, false))
2619 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2623 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2625 // If the file is opened in "write", "append", or "read/write" mode,
2626 // create directories up to the file.
2627 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2628 FS_CreatePath (real_path);
2629 return FS_SysOpen (real_path, mode, false);
2634 ====================
2637 Open a file. The syntax is the same as fopen
2638 ====================
2640 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2642 qfile_t *result = NULL;
2643 if (FS_CheckNastyPath(filepath, false))
2645 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2649 if (fs_mutex) Thread_LockMutex(fs_mutex);
2650 result = FS_OpenReadFile (filepath, quiet, false, 16);
2651 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2657 ====================
2660 Open a file. The syntax is the same as fopen
2661 ====================
2663 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2666 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2667 memset (file, 0, sizeof (*file));
2668 file->flags = QFILE_FLAG_DATA;
2670 file->real_length = size;
2676 ====================
2680 ====================
2682 int FS_Close (qfile_t* file)
2684 if(file->flags & QFILE_FLAG_DATA)
2690 if (close (file->handle))
2695 if (file->flags & QFILE_FLAG_REMOVE)
2696 remove(file->filename);
2698 Mem_Free((void *) file->filename);
2703 qz_inflateEnd (&file->ztk->zstream);
2704 Mem_Free (file->ztk);
2711 void FS_RemoveOnClose(qfile_t* file)
2713 file->flags |= QFILE_FLAG_REMOVE;
2717 ====================
2720 Write "datasize" bytes into a file
2721 ====================
2723 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2725 fs_offset_t written = 0;
2727 // If necessary, seek to the exact file position we're supposed to be
2728 if (file->buff_ind != file->buff_len)
2730 if (lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
2732 Con_Printf("WARNING: could not seek in %s.\n");
2736 // Purge cached data
2739 // Write the buffer and update the position
2740 // 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)
2741 while (written < (fs_offset_t)datasize)
2743 // figure out how much to write in one chunk
2744 fs_offset_t maxchunk = 1<<30; // 1 GiB
2745 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2746 int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
2747 // if at least some was written, add it to our accumulator
2750 // if the result is not what we expected, consider the write to be incomplete
2751 if (result != chunk)
2754 file->position = lseek (file->handle, 0, SEEK_CUR);
2755 if (file->real_length < file->position)
2756 file->real_length = file->position;
2758 // note that this will never be less than 0 even if the write failed
2764 ====================
2767 Read up to "buffersize" bytes from a file
2768 ====================
2770 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2772 fs_offset_t count, done;
2774 if (buffersize == 0)
2777 // Get rid of the ungetc character
2778 if (file->ungetc != EOF)
2780 ((char*)buffer)[0] = file->ungetc;
2788 if(file->flags & QFILE_FLAG_DATA)
2790 size_t left = file->real_length - file->position;
2791 if(buffersize > left)
2793 memcpy(buffer, file->data + file->position, buffersize);
2794 file->position += buffersize;
2798 // First, we copy as many bytes as we can from "buff"
2799 if (file->buff_ind < file->buff_len)
2801 count = file->buff_len - file->buff_ind;
2802 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2804 memcpy (buffer, &file->buff[file->buff_ind], count);
2805 file->buff_ind += count;
2807 buffersize -= count;
2808 if (buffersize == 0)
2812 // NOTE: at this point, the read buffer is always empty
2814 // If the file isn't compressed
2815 if (! (file->flags & QFILE_FLAG_DEFLATED))
2819 // We must take care to not read after the end of the file
2820 count = file->real_length - file->position;
2822 // If we have a lot of data to get, put them directly into "buffer"
2823 if (buffersize > sizeof (file->buff) / 2)
2825 if (count > (fs_offset_t)buffersize)
2826 count = (fs_offset_t)buffersize;
2827 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2829 // Seek failed. When reading from a pipe, and
2830 // the caller never called FS_Seek, this still
2831 // works fine. So no reporting this error.
2833 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2837 file->position += nb;
2839 // Purge cached data
2845 if (count > (fs_offset_t)sizeof (file->buff))
2846 count = (fs_offset_t)sizeof (file->buff);
2847 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2849 // Seek failed. When reading from a pipe, and
2850 // the caller never called FS_Seek, this still
2851 // works fine. So no reporting this error.
2853 nb = read (file->handle, file->buff, count);
2856 file->buff_len = nb;
2857 file->position += nb;
2859 // Copy the requested data in "buffer" (as much as we can)
2860 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2861 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2862 file->buff_ind = count;
2870 // If the file is compressed, it's more complicated...
2871 // We cycle through a few operations until we have read enough data
2872 while (buffersize > 0)
2874 ztoolkit_t *ztk = file->ztk;
2877 // NOTE: at this point, the read buffer is always empty
2879 // If "input" is also empty, we need to refill it
2880 if (ztk->in_ind == ztk->in_len)
2882 // If we are at the end of the file
2883 if (file->position == file->real_length)
2886 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2887 if (count > (fs_offset_t)sizeof (ztk->input))
2888 count = (fs_offset_t)sizeof (ztk->input);
2889 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2890 if (read (file->handle, ztk->input, count) != count)
2892 Con_Printf ("FS_Read: unexpected end of file\n");
2897 ztk->in_len = count;
2898 ztk->in_position += count;
2901 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2902 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2904 // Now that we are sure we have compressed data available, we need to determine
2905 // if it's better to inflate it in "file->buff" or directly in "buffer"
2907 // Inflate the data in "file->buff"
2908 if (buffersize < sizeof (file->buff) / 2)
2910 ztk->zstream.next_out = file->buff;
2911 ztk->zstream.avail_out = sizeof (file->buff);
2912 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2913 if (error != Z_OK && error != Z_STREAM_END)
2915 Con_Printf ("FS_Read: Can't inflate file\n");
2918 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2920 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2921 file->position += file->buff_len;
2923 // Copy the requested data in "buffer" (as much as we can)
2924 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2925 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2926 file->buff_ind = count;
2929 // Else, we inflate directly in "buffer"
2932 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2933 ztk->zstream.avail_out = (unsigned int)buffersize;
2934 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2935 if (error != Z_OK && error != Z_STREAM_END)
2937 Con_Printf ("FS_Read: Can't inflate file\n");
2940 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2942 // How much data did it inflate?
2943 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2944 file->position += count;
2946 // Purge cached data
2951 buffersize -= count;
2959 ====================
2962 Print a string into a file
2963 ====================
2965 int FS_Print (qfile_t* file, const char *msg)
2967 return (int)FS_Write (file, msg, strlen (msg));
2971 ====================
2974 Print a string into a file
2975 ====================
2977 int FS_Printf(qfile_t* file, const char* format, ...)
2982 va_start (args, format);
2983 result = FS_VPrintf (file, format, args);
2991 ====================
2994 Print a string into a file
2995 ====================
2997 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3000 fs_offset_t buff_size = MAX_INPUTLINE;
3005 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3006 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3007 if (len >= 0 && len < buff_size)
3009 Mem_Free (tempbuff);
3013 len = write (file->handle, tempbuff, len);
3014 Mem_Free (tempbuff);
3021 ====================
3024 Get the next character of a file
3025 ====================
3027 int FS_Getc (qfile_t* file)
3031 if (FS_Read (file, &c, 1) != 1)
3039 ====================
3042 Put a character back into the read buffer (only supports one character!)
3043 ====================
3045 int FS_UnGetc (qfile_t* file, unsigned char c)
3047 // If there's already a character waiting to be read
3048 if (file->ungetc != EOF)
3057 ====================
3060 Move the position index in a file
3061 ====================
3063 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3066 unsigned char* buffer;
3067 fs_offset_t buffersize;
3069 // Compute the file offset
3073 offset += file->position - file->buff_len + file->buff_ind;
3080 offset += file->real_length;
3086 if (offset < 0 || offset > file->real_length)
3089 if(file->flags & QFILE_FLAG_DATA)
3091 file->position = offset;
3095 // If we have the data in our read buffer, we don't need to actually seek
3096 if (file->position - file->buff_len <= offset && offset <= file->position)
3098 file->buff_ind = offset + file->buff_len - file->position;
3102 // Purge cached data
3105 // Unpacked or uncompressed files can seek directly
3106 if (! (file->flags & QFILE_FLAG_DEFLATED))
3108 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3110 file->position = offset;
3114 // Seeking in compressed files is more a hack than anything else,
3115 // but we need to support it, so here we go.
3118 // If we have to go back in the file, we need to restart from the beginning
3119 if (offset <= file->position)
3123 ztk->in_position = 0;
3125 if (lseek (file->handle, file->offset, SEEK_SET) == -1)
3126 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3128 // Reset the Zlib stream
3129 ztk->zstream.next_in = ztk->input;
3130 ztk->zstream.avail_in = 0;
3131 qz_inflateReset (&ztk->zstream);
3134 // We need a big buffer to force inflating into it directly
3135 buffersize = 2 * sizeof (file->buff);
3136 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3138 // Skip all data until we reach the requested offset
3139 while (offset > file->position)
3141 fs_offset_t diff = offset - file->position;
3142 fs_offset_t count, len;
3144 count = (diff > buffersize) ? buffersize : diff;
3145 len = FS_Read (file, buffer, count);
3159 ====================
3162 Give the current position in a file
3163 ====================
3165 fs_offset_t FS_Tell (qfile_t* file)
3167 return file->position - file->buff_len + file->buff_ind;
3172 ====================
3175 Give the total size of a file
3176 ====================
3178 fs_offset_t FS_FileSize (qfile_t* file)
3180 return file->real_length;
3185 ====================
3188 Erases any buffered input or output data
3189 ====================
3191 void FS_Purge (qfile_t* file)
3203 Filename are relative to the quake directory.
3204 Always appends a 0 byte.
3207 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3210 unsigned char *buf = NULL;
3211 fs_offset_t filesize = 0;
3213 file = FS_OpenVirtualFile(path, quiet);
3216 filesize = file->real_length;
3219 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3224 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3225 buf[filesize] = '\0';
3226 FS_Read (file, buf, filesize);
3228 if (developer_loadfile.integer)
3229 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3232 if (filesizepointer)
3233 *filesizepointer = filesize;
3242 The filename will be prefixed by the current game directory
3245 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3249 fs_offset_t lentotal;
3251 file = FS_OpenRealFile(filename, "wb", false);
3254 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3259 for(i = 0; i < count; ++i)
3261 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3262 for(i = 0; i < count; ++i)
3263 FS_Write (file, data[i], len[i]);
3268 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3270 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3275 =============================================================================
3277 OTHERS PUBLIC FUNCTIONS
3279 =============================================================================
3287 void FS_StripExtension (const char *in, char *out, size_t size_out)
3295 while ((currentchar = *in) && size_out > 1)
3297 if (currentchar == '.')
3299 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3301 *out++ = currentchar;
3317 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3321 // if path doesn't have a .EXT, append extension
3322 // (extension should include the .)
3323 src = path + strlen(path) - 1;
3325 while (*src != '/' && src != path)
3328 return; // it has an extension
3332 strlcat (path, extension, size_path);
3340 Look for a file in the packages and in the filesystem
3343 int FS_FileType (const char *filename)
3345 searchpath_t *search;
3346 char fullpath[MAX_OSPATH];
3348 search = FS_FindFile (filename, NULL, true);
3350 return FS_FILETYPE_NONE;
3352 if(search->pack && !search->pack->vpack)
3353 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3355 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3356 return FS_SysFileType(fullpath);
3364 Look for a file in the packages and in the filesystem
3367 qboolean FS_FileExists (const char *filename)
3369 return (FS_FindFile (filename, NULL, true) != NULL);
3377 Look for a file in the filesystem only
3380 int FS_SysFileType (const char *path)
3383 // Sajt - some older sdks are missing this define
3384 # ifndef INVALID_FILE_ATTRIBUTES
3385 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3388 DWORD result = GetFileAttributes(path);
3390 if(result == INVALID_FILE_ATTRIBUTES)
3391 return FS_FILETYPE_NONE;
3393 if(result & FILE_ATTRIBUTE_DIRECTORY)
3394 return FS_FILETYPE_DIRECTORY;
3396 return FS_FILETYPE_FILE;
3400 if (stat (path,&buf) == -1)
3401 return FS_FILETYPE_NONE;
3404 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3406 if(S_ISDIR(buf.st_mode))
3407 return FS_FILETYPE_DIRECTORY;
3409 return FS_FILETYPE_FILE;
3413 qboolean FS_SysFileExists (const char *path)
3415 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3418 void FS_mkdir (const char *path)
3420 if(COM_CheckParm("-readonly"))
3434 Allocate and fill a search structure with information on matching filenames.
3437 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3440 searchpath_t *searchpath;
3442 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3443 stringlist_t resultlist;
3444 stringlist_t dirlist;
3445 const char *slash, *backslash, *colon, *separator;
3447 char temp[MAX_OSPATH];
3449 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3454 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3458 stringlistinit(&resultlist);
3459 stringlistinit(&dirlist);
3461 slash = strrchr(pattern, '/');
3462 backslash = strrchr(pattern, '\\');
3463 colon = strrchr(pattern, ':');
3464 separator = max(slash, backslash);
3465 separator = max(separator, colon);
3466 basepathlength = separator ? (separator + 1 - pattern) : 0;
3467 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3469 memcpy(basepath, pattern, basepathlength);
3470 basepath[basepathlength] = 0;
3472 // search through the path, one element at a time
3473 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3475 // is the element a pak file?
3476 if (searchpath->pack && !searchpath->pack->vpack)
3478 // look through all the pak file elements
3479 pak = searchpath->pack;
3480 for (i = 0;i < pak->numfiles;i++)
3482 strlcpy(temp, pak->files[i].name, sizeof(temp));
3485 if (matchpattern(temp, (char *)pattern, true))
3487 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3488 if (!strcmp(resultlist.strings[resultlistindex], temp))
3490 if (resultlistindex == resultlist.numstrings)
3492 stringlistappend(&resultlist, temp);
3493 if (!quiet && developer_loading.integer)
3494 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3497 // strip off one path element at a time until empty
3498 // this way directories are added to the listing if they match the pattern
3499 slash = strrchr(temp, '/');
3500 backslash = strrchr(temp, '\\');
3501 colon = strrchr(temp, ':');
3503 if (separator < slash)
3505 if (separator < backslash)
3506 separator = backslash;
3507 if (separator < colon)
3509 *((char *)separator) = 0;
3515 stringlist_t matchedSet, foundSet;
3516 const char *start = pattern;
3518 stringlistinit(&matchedSet);
3519 stringlistinit(&foundSet);
3520 // add a first entry to the set
3521 stringlistappend(&matchedSet, "");
3522 // iterate through pattern's path
3525 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3526 char subpath[MAX_OSPATH];
3527 char subpattern[MAX_OSPATH];
3529 // find the next wildcard
3530 wildcard = strchr(start, '?');
3531 asterisk = strchr(start, '*');
3532 if (asterisk && (!wildcard || asterisk < wildcard))
3534 wildcard = asterisk;
3539 nextseparator = strchr( wildcard, '/' );
3543 nextseparator = NULL;
3546 if( !nextseparator ) {
3547 nextseparator = start + strlen( start );
3550 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3551 // copy everything up except nextseperator
3552 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3553 // find the last '/' before the wildcard
3554 prevseparator = strrchr( subpattern, '/' );
3556 prevseparator = subpattern;
3559 // copy everything from start to the previous including the '/' (before the wildcard)
3560 // everything up to start is already included in the path of matchedSet's entries
3561 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3563 // for each entry in matchedSet try to open the subdirectories specified in subpath
3564 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3565 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3566 strlcat( temp, subpath, sizeof(temp) );
3567 listdirectory( &foundSet, searchpath->filename, temp );
3569 if( dirlistindex == 0 ) {
3572 // reset the current result set
3573 stringlistfreecontents( &matchedSet );
3574 // match against the pattern
3575 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3576 const char *direntry = foundSet.strings[ dirlistindex ];
3577 if (matchpattern(direntry, subpattern, true)) {
3578 stringlistappend( &matchedSet, direntry );
3581 stringlistfreecontents( &foundSet );
3583 start = nextseparator;
3586 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3588 const char *temp = matchedSet.strings[dirlistindex];
3589 if (matchpattern(temp, (char *)pattern, true))
3591 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3592 if (!strcmp(resultlist.strings[resultlistindex], temp))
3594 if (resultlistindex == resultlist.numstrings)
3596 stringlistappend(&resultlist, temp);
3597 if (!quiet && developer_loading.integer)
3598 Con_Printf("SearchDirFile: %s\n", temp);
3602 stringlistfreecontents( &matchedSet );
3606 if (resultlist.numstrings)
3608 stringlistsort(&resultlist, true);
3609 numfiles = resultlist.numstrings;
3611 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3612 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3613 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3614 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3615 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3616 search->numfilenames = (int)numfiles;
3619 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3622 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3623 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3624 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3626 numchars += (int)textlen;
3629 stringlistfreecontents(&resultlist);
3635 void FS_FreeSearch(fssearch_t *search)
3640 extern int con_linewidth;
3641 static int FS_ListDirectory(const char *pattern, int oneperline)
3650 char linebuf[MAX_INPUTLINE];
3652 search = FS_Search(pattern, true, true);
3655 numfiles = search->numfilenames;
3658 // FIXME: the names could be added to one column list and then
3659 // gradually shifted into the next column if they fit, and then the
3660 // next to make a compact variable width listing but it's a lot more
3662 // find width for columns
3664 for (i = 0;i < numfiles;i++)
3666 l = (int)strlen(search->filenames[i]);
3667 if (columnwidth < l)
3670 // count the spacing character
3672 // calculate number of columns
3673 numcolumns = con_linewidth / columnwidth;
3674 // don't bother with the column printing if it's only one column
3675 if (numcolumns >= 2)
3677 numlines = (numfiles + numcolumns - 1) / numcolumns;
3678 for (i = 0;i < numlines;i++)
3681 for (k = 0;k < numcolumns;k++)
3683 l = i * numcolumns + k;
3686 name = search->filenames[l];
3687 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3688 linebuf[linebufpos++] = name[j];
3689 // space out name unless it's the last on the line
3690 if (k + 1 < numcolumns && l + 1 < numfiles)
3691 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3692 linebuf[linebufpos++] = ' ';
3695 linebuf[linebufpos] = 0;
3696 Con_Printf("%s\n", linebuf);
3703 for (i = 0;i < numfiles;i++)
3704 Con_Printf("%s\n", search->filenames[i]);
3705 FS_FreeSearch(search);
3706 return (int)numfiles;
3709 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3711 const char *pattern;
3712 if (Cmd_Argc() >= 3)
3714 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3717 if (Cmd_Argc() == 2)
3718 pattern = Cmd_Argv(1);
3721 if (!FS_ListDirectory(pattern, oneperline))
3722 Con_Print("No files found.\n");
3727 FS_ListDirectoryCmd("dir", true);
3732 FS_ListDirectoryCmd("ls", false);
3735 void FS_Which_f(void)
3737 const char *filename;
3740 if (Cmd_Argc() != 2)
3742 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3745 filename = Cmd_Argv(1);
3746 sp = FS_FindFile(filename, &index, true);
3748 Con_Printf("%s isn't anywhere\n", filename);
3754 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3756 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3759 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3763 const char *FS_WhichPack(const char *filename)
3766 searchpath_t *sp = FS_FindFile(filename, &index, true);
3768 return sp->pack->shortname;
3776 ====================
3777 FS_IsRegisteredQuakePack
3779 Look for a proof of purchase file file in the requested package
3781 If it is found, this file should NOT be downloaded.
3782 ====================
3784 qboolean FS_IsRegisteredQuakePack(const char *name)
3786 searchpath_t *search;
3789 // search through the path, one element at a time
3790 for (search = fs_searchpaths;search;search = search->next)
3792 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3793 // TODO do we want to support vpacks in here too?
3795 int (*strcmp_funct) (const char* str1, const char* str2);
3796 int left, right, middle;
3799 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3801 // Look for the file (binary search)
3803 right = pak->numfiles - 1;
3804 while (left <= right)
3808 middle = (left + right) / 2;
3809 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3815 // If we're too far in the list
3822 // we found the requested pack but it is not registered quake
3830 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3833 unsigned char *filedata;
3834 fs_offset_t filesize;
3835 if (filesizepointer)
3836 *filesizepointer = 0;
3837 if (!filename || !*filename)
3839 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3842 if (filesizepointer)
3843 *filesizepointer = filesize;
3844 crc = CRC_Block(filedata, filesize);
3850 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3853 unsigned char *out = NULL;
3857 #ifndef LINK_TO_ZLIB
3862 memset(&strm, 0, sizeof(strm));
3863 strm.zalloc = Z_NULL;
3864 strm.zfree = Z_NULL;
3865 strm.opaque = Z_NULL;
3868 level = Z_DEFAULT_COMPRESSION;
3870 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3872 Con_Printf("FS_Deflate: deflate init error!\n");
3876 strm.next_in = (unsigned char*)data;
3877 strm.avail_in = (unsigned int)size;
3879 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3882 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3883 qz_deflateEnd(&strm);
3887 strm.next_out = tmp;
3888 strm.avail_out = (unsigned int)size;
3890 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3892 Con_Printf("FS_Deflate: deflate failed!\n");
3893 qz_deflateEnd(&strm);
3898 if(qz_deflateEnd(&strm) != Z_OK)
3900 Con_Printf("FS_Deflate: deflateEnd failed\n");
3905 if(strm.total_out >= size)
3907 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3912 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3915 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3921 *deflated_size = (size_t)strm.total_out;
3923 memcpy(out, tmp, strm.total_out);
3929 static void AssertBufsize(sizebuf_t *buf, int length)
3931 if(buf->cursize + length > buf->maxsize)
3933 int oldsize = buf->maxsize;
3934 unsigned char *olddata;
3935 olddata = buf->data;
3936 buf->maxsize += length;
3937 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3940 memcpy(buf->data, olddata, oldsize);
3946 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3950 unsigned char *out = NULL;
3951 unsigned char tmp[2048];
3956 #ifndef LINK_TO_ZLIB
3961 memset(&outbuf, 0, sizeof(outbuf));
3962 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3963 outbuf.maxsize = sizeof(tmp);
3965 memset(&strm, 0, sizeof(strm));
3966 strm.zalloc = Z_NULL;
3967 strm.zfree = Z_NULL;
3968 strm.opaque = Z_NULL;
3970 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3972 Con_Printf("FS_Inflate: inflate init error!\n");
3973 Mem_Free(outbuf.data);
3977 strm.next_in = (unsigned char*)data;
3978 strm.avail_in = (unsigned int)size;
3982 strm.next_out = tmp;
3983 strm.avail_out = sizeof(tmp);
3984 ret = qz_inflate(&strm, Z_NO_FLUSH);
3985 // it either returns Z_OK on progress, Z_STREAM_END on end
3993 case Z_STREAM_ERROR:
3994 Con_Print("FS_Inflate: stream error!\n");
3997 Con_Print("FS_Inflate: data error!\n");
4000 Con_Print("FS_Inflate: mem error!\n");
4003 Con_Print("FS_Inflate: buf error!\n");
4006 Con_Print("FS_Inflate: unknown error!\n");
4010 if(ret != Z_OK && ret != Z_STREAM_END)
4012 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4013 Mem_Free(outbuf.data);
4014 qz_inflateEnd(&strm);
4017 have = sizeof(tmp) - strm.avail_out;
4018 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4019 SZ_Write(&outbuf, tmp, have);
4020 } while(ret != Z_STREAM_END);
4022 qz_inflateEnd(&strm);
4024 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4027 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4028 Mem_Free(outbuf.data);
4032 memcpy(out, outbuf.data, outbuf.cursize);
4033 Mem_Free(outbuf.data);
4036 *inflated_size = (size_t)outbuf.cursize;