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 > filesize ||
591 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 < 0 || 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 // Ensure a zero terminated file name (required by format).
1041 info[i].name[sizeof(info[i].name) - 1] = 0;
1043 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1048 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1053 ====================
1056 Create a package entry associated with a directory file
1057 ====================
1059 static pack_t *FS_LoadPackVirtual (const char *dirname)
1062 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1064 pack->ignorecase = false;
1065 strlcpy (pack->filename, dirname, sizeof(pack->filename));
1067 pack->numfiles = -1;
1069 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1078 /*! Adds the given pack to the search path.
1079 * The pack type is autodetected by the file extension.
1081 * Returns true if the file was successfully added to the
1082 * search path or if it was already included.
1084 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1085 * plain directories.
1088 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1090 searchpath_t *search;
1092 const char *ext = FS_FileExtension(pakfile);
1095 for(search = fs_searchpaths; search; search = search->next)
1097 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1100 *already_loaded = true;
1101 return true; // already loaded
1106 *already_loaded = false;
1108 if(!strcasecmp(ext, "pk3dir"))
1109 pak = FS_LoadPackVirtual (pakfile);
1110 else if(!strcasecmp(ext, "pak"))
1111 pak = FS_LoadPackPAK (pakfile);
1112 else if(!strcasecmp(ext, "pk3"))
1113 pak = FS_LoadPackPK3 (pakfile);
1114 else if(!strcasecmp(ext, "obb")) // android apk expansion
1115 pak = FS_LoadPackPK3 (pakfile);
1117 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1121 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1123 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1126 // find the first item whose next one is a pack or NULL
1127 searchpath_t *insertion_point = 0;
1128 if(fs_searchpaths && !fs_searchpaths->pack)
1130 insertion_point = fs_searchpaths;
1133 if(!insertion_point->next)
1135 if(insertion_point->next->pack)
1137 insertion_point = insertion_point->next;
1140 // If insertion_point is NULL, this means that either there is no
1141 // item in the list yet, or that the very first item is a pack. In
1142 // that case, we want to insert at the beginning...
1143 if(!insertion_point)
1145 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1146 search->next = fs_searchpaths;
1147 fs_searchpaths = search;
1150 // otherwise we want to append directly after insertion_point.
1152 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1153 search->next = insertion_point->next;
1154 insertion_point->next = search;
1159 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1160 search->next = fs_searchpaths;
1161 fs_searchpaths = search;
1166 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1167 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1168 // same goes for the name inside the pack structure
1169 l = strlen(pak->shortname);
1171 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1172 pak->shortname[l - 3] = 0;
1173 l = strlen(pak->filename);
1175 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1176 pak->filename[l - 3] = 0;
1182 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1193 /*! Adds the given pack to the search path and searches for it in the game path.
1194 * The pack type is autodetected by the file extension.
1196 * Returns true if the file was successfully added to the
1197 * search path or if it was already included.
1199 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1200 * plain directories.
1202 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1204 char fullpath[MAX_OSPATH];
1206 searchpath_t *search;
1209 *already_loaded = false;
1211 // then find the real name...
1212 search = FS_FindFile(pakfile, &index, true);
1213 if(!search || search->pack)
1215 Con_Printf("could not find pak \"%s\"\n", pakfile);
1219 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1221 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1229 Sets fs_gamedir, adds the directory to the head of the path,
1230 then loads and adds pak1.pak pak2.pak ...
1233 static void FS_AddGameDirectory (const char *dir)
1237 searchpath_t *search;
1239 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1241 stringlistinit(&list);
1242 listdirectory(&list, "", dir);
1243 stringlistsort(&list, false);
1245 // add any PAK package in the directory
1246 for (i = 0;i < list.numstrings;i++)
1248 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1250 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1254 // add any PK3 package in the directory
1255 for (i = 0;i < list.numstrings;i++)
1257 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1259 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1263 stringlistfreecontents(&list);
1265 // Add the directory to the search path
1266 // (unpacked files have the priority over packed files)
1267 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1268 strlcpy (search->filename, dir, sizeof (search->filename));
1269 search->next = fs_searchpaths;
1270 fs_searchpaths = search;
1279 static void FS_AddGameHierarchy (const char *dir)
1282 // Add the common game directory
1283 FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1286 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1295 const char *FS_FileExtension (const char *in)
1297 const char *separator, *backslash, *colon, *dot;
1299 separator = strrchr(in, '/');
1300 backslash = strrchr(in, '\\');
1301 if (!separator || separator < backslash)
1302 separator = backslash;
1303 colon = strrchr(in, ':');
1304 if (!separator || separator < colon)
1307 dot = strrchr(in, '.');
1308 if (dot == NULL || (separator && (dot < separator)))
1320 const char *FS_FileWithoutPath (const char *in)
1322 const char *separator, *backslash, *colon;
1324 separator = strrchr(in, '/');
1325 backslash = strrchr(in, '\\');
1326 if (!separator || separator < backslash)
1327 separator = backslash;
1328 colon = strrchr(in, ':');
1329 if (!separator || separator < colon)
1331 return separator ? separator + 1 : in;
1340 static void FS_ClearSearchPath (void)
1342 // unload all packs and directory information, close all pack files
1343 // (if a qfile is still reading a pack it won't be harmed because it used
1344 // dup() to get its own handle already)
1345 while (fs_searchpaths)
1347 searchpath_t *search = fs_searchpaths;
1348 fs_searchpaths = search->next;
1349 if (search->pack && search->pack != fs_selfpack)
1351 if(!search->pack->vpack)
1354 close(search->pack->handle);
1355 // free any memory associated with it
1356 if (search->pack->files)
1357 Mem_Free(search->pack->files);
1359 Mem_Free(search->pack);
1365 static void FS_AddSelfPack(void)
1369 searchpath_t *search;
1370 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1371 search->next = fs_searchpaths;
1372 search->pack = fs_selfpack;
1373 fs_searchpaths = search;
1383 void FS_Rescan (void)
1386 qboolean fs_modified = false;
1387 qboolean reset = false;
1388 char gamedirbuf[MAX_INPUTLINE];
1393 FS_ClearSearchPath();
1395 // automatically activate gamemode for the gamedirs specified
1397 COM_ChangeGameTypeForGameDirs();
1399 // add the game-specific paths
1400 // gamedirname1 (typically id1)
1401 FS_AddGameHierarchy (gamedirname1);
1402 // update the com_modname (used for server info)
1403 if (gamedirname2 && gamedirname2[0])
1404 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1406 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1408 // add the game-specific path, if any
1409 // (only used for mission packs and the like, which should set fs_modified)
1410 if (gamedirname2 && gamedirname2[0])
1413 FS_AddGameHierarchy (gamedirname2);
1417 // Adds basedir/gamedir as an override game
1418 // LordHavoc: now supports multiple -game directories
1419 // set the com_modname (reported in server info)
1421 for (i = 0;i < fs_numgamedirs;i++)
1424 FS_AddGameHierarchy (fs_gamedirs[i]);
1425 // update the com_modname (used server info)
1426 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1428 strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1430 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1432 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1434 // add back the selfpack as new first item
1437 // set the default screenshot name to either the mod name or the
1438 // gamemode screenshot name
1439 if (strcmp(com_modname, gamedirname1))
1440 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1442 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1444 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1445 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1447 // If "-condebug" is in the command line, remove the previous log file
1448 if (COM_CheckParm ("-condebug") != 0)
1449 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1451 // look for the pop.lmp file and set registered to true if it is found
1452 if (FS_FileExists("gfx/pop.lmp"))
1453 Cvar_Set ("registered", "1");
1459 if (!registered.integer)
1462 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1464 Con_Print("Playing shareware version.\n");
1467 Con_Print("Playing registered version.\n");
1469 case GAME_STEELSTORM:
1470 if (registered.integer)
1471 Con_Print("Playing registered version.\n");
1473 Con_Print("Playing shareware version.\n");
1479 // unload all wads so that future queries will return the new data
1483 static void FS_Rescan_f(void)
1493 extern qboolean vid_opened;
1494 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1499 if (fs_numgamedirs == numgamedirs)
1501 for (i = 0;i < numgamedirs;i++)
1502 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1504 if (i == numgamedirs)
1505 return true; // already using this set of gamedirs, do nothing
1508 if (numgamedirs > MAX_GAMEDIRS)
1511 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1512 return false; // too many gamedirs
1515 for (i = 0;i < numgamedirs;i++)
1517 // if string is nasty, reject it
1518 p = FS_CheckGameDir(gamedirs[i]);
1522 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1523 return false; // nasty gamedirs
1525 if(p == fs_checkgamedir_missing && failmissing)
1528 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1529 return false; // missing gamedirs
1535 fs_numgamedirs = numgamedirs;
1536 for (i = 0;i < fs_numgamedirs;i++)
1537 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1539 // reinitialize filesystem to detect the new paks
1542 if (cls.demoplayback)
1548 // unload all sounds so they will be reloaded from the new files as needed
1549 S_UnloadAllSounds_f();
1551 // close down the video subsystem, it will start up again when the config finishes...
1555 // restart the video subsystem after the config is executed
1556 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1566 static void FS_GameDir_f (void)
1570 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1574 Con_Printf("gamedirs active:");
1575 for (i = 0;i < fs_numgamedirs;i++)
1576 Con_Printf(" %s", fs_gamedirs[i]);
1581 numgamedirs = Cmd_Argc() - 1;
1582 if (numgamedirs > MAX_GAMEDIRS)
1584 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1588 for (i = 0;i < numgamedirs;i++)
1589 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1591 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1593 // actually, changing during game would work fine, but would be stupid
1594 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1598 // halt demo playback to close the file
1601 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1604 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1612 stringlistinit(&list);
1613 listdirectory(&list, gamedir, "");
1614 success = list.numstrings > 0;
1615 stringlistfreecontents(&list);
1619 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1622 n = FS_Read (f, buf, buflength - 1);
1642 const char *FS_CheckGameDir(const char *gamedir)
1645 static char buf[8192];
1648 if (FS_CheckNastyPath(gamedir, true))
1651 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1656 // get description from basedir
1657 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1665 ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1669 return fs_checkgamedir_missing;
1672 static void FS_ListGameDirs(void)
1674 stringlist_t list, list2;
1679 fs_all_gamedirs_count = 0;
1681 Mem_Free(fs_all_gamedirs);
1683 stringlistinit(&list);
1684 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1685 listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1686 stringlistsort(&list, false);
1688 stringlistinit(&list2);
1689 for(i = 0; i < list.numstrings; ++i)
1692 if(!strcmp(list.strings[i-1], list.strings[i]))
1694 info = FS_CheckGameDir(list.strings[i]);
1697 if(info == fs_checkgamedir_missing)
1701 stringlistappend(&list2, list.strings[i]);
1703 stringlistfreecontents(&list);
1705 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1706 for(i = 0; i < list2.numstrings; ++i)
1708 info = FS_CheckGameDir(list2.strings[i]);
1709 // all this cannot happen any more, but better be safe than sorry
1712 if(info == fs_checkgamedir_missing)
1716 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1717 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1718 ++fs_all_gamedirs_count;
1724 #pragma comment(lib, "shell32.lib")
1729 static void COM_InsertFlags(const char *buf) {
1732 const char **new_argv;
1734 int args_left = 256;
1735 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1737 new_argv[0] = "dummy"; // Can't really happen.
1739 new_argv[0] = com_argv[0];
1742 while(COM_ParseToken_Console(&p))
1744 size_t sz = strlen(com_token) + 1; // shut up clang
1747 q = (char *)Mem_Alloc(fs_mempool, sz);
1748 strlcpy(q, com_token, sz);
1752 // Now: i <= args_left + 1.
1755 memcpy((char *)(&new_argv[i]), &com_argv[1], sizeof(*com_argv) * (com_argc - 1));
1758 // Now: i <= args_left + (com_argc || 1).
1760 com_argv = new_argv;
1769 static unsigned char *FS_SysLoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer);
1770 void FS_Init_SelfPack (void)
1773 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1775 // Load darkplaces.opt from the FS.
1776 if (!COM_CheckParm("-noopt"))
1778 char *buf = (char *) FS_SysLoadFile("darkplaces.opt", tempmempool, true, NULL);
1780 COM_InsertFlags(buf);
1784 // Provide the SelfPack.
1785 if (!COM_CheckParm("-noselfpack"))
1787 if (com_selffd >= 0)
1789 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1793 if (!COM_CheckParm("-noopt"))
1795 char *buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1797 COM_InsertFlags(buf);
1805 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1807 #if defined(__IPHONEOS__)
1808 if (userdirmode == USERDIRMODE_HOME)
1810 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1811 // fs_userdir stores configurations to the Documents folder of the app
1812 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1817 #elif defined(WIN32)
1819 #if _MSC_VER >= 1400
1822 TCHAR mydocsdir[MAX_PATH + 1];
1823 wchar_t *savedgamesdirw;
1824 char savedgamesdir[MAX_OSPATH];
1833 case USERDIRMODE_NOHOME:
1834 strlcpy(userdir, fs_basedir, userdirsize);
1836 case USERDIRMODE_MYGAMES:
1838 Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1840 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1842 dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1845 #if _MSC_VER >= 1400
1846 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1849 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1854 homedir = getenv("USERPROFILE");
1857 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1862 case USERDIRMODE_SAVEDGAMES:
1864 Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1866 Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1867 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1869 savedgamesdir[0] = 0;
1870 qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1873 if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1875 if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1878 if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1880 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1881 #if _MSC_VER >= 1400
1882 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1884 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1886 qCoTaskMemFree(savedgamesdirw);
1889 if (savedgamesdir[0])
1891 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1906 case USERDIRMODE_NOHOME:
1907 strlcpy(userdir, fs_basedir, userdirsize);
1909 case USERDIRMODE_HOME:
1910 homedir = getenv("HOME");
1913 dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1917 case USERDIRMODE_SAVEDGAMES:
1918 homedir = getenv("HOME");
1922 dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1924 // the XDG say some files would need to go in:
1925 // XDG_CONFIG_HOME (or ~/.config/%s/)
1926 // XDG_DATA_HOME (or ~/.local/share/%s/)
1927 // XDG_CACHE_HOME (or ~/.cache/%s/)
1928 // and also search the following global locations if defined:
1929 // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1930 // XDG_DATA_DIRS (normally /usr/share/%s/)
1931 // this would be too complicated...
1941 #if !defined(__IPHONEOS__)
1944 // historical behavior...
1945 if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1946 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
1949 // see if we can write to this path (note: won't create path)
1951 // no access() here, we must try to open the file for appending
1952 fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1956 // on Unix, we don't need to ACTUALLY attempt to open the file
1957 if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1964 return 1; // good choice - the path exists and is writable
1968 if (userdirmode == USERDIRMODE_NOHOME)
1969 return -1; // path usually already exists, we lack permissions
1971 return 0; // probably good - failed to write but maybe we need to create path
1991 // Overrides the system supplied base directory (under GAMENAME)
1992 // 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)
1993 i = COM_CheckParm ("-basedir");
1994 if (i && i < com_argc-1)
1996 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1997 i = (int)strlen (fs_basedir);
1998 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1999 fs_basedir[i-1] = 0;
2003 // If the base directory is explicitly defined by the compilation process
2004 #ifdef DP_FS_BASEDIR
2005 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
2006 #elif defined(__ANDROID__)
2007 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
2008 #elif defined(MACOSX)
2009 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
2010 if (strstr(com_argv[0], ".app/"))
2013 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
2014 split = strstr(fs_basedir, ".app/");
2017 struct stat statresult;
2019 // truncate to just after the .app/
2021 // see if gamedir exists in Resources
2022 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
2024 // found gamedir inside Resources, use it
2025 strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
2029 // no gamedir found in Resources, gamedir is probably
2030 // outside the .app, remove .app part of path
2031 while (split > fs_basedir && *split != '/')
2040 // make sure the appending of a path separator won't create an unterminated string
2041 memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
2042 // add a path separator to the end of the basedir if it lacks one
2043 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
2044 strlcat(fs_basedir, "/", sizeof(fs_basedir));
2046 // Add the personal game directory
2047 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
2048 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
2049 else if (COM_CheckParm("-nohome"))
2050 *fs_userdir = 0; // user wants roaming installation, no userdir
2054 int highestuserdirmode = USERDIRMODE_COUNT - 1;
2055 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
2056 int userdirstatus[USERDIRMODE_COUNT];
2058 // historical behavior...
2059 if (!strcmp(gamedirname1, "id1"))
2060 preferreduserdirmode = USERDIRMODE_NOHOME;
2062 // check what limitations the user wants to impose
2063 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2064 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2065 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2066 // gather the status of the possible userdirs
2067 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2069 userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2070 if (userdirstatus[dirmode] == 1)
2071 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2072 else if (userdirstatus[dirmode] == 0)
2073 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2075 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2077 // some games may prefer writing to basedir, but if write fails we
2078 // have to search for a real userdir...
2079 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2080 preferreduserdirmode = highestuserdirmode;
2081 // check for an existing userdir and continue using it if possible...
2082 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2083 if (userdirstatus[dirmode] == 1)
2085 // if no existing userdir found, make a new one...
2086 if (dirmode == 0 && preferreduserdirmode > 0)
2087 for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2088 if (userdirstatus[dirmode] >= 0)
2090 // and finally, we picked one...
2091 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2092 Con_DPrintf("userdir %i is the winner\n", dirmode);
2095 // if userdir equal to basedir, clear it to avoid confusion later
2096 if (!strcmp(fs_basedir, fs_userdir))
2101 p = FS_CheckGameDir(gamedirname1);
2102 if(!p || p == fs_checkgamedir_missing)
2103 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2107 p = FS_CheckGameDir(gamedirname2);
2108 if(!p || p == fs_checkgamedir_missing)
2109 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2113 // Adds basedir/gamedir as an override game
2114 // LordHavoc: now supports multiple -game directories
2115 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2119 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2122 p = FS_CheckGameDir(com_argv[i]);
2124 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2125 if(p == fs_checkgamedir_missing)
2126 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2127 // add the gamedir to the list of active gamedirs
2128 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2133 // generate the searchpath
2136 if (Thread_HasThreads())
2137 fs_mutex = Thread_CreateMutex();
2140 void FS_Init_Commands(void)
2142 Cvar_RegisterVariable (&scr_screenshot_name);
2143 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2144 Cvar_RegisterVariable (&cvar_fs_gamedir);
2146 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2147 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2148 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2149 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2150 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2151 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2159 void FS_Shutdown (void)
2161 // close all pack files and such
2162 // (hopefully there aren't any other open files, but they'll be cleaned up
2163 // by the OS anyway)
2164 FS_ClearSearchPath();
2165 Mem_FreePool (&fs_mempool);
2166 PK3_CloseLibrary ();
2169 Sys_UnloadLibrary (&shfolder_dll);
2170 Sys_UnloadLibrary (&shell32_dll);
2171 Sys_UnloadLibrary (&ole32_dll);
2175 Thread_DestroyMutex(fs_mutex);
2178 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2183 qboolean dolock = false;
2185 // Parse the mode string
2194 opt = O_CREAT | O_TRUNC;
2198 opt = O_CREAT | O_APPEND;
2201 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2204 for (ind = 1; mode[ind] != '\0'; ind++)
2218 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2219 filepath, mode, mode[ind]);
2226 if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2230 # if _MSC_VER >= 1400
2231 _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2233 handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2236 handle = open (filepath, mod | opt, 0666);
2237 if(handle >= 0 && dolock)
2240 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2241 l.l_whence = SEEK_SET;
2244 if(fcntl(handle, F_SETLK, &l) == -1)
2256 ====================
2259 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2260 ====================
2262 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2266 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2268 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2269 if (file->handle < 0)
2275 file->filename = Mem_strdup(fs_mempool, filepath);
2277 file->real_length = lseek (file->handle, 0, SEEK_END);
2279 // For files opened in append mode, we start at the end of the file
2281 file->position = file->real_length;
2283 lseek (file->handle, 0, SEEK_SET);
2293 Open a packed file using its package file descriptor
2296 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2302 pfile = &pack->files[pack_ind];
2304 // If we don't have the true offset, get it now
2305 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2306 if (!PK3_GetTrueFileOffset (pfile, pack))
2309 #ifndef LINK_TO_ZLIB
2310 // No Zlib DLL = no compressed files
2311 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2313 Con_Printf("WARNING: can't open the compressed file %s\n"
2314 "You need the Zlib DLL to use compressed files\n",
2320 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2321 // the dup() call to avoid having to close the dup_handle on error here
2322 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2324 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2325 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2329 dup_handle = dup (pack->handle);
2332 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2336 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2337 memset (file, 0, sizeof (*file));
2338 file->handle = dup_handle;
2339 file->flags = QFILE_FLAG_PACKED;
2340 file->real_length = pfile->realsize;
2341 file->offset = pfile->offset;
2345 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2349 file->flags |= QFILE_FLAG_DEFLATED;
2351 // We need some more variables
2352 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2354 ztk->comp_length = pfile->packsize;
2356 // Initialize zlib stream
2357 ztk->zstream.next_in = ztk->input;
2358 ztk->zstream.avail_in = 0;
2360 /* From Zlib's "unzip.c":
2362 * windowBits is passed < 0 to tell that there is no zlib header.
2363 * Note that in this case inflate *requires* an extra "dummy" byte
2364 * after the compressed stream in order to complete decompression and
2365 * return Z_STREAM_END.
2366 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2367 * size of both compressed and uncompressed data
2369 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2371 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2377 ztk->zstream.next_out = file->buff;
2378 ztk->zstream.avail_out = sizeof (file->buff);
2387 ====================
2390 Return true if the path should be rejected due to one of the following:
2391 1: path elements that are non-portable
2392 2: path elements that would allow access to files outside the game directory,
2393 or are just not a good idea for a mod to be using.
2394 ====================
2396 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2398 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2402 // Windows: don't allow \ in filenames (windows-only), period.
2403 // (on Windows \ is a directory separator, but / is also supported)
2404 if (strstr(path, "\\"))
2405 return 1; // non-portable
2407 // Mac: don't allow Mac-only filenames - : is a directory separator
2408 // instead of /, but we rely on / working already, so there's no reason to
2409 // support a Mac-only path
2410 // Amiga and Windows: : tries to go to root of drive
2411 if (strstr(path, ":"))
2412 return 1; // non-portable attempt to go to root of drive
2414 // Amiga: // is parent directory
2415 if (strstr(path, "//"))
2416 return 1; // non-portable attempt to go to parent directory
2418 // all: don't allow going to parent directory (../ or /../)
2419 if (strstr(path, ".."))
2420 return 2; // attempt to go outside the game directory
2422 // Windows and UNIXes: don't allow absolute paths
2424 return 2; // attempt to go outside the game directory
2426 // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2427 if (strstr(path, "./"))
2428 return 2; // possible attempt to go outside the game directory
2430 // all: forbid trailing slash on gamedir
2431 if (isgamedir && path[strlen(path)-1] == '/')
2434 // all: forbid leading dot on any filename for any reason
2435 if (strstr(path, "/."))
2436 return 2; // attempt to go outside the game directory
2438 // after all these checks we're pretty sure it's a / separated filename
2439 // and won't do much if any harm
2445 ====================
2448 Look for a file in the packages and in the filesystem
2450 Return the searchpath where the file was found (or NULL)
2451 and the file index in the package if relevant
2452 ====================
2454 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2456 searchpath_t *search;
2459 // search through the path, one element at a time
2460 for (search = fs_searchpaths;search;search = search->next)
2462 // is the element a pak file?
2463 if (search->pack && !search->pack->vpack)
2465 int (*strcmp_funct) (const char* str1, const char* str2);
2466 int left, right, middle;
2469 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2471 // Look for the file (binary search)
2473 right = pak->numfiles - 1;
2474 while (left <= right)
2478 middle = (left + right) / 2;
2479 diff = strcmp_funct (pak->files[middle].name, name);
2484 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2486 // yes, but the first one is empty so we treat it as not being there
2487 if (!quiet && developer_extra.integer)
2488 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2495 if (!quiet && developer_extra.integer)
2496 Con_DPrintf("FS_FindFile: %s in %s\n",
2497 pak->files[middle].name, pak->filename);
2504 // If we're too far in the list
2513 char netpath[MAX_OSPATH];
2514 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2515 if (FS_SysFileExists (netpath))
2517 if (!quiet && developer_extra.integer)
2518 Con_DPrintf("FS_FindFile: %s\n", netpath);
2527 if (!quiet && developer_extra.integer)
2528 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2540 Look for a file in the search paths and open it in read-only mode
2543 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2545 searchpath_t *search;
2548 search = FS_FindFile (filename, &pack_ind, quiet);
2554 // Found in the filesystem?
2557 // this works with vpacks, so we are fine
2558 char path [MAX_OSPATH];
2559 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2560 return FS_SysOpen (path, "rb", nonblocking);
2563 // So, we found it in a package...
2565 // Is it a PK3 symlink?
2566 // TODO also handle directory symlinks by parsing the whole structure...
2567 // but heck, file symlinks are good enough for now
2568 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2570 if(symlinkLevels <= 0)
2572 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2577 char linkbuf[MAX_QPATH];
2579 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2580 const char *mergeslash;
2585 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2591 // Now combine the paths...
2592 mergeslash = strrchr(filename, '/');
2593 mergestart = linkbuf;
2595 mergeslash = filename;
2596 while(!strncmp(mergestart, "../", 3))
2599 while(mergeslash > filename)
2602 if(*mergeslash == '/')
2606 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2607 if(mergeslash == filename)
2609 // Either mergeslash == filename, then we just replace the name (done below)
2613 // Or, we append the name after mergeslash;
2614 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2615 int spaceNeeded = mergeslash - filename + 1;
2616 int spaceRemoved = mergestart - linkbuf;
2617 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2619 Con_DPrintf("symlink: too long path rejected\n");
2622 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2623 memcpy(linkbuf, filename, spaceNeeded);
2624 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2625 mergestart = linkbuf;
2627 if (!quiet && developer_loading.integer)
2628 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2629 if(FS_CheckNastyPath (mergestart, false))
2631 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2634 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2638 return FS_OpenPackedFile (search->pack, pack_ind);
2643 =============================================================================
2645 MAIN PUBLIC FUNCTIONS
2647 =============================================================================
2651 ====================
2654 Open a file in the userpath. The syntax is the same as fopen
2655 Used for savegame scanning in menu, and all file writing.
2656 ====================
2658 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2660 char real_path [MAX_OSPATH];
2662 if (FS_CheckNastyPath(filepath, false))
2664 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2668 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2670 // If the file is opened in "write", "append", or "read/write" mode,
2671 // create directories up to the file.
2672 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2673 FS_CreatePath (real_path);
2674 return FS_SysOpen (real_path, mode, false);
2679 ====================
2682 Open a file. The syntax is the same as fopen
2683 ====================
2685 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2687 qfile_t *result = NULL;
2688 if (FS_CheckNastyPath(filepath, false))
2690 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2694 if (fs_mutex) Thread_LockMutex(fs_mutex);
2695 result = FS_OpenReadFile (filepath, quiet, false, 16);
2696 if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2702 ====================
2705 Open a file. The syntax is the same as fopen
2706 ====================
2708 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2711 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2712 memset (file, 0, sizeof (*file));
2713 file->flags = QFILE_FLAG_DATA;
2715 file->real_length = size;
2721 ====================
2725 ====================
2727 int FS_Close (qfile_t* file)
2729 if(file->flags & QFILE_FLAG_DATA)
2735 if (close (file->handle))
2740 if (file->flags & QFILE_FLAG_REMOVE)
2742 if (remove(file->filename) == -1)
2744 // No need to report this. If removing a just
2745 // written file failed, this most likely means
2746 // someone else deleted it first - which we
2751 Mem_Free((void *) file->filename);
2756 qz_inflateEnd (&file->ztk->zstream);
2757 Mem_Free (file->ztk);
2764 void FS_RemoveOnClose(qfile_t* file)
2766 file->flags |= QFILE_FLAG_REMOVE;
2770 ====================
2773 Write "datasize" bytes into a file
2774 ====================
2776 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2778 fs_offset_t written = 0;
2780 // If necessary, seek to the exact file position we're supposed to be
2781 if (file->buff_ind != file->buff_len)
2783 if (lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
2785 Con_Printf("WARNING: could not seek in %s.\n", file->filename);
2789 // Purge cached data
2792 // Write the buffer and update the position
2793 // 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)
2794 while (written < (fs_offset_t)datasize)
2796 // figure out how much to write in one chunk
2797 fs_offset_t maxchunk = 1<<30; // 1 GiB
2798 int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
2799 int result = (int)write (file->handle, (const unsigned char *)data + written, chunk);
2800 // if at least some was written, add it to our accumulator
2803 // if the result is not what we expected, consider the write to be incomplete
2804 if (result != chunk)
2807 file->position = lseek (file->handle, 0, SEEK_CUR);
2808 if (file->real_length < file->position)
2809 file->real_length = file->position;
2811 // note that this will never be less than 0 even if the write failed
2817 ====================
2820 Read up to "buffersize" bytes from a file
2821 ====================
2823 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2825 fs_offset_t count, done;
2827 if (buffersize == 0)
2830 // Get rid of the ungetc character
2831 if (file->ungetc != EOF)
2833 ((char*)buffer)[0] = file->ungetc;
2841 if(file->flags & QFILE_FLAG_DATA)
2843 size_t left = file->real_length - file->position;
2844 if(buffersize > left)
2846 memcpy(buffer, file->data + file->position, buffersize);
2847 file->position += buffersize;
2851 // First, we copy as many bytes as we can from "buff"
2852 if (file->buff_ind < file->buff_len)
2854 count = file->buff_len - file->buff_ind;
2855 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2857 memcpy (buffer, &file->buff[file->buff_ind], count);
2858 file->buff_ind += count;
2860 buffersize -= count;
2861 if (buffersize == 0)
2865 // NOTE: at this point, the read buffer is always empty
2867 // If the file isn't compressed
2868 if (! (file->flags & QFILE_FLAG_DEFLATED))
2872 // We must take care to not read after the end of the file
2873 count = file->real_length - file->position;
2875 // If we have a lot of data to get, put them directly into "buffer"
2876 if (buffersize > sizeof (file->buff) / 2)
2878 if (count > (fs_offset_t)buffersize)
2879 count = (fs_offset_t)buffersize;
2880 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2882 // Seek failed. When reading from a pipe, and
2883 // the caller never called FS_Seek, this still
2884 // works fine. So no reporting this error.
2886 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2890 file->position += nb;
2892 // Purge cached data
2898 if (count > (fs_offset_t)sizeof (file->buff))
2899 count = (fs_offset_t)sizeof (file->buff);
2900 if (lseek (file->handle, file->offset + file->position, SEEK_SET) == -1)
2902 // Seek failed. When reading from a pipe, and
2903 // the caller never called FS_Seek, this still
2904 // works fine. So no reporting this error.
2906 nb = read (file->handle, file->buff, count);
2909 file->buff_len = nb;
2910 file->position += nb;
2912 // Copy the requested data in "buffer" (as much as we can)
2913 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2914 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2915 file->buff_ind = count;
2923 // If the file is compressed, it's more complicated...
2924 // We cycle through a few operations until we have read enough data
2925 while (buffersize > 0)
2927 ztoolkit_t *ztk = file->ztk;
2930 // NOTE: at this point, the read buffer is always empty
2932 // If "input" is also empty, we need to refill it
2933 if (ztk->in_ind == ztk->in_len)
2935 // If we are at the end of the file
2936 if (file->position == file->real_length)
2939 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2940 if (count > (fs_offset_t)sizeof (ztk->input))
2941 count = (fs_offset_t)sizeof (ztk->input);
2942 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2943 if (read (file->handle, ztk->input, count) != count)
2945 Con_Printf ("FS_Read: unexpected end of file\n");
2950 ztk->in_len = count;
2951 ztk->in_position += count;
2954 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2955 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2957 // Now that we are sure we have compressed data available, we need to determine
2958 // if it's better to inflate it in "file->buff" or directly in "buffer"
2960 // Inflate the data in "file->buff"
2961 if (buffersize < sizeof (file->buff) / 2)
2963 ztk->zstream.next_out = file->buff;
2964 ztk->zstream.avail_out = sizeof (file->buff);
2965 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2966 if (error != Z_OK && error != Z_STREAM_END)
2968 Con_Printf ("FS_Read: Can't inflate file\n");
2971 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2973 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2974 file->position += file->buff_len;
2976 // Copy the requested data in "buffer" (as much as we can)
2977 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2978 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2979 file->buff_ind = count;
2982 // Else, we inflate directly in "buffer"
2985 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2986 ztk->zstream.avail_out = (unsigned int)buffersize;
2987 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2988 if (error != Z_OK && error != Z_STREAM_END)
2990 Con_Printf ("FS_Read: Can't inflate file\n");
2993 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2995 // How much data did it inflate?
2996 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2997 file->position += count;
2999 // Purge cached data
3004 buffersize -= count;
3012 ====================
3015 Print a string into a file
3016 ====================
3018 int FS_Print (qfile_t* file, const char *msg)
3020 return (int)FS_Write (file, msg, strlen (msg));
3024 ====================
3027 Print a string into a file
3028 ====================
3030 int FS_Printf(qfile_t* file, const char* format, ...)
3035 va_start (args, format);
3036 result = FS_VPrintf (file, format, args);
3044 ====================
3047 Print a string into a file
3048 ====================
3050 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
3053 fs_offset_t buff_size = MAX_INPUTLINE;
3058 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
3059 len = dpvsnprintf (tempbuff, buff_size, format, ap);
3060 if (len >= 0 && len < buff_size)
3062 Mem_Free (tempbuff);
3066 len = write (file->handle, tempbuff, len);
3067 Mem_Free (tempbuff);
3074 ====================
3077 Get the next character of a file
3078 ====================
3080 int FS_Getc (qfile_t* file)
3084 if (FS_Read (file, &c, 1) != 1)
3092 ====================
3095 Put a character back into the read buffer (only supports one character!)
3096 ====================
3098 int FS_UnGetc (qfile_t* file, unsigned char c)
3100 // If there's already a character waiting to be read
3101 if (file->ungetc != EOF)
3110 ====================
3113 Move the position index in a file
3114 ====================
3116 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3119 unsigned char* buffer;
3120 fs_offset_t buffersize;
3122 // Compute the file offset
3126 offset += file->position - file->buff_len + file->buff_ind;
3133 offset += file->real_length;
3139 if (offset < 0 || offset > file->real_length)
3142 if(file->flags & QFILE_FLAG_DATA)
3144 file->position = offset;
3148 // If we have the data in our read buffer, we don't need to actually seek
3149 if (file->position - file->buff_len <= offset && offset <= file->position)
3151 file->buff_ind = offset + file->buff_len - file->position;
3155 // Purge cached data
3158 // Unpacked or uncompressed files can seek directly
3159 if (! (file->flags & QFILE_FLAG_DEFLATED))
3161 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3163 file->position = offset;
3167 // Seeking in compressed files is more a hack than anything else,
3168 // but we need to support it, so here we go.
3171 // If we have to go back in the file, we need to restart from the beginning
3172 if (offset <= file->position)
3176 ztk->in_position = 0;
3178 if (lseek (file->handle, file->offset, SEEK_SET) == -1)
3179 Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
3181 // Reset the Zlib stream
3182 ztk->zstream.next_in = ztk->input;
3183 ztk->zstream.avail_in = 0;
3184 qz_inflateReset (&ztk->zstream);
3187 // We need a big buffer to force inflating into it directly
3188 buffersize = 2 * sizeof (file->buff);
3189 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3191 // Skip all data until we reach the requested offset
3192 while (offset > file->position)
3194 fs_offset_t diff = offset - file->position;
3195 fs_offset_t count, len;
3197 count = (diff > buffersize) ? buffersize : diff;
3198 len = FS_Read (file, buffer, count);
3212 ====================
3215 Give the current position in a file
3216 ====================
3218 fs_offset_t FS_Tell (qfile_t* file)
3220 return file->position - file->buff_len + file->buff_ind;
3225 ====================
3228 Give the total size of a file
3229 ====================
3231 fs_offset_t FS_FileSize (qfile_t* file)
3233 return file->real_length;
3238 ====================
3241 Erases any buffered input or output data
3242 ====================
3244 void FS_Purge (qfile_t* file)
3254 FS_LoadAndCloseQFile
3256 Loads full content of a qfile_t and closes it.
3257 Always appends a 0 byte.
3260 static unsigned char *FS_LoadAndCloseQFile (qfile_t *file, const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3262 unsigned char *buf = NULL;
3263 fs_offset_t filesize = 0;
3267 filesize = file->real_length;
3270 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3275 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3276 buf[filesize] = '\0';
3277 FS_Read (file, buf, filesize);
3279 if (developer_loadfile.integer)
3280 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3283 if (filesizepointer)
3284 *filesizepointer = filesize;
3293 Filename are relative to the quake directory.
3294 Always appends a 0 byte.
3297 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3299 qfile_t *file = FS_OpenVirtualFile(path, quiet);
3300 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3308 Filename are OS paths.
3309 Always appends a 0 byte.
3312 static unsigned char *FS_SysLoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3314 qfile_t *file = FS_SysOpen(path, "rb", false);
3315 return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
3323 The filename will be prefixed by the current game directory
3326 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3330 fs_offset_t lentotal;
3332 file = FS_OpenRealFile(filename, "wb", false);
3335 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3340 for(i = 0; i < count; ++i)
3342 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3343 for(i = 0; i < count; ++i)
3344 FS_Write (file, data[i], len[i]);
3349 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3351 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3356 =============================================================================
3358 OTHERS PUBLIC FUNCTIONS
3360 =============================================================================
3368 void FS_StripExtension (const char *in, char *out, size_t size_out)
3376 while ((currentchar = *in) && size_out > 1)
3378 if (currentchar == '.')
3380 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3382 *out++ = currentchar;
3398 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3402 // if path doesn't have a .EXT, append extension
3403 // (extension should include the .)
3404 src = path + strlen(path);
3406 while (*src != '/' && src != path)
3409 return; // it has an extension
3413 strlcat (path, extension, size_path);
3421 Look for a file in the packages and in the filesystem
3424 int FS_FileType (const char *filename)
3426 searchpath_t *search;
3427 char fullpath[MAX_OSPATH];
3429 search = FS_FindFile (filename, NULL, true);
3431 return FS_FILETYPE_NONE;
3433 if(search->pack && !search->pack->vpack)
3434 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3436 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3437 return FS_SysFileType(fullpath);
3445 Look for a file in the packages and in the filesystem
3448 qboolean FS_FileExists (const char *filename)
3450 return (FS_FindFile (filename, NULL, true) != NULL);
3458 Look for a file in the filesystem only
3461 int FS_SysFileType (const char *path)
3464 // Sajt - some older sdks are missing this define
3465 # ifndef INVALID_FILE_ATTRIBUTES
3466 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3469 DWORD result = GetFileAttributes(path);
3471 if(result == INVALID_FILE_ATTRIBUTES)
3472 return FS_FILETYPE_NONE;
3474 if(result & FILE_ATTRIBUTE_DIRECTORY)
3475 return FS_FILETYPE_DIRECTORY;
3477 return FS_FILETYPE_FILE;
3481 if (stat (path,&buf) == -1)
3482 return FS_FILETYPE_NONE;
3485 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3487 if(S_ISDIR(buf.st_mode))
3488 return FS_FILETYPE_DIRECTORY;
3490 return FS_FILETYPE_FILE;
3494 qboolean FS_SysFileExists (const char *path)
3496 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3503 Allocate and fill a search structure with information on matching filenames.
3506 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3509 searchpath_t *searchpath;
3511 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3512 stringlist_t resultlist;
3513 stringlist_t dirlist;
3514 const char *slash, *backslash, *colon, *separator;
3516 char temp[MAX_OSPATH];
3518 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3523 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3527 stringlistinit(&resultlist);
3528 stringlistinit(&dirlist);
3530 slash = strrchr(pattern, '/');
3531 backslash = strrchr(pattern, '\\');
3532 colon = strrchr(pattern, ':');
3533 separator = max(slash, backslash);
3534 separator = max(separator, colon);
3535 basepathlength = separator ? (separator + 1 - pattern) : 0;
3536 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3538 memcpy(basepath, pattern, basepathlength);
3539 basepath[basepathlength] = 0;
3541 // search through the path, one element at a time
3542 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3544 // is the element a pak file?
3545 if (searchpath->pack && !searchpath->pack->vpack)
3547 // look through all the pak file elements
3548 pak = searchpath->pack;
3549 for (i = 0;i < pak->numfiles;i++)
3551 strlcpy(temp, pak->files[i].name, sizeof(temp));
3554 if (matchpattern(temp, (char *)pattern, true))
3556 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3557 if (!strcmp(resultlist.strings[resultlistindex], temp))
3559 if (resultlistindex == resultlist.numstrings)
3561 stringlistappend(&resultlist, temp);
3562 if (!quiet && developer_loading.integer)
3563 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3566 // strip off one path element at a time until empty
3567 // this way directories are added to the listing if they match the pattern
3568 slash = strrchr(temp, '/');
3569 backslash = strrchr(temp, '\\');
3570 colon = strrchr(temp, ':');
3572 if (separator < slash)
3574 if (separator < backslash)
3575 separator = backslash;
3576 if (separator < colon)
3578 *((char *)separator) = 0;
3584 stringlist_t matchedSet, foundSet;
3585 const char *start = pattern;
3587 stringlistinit(&matchedSet);
3588 stringlistinit(&foundSet);
3589 // add a first entry to the set
3590 stringlistappend(&matchedSet, "");
3591 // iterate through pattern's path
3594 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3595 char subpath[MAX_OSPATH];
3596 char subpattern[MAX_OSPATH];
3598 // find the next wildcard
3599 wildcard = strchr(start, '?');
3600 asterisk = strchr(start, '*');
3601 if (asterisk && (!wildcard || asterisk < wildcard))
3603 wildcard = asterisk;
3608 nextseparator = strchr( wildcard, '/' );
3612 nextseparator = NULL;
3615 if( !nextseparator ) {
3616 nextseparator = start + strlen( start );
3619 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3620 // copy everything up except nextseperator
3621 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3622 // find the last '/' before the wildcard
3623 prevseparator = strrchr( subpattern, '/' );
3625 prevseparator = subpattern;
3628 // copy everything from start to the previous including the '/' (before the wildcard)
3629 // everything up to start is already included in the path of matchedSet's entries
3630 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3632 // for each entry in matchedSet try to open the subdirectories specified in subpath
3633 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3634 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3635 strlcat( temp, subpath, sizeof(temp) );
3636 listdirectory( &foundSet, searchpath->filename, temp );
3638 if( dirlistindex == 0 ) {
3641 // reset the current result set
3642 stringlistfreecontents( &matchedSet );
3643 // match against the pattern
3644 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3645 const char *direntry = foundSet.strings[ dirlistindex ];
3646 if (matchpattern(direntry, subpattern, true)) {
3647 stringlistappend( &matchedSet, direntry );
3650 stringlistfreecontents( &foundSet );
3652 start = nextseparator;
3655 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3657 const char *temp = matchedSet.strings[dirlistindex];
3658 if (matchpattern(temp, (char *)pattern, true))
3660 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3661 if (!strcmp(resultlist.strings[resultlistindex], temp))
3663 if (resultlistindex == resultlist.numstrings)
3665 stringlistappend(&resultlist, temp);
3666 if (!quiet && developer_loading.integer)
3667 Con_Printf("SearchDirFile: %s\n", temp);
3671 stringlistfreecontents( &matchedSet );
3675 if (resultlist.numstrings)
3677 stringlistsort(&resultlist, true);
3678 numfiles = resultlist.numstrings;
3680 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3681 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3682 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3683 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3684 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3685 search->numfilenames = (int)numfiles;
3688 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3691 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3692 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3693 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3695 numchars += (int)textlen;
3698 stringlistfreecontents(&resultlist);
3704 void FS_FreeSearch(fssearch_t *search)
3709 extern int con_linewidth;
3710 static int FS_ListDirectory(const char *pattern, int oneperline)
3719 char linebuf[MAX_INPUTLINE];
3721 search = FS_Search(pattern, true, true);
3724 numfiles = search->numfilenames;
3727 // FIXME: the names could be added to one column list and then
3728 // gradually shifted into the next column if they fit, and then the
3729 // next to make a compact variable width listing but it's a lot more
3731 // find width for columns
3733 for (i = 0;i < numfiles;i++)
3735 l = (int)strlen(search->filenames[i]);
3736 if (columnwidth < l)
3739 // count the spacing character
3741 // calculate number of columns
3742 numcolumns = con_linewidth / columnwidth;
3743 // don't bother with the column printing if it's only one column
3744 if (numcolumns >= 2)
3746 numlines = (numfiles + numcolumns - 1) / numcolumns;
3747 for (i = 0;i < numlines;i++)
3750 for (k = 0;k < numcolumns;k++)
3752 l = i * numcolumns + k;
3755 name = search->filenames[l];
3756 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3757 linebuf[linebufpos++] = name[j];
3758 // space out name unless it's the last on the line
3759 if (k + 1 < numcolumns && l + 1 < numfiles)
3760 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3761 linebuf[linebufpos++] = ' ';
3764 linebuf[linebufpos] = 0;
3765 Con_Printf("%s\n", linebuf);
3772 for (i = 0;i < numfiles;i++)
3773 Con_Printf("%s\n", search->filenames[i]);
3774 FS_FreeSearch(search);
3775 return (int)numfiles;
3778 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3780 const char *pattern;
3781 if (Cmd_Argc() >= 3)
3783 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3786 if (Cmd_Argc() == 2)
3787 pattern = Cmd_Argv(1);
3790 if (!FS_ListDirectory(pattern, oneperline))
3791 Con_Print("No files found.\n");
3796 FS_ListDirectoryCmd("dir", true);
3801 FS_ListDirectoryCmd("ls", false);
3804 void FS_Which_f(void)
3806 const char *filename;
3809 if (Cmd_Argc() != 2)
3811 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3814 filename = Cmd_Argv(1);
3815 sp = FS_FindFile(filename, &index, true);
3817 Con_Printf("%s isn't anywhere\n", filename);
3823 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3825 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3828 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3832 const char *FS_WhichPack(const char *filename)
3835 searchpath_t *sp = FS_FindFile(filename, &index, true);
3837 return sp->pack->shortname;
3845 ====================
3846 FS_IsRegisteredQuakePack
3848 Look for a proof of purchase file file in the requested package
3850 If it is found, this file should NOT be downloaded.
3851 ====================
3853 qboolean FS_IsRegisteredQuakePack(const char *name)
3855 searchpath_t *search;
3858 // search through the path, one element at a time
3859 for (search = fs_searchpaths;search;search = search->next)
3861 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3862 // TODO do we want to support vpacks in here too?
3864 int (*strcmp_funct) (const char* str1, const char* str2);
3865 int left, right, middle;
3868 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3870 // Look for the file (binary search)
3872 right = pak->numfiles - 1;
3873 while (left <= right)
3877 middle = (left + right) / 2;
3878 diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3884 // If we're too far in the list
3891 // we found the requested pack but it is not registered quake
3899 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3902 unsigned char *filedata;
3903 fs_offset_t filesize;
3904 if (filesizepointer)
3905 *filesizepointer = 0;
3906 if (!filename || !*filename)
3908 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3911 if (filesizepointer)
3912 *filesizepointer = filesize;
3913 crc = CRC_Block(filedata, filesize);
3919 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3922 unsigned char *out = NULL;
3926 #ifndef LINK_TO_ZLIB
3931 memset(&strm, 0, sizeof(strm));
3932 strm.zalloc = Z_NULL;
3933 strm.zfree = Z_NULL;
3934 strm.opaque = Z_NULL;
3937 level = Z_DEFAULT_COMPRESSION;
3939 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3941 Con_Printf("FS_Deflate: deflate init error!\n");
3945 strm.next_in = (unsigned char*)data;
3946 strm.avail_in = (unsigned int)size;
3948 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3951 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3952 qz_deflateEnd(&strm);
3956 strm.next_out = tmp;
3957 strm.avail_out = (unsigned int)size;
3959 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3961 Con_Printf("FS_Deflate: deflate failed!\n");
3962 qz_deflateEnd(&strm);
3967 if(qz_deflateEnd(&strm) != Z_OK)
3969 Con_Printf("FS_Deflate: deflateEnd failed\n");
3974 if(strm.total_out >= size)
3976 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3981 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3984 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3989 *deflated_size = (size_t)strm.total_out;
3991 memcpy(out, tmp, strm.total_out);
3997 static void AssertBufsize(sizebuf_t *buf, int length)
3999 if(buf->cursize + length > buf->maxsize)
4001 int oldsize = buf->maxsize;
4002 unsigned char *olddata;
4003 olddata = buf->data;
4004 buf->maxsize += length;
4005 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
4008 memcpy(buf->data, olddata, oldsize);
4014 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
4018 unsigned char *out = NULL;
4019 unsigned char tmp[2048];
4024 #ifndef LINK_TO_ZLIB
4029 memset(&outbuf, 0, sizeof(outbuf));
4030 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
4031 outbuf.maxsize = sizeof(tmp);
4033 memset(&strm, 0, sizeof(strm));
4034 strm.zalloc = Z_NULL;
4035 strm.zfree = Z_NULL;
4036 strm.opaque = Z_NULL;
4038 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
4040 Con_Printf("FS_Inflate: inflate init error!\n");
4041 Mem_Free(outbuf.data);
4045 strm.next_in = (unsigned char*)data;
4046 strm.avail_in = (unsigned int)size;
4050 strm.next_out = tmp;
4051 strm.avail_out = sizeof(tmp);
4052 ret = qz_inflate(&strm, Z_NO_FLUSH);
4053 // it either returns Z_OK on progress, Z_STREAM_END on end
4061 case Z_STREAM_ERROR:
4062 Con_Print("FS_Inflate: stream error!\n");
4065 Con_Print("FS_Inflate: data error!\n");
4068 Con_Print("FS_Inflate: mem error!\n");
4071 Con_Print("FS_Inflate: buf error!\n");
4074 Con_Print("FS_Inflate: unknown error!\n");
4078 if(ret != Z_OK && ret != Z_STREAM_END)
4080 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
4081 Mem_Free(outbuf.data);
4082 qz_inflateEnd(&strm);
4085 have = sizeof(tmp) - strm.avail_out;
4086 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
4087 SZ_Write(&outbuf, tmp, have);
4088 } while(ret != Z_STREAM_END);
4090 qz_inflateEnd(&strm);
4092 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
4095 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
4096 Mem_Free(outbuf.data);
4100 memcpy(out, outbuf.data, outbuf.cursize);
4101 Mem_Free(outbuf.data);
4103 *inflated_size = (size_t)outbuf.cursize;