4 Copyright (C) 2003-2006 Mathieu Olivier
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 See the GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to:
20 Free Software Foundation, Inc.
21 59 Temple Place - Suite 330
22 Boston, MA 02111-1307, USA
26 // include SDL for IPHONEOS code
27 # include <TargetConditionals.h>
42 # include <sys/stat.h>
51 // Win32 requires us to add O_BINARY, but the other OSes don't have it
56 // In case the system doesn't support the O_NONBLOCK flag
61 // largefile support for Win32
63 # define lseek _lseeki64
67 // suppress deprecated warnings
68 # include <sys/stat.h>
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;
335 searchpath_t *fs_searchpaths = NULL;
336 const char *const fs_checkgamedir_missing = "missing";
338 #define MAX_FILES_IN_PACK 65536
340 char fs_userdir[MAX_OSPATH];
341 char fs_gamedir[MAX_OSPATH];
342 char fs_basedir[MAX_OSPATH];
343 static pack_t *fs_selfpack = NULL;
345 // list of active game directories (empty if not running a mod)
346 int fs_numgamedirs = 0;
347 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
349 // list of all gamedirs with modinfo.txt
350 gamedir_t *fs_all_gamedirs = NULL;
351 int fs_all_gamedirs_count = 0;
353 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)"};
354 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"};
355 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
359 =============================================================================
361 PRIVATE FUNCTIONS - PK3 HANDLING
363 =============================================================================
367 // Functions exported from zlib
368 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
369 # define ZEXPORT WINAPI
374 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
375 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
376 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
377 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
378 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
379 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
380 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
383 #define qz_inflateInit2(strm, windowBits) \
384 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
385 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
386 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
389 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
391 static dllfunction_t zlibfuncs[] =
393 {"inflate", (void **) &qz_inflate},
394 {"inflateEnd", (void **) &qz_inflateEnd},
395 {"inflateInit2_", (void **) &qz_inflateInit2_},
396 {"inflateReset", (void **) &qz_inflateReset},
397 {"deflateInit2_", (void **) &qz_deflateInit2_},
398 {"deflateEnd", (void **) &qz_deflateEnd},
399 {"deflate", (void **) &qz_deflate},
403 /// Handle for Zlib DLL
404 static dllhandle_t zlib_dll = NULL;
408 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
409 static dllfunction_t shfolderfuncs[] =
411 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
414 static dllhandle_t shfolder_dll = NULL;
424 void PK3_CloseLibrary (void)
427 Sys_UnloadLibrary (&zlib_dll);
436 Try to load the Zlib DLL
439 qboolean PK3_OpenLibrary (void)
444 const char* dllnames [] =
447 # ifdef ZLIB_USES_WINAPI
453 #elif defined(MACOSX)
467 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
475 See if zlib is available
478 qboolean FS_HasZlib(void)
483 PK3_OpenLibrary(); // to be safe
484 return (zlib_dll != 0);
490 PK3_GetEndOfCentralDir
492 Extract the end of the central directory from a PK3 package
495 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
497 fs_offset_t filesize, maxsize;
498 unsigned char *buffer, *ptr;
501 // Get the package size
502 filesize = lseek (packhandle, 0, SEEK_END);
503 if (filesize < ZIP_END_CDIR_SIZE)
506 // Load the end of the file in memory
507 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
510 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
511 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
512 lseek (packhandle, filesize - maxsize, SEEK_SET);
513 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
519 // Look for the end of central dir signature around the end of the file
520 maxsize -= ZIP_END_CDIR_SIZE;
521 ptr = &buffer[maxsize];
523 while (BuffBigLong (ptr) != ZIP_END_HEADER)
535 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
536 eocd->signature = LittleLong (eocd->signature);
537 eocd->disknum = LittleShort (eocd->disknum);
538 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
539 eocd->localentries = LittleShort (eocd->localentries);
540 eocd->nbentries = LittleShort (eocd->nbentries);
541 eocd->cdir_size = LittleLong (eocd->cdir_size);
542 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
543 eocd->comment_size = LittleShort (eocd->comment_size);
544 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
545 eocd->cdir_offset += eocd->prepended_garbage;
557 Extract the file list from a PK3 file
560 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
562 unsigned char *central_dir, *ptr;
564 fs_offset_t remaining;
566 // Load the central directory in memory
567 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
568 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
569 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
571 Mem_Free (central_dir);
575 // Extract the files properties
576 // The parsing is done "by hand" because some fields have variable sizes and
577 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
578 remaining = eocd->cdir_size;
581 for (ind = 0; ind < eocd->nbentries; ind++)
583 fs_offset_t namesize, count;
585 // Checking the remaining size
586 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
588 Mem_Free (central_dir);
591 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
594 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
596 Mem_Free (central_dir);
600 namesize = BuffLittleShort (&ptr[28]); // filename length
602 // Check encryption, compression, and attributes
603 // 1st uint8 : general purpose bit flag
604 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
606 // LordHavoc: bit 3 would be a problem if we were scanning the archive
607 // but is not a problem in the central directory where the values are
610 // bit 3 seems to always be set by the standard Mac OSX zip maker
612 // 2nd uint8 : external file attributes
613 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
614 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
616 // Still enough bytes for the name?
617 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
619 Mem_Free (central_dir);
623 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
624 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
626 char filename [sizeof (pack->files[0].name)];
627 fs_offset_t offset, packsize, realsize;
630 // Extract the name (strip it if necessary)
631 namesize = min(namesize, (int)sizeof (filename) - 1);
632 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
633 filename[namesize] = '\0';
635 if (BuffLittleShort (&ptr[10]))
636 flags = PACKFILE_FLAG_DEFLATED;
639 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
640 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
641 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
643 switch(ptr[5]) // C_VERSION_MADE_BY_1
648 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
649 // can't use S_ISLNK here, as this has to compile on non-UNIX too
650 flags |= PACKFILE_FLAG_SYMLINK;
654 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
658 // Skip the name, additionnal field, and comment
659 // 1er uint16 : extra field length
660 // 2eme uint16 : file comment length
661 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
662 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
666 // If the package is empty, central_dir is NULL here
667 if (central_dir != NULL)
668 Mem_Free (central_dir);
669 return pack->numfiles;
677 Create a package entry associated with a PK3 file
680 pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
682 pk3_endOfCentralDir_t eocd;
686 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
689 Con_Printf ("%s is not a PK3 file\n", packfile);
694 // Multi-volume ZIP archives are NOT allowed
695 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
697 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
702 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
703 // since eocd.nbentries is an unsigned 16 bits integer
704 #if MAX_FILES_IN_PACK < 65535
705 if (eocd.nbentries > MAX_FILES_IN_PACK)
707 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
713 // Create a package structure in memory
714 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
715 pack->ignorecase = true; // PK3 ignores case
716 strlcpy (pack->filename, packfile, sizeof (pack->filename));
717 pack->handle = packhandle;
718 pack->numfiles = eocd.nbentries;
719 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
721 real_nb_files = PK3_BuildFileList (pack, &eocd);
722 if (real_nb_files < 0)
724 Con_Printf ("%s is not a valid PK3 file\n", packfile);
730 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
733 pack_t *FS_LoadPackPK3 (const char *packfile)
737 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
739 packhandle = open (packfile, O_RDONLY | O_BINARY);
743 return FS_LoadPackPK3FromFD(packfile, packhandle, false);
749 PK3_GetTrueFileOffset
751 Find where the true file data offset is
754 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
756 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
760 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
763 // Load the local file description
764 lseek (pack->handle, pfile->offset, SEEK_SET);
765 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
766 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
768 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
772 // Skip name and extra field
773 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
775 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
781 =============================================================================
783 OTHER PRIVATE FUNCTIONS
785 =============================================================================
793 Add a file to the list of files contained into a package
796 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
797 fs_offset_t offset, fs_offset_t packsize,
798 fs_offset_t realsize, int flags)
800 int (*strcmp_funct) (const char* str1, const char* str2);
801 int left, right, middle;
804 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
806 // Look for the slot we should put that file into (binary search)
808 right = pack->numfiles - 1;
809 while (left <= right)
813 middle = (left + right) / 2;
814 diff = strcmp_funct (pack->files[middle].name, name);
816 // If we found the file, there's a problem
818 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
820 // If we're too far in the list
827 // We have to move the right of the list by one slot to free the one we need
828 pfile = &pack->files[left];
829 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
832 strlcpy (pfile->name, name, sizeof (pfile->name));
833 pfile->offset = offset;
834 pfile->packsize = packsize;
835 pfile->realsize = realsize;
836 pfile->flags = flags;
846 Only used for FS_OpenRealFile.
849 void FS_CreatePath (char *path)
853 for (ofs = path+1 ; *ofs ; ofs++)
855 if (*ofs == '/' || *ofs == '\\')
857 // create the directory
873 void FS_Path_f (void)
877 Con_Print("Current search path:\n");
878 for (s=fs_searchpaths ; s ; s=s->next)
883 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
885 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
888 Con_Printf("%s\n", s->filename);
898 /*! Takes an explicit (not game tree related) path to a pak file.
899 *Loads the header and directory, adding the files at the beginning
900 *of the list so they override previous pack files.
902 pack_t *FS_LoadPackPAK (const char *packfile)
904 dpackheader_t header;
911 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
913 packhandle = open (packfile, O_RDONLY | O_BINARY);
917 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
919 Con_Printf ("%s is not a packfile\n", packfile);
923 if (memcmp(header.id, "PACK", 4))
925 Con_Printf ("%s is not a packfile\n", packfile);
929 header.dirofs = LittleLong (header.dirofs);
930 header.dirlen = LittleLong (header.dirlen);
932 if (header.dirlen % sizeof(dpackfile_t))
934 Con_Printf ("%s has an invalid directory size\n", packfile);
939 numpackfiles = header.dirlen / sizeof(dpackfile_t);
941 if (numpackfiles > MAX_FILES_IN_PACK)
943 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
948 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
949 lseek (packhandle, header.dirofs, SEEK_SET);
950 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
952 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
958 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
959 pack->ignorecase = false; // PAK is case sensitive
960 strlcpy (pack->filename, packfile, sizeof (pack->filename));
961 pack->handle = packhandle;
963 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
965 // parse the directory
966 for (i = 0;i < numpackfiles;i++)
968 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
969 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
971 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
976 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
984 Create a package entry associated with a directory file
987 pack_t *FS_LoadPackVirtual (const char *dirname)
990 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
992 pack->ignorecase = false;
993 strlcpy (pack->filename, dirname, sizeof(pack->filename));
997 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1006 /*! Adds the given pack to the search path.
1007 * The pack type is autodetected by the file extension.
1009 * Returns true if the file was successfully added to the
1010 * search path or if it was already included.
1012 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1013 * plain directories.
1016 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1018 searchpath_t *search;
1020 const char *ext = FS_FileExtension(pakfile);
1023 for(search = fs_searchpaths; search; search = search->next)
1025 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1028 *already_loaded = true;
1029 return true; // already loaded
1034 *already_loaded = false;
1036 if(!strcasecmp(ext, "pk3dir"))
1037 pak = FS_LoadPackVirtual (pakfile);
1038 else if(!strcasecmp(ext, "pak"))
1039 pak = FS_LoadPackPAK (pakfile);
1040 else if(!strcasecmp(ext, "pk3"))
1041 pak = FS_LoadPackPK3 (pakfile);
1043 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1047 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1049 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1052 // find the first item whose next one is a pack or NULL
1053 searchpath_t *insertion_point = 0;
1054 if(fs_searchpaths && !fs_searchpaths->pack)
1056 insertion_point = fs_searchpaths;
1059 if(!insertion_point->next)
1061 if(insertion_point->next->pack)
1063 insertion_point = insertion_point->next;
1066 // If insertion_point is NULL, this means that either there is no
1067 // item in the list yet, or that the very first item is a pack. In
1068 // that case, we want to insert at the beginning...
1069 if(!insertion_point)
1071 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1072 search->next = fs_searchpaths;
1073 fs_searchpaths = search;
1076 // otherwise we want to append directly after insertion_point.
1078 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1079 search->next = insertion_point->next;
1080 insertion_point->next = search;
1085 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1086 search->next = fs_searchpaths;
1087 fs_searchpaths = search;
1092 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1093 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1094 // same goes for the name inside the pack structure
1095 l = strlen(pak->shortname);
1097 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1098 pak->shortname[l - 3] = 0;
1099 l = strlen(pak->filename);
1101 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1102 pak->filename[l - 3] = 0;
1108 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1119 /*! Adds the given pack to the search path and searches for it in the game path.
1120 * The pack type is autodetected by the file extension.
1122 * Returns true if the file was successfully added to the
1123 * search path or if it was already included.
1125 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1126 * plain directories.
1128 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1130 char fullpath[MAX_OSPATH];
1132 searchpath_t *search;
1135 *already_loaded = false;
1137 // then find the real name...
1138 search = FS_FindFile(pakfile, &index, true);
1139 if(!search || search->pack)
1141 Con_Printf("could not find pak \"%s\"\n", pakfile);
1145 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1147 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1155 Sets fs_gamedir, adds the directory to the head of the path,
1156 then loads and adds pak1.pak pak2.pak ...
1159 void FS_AddGameDirectory (const char *dir)
1163 searchpath_t *search;
1165 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1167 stringlistinit(&list);
1168 listdirectory(&list, "", dir);
1169 stringlistsort(&list);
1171 // add any PAK package in the directory
1172 for (i = 0;i < list.numstrings;i++)
1174 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1176 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1180 // add any PK3 package in the directory
1181 for (i = 0;i < list.numstrings;i++)
1183 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1185 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1189 stringlistfreecontents(&list);
1191 // Add the directory to the search path
1192 // (unpacked files have the priority over packed files)
1193 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1194 strlcpy (search->filename, dir, sizeof (search->filename));
1195 search->next = fs_searchpaths;
1196 fs_searchpaths = search;
1205 void FS_AddGameHierarchy (const char *dir)
1207 // Add the common game directory
1208 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1211 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1220 const char *FS_FileExtension (const char *in)
1222 const char *separator, *backslash, *colon, *dot;
1224 separator = strrchr(in, '/');
1225 backslash = strrchr(in, '\\');
1226 if (!separator || separator < backslash)
1227 separator = backslash;
1228 colon = strrchr(in, ':');
1229 if (!separator || separator < colon)
1232 dot = strrchr(in, '.');
1233 if (dot == NULL || (separator && (dot < separator)))
1245 const char *FS_FileWithoutPath (const char *in)
1247 const char *separator, *backslash, *colon;
1249 separator = strrchr(in, '/');
1250 backslash = strrchr(in, '\\');
1251 if (!separator || separator < backslash)
1252 separator = backslash;
1253 colon = strrchr(in, ':');
1254 if (!separator || separator < colon)
1256 return separator ? separator + 1 : in;
1265 void FS_ClearSearchPath (void)
1267 // unload all packs and directory information, close all pack files
1268 // (if a qfile is still reading a pack it won't be harmed because it used
1269 // dup() to get its own handle already)
1270 while (fs_searchpaths)
1272 searchpath_t *search = fs_searchpaths;
1273 fs_searchpaths = search->next;
1274 if (search->pack && search->pack != fs_selfpack)
1276 if(!search->pack->vpack)
1279 close(search->pack->handle);
1280 // free any memory associated with it
1281 if (search->pack->files)
1282 Mem_Free(search->pack->files);
1284 Mem_Free(search->pack);
1290 static void FS_AddSelfPack(void)
1294 searchpath_t *search;
1295 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1296 search->next = fs_searchpaths;
1297 search->pack = fs_selfpack;
1298 fs_searchpaths = search;
1308 void FS_Rescan (void)
1311 qboolean fs_modified = false;
1312 qboolean reset = false;
1313 char gamedirbuf[MAX_INPUTLINE];
1317 FS_ClearSearchPath();
1319 // automatically activate gamemode for the gamedirs specified
1321 COM_ChangeGameTypeForGameDirs();
1323 // add the game-specific paths
1324 // gamedirname1 (typically id1)
1325 FS_AddGameHierarchy (gamedirname1);
1326 // update the com_modname (used for server info)
1327 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1329 // add the game-specific path, if any
1330 // (only used for mission packs and the like, which should set fs_modified)
1334 FS_AddGameHierarchy (gamedirname2);
1338 // Adds basedir/gamedir as an override game
1339 // LordHavoc: now supports multiple -game directories
1340 // set the com_modname (reported in server info)
1342 for (i = 0;i < fs_numgamedirs;i++)
1345 FS_AddGameHierarchy (fs_gamedirs[i]);
1346 // update the com_modname (used server info)
1347 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1349 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1351 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1353 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1355 // add back the selfpack as new first item
1358 // set the default screenshot name to either the mod name or the
1359 // gamemode screenshot name
1360 if (strcmp(com_modname, gamedirname1))
1361 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1363 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1365 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1366 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1368 // If "-condebug" is in the command line, remove the previous log file
1369 if (COM_CheckParm ("-condebug") != 0)
1370 unlink (va("%s/qconsole.log", fs_gamedir));
1372 // look for the pop.lmp file and set registered to true if it is found
1373 if (FS_FileExists("gfx/pop.lmp"))
1374 Cvar_Set ("registered", "1");
1380 if (!registered.integer)
1383 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1385 Con_Print("Playing shareware version.\n");
1388 Con_Print("Playing registered version.\n");
1390 case GAME_STEELSTORM:
1391 if (registered.integer)
1392 Con_Print("Playing registered version.\n");
1394 Con_Print("Playing shareware version.\n");
1400 // unload all wads so that future queries will return the new data
1404 void FS_Rescan_f(void)
1414 extern void Host_SaveConfig (void);
1415 extern void Host_LoadConfig_f (void);
1416 extern qboolean vid_opened;
1417 extern void VID_Stop(void);
1418 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1423 if (fs_numgamedirs == numgamedirs)
1425 for (i = 0;i < numgamedirs;i++)
1426 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1428 if (i == numgamedirs)
1429 return true; // already using this set of gamedirs, do nothing
1432 if (numgamedirs > MAX_GAMEDIRS)
1435 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1436 return false; // too many gamedirs
1439 for (i = 0;i < numgamedirs;i++)
1441 // if string is nasty, reject it
1442 p = FS_CheckGameDir(gamedirs[i]);
1446 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1447 return false; // nasty gamedirs
1449 if(p == fs_checkgamedir_missing && failmissing)
1452 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1453 return false; // missing gamedirs
1459 fs_numgamedirs = numgamedirs;
1460 for (i = 0;i < fs_numgamedirs;i++)
1461 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1463 // reinitialize filesystem to detect the new paks
1466 if (cls.demoplayback)
1472 // unload all sounds so they will be reloaded from the new files as needed
1473 S_UnloadAllSounds_f();
1475 // close down the video subsystem, it will start up again when the config finishes...
1479 // restart the video subsystem after the config is executed
1480 Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1490 void FS_GameDir_f (void)
1494 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1498 Con_Printf("gamedirs active:");
1499 for (i = 0;i < fs_numgamedirs;i++)
1500 Con_Printf(" %s", fs_gamedirs[i]);
1505 numgamedirs = Cmd_Argc() - 1;
1506 if (numgamedirs > MAX_GAMEDIRS)
1508 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1512 for (i = 0;i < numgamedirs;i++)
1513 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1515 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1517 // actually, changing during game would work fine, but would be stupid
1518 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1522 // halt demo playback to close the file
1525 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1528 static const char *FS_SysCheckGameDir(const char *gamedir)
1530 static char buf[8192];
1536 stringlistinit(&list);
1537 listdirectory(&list, gamedir, "");
1538 success = list.numstrings > 0;
1539 stringlistfreecontents(&list);
1543 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1546 n = FS_Read (f, buf, sizeof(buf) - 1);
1566 const char *FS_CheckGameDir(const char *gamedir)
1570 if (FS_CheckNastyPath(gamedir, true))
1573 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1578 // get description from basedir
1579 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1587 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1591 return fs_checkgamedir_missing;
1594 static void FS_ListGameDirs(void)
1596 stringlist_t list, list2;
1600 fs_all_gamedirs_count = 0;
1602 Mem_Free(fs_all_gamedirs);
1604 stringlistinit(&list);
1605 listdirectory(&list, va("%s/", fs_basedir), "");
1606 listdirectory(&list, va("%s/", fs_userdir), "");
1607 stringlistsort(&list);
1609 stringlistinit(&list2);
1610 for(i = 0; i < list.numstrings; ++i)
1613 if(!strcmp(list.strings[i-1], list.strings[i]))
1615 info = FS_CheckGameDir(list.strings[i]);
1618 if(info == fs_checkgamedir_missing)
1622 stringlistappend(&list2, list.strings[i]);
1624 stringlistfreecontents(&list);
1626 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1627 for(i = 0; i < list2.numstrings; ++i)
1629 info = FS_CheckGameDir(list2.strings[i]);
1630 // all this cannot happen any more, but better be safe than sorry
1633 if(info == fs_checkgamedir_missing)
1637 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1638 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1639 ++fs_all_gamedirs_count;
1648 void FS_Init_SelfPack (void)
1651 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1654 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1660 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1663 const char **new_argv;
1665 int args_left = 256;
1666 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1669 new_argv[0] = "dummy";
1674 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1677 while(COM_ParseToken_Console(&p))
1681 q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1682 strlcpy(q, com_token, strlen(com_token) + 1);
1683 new_argv[com_argc + i] = q;
1686 new_argv[i+com_argc] = NULL;
1687 com_argv = new_argv;
1688 com_argc = com_argc + i;
1705 TCHAR mydocsdir[MAX_PATH + 1];
1706 #if _MSC_VER >= 1400
1710 #ifndef __IPHONEOS__
1715 const char* dllnames [] =
1717 "shfolder.dll", // IE 4, or Win NT and higher
1720 Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1721 // don't care for the result; if it fails, %USERPROFILE% will be used instead
1729 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1730 // fs_userdir stores configurations to the Documents folder of the app
1731 strlcpy(fs_userdir, "../Documents/", sizeof(fs_userdir));
1733 // Add the personal game directory
1734 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1736 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1738 else if(COM_CheckParm("-nohome"))
1745 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1747 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1748 Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1752 // use the environment
1753 #if _MSC_VER >= 1400
1754 _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1756 homedir = getenv("USERPROFILE");
1761 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1762 #if _MSC_VER >= 1400
1765 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1770 Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1772 homedir = getenv ("HOME");
1776 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1778 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1783 Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1787 if(!COM_CheckParm("-mygames"))
1789 #if _MSC_VER >= 1400
1791 _sopen_s(&fd, va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
1793 int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1798 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1804 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1806 // If the base directory is explicitly defined by the compilation process
1807 #ifdef DP_FS_BASEDIR
1808 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1813 // FIXME: is there a better way to find the directory outside the .app?
1814 if (strstr(com_argv[0], ".app/"))
1818 split = strstr(com_argv[0], ".app/");
1819 while (split > com_argv[0] && *split != '/')
1821 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1822 fs_basedir[split - com_argv[0]] = 0;
1829 // Overrides the system supplied base directory (under GAMENAME)
1830 // 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)
1831 i = COM_CheckParm ("-basedir");
1832 if (i && i < com_argc-1)
1834 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1835 i = (int)strlen (fs_basedir);
1836 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1837 fs_basedir[i-1] = 0;
1840 // add a path separator to the end of the basedir if it lacks one
1841 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1842 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1846 p = FS_CheckGameDir(gamedirname1);
1847 if(!p || p == fs_checkgamedir_missing)
1848 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1852 p = FS_CheckGameDir(gamedirname2);
1853 if(!p || p == fs_checkgamedir_missing)
1854 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1858 // Adds basedir/gamedir as an override game
1859 // LordHavoc: now supports multiple -game directories
1860 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1864 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1867 p = FS_CheckGameDir(com_argv[i]);
1869 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1870 if(p == fs_checkgamedir_missing)
1871 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1872 // add the gamedir to the list of active gamedirs
1873 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1878 // generate the searchpath
1882 void FS_Init_Commands(void)
1884 Cvar_RegisterVariable (&scr_screenshot_name);
1885 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1886 Cvar_RegisterVariable (&cvar_fs_gamedir);
1888 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1889 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1890 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1891 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1892 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1893 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1901 void FS_Shutdown (void)
1903 // close all pack files and such
1904 // (hopefully there aren't any other open files, but they'll be cleaned up
1905 // by the OS anyway)
1906 FS_ClearSearchPath();
1907 Mem_FreePool (&fs_mempool);
1910 Sys_UnloadLibrary (&shfolder_dll);
1914 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
1920 // Parse the mode string
1929 opt = O_CREAT | O_TRUNC;
1933 opt = O_CREAT | O_APPEND;
1936 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1939 for (ind = 1; mode[ind] != '\0'; ind++)
1950 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1951 filepath, mode, mode[ind]);
1958 #if _MSC_VER >= 1400
1959 _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1961 handle = open (filepath, mod | opt, 0666);
1967 ====================
1970 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1971 ====================
1973 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1977 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1979 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
1980 if (file->handle < 0)
1986 file->filename = Mem_strdup(fs_mempool, filepath);
1988 file->real_length = lseek (file->handle, 0, SEEK_END);
1990 // For files opened in append mode, we start at the end of the file
1992 file->position = file->real_length;
1994 lseek (file->handle, 0, SEEK_SET);
2004 Open a packed file using its package file descriptor
2007 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2013 pfile = &pack->files[pack_ind];
2015 // If we don't have the true offset, get it now
2016 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2017 if (!PK3_GetTrueFileOffset (pfile, pack))
2020 #ifndef LINK_TO_ZLIB
2021 // No Zlib DLL = no compressed files
2022 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2024 Con_Printf("WARNING: can't open the compressed file %s\n"
2025 "You need the Zlib DLL to use compressed files\n",
2031 // LordHavoc: lseek affects all duplicates of a handle so we do it before
2032 // the dup() call to avoid having to close the dup_handle on error here
2033 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2035 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2036 pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2040 dup_handle = dup (pack->handle);
2043 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2047 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2048 memset (file, 0, sizeof (*file));
2049 file->handle = dup_handle;
2050 file->flags = QFILE_FLAG_PACKED;
2051 file->real_length = pfile->realsize;
2052 file->offset = pfile->offset;
2056 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2060 file->flags |= QFILE_FLAG_DEFLATED;
2062 // We need some more variables
2063 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2065 ztk->comp_length = pfile->packsize;
2067 // Initialize zlib stream
2068 ztk->zstream.next_in = ztk->input;
2069 ztk->zstream.avail_in = 0;
2071 /* From Zlib's "unzip.c":
2073 * windowBits is passed < 0 to tell that there is no zlib header.
2074 * Note that in this case inflate *requires* an extra "dummy" byte
2075 * after the compressed stream in order to complete decompression and
2076 * return Z_STREAM_END.
2077 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2078 * size of both compressed and uncompressed data
2080 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2082 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2088 ztk->zstream.next_out = file->buff;
2089 ztk->zstream.avail_out = sizeof (file->buff);
2098 ====================
2101 Return true if the path should be rejected due to one of the following:
2102 1: path elements that are non-portable
2103 2: path elements that would allow access to files outside the game directory,
2104 or are just not a good idea for a mod to be using.
2105 ====================
2107 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2109 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2113 // Windows: don't allow \ in filenames (windows-only), period.
2114 // (on Windows \ is a directory separator, but / is also supported)
2115 if (strstr(path, "\\"))
2116 return 1; // non-portable
2118 // Mac: don't allow Mac-only filenames - : is a directory separator
2119 // instead of /, but we rely on / working already, so there's no reason to
2120 // support a Mac-only path
2121 // Amiga and Windows: : tries to go to root of drive
2122 if (strstr(path, ":"))
2123 return 1; // non-portable attempt to go to root of drive
2125 // Amiga: // is parent directory
2126 if (strstr(path, "//"))
2127 return 1; // non-portable attempt to go to parent directory
2129 // all: don't allow going to parent directory (../ or /../)
2130 if (strstr(path, ".."))
2131 return 2; // attempt to go outside the game directory
2133 // Windows and UNIXes: don't allow absolute paths
2135 return 2; // attempt to go outside the game directory
2137 // all: don't allow . characters before the last slash (it should only be used in filenames, not path elements), this catches all imaginable cases of ./, ../, .../, etc
2138 if (strchr(path, '.'))
2142 // gamedir is entirely path elements, so simply forbid . entirely
2145 if (strchr(path, '.') < strrchr(path, '/'))
2146 return 2; // possible attempt to go outside the game directory
2149 // all: forbid trailing slash on gamedir
2150 if (isgamedir && path[strlen(path)-1] == '/')
2153 // all: forbid leading dot on any filename for any reason
2154 if (strstr(path, "/."))
2155 return 2; // attempt to go outside the game directory
2157 // after all these checks we're pretty sure it's a / separated filename
2158 // and won't do much if any harm
2164 ====================
2167 Look for a file in the packages and in the filesystem
2169 Return the searchpath where the file was found (or NULL)
2170 and the file index in the package if relevant
2171 ====================
2173 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2175 searchpath_t *search;
2178 // search through the path, one element at a time
2179 for (search = fs_searchpaths;search;search = search->next)
2181 // is the element a pak file?
2182 if (search->pack && !search->pack->vpack)
2184 int (*strcmp_funct) (const char* str1, const char* str2);
2185 int left, right, middle;
2188 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2190 // Look for the file (binary search)
2192 right = pak->numfiles - 1;
2193 while (left <= right)
2197 middle = (left + right) / 2;
2198 diff = strcmp_funct (pak->files[middle].name, name);
2203 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2205 // yes, but the first one is empty so we treat it as not being there
2206 if (!quiet && developer_extra.integer)
2207 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2214 if (!quiet && developer_extra.integer)
2215 Con_DPrintf("FS_FindFile: %s in %s\n",
2216 pak->files[middle].name, pak->filename);
2223 // If we're too far in the list
2232 char netpath[MAX_OSPATH];
2233 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2234 if (FS_SysFileExists (netpath))
2236 if (!quiet && developer_extra.integer)
2237 Con_DPrintf("FS_FindFile: %s\n", netpath);
2246 if (!quiet && developer_extra.integer)
2247 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2259 Look for a file in the search paths and open it in read-only mode
2262 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2264 searchpath_t *search;
2267 search = FS_FindFile (filename, &pack_ind, quiet);
2273 // Found in the filesystem?
2276 // this works with vpacks, so we are fine
2277 char path [MAX_OSPATH];
2278 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2279 return FS_SysOpen (path, "rb", nonblocking);
2282 // So, we found it in a package...
2284 // Is it a PK3 symlink?
2285 // TODO also handle directory symlinks by parsing the whole structure...
2286 // but heck, file symlinks are good enough for now
2287 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2289 if(symlinkLevels <= 0)
2291 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2296 char linkbuf[MAX_QPATH];
2298 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2299 const char *mergeslash;
2304 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2310 // Now combine the paths...
2311 mergeslash = strrchr(filename, '/');
2312 mergestart = linkbuf;
2314 mergeslash = filename;
2315 while(!strncmp(mergestart, "../", 3))
2318 while(mergeslash > filename)
2321 if(*mergeslash == '/')
2325 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2326 if(mergeslash == filename)
2328 // Either mergeslash == filename, then we just replace the name (done below)
2332 // Or, we append the name after mergeslash;
2333 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2334 int spaceNeeded = mergeslash - filename + 1;
2335 int spaceRemoved = mergestart - linkbuf;
2336 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2338 Con_DPrintf("symlink: too long path rejected\n");
2341 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2342 memcpy(linkbuf, filename, spaceNeeded);
2343 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2344 mergestart = linkbuf;
2346 if (!quiet && developer_loading.integer)
2347 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2348 if(FS_CheckNastyPath (mergestart, false))
2350 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2353 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2357 return FS_OpenPackedFile (search->pack, pack_ind);
2362 =============================================================================
2364 MAIN PUBLIC FUNCTIONS
2366 =============================================================================
2370 ====================
2373 Open a file in the userpath. The syntax is the same as fopen
2374 Used for savegame scanning in menu, and all file writing.
2375 ====================
2377 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2379 char real_path [MAX_OSPATH];
2381 if (FS_CheckNastyPath(filepath, false))
2383 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2387 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2389 // If the file is opened in "write", "append", or "read/write" mode,
2390 // create directories up to the file.
2391 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2392 FS_CreatePath (real_path);
2393 return FS_SysOpen (real_path, mode, false);
2398 ====================
2401 Open a file. The syntax is the same as fopen
2402 ====================
2404 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2406 if (FS_CheckNastyPath(filepath, false))
2408 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2412 return FS_OpenReadFile (filepath, quiet, false, 16);
2417 ====================
2420 Open a file. The syntax is the same as fopen
2421 ====================
2423 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2426 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2427 memset (file, 0, sizeof (*file));
2428 file->flags = QFILE_FLAG_DATA;
2430 file->real_length = size;
2436 ====================
2440 ====================
2442 int FS_Close (qfile_t* file)
2444 if(file->flags & QFILE_FLAG_DATA)
2450 if (close (file->handle))
2455 if (file->flags & QFILE_FLAG_REMOVE)
2456 remove(file->filename);
2458 Mem_Free((void *) file->filename);
2463 qz_inflateEnd (&file->ztk->zstream);
2464 Mem_Free (file->ztk);
2471 void FS_RemoveOnClose(qfile_t* file)
2473 file->flags |= QFILE_FLAG_REMOVE;
2477 ====================
2480 Write "datasize" bytes into a file
2481 ====================
2483 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2487 // If necessary, seek to the exact file position we're supposed to be
2488 if (file->buff_ind != file->buff_len)
2489 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2491 // Purge cached data
2494 // Write the buffer and update the position
2495 result = write (file->handle, data, (fs_offset_t)datasize);
2496 file->position = lseek (file->handle, 0, SEEK_CUR);
2497 if (file->real_length < file->position)
2498 file->real_length = file->position;
2508 ====================
2511 Read up to "buffersize" bytes from a file
2512 ====================
2514 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2516 fs_offset_t count, done;
2518 if (buffersize == 0)
2521 // Get rid of the ungetc character
2522 if (file->ungetc != EOF)
2524 ((char*)buffer)[0] = file->ungetc;
2532 if(file->flags & QFILE_FLAG_DATA)
2534 size_t left = file->real_length - file->position;
2535 if(buffersize > left)
2537 memcpy(buffer, file->data + file->position, buffersize);
2538 file->position += buffersize;
2542 // First, we copy as many bytes as we can from "buff"
2543 if (file->buff_ind < file->buff_len)
2545 count = file->buff_len - file->buff_ind;
2546 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2548 memcpy (buffer, &file->buff[file->buff_ind], count);
2549 file->buff_ind += count;
2551 buffersize -= count;
2552 if (buffersize == 0)
2556 // NOTE: at this point, the read buffer is always empty
2558 // If the file isn't compressed
2559 if (! (file->flags & QFILE_FLAG_DEFLATED))
2563 // We must take care to not read after the end of the file
2564 count = file->real_length - file->position;
2566 // If we have a lot of data to get, put them directly into "buffer"
2567 if (buffersize > sizeof (file->buff) / 2)
2569 if (count > (fs_offset_t)buffersize)
2570 count = (fs_offset_t)buffersize;
2571 lseek (file->handle, file->offset + file->position, SEEK_SET);
2572 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2576 file->position += nb;
2578 // Purge cached data
2584 if (count > (fs_offset_t)sizeof (file->buff))
2585 count = (fs_offset_t)sizeof (file->buff);
2586 lseek (file->handle, file->offset + file->position, SEEK_SET);
2587 nb = read (file->handle, file->buff, count);
2590 file->buff_len = nb;
2591 file->position += nb;
2593 // Copy the requested data in "buffer" (as much as we can)
2594 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2595 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2596 file->buff_ind = count;
2604 // If the file is compressed, it's more complicated...
2605 // We cycle through a few operations until we have read enough data
2606 while (buffersize > 0)
2608 ztoolkit_t *ztk = file->ztk;
2611 // NOTE: at this point, the read buffer is always empty
2613 // If "input" is also empty, we need to refill it
2614 if (ztk->in_ind == ztk->in_len)
2616 // If we are at the end of the file
2617 if (file->position == file->real_length)
2620 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2621 if (count > (fs_offset_t)sizeof (ztk->input))
2622 count = (fs_offset_t)sizeof (ztk->input);
2623 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2624 if (read (file->handle, ztk->input, count) != count)
2626 Con_Printf ("FS_Read: unexpected end of file\n");
2631 ztk->in_len = count;
2632 ztk->in_position += count;
2635 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2636 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2638 // Now that we are sure we have compressed data available, we need to determine
2639 // if it's better to inflate it in "file->buff" or directly in "buffer"
2641 // Inflate the data in "file->buff"
2642 if (buffersize < sizeof (file->buff) / 2)
2644 ztk->zstream.next_out = file->buff;
2645 ztk->zstream.avail_out = sizeof (file->buff);
2646 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2647 if (error != Z_OK && error != Z_STREAM_END)
2649 Con_Printf ("FS_Read: Can't inflate file\n");
2652 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2654 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2655 file->position += file->buff_len;
2657 // Copy the requested data in "buffer" (as much as we can)
2658 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2659 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2660 file->buff_ind = count;
2663 // Else, we inflate directly in "buffer"
2666 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2667 ztk->zstream.avail_out = (unsigned int)buffersize;
2668 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2669 if (error != Z_OK && error != Z_STREAM_END)
2671 Con_Printf ("FS_Read: Can't inflate file\n");
2674 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2676 // How much data did it inflate?
2677 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2678 file->position += count;
2680 // Purge cached data
2685 buffersize -= count;
2693 ====================
2696 Print a string into a file
2697 ====================
2699 int FS_Print (qfile_t* file, const char *msg)
2701 return (int)FS_Write (file, msg, strlen (msg));
2705 ====================
2708 Print a string into a file
2709 ====================
2711 int FS_Printf(qfile_t* file, const char* format, ...)
2716 va_start (args, format);
2717 result = FS_VPrintf (file, format, args);
2725 ====================
2728 Print a string into a file
2729 ====================
2731 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2734 fs_offset_t buff_size = MAX_INPUTLINE;
2739 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2740 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2741 if (len >= 0 && len < buff_size)
2743 Mem_Free (tempbuff);
2747 len = write (file->handle, tempbuff, len);
2748 Mem_Free (tempbuff);
2755 ====================
2758 Get the next character of a file
2759 ====================
2761 int FS_Getc (qfile_t* file)
2765 if (FS_Read (file, &c, 1) != 1)
2773 ====================
2776 Put a character back into the read buffer (only supports one character!)
2777 ====================
2779 int FS_UnGetc (qfile_t* file, unsigned char c)
2781 // If there's already a character waiting to be read
2782 if (file->ungetc != EOF)
2791 ====================
2794 Move the position index in a file
2795 ====================
2797 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2800 unsigned char* buffer;
2801 fs_offset_t buffersize;
2803 // Compute the file offset
2807 offset += file->position - file->buff_len + file->buff_ind;
2814 offset += file->real_length;
2820 if (offset < 0 || offset > file->real_length)
2823 if(file->flags & QFILE_FLAG_DATA)
2825 file->position = offset;
2829 // If we have the data in our read buffer, we don't need to actually seek
2830 if (file->position - file->buff_len <= offset && offset <= file->position)
2832 file->buff_ind = offset + file->buff_len - file->position;
2836 // Purge cached data
2839 // Unpacked or uncompressed files can seek directly
2840 if (! (file->flags & QFILE_FLAG_DEFLATED))
2842 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2844 file->position = offset;
2848 // Seeking in compressed files is more a hack than anything else,
2849 // but we need to support it, so here we go.
2852 // If we have to go back in the file, we need to restart from the beginning
2853 if (offset <= file->position)
2857 ztk->in_position = 0;
2859 lseek (file->handle, file->offset, SEEK_SET);
2861 // Reset the Zlib stream
2862 ztk->zstream.next_in = ztk->input;
2863 ztk->zstream.avail_in = 0;
2864 qz_inflateReset (&ztk->zstream);
2867 // We need a big buffer to force inflating into it directly
2868 buffersize = 2 * sizeof (file->buff);
2869 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2871 // Skip all data until we reach the requested offset
2872 while (offset > file->position)
2874 fs_offset_t diff = offset - file->position;
2875 fs_offset_t count, len;
2877 count = (diff > buffersize) ? buffersize : diff;
2878 len = FS_Read (file, buffer, count);
2892 ====================
2895 Give the current position in a file
2896 ====================
2898 fs_offset_t FS_Tell (qfile_t* file)
2900 return file->position - file->buff_len + file->buff_ind;
2905 ====================
2908 Give the total size of a file
2909 ====================
2911 fs_offset_t FS_FileSize (qfile_t* file)
2913 return file->real_length;
2918 ====================
2921 Erases any buffered input or output data
2922 ====================
2924 void FS_Purge (qfile_t* file)
2936 Filename are relative to the quake directory.
2937 Always appends a 0 byte.
2940 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2943 unsigned char *buf = NULL;
2944 fs_offset_t filesize = 0;
2946 file = FS_OpenVirtualFile(path, quiet);
2949 filesize = file->real_length;
2952 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2957 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2958 buf[filesize] = '\0';
2959 FS_Read (file, buf, filesize);
2961 if (developer_loadfile.integer)
2962 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2965 if (filesizepointer)
2966 *filesizepointer = filesize;
2975 The filename will be prefixed by the current game directory
2978 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
2982 fs_offset_t lentotal;
2984 file = FS_OpenRealFile(filename, "wb", false);
2987 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2992 for(i = 0; i < count; ++i)
2994 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
2995 for(i = 0; i < count; ++i)
2996 FS_Write (file, data[i], len[i]);
3001 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3003 return FS_WriteFileInBlocks(filename, &data, &len, 1);
3008 =============================================================================
3010 OTHERS PUBLIC FUNCTIONS
3012 =============================================================================
3020 void FS_StripExtension (const char *in, char *out, size_t size_out)
3028 while ((currentchar = *in) && size_out > 1)
3030 if (currentchar == '.')
3032 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3034 *out++ = currentchar;
3050 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3054 // if path doesn't have a .EXT, append extension
3055 // (extension should include the .)
3056 src = path + strlen(path) - 1;
3058 while (*src != '/' && src != path)
3061 return; // it has an extension
3065 strlcat (path, extension, size_path);
3073 Look for a file in the packages and in the filesystem
3076 int FS_FileType (const char *filename)
3078 searchpath_t *search;
3079 char fullpath[MAX_OSPATH];
3081 search = FS_FindFile (filename, NULL, true);
3083 return FS_FILETYPE_NONE;
3085 if(search->pack && !search->pack->vpack)
3086 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3088 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3089 return FS_SysFileType(fullpath);
3097 Look for a file in the packages and in the filesystem
3100 qboolean FS_FileExists (const char *filename)
3102 return (FS_FindFile (filename, NULL, true) != NULL);
3110 Look for a file in the filesystem only
3113 int FS_SysFileType (const char *path)
3116 // Sajt - some older sdks are missing this define
3117 # ifndef INVALID_FILE_ATTRIBUTES
3118 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3121 DWORD result = GetFileAttributes(path);
3123 if(result == INVALID_FILE_ATTRIBUTES)
3124 return FS_FILETYPE_NONE;
3126 if(result & FILE_ATTRIBUTE_DIRECTORY)
3127 return FS_FILETYPE_DIRECTORY;
3129 return FS_FILETYPE_FILE;
3133 if (stat (path,&buf) == -1)
3134 return FS_FILETYPE_NONE;
3137 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3139 if(S_ISDIR(buf.st_mode))
3140 return FS_FILETYPE_DIRECTORY;
3142 return FS_FILETYPE_FILE;
3146 qboolean FS_SysFileExists (const char *path)
3148 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3151 void FS_mkdir (const char *path)
3164 Allocate and fill a search structure with information on matching filenames.
3167 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3170 searchpath_t *searchpath;
3172 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3173 stringlist_t resultlist;
3174 stringlist_t dirlist;
3175 const char *slash, *backslash, *colon, *separator;
3177 char temp[MAX_OSPATH];
3179 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3184 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3188 stringlistinit(&resultlist);
3189 stringlistinit(&dirlist);
3191 slash = strrchr(pattern, '/');
3192 backslash = strrchr(pattern, '\\');
3193 colon = strrchr(pattern, ':');
3194 separator = max(slash, backslash);
3195 separator = max(separator, colon);
3196 basepathlength = separator ? (separator + 1 - pattern) : 0;
3197 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3199 memcpy(basepath, pattern, basepathlength);
3200 basepath[basepathlength] = 0;
3202 // search through the path, one element at a time
3203 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3205 // is the element a pak file?
3206 if (searchpath->pack && !searchpath->pack->vpack)
3208 // look through all the pak file elements
3209 pak = searchpath->pack;
3210 for (i = 0;i < pak->numfiles;i++)
3212 strlcpy(temp, pak->files[i].name, sizeof(temp));
3215 if (matchpattern(temp, (char *)pattern, true))
3217 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3218 if (!strcmp(resultlist.strings[resultlistindex], temp))
3220 if (resultlistindex == resultlist.numstrings)
3222 stringlistappend(&resultlist, temp);
3223 if (!quiet && developer_loading.integer)
3224 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3227 // strip off one path element at a time until empty
3228 // this way directories are added to the listing if they match the pattern
3229 slash = strrchr(temp, '/');
3230 backslash = strrchr(temp, '\\');
3231 colon = strrchr(temp, ':');
3233 if (separator < slash)
3235 if (separator < backslash)
3236 separator = backslash;
3237 if (separator < colon)
3239 *((char *)separator) = 0;
3245 stringlist_t matchedSet, foundSet;
3246 const char *start = pattern;
3248 stringlistinit(&matchedSet);
3249 stringlistinit(&foundSet);
3250 // add a first entry to the set
3251 stringlistappend(&matchedSet, "");
3252 // iterate through pattern's path
3255 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3256 char subpath[MAX_OSPATH];
3257 char subpattern[MAX_OSPATH];
3259 // find the next wildcard
3260 wildcard = strchr(start, '?');
3261 asterisk = strchr(start, '*');
3262 if (asterisk && (!wildcard || asterisk < wildcard))
3264 wildcard = asterisk;
3269 nextseparator = strchr( wildcard, '/' );
3273 nextseparator = NULL;
3276 if( !nextseparator ) {
3277 nextseparator = start + strlen( start );
3280 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3281 // copy everything up except nextseperator
3282 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3283 // find the last '/' before the wildcard
3284 prevseparator = strrchr( subpattern, '/' );
3286 prevseparator = subpattern;
3289 // copy everything from start to the previous including the '/' (before the wildcard)
3290 // everything up to start is already included in the path of matchedSet's entries
3291 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3293 // for each entry in matchedSet try to open the subdirectories specified in subpath
3294 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3295 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3296 strlcat( temp, subpath, sizeof(temp) );
3297 listdirectory( &foundSet, searchpath->filename, temp );
3299 if( dirlistindex == 0 ) {
3302 // reset the current result set
3303 stringlistfreecontents( &matchedSet );
3304 // match against the pattern
3305 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3306 const char *direntry = foundSet.strings[ dirlistindex ];
3307 if (matchpattern(direntry, subpattern, true)) {
3308 stringlistappend( &matchedSet, direntry );
3311 stringlistfreecontents( &foundSet );
3313 start = nextseparator;
3316 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3318 const char *temp = matchedSet.strings[dirlistindex];
3319 if (matchpattern(temp, (char *)pattern, true))
3321 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3322 if (!strcmp(resultlist.strings[resultlistindex], temp))
3324 if (resultlistindex == resultlist.numstrings)
3326 stringlistappend(&resultlist, temp);
3327 if (!quiet && developer_loading.integer)
3328 Con_Printf("SearchDirFile: %s\n", temp);
3332 stringlistfreecontents( &matchedSet );
3336 if (resultlist.numstrings)
3338 stringlistsort(&resultlist);
3339 numfiles = resultlist.numstrings;
3341 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3342 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3343 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3344 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3345 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3346 search->numfilenames = (int)numfiles;
3349 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3352 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3353 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3354 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3356 numchars += (int)textlen;
3359 stringlistfreecontents(&resultlist);
3365 void FS_FreeSearch(fssearch_t *search)
3370 extern int con_linewidth;
3371 int FS_ListDirectory(const char *pattern, int oneperline)
3380 char linebuf[MAX_INPUTLINE];
3382 search = FS_Search(pattern, true, true);
3385 numfiles = search->numfilenames;
3388 // FIXME: the names could be added to one column list and then
3389 // gradually shifted into the next column if they fit, and then the
3390 // next to make a compact variable width listing but it's a lot more
3392 // find width for columns
3394 for (i = 0;i < numfiles;i++)
3396 l = (int)strlen(search->filenames[i]);
3397 if (columnwidth < l)
3400 // count the spacing character
3402 // calculate number of columns
3403 numcolumns = con_linewidth / columnwidth;
3404 // don't bother with the column printing if it's only one column
3405 if (numcolumns >= 2)
3407 numlines = (numfiles + numcolumns - 1) / numcolumns;
3408 for (i = 0;i < numlines;i++)
3411 for (k = 0;k < numcolumns;k++)
3413 l = i * numcolumns + k;
3416 name = search->filenames[l];
3417 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3418 linebuf[linebufpos++] = name[j];
3419 // space out name unless it's the last on the line
3420 if (k + 1 < numcolumns && l + 1 < numfiles)
3421 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3422 linebuf[linebufpos++] = ' ';
3425 linebuf[linebufpos] = 0;
3426 Con_Printf("%s\n", linebuf);
3433 for (i = 0;i < numfiles;i++)
3434 Con_Printf("%s\n", search->filenames[i]);
3435 FS_FreeSearch(search);
3436 return (int)numfiles;
3439 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3441 const char *pattern;
3444 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3447 if (Cmd_Argc() == 2)
3448 pattern = Cmd_Argv(1);
3451 if (!FS_ListDirectory(pattern, oneperline))
3452 Con_Print("No files found.\n");
3457 FS_ListDirectoryCmd("dir", true);
3462 FS_ListDirectoryCmd("ls", false);
3465 void FS_Which_f(void)
3467 const char *filename;
3470 if (Cmd_Argc() != 2)
3472 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3475 filename = Cmd_Argv(1);
3476 sp = FS_FindFile(filename, &index, true);
3478 Con_Printf("%s isn't anywhere\n", filename);
3484 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3486 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3489 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3493 const char *FS_WhichPack(const char *filename)
3496 searchpath_t *sp = FS_FindFile(filename, &index, true);
3498 return sp->pack->shortname;
3504 ====================
3505 FS_IsRegisteredQuakePack
3507 Look for a proof of purchase file file in the requested package
3509 If it is found, this file should NOT be downloaded.
3510 ====================
3512 qboolean FS_IsRegisteredQuakePack(const char *name)
3514 searchpath_t *search;
3517 // search through the path, one element at a time
3518 for (search = fs_searchpaths;search;search = search->next)
3520 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3521 // TODO do we want to support vpacks in here too?
3523 int (*strcmp_funct) (const char* str1, const char* str2);
3524 int left, right, middle;
3527 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3529 // Look for the file (binary search)
3531 right = pak->numfiles - 1;
3532 while (left <= right)
3536 middle = (left + right) / 2;
3537 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3543 // If we're too far in the list
3550 // we found the requested pack but it is not registered quake
3558 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3561 unsigned char *filedata;
3562 fs_offset_t filesize;
3563 if (filesizepointer)
3564 *filesizepointer = 0;
3565 if (!filename || !*filename)
3567 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3570 if (filesizepointer)
3571 *filesizepointer = filesize;
3572 crc = CRC_Block(filedata, filesize);
3578 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3581 unsigned char *out = NULL;
3585 #ifndef LINK_TO_ZLIB
3590 memset(&strm, 0, sizeof(strm));
3591 strm.zalloc = Z_NULL;
3592 strm.zfree = Z_NULL;
3593 strm.opaque = Z_NULL;
3596 level = Z_DEFAULT_COMPRESSION;
3598 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3600 Con_Printf("FS_Deflate: deflate init error!\n");
3604 strm.next_in = (unsigned char*)data;
3605 strm.avail_in = size;
3607 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3610 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3611 qz_deflateEnd(&strm);
3615 strm.next_out = tmp;
3616 strm.avail_out = size;
3618 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3620 Con_Printf("FS_Deflate: deflate failed!\n");
3621 qz_deflateEnd(&strm);
3626 if(qz_deflateEnd(&strm) != Z_OK)
3628 Con_Printf("FS_Deflate: deflateEnd failed\n");
3633 if(strm.total_out >= size)
3635 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3640 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3643 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3649 *deflated_size = (size_t)strm.total_out;
3651 memcpy(out, tmp, strm.total_out);
3657 static void AssertBufsize(sizebuf_t *buf, int length)
3659 if(buf->cursize + length > buf->maxsize)
3661 int oldsize = buf->maxsize;
3662 unsigned char *olddata;
3663 olddata = buf->data;
3664 buf->maxsize += length;
3665 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3668 memcpy(buf->data, olddata, oldsize);
3674 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3678 unsigned char *out = NULL;
3679 unsigned char tmp[2048];
3684 #ifndef LINK_TO_ZLIB
3689 memset(&outbuf, 0, sizeof(outbuf));
3690 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3691 outbuf.maxsize = sizeof(tmp);
3693 memset(&strm, 0, sizeof(strm));
3694 strm.zalloc = Z_NULL;
3695 strm.zfree = Z_NULL;
3696 strm.opaque = Z_NULL;
3698 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3700 Con_Printf("FS_Inflate: inflate init error!\n");
3701 Mem_Free(outbuf.data);
3705 strm.next_in = (unsigned char*)data;
3706 strm.avail_in = size;
3710 strm.next_out = tmp;
3711 strm.avail_out = sizeof(tmp);
3712 ret = qz_inflate(&strm, Z_NO_FLUSH);
3713 // it either returns Z_OK on progress, Z_STREAM_END on end
3721 case Z_STREAM_ERROR:
3722 Con_Print("FS_Inflate: stream error!\n");
3725 Con_Print("FS_Inflate: data error!\n");
3728 Con_Print("FS_Inflate: mem error!\n");
3731 Con_Print("FS_Inflate: buf error!\n");
3734 Con_Print("FS_Inflate: unknown error!\n");
3738 if(ret != Z_OK && ret != Z_STREAM_END)
3740 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3741 Mem_Free(outbuf.data);
3742 qz_inflateEnd(&strm);
3745 have = sizeof(tmp) - strm.avail_out;
3746 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3747 SZ_Write(&outbuf, tmp, have);
3748 } while(ret != Z_STREAM_END);
3750 qz_inflateEnd(&strm);
3752 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3755 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3756 Mem_Free(outbuf.data);
3760 memcpy(out, outbuf.data, outbuf.cursize);
3761 Mem_Free(outbuf.data);
3764 *inflated_size = (size_t)outbuf.cursize;