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
36 # include <sys/stat.h>
43 // Win32 requires us to add O_BINARY, but the other OSes don't have it
48 // In case the system doesn't support the O_NONBLOCK flag
53 // largefile support for Win32
55 # define lseek _lseeki64
59 // suppress deprecated warnings
60 # include <sys/stat.h>
65 # define unlink _unlink
69 /** \page fs File System
71 All of Quake's data access is through a hierchal file system, but the contents
72 of the file system can be transparently merged from several sources.
74 The "base directory" is the path to the directory holding the quake.exe and
75 all game directories. The sys_* files pass this to host_init in
76 quakeparms_t->basedir. This can be overridden with the "-basedir" command
77 line parm to allow code debugging in a different directory. The base
78 directory is only used during filesystem initialization.
80 The "game directory" is the first tree on the search path and directory that
81 all generated files (savegames, screenshots, demos, config files) will be
82 saved to. This can be overridden with the "-game" command line parameter.
83 The game directory can never be changed while quake is executing. This is a
84 precaution against having a malicious server instruct clients to write files
85 over areas they shouldn't.
91 =============================================================================
95 =============================================================================
98 // Magic numbers of a ZIP file (big-endian format)
99 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
100 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
101 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
103 // Other constants for ZIP files
104 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
105 #define ZIP_END_CDIR_SIZE 22
106 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
107 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
112 #define qz_inflate inflate
113 #define qz_inflateEnd inflateEnd
114 #define qz_inflateInit2_ inflateInit2_
115 #define qz_inflateReset inflateReset
116 #define qz_deflateInit2_ deflateInit2_
117 #define qz_deflateEnd deflateEnd
118 #define qz_deflate deflate
119 #define Z_MEMLEVEL_DEFAULT 8
122 // Zlib constants (from zlib.h)
123 #define Z_SYNC_FLUSH 2
126 #define Z_STREAM_END 1
127 #define Z_STREAM_ERROR (-2)
128 #define Z_DATA_ERROR (-3)
129 #define Z_MEM_ERROR (-4)
130 #define Z_BUF_ERROR (-5)
131 #define ZLIB_VERSION "1.2.3"
135 #define Z_MEMLEVEL_DEFAULT 8
138 #define Z_DEFAULT_COMPRESSION (-1)
140 #define Z_SYNC_FLUSH 2
141 #define Z_FULL_FLUSH 3
144 // Uncomment the following line if the zlib DLL you have still uses
145 // the 1.1.x series calling convention on Win32 (WINAPI)
146 //#define ZLIB_USES_WINAPI
150 =============================================================================
154 =============================================================================
157 /*! Zlib stream (from zlib.h)
158 * \warning: some pointers we don't use directly have
159 * been cast to "void*" for a matter of simplicity
163 unsigned char *next_in; ///< next input byte
164 unsigned int avail_in; ///< number of bytes available at next_in
165 unsigned long total_in; ///< total nb of input bytes read so far
167 unsigned char *next_out; ///< next output byte should be put there
168 unsigned int avail_out; ///< remaining free space at next_out
169 unsigned long total_out; ///< total nb of bytes output so far
171 char *msg; ///< last error message, NULL if no error
172 void *state; ///< not visible by applications
174 void *zalloc; ///< used to allocate the internal state
175 void *zfree; ///< used to free the internal state
176 void *opaque; ///< private data object passed to zalloc and zfree
178 int data_type; ///< best guess about the data type: ascii or binary
179 unsigned long adler; ///< adler32 value of the uncompressed data
180 unsigned long reserved; ///< reserved for future use
185 /// inside a package (PAK or PK3)
186 #define QFILE_FLAG_PACKED (1 << 0)
187 /// file is compressed using the deflate algorithm (PK3 only)
188 #define QFILE_FLAG_DEFLATED (1 << 1)
189 /// file is actually already loaded data
190 #define QFILE_FLAG_DATA (1 << 2)
192 #define FILE_BUFF_SIZE 2048
196 size_t comp_length; ///< length of the compressed file
197 size_t in_ind, in_len; ///< input buffer current index and length
198 size_t in_position; ///< position in the compressed file
199 unsigned char input [FILE_BUFF_SIZE];
205 int handle; ///< file descriptor
206 fs_offset_t real_length; ///< uncompressed file size (for files opened in "read" mode)
207 fs_offset_t position; ///< current position in the file
208 fs_offset_t offset; ///< offset into the package (0 if external file)
209 int ungetc; ///< single stored character from ungetc, cleared to EOF when read
212 fs_offset_t buff_ind, buff_len; ///< buffer current index and length
213 unsigned char buff [FILE_BUFF_SIZE];
215 ztoolkit_t* ztk; ///< For zipped files.
217 const unsigned char *data; ///< For data files.
221 // ------ PK3 files on disk ------ //
223 // You can get the complete ZIP format description from PKWARE website
225 typedef struct pk3_endOfCentralDir_s
227 unsigned int signature;
228 unsigned short disknum;
229 unsigned short cdir_disknum; ///< number of the disk with the start of the central directory
230 unsigned short localentries; ///< number of entries in the central directory on this disk
231 unsigned short nbentries; ///< total number of entries in the central directory on this disk
232 unsigned int cdir_size; ///< size of the central directory
233 unsigned int cdir_offset; ///< with respect to the starting disk number
234 unsigned short comment_size;
235 fs_offset_t prepended_garbage;
236 } pk3_endOfCentralDir_t;
239 // ------ PAK files on disk ------ //
240 typedef struct dpackfile_s
243 int filepos, filelen;
246 typedef struct dpackheader_s
254 /*! \name Packages in memory
257 /// the offset in packfile_t is the true contents offset
258 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
259 /// file compressed using the deflate algorithm
260 #define PACKFILE_FLAG_DEFLATED (1 << 1)
261 /// file is a symbolic link
262 #define PACKFILE_FLAG_SYMLINK (1 << 2)
264 typedef struct packfile_s
266 char name [MAX_QPATH];
269 fs_offset_t packsize; ///< size in the package
270 fs_offset_t realsize; ///< real file size (uncompressed)
273 typedef struct pack_s
275 char filename [MAX_OSPATH];
276 char shortname [MAX_QPATH];
278 int ignorecase; ///< PK3 ignores case
285 /// Search paths for files (including packages)
286 typedef struct searchpath_s
288 // only one of filename / pack will be used
289 char filename[MAX_OSPATH];
291 struct searchpath_s *next;
296 =============================================================================
300 =============================================================================
305 void FS_Which_f(void);
307 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
308 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
309 fs_offset_t offset, fs_offset_t packsize,
310 fs_offset_t realsize, int flags);
314 =============================================================================
318 =============================================================================
321 mempool_t *fs_mempool;
323 searchpath_t *fs_searchpaths = NULL;
324 const char *const fs_checkgamedir_missing = "missing";
326 #define MAX_FILES_IN_PACK 65536
328 char fs_userdir[MAX_OSPATH];
329 char fs_gamedir[MAX_OSPATH];
330 char fs_basedir[MAX_OSPATH];
331 static pack_t *fs_selfpack = NULL;
333 // list of active game directories (empty if not running a mod)
334 int fs_numgamedirs = 0;
335 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
337 // list of all gamedirs with modinfo.txt
338 gamedir_t *fs_all_gamedirs = NULL;
339 int fs_all_gamedirs_count = 0;
341 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)"};
342 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"};
343 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
347 =============================================================================
349 PRIVATE FUNCTIONS - PK3 HANDLING
351 =============================================================================
355 // Functions exported from zlib
356 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
357 # define ZEXPORT WINAPI
362 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
363 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
364 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
365 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
366 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
367 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
368 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
371 #define qz_inflateInit2(strm, windowBits) \
372 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
373 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
374 qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
377 // qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
379 static dllfunction_t zlibfuncs[] =
381 {"inflate", (void **) &qz_inflate},
382 {"inflateEnd", (void **) &qz_inflateEnd},
383 {"inflateInit2_", (void **) &qz_inflateInit2_},
384 {"inflateReset", (void **) &qz_inflateReset},
385 {"deflateInit2_", (void **) &qz_deflateInit2_},
386 {"deflateEnd", (void **) &qz_deflateEnd},
387 {"deflate", (void **) &qz_deflate},
391 /// Handle for Zlib DLL
392 static dllhandle_t zlib_dll = NULL;
396 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
397 static dllfunction_t shfolderfuncs[] =
399 {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
402 static dllhandle_t shfolder_dll = NULL;
412 void PK3_CloseLibrary (void)
415 Sys_UnloadLibrary (&zlib_dll);
424 Try to load the Zlib DLL
427 qboolean PK3_OpenLibrary (void)
432 const char* dllnames [] =
435 # ifdef ZLIB_USES_WINAPI
441 #elif defined(MACOSX)
455 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
463 See if zlib is available
466 qboolean FS_HasZlib(void)
471 PK3_OpenLibrary(); // to be safe
472 return (zlib_dll != 0);
478 PK3_GetEndOfCentralDir
480 Extract the end of the central directory from a PK3 package
483 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
485 fs_offset_t filesize, maxsize;
486 unsigned char *buffer, *ptr;
489 // Get the package size
490 filesize = lseek (packhandle, 0, SEEK_END);
491 if (filesize < ZIP_END_CDIR_SIZE)
494 // Load the end of the file in memory
495 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
498 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
499 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
500 lseek (packhandle, filesize - maxsize, SEEK_SET);
501 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
507 // Look for the end of central dir signature around the end of the file
508 maxsize -= ZIP_END_CDIR_SIZE;
509 ptr = &buffer[maxsize];
511 while (BuffBigLong (ptr) != ZIP_END_HEADER)
523 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
524 eocd->signature = LittleLong (eocd->signature);
525 eocd->disknum = LittleShort (eocd->disknum);
526 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
527 eocd->localentries = LittleShort (eocd->localentries);
528 eocd->nbentries = LittleShort (eocd->nbentries);
529 eocd->cdir_size = LittleLong (eocd->cdir_size);
530 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
531 eocd->comment_size = LittleShort (eocd->comment_size);
532 eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
533 eocd->cdir_offset += eocd->prepended_garbage;
545 Extract the file list from a PK3 file
548 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
550 unsigned char *central_dir, *ptr;
552 fs_offset_t remaining;
554 // Load the central directory in memory
555 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
556 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
557 if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
559 Mem_Free (central_dir);
563 // Extract the files properties
564 // The parsing is done "by hand" because some fields have variable sizes and
565 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
566 remaining = eocd->cdir_size;
569 for (ind = 0; ind < eocd->nbentries; ind++)
571 fs_offset_t namesize, count;
573 // Checking the remaining size
574 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
576 Mem_Free (central_dir);
579 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
582 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
584 Mem_Free (central_dir);
588 namesize = BuffLittleShort (&ptr[28]); // filename length
590 // Check encryption, compression, and attributes
591 // 1st uint8 : general purpose bit flag
592 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
594 // LordHavoc: bit 3 would be a problem if we were scanning the archive
595 // but is not a problem in the central directory where the values are
598 // bit 3 seems to always be set by the standard Mac OSX zip maker
600 // 2nd uint8 : external file attributes
601 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
602 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
604 // Still enough bytes for the name?
605 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
607 Mem_Free (central_dir);
611 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
612 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
614 char filename [sizeof (pack->files[0].name)];
615 fs_offset_t offset, packsize, realsize;
618 // Extract the name (strip it if necessary)
619 namesize = min(namesize, (int)sizeof (filename) - 1);
620 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
621 filename[namesize] = '\0';
623 if (BuffLittleShort (&ptr[10]))
624 flags = PACKFILE_FLAG_DEFLATED;
627 offset = BuffLittleLong (&ptr[42]) + eocd->prepended_garbage;
628 packsize = BuffLittleLong (&ptr[20]);
629 realsize = BuffLittleLong (&ptr[24]);
631 switch(ptr[5]) // C_VERSION_MADE_BY_1
636 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
637 // can't use S_ISLNK here, as this has to compile on non-UNIX too
638 flags |= PACKFILE_FLAG_SYMLINK;
642 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
646 // Skip the name, additionnal field, and comment
647 // 1er uint16 : extra field length
648 // 2eme uint16 : file comment length
649 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
650 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
654 // If the package is empty, central_dir is NULL here
655 if (central_dir != NULL)
656 Mem_Free (central_dir);
657 return pack->numfiles;
665 Create a package entry associated with a PK3 file
668 pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle)
670 pk3_endOfCentralDir_t eocd;
674 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
676 Con_Printf ("%s is not a PK3 file\n", packfile);
681 // Multi-volume ZIP archives are NOT allowed
682 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
684 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
689 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
690 // since eocd.nbentries is an unsigned 16 bits integer
691 #if MAX_FILES_IN_PACK < 65535
692 if (eocd.nbentries > MAX_FILES_IN_PACK)
694 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
700 // Create a package structure in memory
701 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
702 pack->ignorecase = true; // PK3 ignores case
703 strlcpy (pack->filename, packfile, sizeof (pack->filename));
704 pack->handle = packhandle;
705 pack->numfiles = eocd.nbentries;
706 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
708 real_nb_files = PK3_BuildFileList (pack, &eocd);
709 if (real_nb_files < 0)
711 Con_Printf ("%s is not a valid PK3 file\n", packfile);
717 Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
720 pack_t *FS_LoadPackPK3 (const char *packfile)
724 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
726 packhandle = open (packfile, O_RDONLY | O_BINARY);
730 return FS_LoadPackPK3FromFD(packfile, packhandle);
736 PK3_GetTrueFileOffset
738 Find where the true file data offset is
741 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
743 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
747 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
750 // Load the local file description
751 lseek (pack->handle, pfile->offset, SEEK_SET);
752 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
753 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
755 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
759 // Skip name and extra field
760 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
762 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
768 =============================================================================
770 OTHER PRIVATE FUNCTIONS
772 =============================================================================
780 Add a file to the list of files contained into a package
783 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
784 fs_offset_t offset, fs_offset_t packsize,
785 fs_offset_t realsize, int flags)
787 int (*strcmp_funct) (const char* str1, const char* str2);
788 int left, right, middle;
791 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
793 // Look for the slot we should put that file into (binary search)
795 right = pack->numfiles - 1;
796 while (left <= right)
800 middle = (left + right) / 2;
801 diff = strcmp_funct (pack->files[middle].name, name);
803 // If we found the file, there's a problem
805 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
807 // If we're too far in the list
814 // We have to move the right of the list by one slot to free the one we need
815 pfile = &pack->files[left];
816 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
819 strlcpy (pfile->name, name, sizeof (pfile->name));
820 pfile->offset = offset;
821 pfile->packsize = packsize;
822 pfile->realsize = realsize;
823 pfile->flags = flags;
833 Only used for FS_OpenRealFile.
836 void FS_CreatePath (char *path)
840 for (ofs = path+1 ; *ofs ; ofs++)
842 if (*ofs == '/' || *ofs == '\\')
844 // create the directory
860 void FS_Path_f (void)
864 Con_Print("Current search path:\n");
865 for (s=fs_searchpaths ; s ; s=s->next)
870 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
872 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
875 Con_Printf("%s\n", s->filename);
885 /*! Takes an explicit (not game tree related) path to a pak file.
886 *Loads the header and directory, adding the files at the beginning
887 *of the list so they override previous pack files.
889 pack_t *FS_LoadPackPAK (const char *packfile)
891 dpackheader_t header;
898 _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
900 packhandle = open (packfile, O_RDONLY | O_BINARY);
904 if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
906 Con_Printf ("%s is not a packfile\n", packfile);
910 if (memcmp(header.id, "PACK", 4))
912 Con_Printf ("%s is not a packfile\n", packfile);
916 header.dirofs = LittleLong (header.dirofs);
917 header.dirlen = LittleLong (header.dirlen);
919 if (header.dirlen % sizeof(dpackfile_t))
921 Con_Printf ("%s has an invalid directory size\n", packfile);
926 numpackfiles = header.dirlen / sizeof(dpackfile_t);
928 if (numpackfiles > MAX_FILES_IN_PACK)
930 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
935 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
936 lseek (packhandle, header.dirofs, SEEK_SET);
937 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
939 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
945 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
946 pack->ignorecase = false; // PAK is case sensitive
947 strlcpy (pack->filename, packfile, sizeof (pack->filename));
948 pack->handle = packhandle;
950 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
952 // parse the directory
953 for (i = 0;i < numpackfiles;i++)
955 fs_offset_t offset = LittleLong (info[i].filepos);
956 fs_offset_t size = LittleLong (info[i].filelen);
958 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
963 Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
971 Create a package entry associated with a directory file
974 pack_t *FS_LoadPackVirtual (const char *dirname)
977 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
979 pack->ignorecase = false;
980 strlcpy (pack->filename, dirname, sizeof(pack->filename));
984 Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
993 /*! Adds the given pack to the search path.
994 * The pack type is autodetected by the file extension.
996 * Returns true if the file was successfully added to the
997 * search path or if it was already included.
999 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1000 * plain directories.
1003 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1005 searchpath_t *search;
1007 const char *ext = FS_FileExtension(pakfile);
1010 for(search = fs_searchpaths; search; search = search->next)
1012 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1015 *already_loaded = true;
1016 return true; // already loaded
1021 *already_loaded = false;
1023 if(!strcasecmp(ext, "pk3dir"))
1024 pak = FS_LoadPackVirtual (pakfile);
1025 else if(!strcasecmp(ext, "pak"))
1026 pak = FS_LoadPackPAK (pakfile);
1027 else if(!strcasecmp(ext, "pk3"))
1028 pak = FS_LoadPackPK3 (pakfile);
1030 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1034 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1036 //Con_DPrintf(" Registered pack with short name %s\n", shortname);
1039 // find the first item whose next one is a pack or NULL
1040 searchpath_t *insertion_point = 0;
1041 if(fs_searchpaths && !fs_searchpaths->pack)
1043 insertion_point = fs_searchpaths;
1046 if(!insertion_point->next)
1048 if(insertion_point->next->pack)
1050 insertion_point = insertion_point->next;
1053 // If insertion_point is NULL, this means that either there is no
1054 // item in the list yet, or that the very first item is a pack. In
1055 // that case, we want to insert at the beginning...
1056 if(!insertion_point)
1058 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1059 search->next = fs_searchpaths;
1060 fs_searchpaths = search;
1063 // otherwise we want to append directly after insertion_point.
1065 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1066 search->next = insertion_point->next;
1067 insertion_point->next = search;
1072 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1073 search->next = fs_searchpaths;
1074 fs_searchpaths = search;
1079 dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1080 // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1081 // same goes for the name inside the pack structure
1082 l = strlen(pak->shortname);
1084 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1085 pak->shortname[l - 3] = 0;
1086 l = strlen(pak->filename);
1088 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1089 pak->filename[l - 3] = 0;
1095 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1106 /*! Adds the given pack to the search path and searches for it in the game path.
1107 * The pack type is autodetected by the file extension.
1109 * Returns true if the file was successfully added to the
1110 * search path or if it was already included.
1112 * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1113 * plain directories.
1115 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1117 char fullpath[MAX_OSPATH];
1119 searchpath_t *search;
1122 *already_loaded = false;
1124 // then find the real name...
1125 search = FS_FindFile(pakfile, &index, true);
1126 if(!search || search->pack)
1128 Con_Printf("could not find pak \"%s\"\n", pakfile);
1132 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1134 return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1142 Sets fs_gamedir, adds the directory to the head of the path,
1143 then loads and adds pak1.pak pak2.pak ...
1146 void FS_AddGameDirectory (const char *dir)
1150 searchpath_t *search;
1152 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1154 stringlistinit(&list);
1155 listdirectory(&list, "", dir);
1156 stringlistsort(&list);
1158 // add any PAK package in the directory
1159 for (i = 0;i < list.numstrings;i++)
1161 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1163 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1167 // add any PK3 package in the directory
1168 for (i = 0;i < list.numstrings;i++)
1170 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1172 FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1176 stringlistfreecontents(&list);
1178 // Add the directory to the search path
1179 // (unpacked files have the priority over packed files)
1180 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1181 strlcpy (search->filename, dir, sizeof (search->filename));
1182 search->next = fs_searchpaths;
1183 fs_searchpaths = search;
1192 void FS_AddGameHierarchy (const char *dir)
1194 // Add the common game directory
1195 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1198 FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
1207 const char *FS_FileExtension (const char *in)
1209 const char *separator, *backslash, *colon, *dot;
1211 separator = strrchr(in, '/');
1212 backslash = strrchr(in, '\\');
1213 if (!separator || separator < backslash)
1214 separator = backslash;
1215 colon = strrchr(in, ':');
1216 if (!separator || separator < colon)
1219 dot = strrchr(in, '.');
1220 if (dot == NULL || (separator && (dot < separator)))
1232 const char *FS_FileWithoutPath (const char *in)
1234 const char *separator, *backslash, *colon;
1236 separator = strrchr(in, '/');
1237 backslash = strrchr(in, '\\');
1238 if (!separator || separator < backslash)
1239 separator = backslash;
1240 colon = strrchr(in, ':');
1241 if (!separator || separator < colon)
1243 return separator ? separator + 1 : in;
1252 void FS_ClearSearchPath (void)
1254 // unload all packs and directory information, close all pack files
1255 // (if a qfile is still reading a pack it won't be harmed because it used
1256 // dup() to get its own handle already)
1257 while (fs_searchpaths)
1259 searchpath_t *search = fs_searchpaths;
1260 fs_searchpaths = search->next;
1261 if (search->pack && search->pack != fs_selfpack)
1263 if(!search->pack->vpack)
1266 close(search->pack->handle);
1267 // free any memory associated with it
1268 if (search->pack->files)
1269 Mem_Free(search->pack->files);
1271 Mem_Free(search->pack);
1277 static void FS_AddSelfPack(void)
1281 searchpath_t *search;
1282 search = Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1283 search->next = fs_searchpaths;
1284 search->pack = fs_selfpack;
1285 fs_searchpaths = search;
1295 void FS_Rescan (void)
1298 qboolean fs_modified = false;
1299 char gamedirbuf[MAX_INPUTLINE];
1301 FS_ClearSearchPath();
1303 // add the game-specific paths
1304 // gamedirname1 (typically id1)
1305 FS_AddGameHierarchy (gamedirname1);
1306 // update the com_modname (used for server info)
1307 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1309 // add the game-specific path, if any
1310 // (only used for mission packs and the like, which should set fs_modified)
1314 FS_AddGameHierarchy (gamedirname2);
1318 // Adds basedir/gamedir as an override game
1319 // LordHavoc: now supports multiple -game directories
1320 // set the com_modname (reported in server info)
1322 for (i = 0;i < fs_numgamedirs;i++)
1325 FS_AddGameHierarchy (fs_gamedirs[i]);
1326 // update the com_modname (used server info)
1327 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1329 strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1331 strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1333 Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1335 // add back the selfpack as new first item
1338 // set the default screenshot name to either the mod name or the
1339 // gamemode screenshot name
1340 if (strcmp(com_modname, gamedirname1))
1341 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1343 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1345 if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1346 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1348 // If "-condebug" is in the command line, remove the previous log file
1349 if (COM_CheckParm ("-condebug") != 0)
1350 unlink (va("%s/qconsole.log", fs_gamedir));
1352 // look for the pop.lmp file and set registered to true if it is found
1353 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1356 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1358 Con_Print("Playing shareware version.\n");
1362 Cvar_Set ("registered", "1");
1363 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1364 Con_Print("Playing registered version.\n");
1367 // unload all wads so that future queries will return the new data
1371 void FS_Rescan_f(void)
1381 extern void Host_SaveConfig (void);
1382 extern void Host_LoadConfig_f (void);
1383 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1388 if (fs_numgamedirs == numgamedirs)
1390 for (i = 0;i < numgamedirs;i++)
1391 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1393 if (i == numgamedirs)
1394 return true; // already using this set of gamedirs, do nothing
1397 if (numgamedirs > MAX_GAMEDIRS)
1400 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1401 return false; // too many gamedirs
1404 for (i = 0;i < numgamedirs;i++)
1406 // if string is nasty, reject it
1407 p = FS_CheckGameDir(gamedirs[i]);
1411 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1412 return false; // nasty gamedirs
1414 if(p == fs_checkgamedir_missing && failmissing)
1417 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1418 return false; // missing gamedirs
1424 fs_numgamedirs = numgamedirs;
1425 for (i = 0;i < fs_numgamedirs;i++)
1426 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1428 // reinitialize filesystem to detect the new paks
1431 // exec the new config
1432 Host_LoadConfig_f();
1434 // unload all sounds so they will be reloaded from the new files as needed
1435 S_UnloadAllSounds_f();
1437 // reinitialize renderer (this reloads hud/console background/etc)
1438 R_Modules_Restart();
1448 void FS_GameDir_f (void)
1452 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1456 Con_Printf("gamedirs active:");
1457 for (i = 0;i < fs_numgamedirs;i++)
1458 Con_Printf(" %s", fs_gamedirs[i]);
1463 numgamedirs = Cmd_Argc() - 1;
1464 if (numgamedirs > MAX_GAMEDIRS)
1466 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1470 for (i = 0;i < numgamedirs;i++)
1471 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1473 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1475 // actually, changing during game would work fine, but would be stupid
1476 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1480 // halt demo playback to close the file
1483 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1486 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking);
1487 static const char *FS_SysCheckGameDir(const char *gamedir)
1489 static char buf[8192];
1495 stringlistinit(&list);
1496 listdirectory(&list, gamedir, "");
1497 success = list.numstrings > 0;
1498 stringlistfreecontents(&list);
1502 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1505 n = FS_Read (f, buf, sizeof(buf) - 1);
1525 const char *FS_CheckGameDir(const char *gamedir)
1529 if (FS_CheckNastyPath(gamedir, true))
1532 ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1537 // get description from basedir
1538 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1546 ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1550 return fs_checkgamedir_missing;
1553 static void FS_ListGameDirs(void)
1555 stringlist_t list, list2;
1559 fs_all_gamedirs_count = 0;
1561 Mem_Free(fs_all_gamedirs);
1563 stringlistinit(&list);
1564 listdirectory(&list, va("%s/", fs_basedir), "");
1565 listdirectory(&list, va("%s/", fs_userdir), "");
1566 stringlistsort(&list);
1568 stringlistinit(&list2);
1569 for(i = 0; i < list.numstrings; ++i)
1572 if(!strcmp(list.strings[i-1], list.strings[i]))
1574 info = FS_CheckGameDir(list.strings[i]);
1577 if(info == fs_checkgamedir_missing)
1581 stringlistappend(&list2, list.strings[i]);
1583 stringlistfreecontents(&list);
1585 fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1586 for(i = 0; i < list2.numstrings; ++i)
1588 info = FS_CheckGameDir(list2.strings[i]);
1589 // all this cannot happen any more, but better be safe than sorry
1592 if(info == fs_checkgamedir_missing)
1596 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1597 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1598 ++fs_all_gamedirs_count;
1607 void FS_Init_SelfPack (void)
1610 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1613 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd);
1619 buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1622 const char **new_argv;
1624 int args_left = 256;
1625 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1628 new_argv[0] = "dummy";
1633 memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1636 while(COM_ParseToken_Console(&p))
1640 q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1641 strlcpy(q, com_token, strlen(com_token) + 1);
1642 new_argv[com_argc + i] = q;
1645 new_argv[i+com_argc] = NULL;
1646 com_argv = new_argv;
1647 com_argc = com_argc + i;
1664 TCHAR mydocsdir[MAX_PATH + 1];
1665 #if _MSC_VER >= 1400
1672 const char* dllnames [] =
1674 "shfolder.dll", // IE 4, or Win NT and higher
1677 Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1678 // don't care for the result; if it fails, %USERPROFILE% will be used instead
1681 // Add the personal game directory
1682 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1684 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1686 else if(COM_CheckParm("-nohome"))
1693 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1695 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1696 Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1700 // use the environment
1701 #if _MSC_VER >= 1400
1702 _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1704 homedir = getenv("USERPROFILE");
1709 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1710 #if _MSC_VER >= 1400
1713 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1718 Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1720 homedir = getenv ("HOME");
1722 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1725 Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1729 if(!COM_CheckParm("-mygames"))
1731 #if _MSC_VER >= 1400
1733 _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!
1735 int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1740 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1746 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1748 // If the base directory is explicitly defined by the compilation process
1749 #ifdef DP_FS_BASEDIR
1750 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1755 // FIXME: is there a better way to find the directory outside the .app?
1756 if (strstr(com_argv[0], ".app/"))
1760 split = strstr(com_argv[0], ".app/");
1761 while (split > com_argv[0] && *split != '/')
1763 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1764 fs_basedir[split - com_argv[0]] = 0;
1770 // Overrides the system supplied base directory (under GAMENAME)
1771 // 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)
1772 i = COM_CheckParm ("-basedir");
1773 if (i && i < com_argc-1)
1775 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1776 i = (int)strlen (fs_basedir);
1777 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1778 fs_basedir[i-1] = 0;
1781 // add a path separator to the end of the basedir if it lacks one
1782 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1783 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1787 p = FS_CheckGameDir(gamedirname1);
1788 if(!p || p == fs_checkgamedir_missing)
1789 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1793 p = FS_CheckGameDir(gamedirname2);
1794 if(!p || p == fs_checkgamedir_missing)
1795 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1799 // Adds basedir/gamedir as an override game
1800 // LordHavoc: now supports multiple -game directories
1801 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1805 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1808 p = FS_CheckGameDir(com_argv[i]);
1810 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1811 if(p == fs_checkgamedir_missing)
1812 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1813 // add the gamedir to the list of active gamedirs
1814 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1819 // generate the searchpath
1823 void FS_Init_Commands(void)
1825 Cvar_RegisterVariable (&scr_screenshot_name);
1826 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1827 Cvar_RegisterVariable (&cvar_fs_gamedir);
1829 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1830 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1831 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1832 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1833 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1834 Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1842 void FS_Shutdown (void)
1844 // close all pack files and such
1845 // (hopefully there aren't any other open files, but they'll be cleaned up
1846 // by the OS anyway)
1847 FS_ClearSearchPath();
1848 Mem_FreePool (&fs_mempool);
1851 Sys_UnloadLibrary (&shfolder_dll);
1855 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
1861 // Parse the mode string
1870 opt = O_CREAT | O_TRUNC;
1874 opt = O_CREAT | O_APPEND;
1877 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1880 for (ind = 1; mode[ind] != '\0'; ind++)
1891 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1892 filepath, mode, mode[ind]);
1899 #if _MSC_VER >= 1400
1900 _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1902 handle = open (filepath, mod | opt, 0666);
1908 ====================
1911 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1912 ====================
1914 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1918 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1920 file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
1921 if (file->handle < 0)
1927 file->real_length = lseek (file->handle, 0, SEEK_END);
1929 // For files opened in append mode, we start at the end of the file
1931 file->position = file->real_length;
1933 lseek (file->handle, 0, SEEK_SET);
1943 Open a packed file using its package file descriptor
1946 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1952 pfile = &pack->files[pack_ind];
1954 // If we don't have the true offset, get it now
1955 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1956 if (!PK3_GetTrueFileOffset (pfile, pack))
1959 #ifndef LINK_TO_ZLIB
1960 // No Zlib DLL = no compressed files
1961 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1963 Con_Printf("WARNING: can't open the compressed file %s\n"
1964 "You need the Zlib DLL to use compressed files\n",
1970 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1971 // the dup() call to avoid having to close the dup_handle on error here
1972 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1974 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1975 pfile->name, pack->filename, (int) pfile->offset);
1979 dup_handle = dup (pack->handle);
1982 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1986 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1987 memset (file, 0, sizeof (*file));
1988 file->handle = dup_handle;
1989 file->flags = QFILE_FLAG_PACKED;
1990 file->real_length = pfile->realsize;
1991 file->offset = pfile->offset;
1995 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1999 file->flags |= QFILE_FLAG_DEFLATED;
2001 // We need some more variables
2002 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2004 ztk->comp_length = pfile->packsize;
2006 // Initialize zlib stream
2007 ztk->zstream.next_in = ztk->input;
2008 ztk->zstream.avail_in = 0;
2010 /* From Zlib's "unzip.c":
2012 * windowBits is passed < 0 to tell that there is no zlib header.
2013 * Note that in this case inflate *requires* an extra "dummy" byte
2014 * after the compressed stream in order to complete decompression and
2015 * return Z_STREAM_END.
2016 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2017 * size of both compressed and uncompressed data
2019 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2021 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2027 ztk->zstream.next_out = file->buff;
2028 ztk->zstream.avail_out = sizeof (file->buff);
2037 ====================
2040 Return true if the path should be rejected due to one of the following:
2041 1: path elements that are non-portable
2042 2: path elements that would allow access to files outside the game directory,
2043 or are just not a good idea for a mod to be using.
2044 ====================
2046 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2048 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2052 // Windows: don't allow \ in filenames (windows-only), period.
2053 // (on Windows \ is a directory separator, but / is also supported)
2054 if (strstr(path, "\\"))
2055 return 1; // non-portable
2057 // Mac: don't allow Mac-only filenames - : is a directory separator
2058 // instead of /, but we rely on / working already, so there's no reason to
2059 // support a Mac-only path
2060 // Amiga and Windows: : tries to go to root of drive
2061 if (strstr(path, ":"))
2062 return 1; // non-portable attempt to go to root of drive
2064 // Amiga: // is parent directory
2065 if (strstr(path, "//"))
2066 return 1; // non-portable attempt to go to parent directory
2068 // all: don't allow going to parent directory (../ or /../)
2069 if (strstr(path, ".."))
2070 return 2; // attempt to go outside the game directory
2072 // Windows and UNIXes: don't allow absolute paths
2074 return 2; // attempt to go outside the game directory
2076 // 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
2077 if (strchr(path, '.'))
2081 // gamedir is entirely path elements, so simply forbid . entirely
2084 if (strchr(path, '.') < strrchr(path, '/'))
2085 return 2; // possible attempt to go outside the game directory
2088 // all: forbid trailing slash on gamedir
2089 if (isgamedir && path[strlen(path)-1] == '/')
2092 // all: forbid leading dot on any filename for any reason
2093 if (strstr(path, "/."))
2094 return 2; // attempt to go outside the game directory
2096 // after all these checks we're pretty sure it's a / separated filename
2097 // and won't do much if any harm
2103 ====================
2106 Look for a file in the packages and in the filesystem
2108 Return the searchpath where the file was found (or NULL)
2109 and the file index in the package if relevant
2110 ====================
2112 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2114 searchpath_t *search;
2117 // search through the path, one element at a time
2118 for (search = fs_searchpaths;search;search = search->next)
2120 // is the element a pak file?
2121 if (search->pack && !search->pack->vpack)
2123 int (*strcmp_funct) (const char* str1, const char* str2);
2124 int left, right, middle;
2127 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2129 // Look for the file (binary search)
2131 right = pak->numfiles - 1;
2132 while (left <= right)
2136 middle = (left + right) / 2;
2137 diff = strcmp_funct (pak->files[middle].name, name);
2142 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2144 // yes, but the first one is empty so we treat it as not being there
2145 if (!quiet && developer_extra.integer)
2146 Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2153 if (!quiet && developer_extra.integer)
2154 Con_DPrintf("FS_FindFile: %s in %s\n",
2155 pak->files[middle].name, pak->filename);
2162 // If we're too far in the list
2171 char netpath[MAX_OSPATH];
2172 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2173 if (FS_SysFileExists (netpath))
2175 if (!quiet && developer_extra.integer)
2176 Con_DPrintf("FS_FindFile: %s\n", netpath);
2185 if (!quiet && developer_extra.integer)
2186 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2198 Look for a file in the search paths and open it in read-only mode
2201 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2203 searchpath_t *search;
2206 search = FS_FindFile (filename, &pack_ind, quiet);
2212 // Found in the filesystem?
2215 // this works with vpacks, so we are fine
2216 char path [MAX_OSPATH];
2217 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2218 return FS_SysOpen (path, "rb", nonblocking);
2221 // So, we found it in a package...
2223 // Is it a PK3 symlink?
2224 // TODO also handle directory symlinks by parsing the whole structure...
2225 // but heck, file symlinks are good enough for now
2226 if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2228 if(symlinkLevels <= 0)
2230 Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2235 char linkbuf[MAX_QPATH];
2237 qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2238 const char *mergeslash;
2243 count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2249 // Now combine the paths...
2250 mergeslash = strrchr(filename, '/');
2251 mergestart = linkbuf;
2253 mergeslash = filename;
2254 while(!strncmp(mergestart, "../", 3))
2257 while(mergeslash > filename)
2260 if(*mergeslash == '/')
2264 // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2265 if(mergeslash == filename)
2267 // Either mergeslash == filename, then we just replace the name (done below)
2271 // Or, we append the name after mergeslash;
2272 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2273 int spaceNeeded = mergeslash - filename + 1;
2274 int spaceRemoved = mergestart - linkbuf;
2275 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2277 Con_DPrintf("symlink: too long path rejected\n");
2280 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2281 memcpy(linkbuf, filename, spaceNeeded);
2282 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2283 mergestart = linkbuf;
2285 if (!quiet && developer_loading.integer)
2286 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2287 if(FS_CheckNastyPath (mergestart, false))
2289 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2292 return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2296 return FS_OpenPackedFile (search->pack, pack_ind);
2301 =============================================================================
2303 MAIN PUBLIC FUNCTIONS
2305 =============================================================================
2309 ====================
2312 Open a file in the userpath. The syntax is the same as fopen
2313 Used for savegame scanning in menu, and all file writing.
2314 ====================
2316 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2318 char real_path [MAX_OSPATH];
2320 if (FS_CheckNastyPath(filepath, false))
2322 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2326 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2328 // If the file is opened in "write", "append", or "read/write" mode,
2329 // create directories up to the file.
2330 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2331 FS_CreatePath (real_path);
2332 return FS_SysOpen (real_path, mode, false);
2337 ====================
2340 Open a file. The syntax is the same as fopen
2341 ====================
2343 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2345 if (FS_CheckNastyPath(filepath, false))
2347 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2351 return FS_OpenReadFile (filepath, quiet, false, 16);
2356 ====================
2359 Open a file. The syntax is the same as fopen
2360 ====================
2362 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2365 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2366 memset (file, 0, sizeof (*file));
2367 file->flags = QFILE_FLAG_DATA;
2369 file->real_length = size;
2375 ====================
2379 ====================
2381 int FS_Close (qfile_t* file)
2383 if(file->flags & QFILE_FLAG_DATA)
2389 if (close (file->handle))
2394 qz_inflateEnd (&file->ztk->zstream);
2395 Mem_Free (file->ztk);
2404 ====================
2407 Write "datasize" bytes into a file
2408 ====================
2410 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2414 // If necessary, seek to the exact file position we're supposed to be
2415 if (file->buff_ind != file->buff_len)
2416 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2418 // Purge cached data
2421 // Write the buffer and update the position
2422 result = write (file->handle, data, (fs_offset_t)datasize);
2423 file->position = lseek (file->handle, 0, SEEK_CUR);
2424 if (file->real_length < file->position)
2425 file->real_length = file->position;
2435 ====================
2438 Read up to "buffersize" bytes from a file
2439 ====================
2441 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2443 fs_offset_t count, done;
2445 if (buffersize == 0)
2448 // Get rid of the ungetc character
2449 if (file->ungetc != EOF)
2451 ((char*)buffer)[0] = file->ungetc;
2459 if(file->flags & QFILE_FLAG_DATA)
2461 size_t left = file->real_length - file->position;
2462 if(buffersize > left)
2464 memcpy(buffer, file->data + file->position, buffersize);
2465 file->position += buffersize;
2469 // First, we copy as many bytes as we can from "buff"
2470 if (file->buff_ind < file->buff_len)
2472 count = file->buff_len - file->buff_ind;
2473 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2475 memcpy (buffer, &file->buff[file->buff_ind], count);
2476 file->buff_ind += count;
2478 buffersize -= count;
2479 if (buffersize == 0)
2483 // NOTE: at this point, the read buffer is always empty
2485 // If the file isn't compressed
2486 if (! (file->flags & QFILE_FLAG_DEFLATED))
2490 // We must take care to not read after the end of the file
2491 count = file->real_length - file->position;
2493 // If we have a lot of data to get, put them directly into "buffer"
2494 if (buffersize > sizeof (file->buff) / 2)
2496 if (count > (fs_offset_t)buffersize)
2497 count = (fs_offset_t)buffersize;
2498 lseek (file->handle, file->offset + file->position, SEEK_SET);
2499 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2503 file->position += nb;
2505 // Purge cached data
2511 if (count > (fs_offset_t)sizeof (file->buff))
2512 count = (fs_offset_t)sizeof (file->buff);
2513 lseek (file->handle, file->offset + file->position, SEEK_SET);
2514 nb = read (file->handle, file->buff, count);
2517 file->buff_len = nb;
2518 file->position += nb;
2520 // Copy the requested data in "buffer" (as much as we can)
2521 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2522 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2523 file->buff_ind = count;
2531 // If the file is compressed, it's more complicated...
2532 // We cycle through a few operations until we have read enough data
2533 while (buffersize > 0)
2535 ztoolkit_t *ztk = file->ztk;
2538 // NOTE: at this point, the read buffer is always empty
2540 // If "input" is also empty, we need to refill it
2541 if (ztk->in_ind == ztk->in_len)
2543 // If we are at the end of the file
2544 if (file->position == file->real_length)
2547 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2548 if (count > (fs_offset_t)sizeof (ztk->input))
2549 count = (fs_offset_t)sizeof (ztk->input);
2550 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2551 if (read (file->handle, ztk->input, count) != count)
2553 Con_Printf ("FS_Read: unexpected end of file\n");
2558 ztk->in_len = count;
2559 ztk->in_position += count;
2562 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2563 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2565 // Now that we are sure we have compressed data available, we need to determine
2566 // if it's better to inflate it in "file->buff" or directly in "buffer"
2568 // Inflate the data in "file->buff"
2569 if (buffersize < sizeof (file->buff) / 2)
2571 ztk->zstream.next_out = file->buff;
2572 ztk->zstream.avail_out = sizeof (file->buff);
2573 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2574 if (error != Z_OK && error != Z_STREAM_END)
2576 Con_Printf ("FS_Read: Can't inflate file\n");
2579 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2581 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2582 file->position += file->buff_len;
2584 // Copy the requested data in "buffer" (as much as we can)
2585 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2586 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2587 file->buff_ind = count;
2590 // Else, we inflate directly in "buffer"
2593 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2594 ztk->zstream.avail_out = (unsigned int)buffersize;
2595 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2596 if (error != Z_OK && error != Z_STREAM_END)
2598 Con_Printf ("FS_Read: Can't inflate file\n");
2601 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2603 // How much data did it inflate?
2604 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2605 file->position += count;
2607 // Purge cached data
2612 buffersize -= count;
2620 ====================
2623 Print a string into a file
2624 ====================
2626 int FS_Print (qfile_t* file, const char *msg)
2628 return (int)FS_Write (file, msg, strlen (msg));
2632 ====================
2635 Print a string into a file
2636 ====================
2638 int FS_Printf(qfile_t* file, const char* format, ...)
2643 va_start (args, format);
2644 result = FS_VPrintf (file, format, args);
2652 ====================
2655 Print a string into a file
2656 ====================
2658 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2661 fs_offset_t buff_size = MAX_INPUTLINE;
2666 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2667 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2668 if (len >= 0 && len < buff_size)
2670 Mem_Free (tempbuff);
2674 len = write (file->handle, tempbuff, len);
2675 Mem_Free (tempbuff);
2682 ====================
2685 Get the next character of a file
2686 ====================
2688 int FS_Getc (qfile_t* file)
2692 if (FS_Read (file, &c, 1) != 1)
2700 ====================
2703 Put a character back into the read buffer (only supports one character!)
2704 ====================
2706 int FS_UnGetc (qfile_t* file, unsigned char c)
2708 // If there's already a character waiting to be read
2709 if (file->ungetc != EOF)
2718 ====================
2721 Move the position index in a file
2722 ====================
2724 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2727 unsigned char* buffer;
2728 fs_offset_t buffersize;
2730 // Compute the file offset
2734 offset += file->position - file->buff_len + file->buff_ind;
2741 offset += file->real_length;
2747 if (offset < 0 || offset > file->real_length)
2750 if(file->flags & QFILE_FLAG_DATA)
2752 file->position = offset;
2756 // If we have the data in our read buffer, we don't need to actually seek
2757 if (file->position - file->buff_len <= offset && offset <= file->position)
2759 file->buff_ind = offset + file->buff_len - file->position;
2763 // Purge cached data
2766 // Unpacked or uncompressed files can seek directly
2767 if (! (file->flags & QFILE_FLAG_DEFLATED))
2769 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2771 file->position = offset;
2775 // Seeking in compressed files is more a hack than anything else,
2776 // but we need to support it, so here we go.
2779 // If we have to go back in the file, we need to restart from the beginning
2780 if (offset <= file->position)
2784 ztk->in_position = 0;
2786 lseek (file->handle, file->offset, SEEK_SET);
2788 // Reset the Zlib stream
2789 ztk->zstream.next_in = ztk->input;
2790 ztk->zstream.avail_in = 0;
2791 qz_inflateReset (&ztk->zstream);
2794 // We need a big buffer to force inflating into it directly
2795 buffersize = 2 * sizeof (file->buff);
2796 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2798 // Skip all data until we reach the requested offset
2799 while (offset > file->position)
2801 fs_offset_t diff = offset - file->position;
2802 fs_offset_t count, len;
2804 count = (diff > buffersize) ? buffersize : diff;
2805 len = FS_Read (file, buffer, count);
2819 ====================
2822 Give the current position in a file
2823 ====================
2825 fs_offset_t FS_Tell (qfile_t* file)
2827 return file->position - file->buff_len + file->buff_ind;
2832 ====================
2835 Give the total size of a file
2836 ====================
2838 fs_offset_t FS_FileSize (qfile_t* file)
2840 return file->real_length;
2845 ====================
2848 Erases any buffered input or output data
2849 ====================
2851 void FS_Purge (qfile_t* file)
2863 Filename are relative to the quake directory.
2864 Always appends a 0 byte.
2867 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2870 unsigned char *buf = NULL;
2871 fs_offset_t filesize = 0;
2873 file = FS_OpenVirtualFile(path, quiet);
2876 filesize = file->real_length;
2879 Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2884 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2885 buf[filesize] = '\0';
2886 FS_Read (file, buf, filesize);
2888 if (developer_loadfile.integer)
2889 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2892 if (filesizepointer)
2893 *filesizepointer = filesize;
2902 The filename will be prefixed by the current game directory
2905 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2909 file = FS_OpenRealFile(filename, "wb", false);
2912 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2916 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2917 FS_Write (file, data, len);
2924 =============================================================================
2926 OTHERS PUBLIC FUNCTIONS
2928 =============================================================================
2936 void FS_StripExtension (const char *in, char *out, size_t size_out)
2944 while ((currentchar = *in) && size_out > 1)
2946 if (currentchar == '.')
2948 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2950 *out++ = currentchar;
2966 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2970 // if path doesn't have a .EXT, append extension
2971 // (extension should include the .)
2972 src = path + strlen(path) - 1;
2974 while (*src != '/' && src != path)
2977 return; // it has an extension
2981 strlcat (path, extension, size_path);
2989 Look for a file in the packages and in the filesystem
2992 int FS_FileType (const char *filename)
2994 searchpath_t *search;
2995 char fullpath[MAX_OSPATH];
2997 search = FS_FindFile (filename, NULL, true);
2999 return FS_FILETYPE_NONE;
3001 if(search->pack && !search->pack->vpack)
3002 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3004 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3005 return FS_SysFileType(fullpath);
3013 Look for a file in the packages and in the filesystem
3016 qboolean FS_FileExists (const char *filename)
3018 return (FS_FindFile (filename, NULL, true) != NULL);
3026 Look for a file in the filesystem only
3029 int FS_SysFileType (const char *path)
3032 // Sajt - some older sdks are missing this define
3033 # ifndef INVALID_FILE_ATTRIBUTES
3034 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3037 DWORD result = GetFileAttributes(path);
3039 if(result == INVALID_FILE_ATTRIBUTES)
3040 return FS_FILETYPE_NONE;
3042 if(result & FILE_ATTRIBUTE_DIRECTORY)
3043 return FS_FILETYPE_DIRECTORY;
3045 return FS_FILETYPE_FILE;
3049 if (stat (path,&buf) == -1)
3050 return FS_FILETYPE_NONE;
3053 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3055 if(S_ISDIR(buf.st_mode))
3056 return FS_FILETYPE_DIRECTORY;
3058 return FS_FILETYPE_FILE;
3062 qboolean FS_SysFileExists (const char *path)
3064 return FS_SysFileType (path) != FS_FILETYPE_NONE;
3067 void FS_mkdir (const char *path)
3080 Allocate and fill a search structure with information on matching filenames.
3083 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3086 searchpath_t *searchpath;
3088 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3089 stringlist_t resultlist;
3090 stringlist_t dirlist;
3091 const char *slash, *backslash, *colon, *separator;
3093 char temp[MAX_OSPATH];
3095 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3100 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3104 stringlistinit(&resultlist);
3105 stringlistinit(&dirlist);
3107 slash = strrchr(pattern, '/');
3108 backslash = strrchr(pattern, '\\');
3109 colon = strrchr(pattern, ':');
3110 separator = max(slash, backslash);
3111 separator = max(separator, colon);
3112 basepathlength = separator ? (separator + 1 - pattern) : 0;
3113 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3115 memcpy(basepath, pattern, basepathlength);
3116 basepath[basepathlength] = 0;
3118 // search through the path, one element at a time
3119 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3121 // is the element a pak file?
3122 if (searchpath->pack && !searchpath->pack->vpack)
3124 // look through all the pak file elements
3125 pak = searchpath->pack;
3126 for (i = 0;i < pak->numfiles;i++)
3128 strlcpy(temp, pak->files[i].name, sizeof(temp));
3131 if (matchpattern(temp, (char *)pattern, true))
3133 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3134 if (!strcmp(resultlist.strings[resultlistindex], temp))
3136 if (resultlistindex == resultlist.numstrings)
3138 stringlistappend(&resultlist, temp);
3139 if (!quiet && developer_loading.integer)
3140 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3143 // strip off one path element at a time until empty
3144 // this way directories are added to the listing if they match the pattern
3145 slash = strrchr(temp, '/');
3146 backslash = strrchr(temp, '\\');
3147 colon = strrchr(temp, ':');
3149 if (separator < slash)
3151 if (separator < backslash)
3152 separator = backslash;
3153 if (separator < colon)
3155 *((char *)separator) = 0;
3161 stringlist_t matchedSet, foundSet;
3162 const char *start = pattern;
3164 stringlistinit(&matchedSet);
3165 stringlistinit(&foundSet);
3166 // add a first entry to the set
3167 stringlistappend(&matchedSet, "");
3168 // iterate through pattern's path
3171 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3172 char subpath[MAX_OSPATH];
3173 char subpattern[MAX_OSPATH];
3175 // find the next wildcard
3176 wildcard = strchr(start, '?');
3177 asterisk = strchr(start, '*');
3178 if (asterisk && (!wildcard || asterisk < wildcard))
3180 wildcard = asterisk;
3185 nextseparator = strchr( wildcard, '/' );
3189 nextseparator = NULL;
3192 if( !nextseparator ) {
3193 nextseparator = start + strlen( start );
3196 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3197 // copy everything up except nextseperator
3198 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3199 // find the last '/' before the wildcard
3200 prevseparator = strrchr( subpattern, '/' );
3202 prevseparator = subpattern;
3205 // copy everything from start to the previous including the '/' (before the wildcard)
3206 // everything up to start is already included in the path of matchedSet's entries
3207 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3209 // for each entry in matchedSet try to open the subdirectories specified in subpath
3210 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3211 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3212 strlcat( temp, subpath, sizeof(temp) );
3213 listdirectory( &foundSet, searchpath->filename, temp );
3215 if( dirlistindex == 0 ) {
3218 // reset the current result set
3219 stringlistfreecontents( &matchedSet );
3220 // match against the pattern
3221 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3222 const char *direntry = foundSet.strings[ dirlistindex ];
3223 if (matchpattern(direntry, subpattern, true)) {
3224 stringlistappend( &matchedSet, direntry );
3227 stringlistfreecontents( &foundSet );
3229 start = nextseparator;
3232 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3234 const char *temp = matchedSet.strings[dirlistindex];
3235 if (matchpattern(temp, (char *)pattern, true))
3237 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3238 if (!strcmp(resultlist.strings[resultlistindex], temp))
3240 if (resultlistindex == resultlist.numstrings)
3242 stringlistappend(&resultlist, temp);
3243 if (!quiet && developer_loading.integer)
3244 Con_Printf("SearchDirFile: %s\n", temp);
3248 stringlistfreecontents( &matchedSet );
3252 if (resultlist.numstrings)
3254 stringlistsort(&resultlist);
3255 numfiles = resultlist.numstrings;
3257 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3258 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3259 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3260 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3261 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3262 search->numfilenames = (int)numfiles;
3265 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3268 search->filenames[numfiles] = search->filenamesbuffer + numchars;
3269 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3270 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3272 numchars += (int)textlen;
3275 stringlistfreecontents(&resultlist);
3281 void FS_FreeSearch(fssearch_t *search)
3286 extern int con_linewidth;
3287 int FS_ListDirectory(const char *pattern, int oneperline)
3296 char linebuf[MAX_INPUTLINE];
3298 search = FS_Search(pattern, true, true);
3301 numfiles = search->numfilenames;
3304 // FIXME: the names could be added to one column list and then
3305 // gradually shifted into the next column if they fit, and then the
3306 // next to make a compact variable width listing but it's a lot more
3308 // find width for columns
3310 for (i = 0;i < numfiles;i++)
3312 l = (int)strlen(search->filenames[i]);
3313 if (columnwidth < l)
3316 // count the spacing character
3318 // calculate number of columns
3319 numcolumns = con_linewidth / columnwidth;
3320 // don't bother with the column printing if it's only one column
3321 if (numcolumns >= 2)
3323 numlines = (numfiles + numcolumns - 1) / numcolumns;
3324 for (i = 0;i < numlines;i++)
3327 for (k = 0;k < numcolumns;k++)
3329 l = i * numcolumns + k;
3332 name = search->filenames[l];
3333 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3334 linebuf[linebufpos++] = name[j];
3335 // space out name unless it's the last on the line
3336 if (k + 1 < numcolumns && l + 1 < numfiles)
3337 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3338 linebuf[linebufpos++] = ' ';
3341 linebuf[linebufpos] = 0;
3342 Con_Printf("%s\n", linebuf);
3349 for (i = 0;i < numfiles;i++)
3350 Con_Printf("%s\n", search->filenames[i]);
3351 FS_FreeSearch(search);
3352 return (int)numfiles;
3355 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3357 const char *pattern;
3360 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3363 if (Cmd_Argc() == 2)
3364 pattern = Cmd_Argv(1);
3367 if (!FS_ListDirectory(pattern, oneperline))
3368 Con_Print("No files found.\n");
3373 FS_ListDirectoryCmd("dir", true);
3378 FS_ListDirectoryCmd("ls", false);
3381 void FS_Which_f(void)
3383 const char *filename;
3386 if (Cmd_Argc() != 2)
3388 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3391 filename = Cmd_Argv(1);
3392 sp = FS_FindFile(filename, &index, true);
3394 Con_Printf("%s isn't anywhere\n", filename);
3400 Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3402 Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3405 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3409 const char *FS_WhichPack(const char *filename)
3412 searchpath_t *sp = FS_FindFile(filename, &index, true);
3414 return sp->pack->shortname;
3420 ====================
3421 FS_IsRegisteredQuakePack
3423 Look for a proof of purchase file file in the requested package
3425 If it is found, this file should NOT be downloaded.
3426 ====================
3428 qboolean FS_IsRegisteredQuakePack(const char *name)
3430 searchpath_t *search;
3433 // search through the path, one element at a time
3434 for (search = fs_searchpaths;search;search = search->next)
3436 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3437 // TODO do we want to support vpacks in here too?
3439 int (*strcmp_funct) (const char* str1, const char* str2);
3440 int left, right, middle;
3443 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3445 // Look for the file (binary search)
3447 right = pak->numfiles - 1;
3448 while (left <= right)
3452 middle = (left + right) / 2;
3453 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3459 // If we're too far in the list
3466 // we found the requested pack but it is not registered quake
3474 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3477 unsigned char *filedata;
3478 fs_offset_t filesize;
3479 if (filesizepointer)
3480 *filesizepointer = 0;
3481 if (!filename || !*filename)
3483 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3486 if (filesizepointer)
3487 *filesizepointer = filesize;
3488 crc = CRC_Block(filedata, filesize);
3494 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3497 unsigned char *out = NULL;
3501 #ifndef LINK_TO_ZLIB
3506 memset(&strm, 0, sizeof(strm));
3507 strm.zalloc = Z_NULL;
3508 strm.zfree = Z_NULL;
3509 strm.opaque = Z_NULL;
3512 level = Z_DEFAULT_COMPRESSION;
3514 if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3516 Con_Printf("FS_Deflate: deflate init error!\n");
3520 strm.next_in = (unsigned char*)data;
3521 strm.avail_in = size;
3523 tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3526 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3527 qz_deflateEnd(&strm);
3531 strm.next_out = tmp;
3532 strm.avail_out = size;
3534 if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3536 Con_Printf("FS_Deflate: deflate failed!\n");
3537 qz_deflateEnd(&strm);
3542 if(qz_deflateEnd(&strm) != Z_OK)
3544 Con_Printf("FS_Deflate: deflateEnd failed\n");
3549 if(strm.total_out >= size)
3551 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3556 out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3559 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3565 *deflated_size = (size_t)strm.total_out;
3567 memcpy(out, tmp, strm.total_out);
3573 static void AssertBufsize(sizebuf_t *buf, int length)
3575 if(buf->cursize + length > buf->maxsize)
3577 int oldsize = buf->maxsize;
3578 unsigned char *olddata;
3579 olddata = buf->data;
3580 buf->maxsize += length;
3581 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3584 memcpy(buf->data, olddata, oldsize);
3590 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3594 unsigned char *out = NULL;
3595 unsigned char tmp[2048];
3600 #ifndef LINK_TO_ZLIB
3605 memset(&outbuf, 0, sizeof(outbuf));
3606 outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3607 outbuf.maxsize = sizeof(tmp);
3609 memset(&strm, 0, sizeof(strm));
3610 strm.zalloc = Z_NULL;
3611 strm.zfree = Z_NULL;
3612 strm.opaque = Z_NULL;
3614 if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3616 Con_Printf("FS_Inflate: inflate init error!\n");
3617 Mem_Free(outbuf.data);
3621 strm.next_in = (unsigned char*)data;
3622 strm.avail_in = size;
3626 strm.next_out = tmp;
3627 strm.avail_out = sizeof(tmp);
3628 ret = qz_inflate(&strm, Z_NO_FLUSH);
3629 // it either returns Z_OK on progress, Z_STREAM_END on end
3637 case Z_STREAM_ERROR:
3638 Con_Print("FS_Inflate: stream error!\n");
3641 Con_Print("FS_Inflate: data error!\n");
3644 Con_Print("FS_Inflate: mem error!\n");
3647 Con_Print("FS_Inflate: buf error!\n");
3650 Con_Print("FS_Inflate: unknown error!\n");
3654 if(ret != Z_OK && ret != Z_STREAM_END)
3656 Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3657 Mem_Free(outbuf.data);
3658 qz_inflateEnd(&strm);
3661 have = sizeof(tmp) - strm.avail_out;
3662 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3663 SZ_Write(&outbuf, tmp, have);
3664 } while(ret != Z_STREAM_END);
3666 qz_inflateEnd(&strm);
3668 out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3671 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3672 Mem_Free(outbuf.data);
3676 memcpy(out, outbuf.data, outbuf.cursize);
3677 Mem_Free(outbuf.data);
3680 *inflated_size = (size_t)outbuf.cursize;