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;
896 static void FS_mkdir (const char *path)
898 if(COM_CheckParm("-readonly"))
902 if (_mkdir (path) == -1)
904 if (mkdir (path, 0777) == -1)
907 // No logging for this. The only caller is FS_CreatePath (which
908 // calls it in ways that will intentionally produce EEXIST),
909 // and its own callers always use the directory afterwards and
910 // thus will detect failure that way.
919 Only used for FS_OpenRealFile.
922 void FS_CreatePath (char *path)
926 for (ofs = path+1 ; *ofs ; ofs++)
928 if (*ofs == '/' || *ofs == '\\')
930 // create the directory
946 static void FS_Path_f (void)
950 Con_Print("Current search path:\n");
951 for (s=fs_searchpaths ; s ; s=s->next)
956 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
958 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
961 Con_Printf("%s\n", s->filename);
971 /*! Takes an explicit (not game tree related) path to a pak file.
972 *Loads the header and directory, adding the files at the beginning
973 *of the list so they override previous pack files.
975 static pack_t *FS_LoadPackPAK (const char *packfile)
977 dpackheader_t header;
983 packhandle = FS_SysOpenFD(packfile, "rb", false);
986 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
988 Con_Printf ("%s is not a packfile\n", packfile);
992 if (memcmp(header.id, "PACK", 4))
994 Con_Printf ("%s is not a packfile\n", packfile);
998 header.dirofs = LittleLong (header.dirofs);
999 header.dirlen = LittleLong (header.dirlen);
1001 if (header.dirlen % sizeof(dpackfile_t))
1003 Con_Printf ("%s has an invalid directory size\n", packfile);
1008 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1010 if (numpackfiles > MAX_FILES_IN_PACK)
1012 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
1017 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1018 lseek (packhandle, header.dirofs, SEEK_SET);
1019 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
1021 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
1027 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1028 pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
1029 strlcpy (pack->filename, packfile, sizeof (pack->filename));
1030 pack->handle = packhandle;
1032 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
1034 // parse the directory
1035 for (i = 0;i < numpackfiles;i++)
1037 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1038 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1040 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1045 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1050 ====================
1053 Create a package entry associated with a directory file
1054 ====================
1056 static pack_t *FS_LoadPackVirtual (const char *dirname)
1059 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1061 pack->ignorecase = false;
1062 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1064 pack->numfiles = -1;
1066 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1075 /*! Adds the given pack to the search path.
1076 * The pack type is autodetected by the file extension.
1078 * Returns true if the file was successfully added to the
1079 * search path or if it was already included.
1081 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1082 * plain directories.
1085 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1087 searchpath_t *search;
1089 const char *ext = FS_FileExtension(pakfile);
1092 for(search = fs_searchpaths; search; search = search->next)
1094 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1097 *already_loaded = true;
1098 return true; // already loaded
1103 *already_loaded = false;
1105 if(!strcasecmp(ext, "pk3dir"))
1106 pak = FS_LoadPackVirtual (pakfile);
1107 else if(!strcasecmp(ext, "pak"))
1108 pak = FS_LoadPackPAK (pakfile);
1109 else if(!strcasecmp(ext, "pk3"))
1110 pak = FS_LoadPackPK3 (pakfile);
1111 else if(!strcasecmp(ext, "obb")) // android apk expansion
1112 pak = FS_LoadPackPK3 (pakfile);
1114 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1118 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1120 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1123 // find the first item whose next one is a pack or NULL
1124 searchpath_t *insertion_point = 0;
1125 if(fs_searchpaths && !fs_searchpaths->pack)
1127 insertion_point = fs_searchpaths;
1130 if(!insertion_point->next)
1132 if(insertion_point->next->pack)
1134 insertion_point = insertion_point->next;
1137 // If insertion_point is NULL, this means that either there is no
1138 // item in the list yet, or that the very first item is a pack. In
1139 // that case, we want to insert at the beginning...
1140 if(!insertion_point)
1142 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1143 search->next = fs_searchpaths;
1144 fs_searchpaths = search;
1147 // otherwise we want to append directly after insertion_point.
1149 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1150 search->next = insertion_point->next;
1151 insertion_point->next = search;
1156 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1157 search->next = fs_searchpaths;
1158 fs_searchpaths = search;
1163 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1164 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1165 // same goes for the name inside the pack structure
1166 l = strlen(pak->shortname);
1168 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1169 pak->shortname[l - 3] = 0;
1170 l = strlen(pak->filename);
1172 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1173 pak->filename[l - 3] = 0;
1179 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1190 /*! Adds the given pack to the search path and searches for it in the game path.
1191 * The pack type is autodetected by the file extension.
1193 * Returns true if the file was successfully added to the
1194 * search path or if it was already included.
1196 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1197 * plain directories.
1199 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1201 char fullpath[MAX_OSPATH];
1203 searchpath_t *search;
1206 *already_loaded = false;
1208 // then find the real name...
1209 search = FS_FindFile(pakfile, &index, true);
1210 if(!search || search->pack)
1212 Con_Printf("could not find pak \"%s\"\n", pakfile);
1216 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1218 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1226 Sets fs_gamedir, adds the directory to the head of the path,
1227 then loads and adds pak1.pak pak2.pak ...
1230 static void FS_AddGameDirectory (const char *dir)
1234 searchpath_t *search;
1236 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1238 stringlistinit(&list);
1239 listdirectory(&list, "", dir);
1240 stringlistsort(&list, false);
1242 // add any PAK package in the directory
1243 for (i = 0;i < list.numstrings;i++)
1245 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1247 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1251 // add any PK3 package in the directory
1252 for (i = 0;i < list.numstrings;i++)
1254 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1256 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1260 stringlistfreecontents(&list);
1262 // Add the directory to the search path
1263 // (unpacked files have the priority over packed files)
1264 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1265 strlcpy (search->filename, dir, sizeof (search->filename));
1266 search->next = fs_searchpaths;
1267 fs_searchpaths = search;
1276 static void FS_AddGameHierarchy (const char *dir)
1279 // Add the common game directory
1280 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1283 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1292 const char *FS_FileExtension (const char *in)
1294 const char *separator, *backslash, *colon, *dot;
1296 separator = strrchr(in, '/');
1297 backslash = strrchr(in, '\\');
1298 if (!separator || separator < backslash)
1299 separator = backslash;
1300 colon = strrchr(in, ':');
1301 if (!separator || separator < colon)
1304 dot = strrchr(in, '.');
1305 if (dot == NULL || (separator && (dot < separator)))
1317 const char *FS_FileWithoutPath (const char *in)
1319 const char *separator, *backslash, *colon;
1321 separator = strrchr(in, '/');
1322 backslash = strrchr(in, '\\');
1323 if (!separator || separator < backslash)
1324 separator = backslash;
1325 colon = strrchr(in, ':');
1326 if (!separator || separator < colon)
1328 return separator ? separator + 1 : in;
1337 static void FS_ClearSearchPath (void)
1339 // unload all packs and directory information, close all pack files
1340 // (if a qfile is still reading a pack it won't be harmed because it used
1341 // dup() to get its own handle already)
1342 while (fs_searchpaths)
1344 searchpath_t *search = fs_searchpaths;
1345 fs_searchpaths = search->next;
1346 if (search->pack && search->pack != fs_selfpack)
1348 if(!search->pack->vpack)
1351 close(search->pack->handle);
1352 // free any memory associated with it
1353 if (search->pack->files)
1354 Mem_Free(search->pack->files);
1356 Mem_Free(search->pack);
1362 static void FS_AddSelfPack(void)
1366 searchpath_t *search;
1367 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1368 search->next = fs_searchpaths;
1369 search->pack = fs_selfpack;
1370 fs_searchpaths = search;
1380 void FS_Rescan (void)
1383 qboolean fs_modified = false;
1384 qboolean reset = false;
1385 char gamedirbuf[MAX_INPUTLINE];
1390 FS_ClearSearchPath();
1392 // automatically activate gamemode for the gamedirs specified
1394 COM_ChangeGameTypeForGameDirs();
1396 // add the game-specific paths
1397 // gamedirname1 (typically id1)
1398 FS_AddGameHierarchy (gamedirname1);
1399 // update the com_modname (used for server info)
1400 if (gamedirname2 && gamedirname2[0])
1401 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1403 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1405 // add the game-specific path, if any
1406 // (only used for mission packs and the like, which should set fs_modified)
1407 if (gamedirname2 && gamedirname2[0])
1410 FS_AddGameHierarchy (gamedirname2);
1414 // Adds basedir/gamedir as an override game
1415 // LordHavoc: now supports multiple -game directories
1416 // set the com_modname (reported in server info)
1418 for (i = 0;i < fs_numgamedirs;i++)
1421 FS_AddGameHierarchy (fs_gamedirs[i]);
1422 // update the com_modname (used server info)
1423 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1425 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1427 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1429 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1431 // add back the selfpack as new first item
1434 // set the default screenshot name to either the mod name or the
1435 // gamemode screenshot name
1436 if (strcmp(com_modname, gamedirname1))
1437 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1439 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1441 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1442 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1444 // If "-condebug" is in the command line, remove the previous log file
1445 if (COM_CheckParm ("-condebug") != 0)
1446 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1448 // look for the pop.lmp file and set registered to true if it is found
1449 if (FS_FileExists("gfx/pop.lmp"))
1450 Cvar_Set ("registered", "1");
1456 if (!registered.integer)
1459 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1461 Con_Print("Playing shareware version.\n");
1464 Con_Print("Playing registered version.\n");
1466 case GAME_STEELSTORM:
1467 if (registered.integer)
1468 Con_Print("Playing registered version.\n");
1470 Con_Print("Playing shareware version.\n");
1476 // unload all wads so that future queries will return the new data
1480 static void FS_Rescan_f(void)
1490 extern qboolean vid_opened;
1491 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1496 if (fs_numgamedirs == numgamedirs)
1498 for (i = 0;i < numgamedirs;i++)
1499 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1501 if (i == numgamedirs)
1502 return true; // already using this set of gamedirs, do nothing
1505 if (numgamedirs > MAX_GAMEDIRS)
1508 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1509 return false; // too many gamedirs
1512 for (i = 0;i < numgamedirs;i++)
1514 // if string is nasty, reject it
1515 p = FS_CheckGameDir(gamedirs[i]);
1519 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1520 return false; // nasty gamedirs
1522 if(p == fs_checkgamedir_missing && failmissing)
1525 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1526 return false; // missing gamedirs
1532 fs_numgamedirs = numgamedirs;
1533 for (i = 0;i < fs_numgamedirs;i++)
1534 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1536 // reinitialize filesystem to detect the new paks
1539 if (cls.demoplayback)
1545 // unload all sounds so they will be reloaded from the new files as needed
1546 S_UnloadAllSounds_f();
1548 // close down the video subsystem, it will start up again when the config finishes...
1552 // restart the video subsystem after the config is executed
1553 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1563 static void FS_GameDir_f (void)
1567 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1571 Con_Printf("gamedirs active:");
1572 for (i = 0;i < fs_numgamedirs;i++)
1573 Con_Printf(" %s", fs_gamedirs[i]);
1578 numgamedirs = Cmd_Argc() - 1;
1579 if (numgamedirs > MAX_GAMEDIRS)
1581 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1585 for (i = 0;i < numgamedirs;i++)
1586 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1588 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1590 // actually, changing during game would work fine, but would be stupid
1591 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1595 // halt demo playback to close the file
1598 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1601 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1609 stringlistinit(&list);
1610 listdirectory(&list, gamedir, "");
1611 success = list.numstrings > 0;
1612 stringlistfreecontents(&list);
1616 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1619 n = FS_Read (f, buf, buflength - 1);
1639 const char *FS_CheckGameDir(const char *gamedir)
1645 if (FS_CheckNastyPath(gamedir, true))
1648 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1653 // get description from basedir
1654 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1662 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1666 return fs_checkgamedir_missing;
1669 static void FS_ListGameDirs(void)
1671 stringlist_t list, list2;
1676 fs_all_gamedirs_count = 0;
1678 Mem_Free(fs_all_gamedirs);
1680 stringlistinit(&list);
1681 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1682 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1683 stringlistsort(&list, false);
1685 stringlistinit(&list2);
1686 for(i = 0; i < list.numstrings; ++i)
1689 if(!strcmp(list.strings[i-1], list.strings[i]))
1691 info = FS_CheckGameDir(list.strings[i]);
1694 if(info == fs_checkgamedir_missing)
1698 stringlistappend(&list2, list.strings[i]);
1700 stringlistfreecontents(&list);
1702 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1703 for(i = 0; i < list2.numstrings; ++i)
1705 info = FS_CheckGameDir(list2.strings[i]);
1706 // all this cannot happen any more, but better be safe than sorry
1709 if(info == fs_checkgamedir_missing)
1713 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1714 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1715 ++fs_all_gamedirs_count;
1721 #pragma comment(lib, "shell32.lib")
1731 void FS_Init_SelfPack (void)
1734 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1737 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1743 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1746 const char **new_argv;
1748 int args_left = 256;
1749 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1752 new_argv[0] = "dummy";
1757 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1760 while(COM_ParseToken_Console(&p))
1762 size_t sz = strlen(com_token) + 1; // shut up clang
1765 q = (char *)Mem_Alloc(fs_mempool, sz);
1766 strlcpy(q, com_token, sz);
1767 new_argv[com_argc + i] = q;
1770 new_argv[i+com_argc] = NULL;
1771 com_argv = new_argv;
1772 com_argc = com_argc + i;
1779 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1781 #if defined(__IPHONEOS__)
1782 if (userdirmode == USERDIRMODE_HOME)
1784 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1785 // fs_userdir stores configurations to the Documents folder of the app
1786 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1791 #elif defined(WIN32)
1793 #if _MSC_VER >= 1400
1796 TCHAR mydocsdir[MAX_PATH + 1];
1797 wchar_t *savedgamesdirw;
1798 char savedgamesdir[MAX_OSPATH];
1807 case USERDIRMODE_NOHOME:
1808 strlcpy(userdir, fs_basedir, userdirsize);
1810 case USERDIRMODE_MYGAMES:
1812 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1814 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1816 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1819 #if _MSC_VER >= 1400
1820 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1823 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1828 homedir = getenv("USERPROFILE");
1831 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1836 case USERDIRMODE_SAVEDGAMES:
1838 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1840 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1841 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1843 savedgamesdir[0] = 0;
1844 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1847 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1849 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1852 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1854 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1855 #if _MSC_VER >= 1400
1856 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1858 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1860 qCoTaskMemFree(savedgamesdirw);
1863 if (savedgamesdir[0])
1865 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1880 case USERDIRMODE_NOHOME:
1881 strlcpy(userdir, fs_basedir, userdirsize);
1883 case USERDIRMODE_HOME:
1884 homedir = getenv("HOME");
1887 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1891 case USERDIRMODE_SAVEDGAMES:
1892 homedir = getenv("HOME");
1896 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1898 // the XDG say some files would need to go in:
1899 // XDG_CONFIG_HOME (or ~/.config/%s/)
1900 // XDG_DATA_HOME (or ~/.local/share/%s/)
1901 // XDG_CACHE_HOME (or ~/.cache/%s/)
1902 // and also search the following global locations if defined:
1903 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1904 // XDG_DATA_DIRS (normally /usr/share/%s/)
1905 // this would be too complicated...
1915 #if !defined(__IPHONEOS__)
1918 // historical behavior...
1919 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1920 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
1923 // see if we can write to this path (note: won't create path)
1925 // no access() here, we must try to open the file for appending
1926 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1930 // on Unix, we don't need to ACTUALLY attempt to open the file
1931 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1938 return 1; // good choice - the path exists and is writable
1942 if (userdirmode == USERDIRMODE_NOHOME)
1943 return -1; // path usually already exists, we lack permissions
1945 return 0; // probably good - failed to write but maybe we need to create path
1965 // Overrides the system supplied base directory (under GAMENAME)
1966 // 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)
1967 i = COM_CheckParm ("-basedir");
1968 if (i && i < com_argc-1)
1970 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1971 i = (int)strlen (fs_basedir);
1972 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1973 fs_basedir[i-1] = 0;
1977 // If the base directory is explicitly defined by the compilation process
1978 #ifdef DP_FS_BASEDIR
1979 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1980 #elif defined(__ANDROID__)
1981 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
1982 #elif defined(MACOSX)
1983 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1984 if (strstr(com_argv[0], ".app/"))
1987 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1988 split = strstr(fs_basedir, ".app/");
1991 struct stat statresult;
1993 // truncate to just after the .app/
1995 // see if gamedir exists in Resources
1996 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1998 // found gamedir inside Resources, use it
1999 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
2003 // no gamedir found in Resources, gamedir is probably
2004 // outside the .app, remove .app part of path
2005 while (split > fs_basedir && *split != '/')
2014 // make sure the appending of a path separator won't create an unterminated string
2015 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
2016 // add a path separator to the end of the basedir if it lacks one
2017 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
2018 strlcat(fs_basedir, "/", sizeof(fs_basedir));
2020 // Add the personal game directory
2021 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
2022 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
2023 else if (COM_CheckParm("-nohome"))
2024 *fs_userdir = 0; // user wants roaming installation, no userdir
2028 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2029 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2030 int userdirstatus[USERDIRMODE_COUNT];
2032 // historical behavior...
2033 if (!strcmp(gamedirname1, "id1"))
2034 preferreduserdirmode = USERDIRMODE_NOHOME;
2036 // check what limitations the user wants to impose
2037 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2038 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2039 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2040 // gather the status of the possible userdirs
2041 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2043 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2044 if (userdirstatus[dirmode] == 1)
2045 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2046 else if (userdirstatus[dirmode] == 0)
2047 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2049 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2051 // some games may prefer writing to basedir, but if write fails we
2052 // have to search for a real userdir...
2053 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2054 preferreduserdirmode = highestuserdirmode;
2055 // check for an existing userdir and continue using it if possible...
2056 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2057 if (userdirstatus[dirmode] == 1)
2059 // if no existing userdir found, make a new one...
2060 if (dirmode == 0 && preferreduserdirmode > 0)
2061 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2062 if (userdirstatus[dirmode] >= 0)
2064 // and finally, we picked one...
2065 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2066 Con_DPrintf("userdir %i is the winner\n", dirmode);
2069 // if userdir equal to basedir, clear it to avoid confusion later
2070 if (!strcmp(fs_basedir, fs_userdir))
2075 p = FS_CheckGameDir(gamedirname1);
2076 if(!p || p == fs_checkgamedir_missing)
2077 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2081 p = FS_CheckGameDir(gamedirname2);
2082 if(!p || p == fs_checkgamedir_missing)
2083 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2087 // Adds basedir/gamedir as an override game
2088 // LordHavoc: now supports multiple -game directories
2089 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2093 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2096 p = FS_CheckGameDir(com_argv[i]);
2098 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2099 if(p == fs_checkgamedir_missing)
2100 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2101 // add the gamedir to the list of active gamedirs
2102 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2107 // generate the searchpath
2110 if (Thread_HasThreads())
2111 fs_mutex = Thread_CreateMutex();
2114 void FS_Init_Commands(void)
2116 Cvar_RegisterVariable (&scr_screenshot_name);
2117 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2118 Cvar_RegisterVariable (&cvar_fs_gamedir);
2120 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2121 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2122 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2123 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2124 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2125 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2133 void FS_Shutdown (void)
2135 // close all pack files and such
2136 // (hopefully there aren't any other open files, but they'll be cleaned up
2137 // by the OS anyway)
2138 FS_ClearSearchPath();
2139 Mem_FreePool (&fs_mempool);
2140 PK3_CloseLibrary ();
2143 Sys_UnloadLibrary (&shfolder_dll);
2144 Sys_UnloadLibrary (&shell32_dll);
2145 Sys_UnloadLibrary (&ole32_dll);
2149 Thread_DestroyMutex(fs_mutex);
2152 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2157 qboolean dolock = false;
2159 // Parse the mode string
2168 opt = O_CREAT | O_TRUNC;
2172 opt = O_CREAT | O_APPEND;
2175 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2178 for (ind = 1; mode[ind] != '\0'; ind++)
2192 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2193 filepath, mode, mode[ind]);
2200 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2204 # if _MSC_VER >= 1400
2205 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2207 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2210 handle = open (filepath, mod | opt, 0666);
2211 if(handle >= 0 && dolock)
2214 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2215 l.l_whence = SEEK_SET;
2218 if(fcntl(handle, F_SETLK, &l) == -1)
2230 ====================
2233 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2234 ====================
2236 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2240 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2242 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2243 if (file->handle < 0)
2249 file->filename = Mem_strdup(fs_mempool, filepath);
2251 file->real_length = lseek (file->handle, 0, SEEK_END);
2253 // For files opened in append mode, we start at the end of the file
2255 file->position = file->real_length;
2257 lseek (file->handle, 0, SEEK_SET);
2267 Open a packed file using its package file descriptor
2270 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2276 pfile = &pack->files[pack_ind];
2278 // If we don't have the true offset, get it now
2279 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2280 if (!PK3_GetTrueFileOffset (pfile, pack))
2283 #ifndef LINK_TO_ZLIB
2284 // No Zlib DLL = no compressed files
2285 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2287 Con_Printf("WARNING: can't open the compressed file %s\n"
2288 "You need the Zlib DLL to use compressed files\n",
2294 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2295 // the dup() call to avoid having to close the dup_handle on error here
2296 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2298 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2299 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2303 dup_handle = dup (pack->handle);
2306 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2310 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2311 memset (file, 0, sizeof (*file));
2312 file->handle = dup_handle;
2313 file->flags = QFILE_FLAG_PACKED;
2314 file->real_length = pfile->realsize;
2315 file->offset = pfile->offset;
2319 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2323 file->flags |= QFILE_FLAG_DEFLATED;
2325 // We need some more variables
2326 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2328 ztk->comp_length = pfile->packsize;
2330 // Initialize zlib stream
2331 ztk->zstream.next_in = ztk->input;
2332 ztk->zstream.avail_in = 0;
2334 /* From Zlib's "unzip.c":
2336 * windowBits is passed < 0 to tell that there is no zlib header.
2337 * Note that in this case inflate *requires* an extra "dummy" byte
2338 * after the compressed stream in order to complete decompression and
2339 * return Z_STREAM_END.
2340 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2341 * size of both compressed and uncompressed data
2343 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2345 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2351 ztk->zstream.next_out = file->buff;
2352 ztk->zstream.avail_out = sizeof (file->buff);
2361 ====================
2364 Return true if the path should be rejected due to one of the following:
2365 1: path elements that are non-portable
2366 2: path elements that would allow access to files outside the game directory,
2367 or are just not a good idea for a mod to be using.
2368 ====================
2370 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2372 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2376 // Windows: don't allow \ in filenames (windows-only), period.
2377 // (on Windows \ is a directory separator, but / is also supported)
2378 if (strstr(path, "\\"))
2379 return 1; // non-portable
2381 // Mac: don't allow Mac-only filenames - : is a directory separator
2382 // instead of /, but we rely on / working already, so there's no reason to
2383 // support a Mac-only path
2384 // Amiga and Windows: : tries to go to root of drive
2385 if (strstr(path, ":"))
2386 return 1; // non-portable attempt to go to root of drive
2388 // Amiga: // is parent directory
2389 if (strstr(path, "//"))
2390 return 1; // non-portable attempt to go to parent directory
2392 // all: don't allow going to parent directory (../ or /../)
2393 if (strstr(path, ".."))
2394 return 2; // attempt to go outside the game directory
2396 // Windows and UNIXes: don't allow absolute paths
2398 return 2; // attempt to go outside the game directory
2400 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2401 if (strstr(path, "./"))
2402 return 2; // possible attempt to go outside the game directory
2404 // all: forbid trailing slash on gamedir
2405 if (isgamedir && path[strlen(path)-1] == '/')
2408 // all: forbid leading dot on any filename for any reason
2409 if (strstr(path, "/."))
2410 return 2; // attempt to go outside the game directory
2412 // after all these checks we're pretty sure it's a / separated filename
2413 // and won't do much if any harm
2419 ====================
2422 Look for a file in the packages and in the filesystem
2424 Return the searchpath where the file was found (or NULL)
2425 and the file index in the package if relevant
2426 ====================
2428 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2430 searchpath_t *search;
2433 // search through the path, one element at a time
2434 for (search = fs_searchpaths;search;search = search->next)
2436 // is the element a pak file?
2437 if (search->pack && !search->pack->vpack)
2439 int (*strcmp_funct) (const char* str1, const char* str2);
2440 int left, right, middle;
2443 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2445 // Look for the file (binary search)
2447 right = pak->numfiles - 1;
2448 while (left <= right)
2452 middle = (left + right) / 2;
2453 diff = strcmp_funct (pak->files[middle].name, name);
2458 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2460 // yes, but the first one is empty so we treat it as not being there
2461 if (!quiet && developer_extra.integer)
2462 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2469 if (!quiet && developer_extra.integer)
2470 Con_DPrintf("FS_FindFile: %s in %s\n",
2471 pak->files[middle].name, pak->filename);
2478 // If we're too far in the list
2487 char netpath[MAX_OSPATH];
2488 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2489 if (FS_SysFileExists (netpath))
2491 if (!quiet && developer_extra.integer)
2492 Con_DPrintf("FS_FindFile: %s\n", netpath);
2501 if (!quiet && developer_extra.integer)
2502 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2514 Look for a file in the search paths and open it in read-only mode
2517 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2519 searchpath_t *search;
2522 search = FS_FindFile (filename, &pack_ind, quiet);
2528 // Found in the filesystem?
2531 // this works with vpacks, so we are fine
2532 char path [MAX_OSPATH];
2533 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2534 return FS_SysOpen (path, "rb", nonblocking);
2537 // So, we found it in a package...
2539 // Is it a PK3 symlink?
2540 // TODO also handle directory symlinks by parsing the whole structure...
2541 // but heck, file symlinks are good enough for now
2542 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2544 if(symlinkLevels <= 0)
2546 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2551 char linkbuf[MAX_QPATH];
2553 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2554 const char *mergeslash;
2559 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2565 // Now combine the paths...
2566 mergeslash = strrchr(filename, '/');
2567 mergestart = linkbuf;
2569 mergeslash = filename;
2570 while(!strncmp(mergestart, "../", 3))
2573 while(mergeslash > filename)
2576 if(*mergeslash == '/')
2580 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2581 if(mergeslash == filename)
2583 // Either mergeslash == filename, then we just replace the name (done below)
2587 // Or, we append the name after mergeslash;
2588 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2589 int spaceNeeded = mergeslash - filename + 1;
2590 int spaceRemoved = mergestart - linkbuf;
2591 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2593 Con_DPrintf("symlink: too long path rejected\n");
2596 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2597 memcpy(linkbuf, filename, spaceNeeded);
2598 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2599 mergestart = linkbuf;
2601 if (!quiet && developer_loading.integer)
2602 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2603 if(FS_CheckNastyPath (mergestart, false))
2605 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2608 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2612 return FS_OpenPackedFile (search->pack, pack_ind);
2617 =============================================================================
2619 MAIN PUBLIC FUNCTIONS
2621 =============================================================================
2625 ====================
2628 Open a file in the userpath. The syntax is the same as fopen
2629 Used for savegame scanning in menu, and all file writing.
2630 ====================
2632 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2634 char real_path [MAX_OSPATH];
2636 if (FS_CheckNastyPath(filepath, false))
2638 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2642 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2644 // If the file is opened in "write", "append", or "read/write" mode,
2645 // create directories up to the file.
2646 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2647 FS_CreatePath (real_path);
2648 return FS_SysOpen (real_path, mode, false);
2653 ====================
2656 Open a file. The syntax is the same as fopen
2657 ====================
2659 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2661 qfile_t *result = NULL;
2662 if (FS_CheckNastyPath(filepath, false))
2664 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2668 if (fs_mutex) Thread_LockMutex(fs_mutex);
2669 result = FS_OpenReadFile (filepath, quiet, false, 16);
2670 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2676 ====================
2679 Open a file. The syntax is the same as fopen
2680 ====================
2682 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2685 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2686 memset (file, 0, sizeof (*file));
2687 file->flags = QFILE_FLAG_DATA;
2689 file->real_length = size;
2695 ====================
2699 ====================
2701 int FS_Close (qfile_t* file)
2703 if(file->flags & QFILE_FLAG_DATA)
2709 if (close (file->handle))
2714 if (file->flags & QFILE_FLAG_REMOVE)
2715 remove(file->filename);
2717 Mem_Free((void *) file->filename);
2722 qz_inflateEnd (&file->ztk->zstream);
2723 Mem_Free (file->ztk);
2730 void FS_RemoveOnClose(qfile_t* file)
2732 file->flags |= QFILE_FLAG_REMOVE;
2736 ====================
2739 Write "datasize" bytes into a file
2740 ====================
2742 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2744 fs_offset_t written = 0;
2746 // If necessary, seek to the exact file position we're supposed to be
2747 if (file->buff_ind != file->buff_len)
2749 if (lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
2751 Con_Printf("WARNING: could not seek in %s.\n");
2755 // Purge cached data
2758 // Write the buffer and update the position
2759 // 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)
2760 while (written < (fs_offset_t)datasize)
2762 // figure out how much to write in one chunk
2763 fs_offset_t maxchunk = 1<<30; // 1 GiB
2764 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2765 int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
2766 // if at least some was written, add it to our accumulator
2769 // if the result is not what we expected, consider the write to be incomplete
2770 if (result != chunk)
2773 file->position = lseek (file->handle, 0, SEEK_CUR);
2774 if (file->real_length < file->position)
2775 file->real_length = file->position;
2777 // note that this will never be less than 0 even if the write failed
2783 ====================
2786 Read up to "buffersize" bytes from a file
2787 ====================
2789 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2791 fs_offset_t count, done;
2793 if (buffersize == 0)
2796 // Get rid of the ungetc character
2797 if (file->ungetc != EOF)
2799 ((char*)buffer)[0] = file->ungetc;
2807 if(file->flags & QFILE_FLAG_DATA)
2809 size_t left = file->real_length - file->position;
2810 if(buffersize > left)
2812 memcpy(buffer, file->data + file->position, buffersize);
2813 file->position += buffersize;
2817 // First, we copy as many bytes as we can from "buff"
2818 if (file->buff_ind < file->buff_len)
2820 count = file->buff_len - file->buff_ind;
2821 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2823 memcpy (buffer, &file->buff[file->buff_ind], count);
2824 file->buff_ind += count;
2826 buffersize -= count;
2827 if (buffersize == 0)
2831 // NOTE: at this point, the read buffer is always empty
2833 // If the file isn't compressed
2834 if (! (file->flags & QFILE_FLAG_DEFLATED))
2838 // We must take care to not read after the end of the file
2839 count = file->real_length - file->position;
2841 // If we have a lot of data to get, put them directly into "buffer"
2842 if (buffersize > sizeof (file->buff) / 2)
2844 if (count > (fs_offset_t)buffersize)
2845 count = (fs_offset_t)buffersize;
2846 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2848 // Seek failed. When reading from a pipe, and
2849 // the caller never called FS_Seek, this still
2850 // works fine. So no reporting this error.
2852 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2856 file->position += nb;
2858 // Purge cached data
2864 if (count > (fs_offset_t)sizeof (file->buff))
2865 count = (fs_offset_t)sizeof (file->buff);
2866 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2868 // Seek failed. When reading from a pipe, and
2869 // the caller never called FS_Seek, this still
2870 // works fine. So no reporting this error.
2872 nb = read (file->handle, file->buff, count);
2875 file->buff_len = nb;
2876 file->position += nb;
2878 // Copy the requested data in "buffer" (as much as we can)
2879 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2880 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2881 file->buff_ind = count;
2889 // If the file is compressed, it's more complicated...
2890 // We cycle through a few operations until we have read enough data
2891 while (buffersize > 0)
2893 ztoolkit_t *ztk = file->ztk;
2896 // NOTE: at this point, the read buffer is always empty
2898 // If "input" is also empty, we need to refill it
2899 if (ztk->in_ind == ztk->in_len)
2901 // If we are at the end of the file
2902 if (file->position == file->real_length)
2905 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2906 if (count > (fs_offset_t)sizeof (ztk->input))
2907 count = (fs_offset_t)sizeof (ztk->input);
2908 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2909 if (read (file->handle, ztk->input, count) != count)
2911 Con_Printf ("FS_Read: unexpected end of file\n");
2916 ztk->in_len = count;
2917 ztk->in_position += count;
2920 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2921 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2923 // Now that we are sure we have compressed data available, we need to determine
2924 // if it's better to inflate it in "file->buff" or directly in "buffer"
2926 // Inflate the data in "file->buff"
2927 if (buffersize < sizeof (file->buff) / 2)
2929 ztk->zstream.next_out = file->buff;
2930 ztk->zstream.avail_out = sizeof (file->buff);
2931 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2932 if (error != Z_OK && error != Z_STREAM_END)
2934 Con_Printf ("FS_Read: Can't inflate file\n");
2937 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2939 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2940 file->position += file->buff_len;
2942 // Copy the requested data in "buffer" (as much as we can)
2943 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2944 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2945 file->buff_ind = count;
2948 // Else, we inflate directly in "buffer"
2951 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2952 ztk->zstream.avail_out = (unsigned int)buffersize;
2953 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2954 if (error != Z_OK && error != Z_STREAM_END)
2956 Con_Printf ("FS_Read: Can't inflate file\n");
2959 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2961 // How much data did it inflate?
2962 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2963 file->position += count;
2965 // Purge cached data
2970 buffersize -= count;
2978 ====================
2981 Print a string into a file
2982 ====================
2984 int FS_Print (qfile_t* file, const char *msg)
2986 return (int)FS_Write (file, msg, strlen (msg));
2990 ====================
2993 Print a string into a file
2994 ====================
2996 int FS_Printf(qfile_t* file, const char* format, ...)
3001 va_start (args, format);
3002 result = FS_VPrintf (file, format, args);
3010 ====================
3013 Print a string into a file
3014 ====================
3016 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3019 fs_offset_t buff_size = MAX_INPUTLINE;
3024 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3025 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3026 if (len >= 0 && len < buff_size)
3028 Mem_Free (tempbuff);
3032 len = write (file->handle, tempbuff, len);
3033 Mem_Free (tempbuff);
3040 ====================
3043 Get the next character of a file
3044 ====================
3046 int FS_Getc (qfile_t* file)
3050 if (FS_Read (file, &c, 1) != 1)
3058 ====================
3061 Put a character back into the read buffer (only supports one character!)
3062 ====================
3064 int FS_UnGetc (qfile_t* file, unsigned char c)
3066 // If there's already a character waiting to be read
3067 if (file->ungetc != EOF)
3076 ====================
3079 Move the position index in a file
3080 ====================
3082 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3085 unsigned char* buffer;
3086 fs_offset_t buffersize;
3088 // Compute the file offset
3092 offset += file->position - file->buff_len + file->buff_ind;
3099 offset += file->real_length;
3105 if (offset < 0 || offset > file->real_length)
3108 if(file->flags & QFILE_FLAG_DATA)
3110 file->position = offset;
3114 // If we have the data in our read buffer, we don't need to actually seek
3115 if (file->position - file->buff_len <= offset && offset <= file->position)
3117 file->buff_ind = offset + file->buff_len - file->position;
3121 // Purge cached data
3124 // Unpacked or uncompressed files can seek directly
3125 if (! (file->flags & QFILE_FLAG_DEFLATED))
3127 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3129 file->position = offset;
3133 // Seeking in compressed files is more a hack than anything else,
3134 // but we need to support it, so here we go.
3137 // If we have to go back in the file, we need to restart from the beginning
3138 if (offset <= file->position)
3142 ztk->in_position = 0;
3144 if (lseek (file->handle, file->offset, SEEK_SET) == -1)
3145 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3147 // Reset the Zlib stream
3148 ztk->zstream.next_in = ztk->input;
3149 ztk->zstream.avail_in = 0;
3150 qz_inflateReset (&ztk->zstream);
3153 // We need a big buffer to force inflating into it directly
3154 buffersize = 2 * sizeof (file->buff);
3155 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3157 // Skip all data until we reach the requested offset
3158 while (offset > file->position)
3160 fs_offset_t diff = offset - file->position;
3161 fs_offset_t count, len;
3163 count = (diff > buffersize) ? buffersize : diff;
3164 len = FS_Read (file, buffer, count);
3178 ====================
3181 Give the current position in a file
3182 ====================
3184 fs_offset_t FS_Tell (qfile_t* file)
3186 return file->position - file->buff_len + file->buff_ind;
3191 ====================
3194 Give the total size of a file
3195 ====================
3197 fs_offset_t FS_FileSize (qfile_t* file)
3199 return file->real_length;
3204 ====================
3207 Erases any buffered input or output data
3208 ====================
3210 void FS_Purge (qfile_t* file)
3222 Filename are relative to the quake directory.
3223 Always appends a 0 byte.
3226 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3229 unsigned char *buf = NULL;
3230 fs_offset_t filesize = 0;
3232 file = FS_OpenVirtualFile(path, quiet);
3235 filesize = file->real_length;
3238 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3243 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3244 buf[filesize] = '\0';
3245 FS_Read (file, buf, filesize);
3247 if (developer_loadfile.integer)
3248 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3251 if (filesizepointer)
3252 *filesizepointer = filesize;
3261 The filename will be prefixed by the current game directory
3264 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3268 fs_offset_t lentotal;
3270 file = FS_OpenRealFile(filename, "wb", false);
3273 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3278 for(i = 0; i < count; ++i)
3280 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3281 for(i = 0; i < count; ++i)
3282 FS_Write (file, data[i], len[i]);
3287 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3289 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3294 =============================================================================
3296 OTHERS PUBLIC FUNCTIONS
3298 =============================================================================
3306 void FS_StripExtension (const char *in, char *out, size_t size_out)
3314 while ((currentchar = *in) && size_out > 1)
3316 if (currentchar == '.')
3318 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3320 *out++ = currentchar;
3336 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3340 // if path doesn't have a .EXT, append extension
3341 // (extension should include the .)
3342 src = path + strlen(path) - 1;
3344 while (*src != '/' && src != path)
3347 return; // it has an extension
3351 strlcat (path, extension, size_path);
3359 Look for a file in the packages and in the filesystem
3362 int FS_FileType (const char *filename)
3364 searchpath_t *search;
3365 char fullpath[MAX_OSPATH];
3367 search = FS_FindFile (filename, NULL, true);
3369 return FS_FILETYPE_NONE;
3371 if(search->pack && !search->pack->vpack)
3372 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3374 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3375 return FS_SysFileType(fullpath);
3383 Look for a file in the packages and in the filesystem
3386 qboolean FS_FileExists (const char *filename)
3388 return (FS_FindFile (filename, NULL, true) != NULL);
3396 Look for a file in the filesystem only
3399 int FS_SysFileType (const char *path)
3402 // Sajt - some older sdks are missing this define
3403 # ifndef INVALID_FILE_ATTRIBUTES
3404 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3407 DWORD result = GetFileAttributes(path);
3409 if(result == INVALID_FILE_ATTRIBUTES)
3410 return FS_FILETYPE_NONE;
3412 if(result & FILE_ATTRIBUTE_DIRECTORY)
3413 return FS_FILETYPE_DIRECTORY;
3415 return FS_FILETYPE_FILE;
3419 if (stat (path,&buf) == -1)
3420 return FS_FILETYPE_NONE;
3423 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3425 if(S_ISDIR(buf.st_mode))
3426 return FS_FILETYPE_DIRECTORY;
3428 return FS_FILETYPE_FILE;
3432 qboolean FS_SysFileExists (const char *path)
3434 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3441 Allocate and fill a search structure with information on matching filenames.
3444 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3447 searchpath_t *searchpath;
3449 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3450 stringlist_t resultlist;
3451 stringlist_t dirlist;
3452 const char *slash, *backslash, *colon, *separator;
3454 char temp[MAX_OSPATH];
3456 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3461 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3465 stringlistinit(&resultlist);
3466 stringlistinit(&dirlist);
3468 slash = strrchr(pattern, '/');
3469 backslash = strrchr(pattern, '\\');
3470 colon = strrchr(pattern, ':');
3471 separator = max(slash, backslash);
3472 separator = max(separator, colon);
3473 basepathlength = separator ? (separator + 1 - pattern) : 0;
3474 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3476 memcpy(basepath, pattern, basepathlength);
3477 basepath[basepathlength] = 0;
3479 // search through the path, one element at a time
3480 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3482 // is the element a pak file?
3483 if (searchpath->pack && !searchpath->pack->vpack)
3485 // look through all the pak file elements
3486 pak = searchpath->pack;
3487 for (i = 0;i < pak->numfiles;i++)
3489 strlcpy(temp, pak->files[i].name, sizeof(temp));
3492 if (matchpattern(temp, (char *)pattern, true))
3494 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3495 if (!strcmp(resultlist.strings[resultlistindex], temp))
3497 if (resultlistindex == resultlist.numstrings)
3499 stringlistappend(&resultlist, temp);
3500 if (!quiet && developer_loading.integer)
3501 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3504 // strip off one path element at a time until empty
3505 // this way directories are added to the listing if they match the pattern
3506 slash = strrchr(temp, '/');
3507 backslash = strrchr(temp, '\\');
3508 colon = strrchr(temp, ':');
3510 if (separator < slash)
3512 if (separator < backslash)
3513 separator = backslash;
3514 if (separator < colon)
3516 *((char *)separator) = 0;
3522 stringlist_t matchedSet, foundSet;
3523 const char *start = pattern;
3525 stringlistinit(&matchedSet);
3526 stringlistinit(&foundSet);
3527 // add a first entry to the set
3528 stringlistappend(&matchedSet, "");
3529 // iterate through pattern's path
3532 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3533 char subpath[MAX_OSPATH];
3534 char subpattern[MAX_OSPATH];
3536 // find the next wildcard
3537 wildcard = strchr(start, '?');
3538 asterisk = strchr(start, '*');
3539 if (asterisk && (!wildcard || asterisk < wildcard))
3541 wildcard = asterisk;
3546 nextseparator = strchr( wildcard, '/' );
3550 nextseparator = NULL;
3553 if( !nextseparator ) {
3554 nextseparator = start + strlen( start );
3557 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3558 // copy everything up except nextseperator
3559 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3560 // find the last '/' before the wildcard
3561 prevseparator = strrchr( subpattern, '/' );
3563 prevseparator = subpattern;
3566 // copy everything from start to the previous including the '/' (before the wildcard)
3567 // everything up to start is already included in the path of matchedSet's entries
3568 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3570 // for each entry in matchedSet try to open the subdirectories specified in subpath
3571 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3572 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3573 strlcat( temp, subpath, sizeof(temp) );
3574 listdirectory( &foundSet, searchpath->filename, temp );
3576 if( dirlistindex == 0 ) {
3579 // reset the current result set
3580 stringlistfreecontents( &matchedSet );
3581 // match against the pattern
3582 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3583 const char *direntry = foundSet.strings[ dirlistindex ];
3584 if (matchpattern(direntry, subpattern, true)) {
3585 stringlistappend( &matchedSet, direntry );
3588 stringlistfreecontents( &foundSet );
3590 start = nextseparator;
3593 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3595 const char *temp = matchedSet.strings[dirlistindex];
3596 if (matchpattern(temp, (char *)pattern, true))
3598 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3599 if (!strcmp(resultlist.strings[resultlistindex], temp))
3601 if (resultlistindex == resultlist.numstrings)
3603 stringlistappend(&resultlist, temp);
3604 if (!quiet && developer_loading.integer)
3605 Con_Printf("SearchDirFile: %s\n", temp);
3609 stringlistfreecontents( &matchedSet );
3613 if (resultlist.numstrings)
3615 stringlistsort(&resultlist, true);
3616 numfiles = resultlist.numstrings;
3618 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3619 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3620 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3621 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3622 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3623 search->numfilenames = (int)numfiles;
3626 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3629 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3630 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3631 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3633 numchars += (int)textlen;
3636 stringlistfreecontents(&resultlist);
3642 void FS_FreeSearch(fssearch_t *search)
3647 extern int con_linewidth;
3648 static int FS_ListDirectory(const char *pattern, int oneperline)
3657 char linebuf[MAX_INPUTLINE];
3659 search = FS_Search(pattern, true, true);
3662 numfiles = search->numfilenames;
3665 // FIXME: the names could be added to one column list and then
3666 // gradually shifted into the next column if they fit, and then the
3667 // next to make a compact variable width listing but it's a lot more
3669 // find width for columns
3671 for (i = 0;i < numfiles;i++)
3673 l = (int)strlen(search->filenames[i]);
3674 if (columnwidth < l)
3677 // count the spacing character
3679 // calculate number of columns
3680 numcolumns = con_linewidth / columnwidth;
3681 // don't bother with the column printing if it's only one column
3682 if (numcolumns >= 2)
3684 numlines = (numfiles + numcolumns - 1) / numcolumns;
3685 for (i = 0;i < numlines;i++)
3688 for (k = 0;k < numcolumns;k++)
3690 l = i * numcolumns + k;
3693 name = search->filenames[l];
3694 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3695 linebuf[linebufpos++] = name[j];
3696 // space out name unless it's the last on the line
3697 if (k + 1 < numcolumns && l + 1 < numfiles)
3698 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3699 linebuf[linebufpos++] = ' ';
3702 linebuf[linebufpos] = 0;
3703 Con_Printf("%s\n", linebuf);
3710 for (i = 0;i < numfiles;i++)
3711 Con_Printf("%s\n", search->filenames[i]);
3712 FS_FreeSearch(search);
3713 return (int)numfiles;
3716 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3718 const char *pattern;
3719 if (Cmd_Argc() >= 3)
3721 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3724 if (Cmd_Argc() == 2)
3725 pattern = Cmd_Argv(1);
3728 if (!FS_ListDirectory(pattern, oneperline))
3729 Con_Print("No files found.\n");
3734 FS_ListDirectoryCmd("dir", true);
3739 FS_ListDirectoryCmd("ls", false);
3742 void FS_Which_f(void)
3744 const char *filename;
3747 if (Cmd_Argc() != 2)
3749 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3752 filename = Cmd_Argv(1);
3753 sp = FS_FindFile(filename, &index, true);
3755 Con_Printf("%s isn't anywhere\n", filename);
3761 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3763 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3766 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3770 const char *FS_WhichPack(const char *filename)
3773 searchpath_t *sp = FS_FindFile(filename, &index, true);
3775 return sp->pack->shortname;
3783 ====================
3784 FS_IsRegisteredQuakePack
3786 Look for a proof of purchase file file in the requested package
3788 If it is found, this file should NOT be downloaded.
3789 ====================
3791 qboolean FS_IsRegisteredQuakePack(const char *name)
3793 searchpath_t *search;
3796 // search through the path, one element at a time
3797 for (search = fs_searchpaths;search;search = search->next)
3799 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3800 // TODO do we want to support vpacks in here too?
3802 int (*strcmp_funct) (const char* str1, const char* str2);
3803 int left, right, middle;
3806 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3808 // Look for the file (binary search)
3810 right = pak->numfiles - 1;
3811 while (left <= right)
3815 middle = (left + right) / 2;
3816 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3822 // If we're too far in the list
3829 // we found the requested pack but it is not registered quake
3837 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3840 unsigned char *filedata;
3841 fs_offset_t filesize;
3842 if (filesizepointer)
3843 *filesizepointer = 0;
3844 if (!filename || !*filename)
3846 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3849 if (filesizepointer)
3850 *filesizepointer = filesize;
3851 crc = CRC_Block(filedata, filesize);
3857 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3860 unsigned char *out = NULL;
3864 #ifndef LINK_TO_ZLIB
3869 memset(&strm, 0, sizeof(strm));
3870 strm.zalloc = Z_NULL;
3871 strm.zfree = Z_NULL;
3872 strm.opaque = Z_NULL;
3875 level = Z_DEFAULT_COMPRESSION;
3877 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3879 Con_Printf("FS_Deflate: deflate init error!\n");
3883 strm.next_in = (unsigned char*)data;
3884 strm.avail_in = (unsigned int)size;
3886 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3889 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3890 qz_deflateEnd(&strm);
3894 strm.next_out = tmp;
3895 strm.avail_out = (unsigned int)size;
3897 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3899 Con_Printf("FS_Deflate: deflate failed!\n");
3900 qz_deflateEnd(&strm);
3905 if(qz_deflateEnd(&strm) != Z_OK)
3907 Con_Printf("FS_Deflate: deflateEnd failed\n");
3912 if(strm.total_out >= size)
3914 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3919 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3922 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3928 *deflated_size = (size_t)strm.total_out;
3930 memcpy(out, tmp, strm.total_out);
3936 static void AssertBufsize(sizebuf_t *buf, int length)
3938 if(buf->cursize + length > buf->maxsize)
3940 int oldsize = buf->maxsize;
3941 unsigned char *olddata;
3942 olddata = buf->data;
3943 buf->maxsize += length;
3944 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3947 memcpy(buf->data, olddata, oldsize);
3953 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3957 unsigned char *out = NULL;
3958 unsigned char tmp[2048];
3963 #ifndef LINK_TO_ZLIB
3968 memset(&outbuf, 0, sizeof(outbuf));
3969 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3970 outbuf.maxsize = sizeof(tmp);
3972 memset(&strm, 0, sizeof(strm));
3973 strm.zalloc = Z_NULL;
3974 strm.zfree = Z_NULL;
3975 strm.opaque = Z_NULL;
3977 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3979 Con_Printf("FS_Inflate: inflate init error!\n");
3980 Mem_Free(outbuf.data);
3984 strm.next_in = (unsigned char*)data;
3985 strm.avail_in = (unsigned int)size;
3989 strm.next_out = tmp;
3990 strm.avail_out = sizeof(tmp);
3991 ret = qz_inflate(&strm, Z_NO_FLUSH);
3992 // it either returns Z_OK on progress, Z_STREAM_END on end
4000 case Z_STREAM_ERROR:
4001 Con_Print("FS_Inflate: stream error!\n");
4004 Con_Print("FS_Inflate: data error!\n");
4007 Con_Print("FS_Inflate: mem error!\n");
4010 Con_Print("FS_Inflate: buf error!\n");
4013 Con_Print("FS_Inflate: unknown error!\n");
4017 if(ret != Z_OK && ret != Z_STREAM_END)
4019 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4020 Mem_Free(outbuf.data);
4021 qz_inflateEnd(&strm);
4024 have = sizeof(tmp) - strm.avail_out;
4025 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4026 SZ_Write(&outbuf, tmp, have);
4027 } while(ret != Z_STREAM_END);
4029 qz_inflateEnd(&strm);
4031 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4034 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4035 Mem_Free(outbuf.data);
4039 memcpy(out, outbuf.data, outbuf.cursize);
4040 Mem_Free(outbuf.data);
4043 *inflated_size = (size_t)outbuf.cursize;