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
60 All of Quake's data access is through a hierchal file system, but the contents
61 of the file system can be transparently merged from several sources.
63 The "base directory" is the path to the directory holding the quake.exe and
64 all game directories. The sys_* files pass this to host_init in
65 quakeparms_t->basedir. This can be overridden with the "-basedir" command
66 line parm to allow code debugging in a different directory. The base
67 directory is only used during filesystem initialization.
69 The "game directory" is the first tree on the search path and directory that
70 all generated files (savegames, screenshots, demos, config files) will be
71 saved to. This can be overridden with the "-game" command line parameter.
72 The game directory can never be changed while quake is executing. This is a
73 precaution against having a malicious server instruct clients to write files
74 over areas they shouldn't.
80 =============================================================================
84 =============================================================================
87 // Magic numbers of a ZIP file (big-endian format)
88 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
89 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
90 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
92 // Other constants for ZIP files
93 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
94 #define ZIP_END_CDIR_SIZE 22
95 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
96 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
98 // Zlib constants (from zlib.h)
99 #define Z_SYNC_FLUSH 2
102 #define Z_STREAM_END 1
103 #define ZLIB_VERSION "1.2.3"
105 // Uncomment the following line if the zlib DLL you have still uses
106 // the 1.1.x series calling convention on Win32 (WINAPI)
107 //#define ZLIB_USES_WINAPI
111 =============================================================================
115 =============================================================================
118 // Zlib stream (from zlib.h)
119 // Warning: some pointers we don't use directly have
120 // been cast to "void*" for a matter of simplicity
123 unsigned char *next_in; // next input byte
124 unsigned int avail_in; // number of bytes available at next_in
125 unsigned long total_in; // total nb of input bytes read so far
127 unsigned char *next_out; // next output byte should be put there
128 unsigned int avail_out; // remaining free space at next_out
129 unsigned long total_out; // total nb of bytes output so far
131 char *msg; // last error message, NULL if no error
132 void *state; // not visible by applications
134 void *zalloc; // used to allocate the internal state
135 void *zfree; // used to free the internal state
136 void *opaque; // private data object passed to zalloc and zfree
138 int data_type; // best guess about the data type: ascii or binary
139 unsigned long adler; // adler32 value of the uncompressed data
140 unsigned long reserved; // reserved for future use
144 // inside a package (PAK or PK3)
145 #define QFILE_FLAG_PACKED (1 << 0)
146 // file is compressed using the deflate algorithm (PK3 only)
147 #define QFILE_FLAG_DEFLATED (1 << 1)
149 #define FILE_BUFF_SIZE 2048
153 size_t comp_length; // length of the compressed file
154 size_t in_ind, in_len; // input buffer current index and length
155 size_t in_position; // position in the compressed file
156 unsigned char input [FILE_BUFF_SIZE];
162 int handle; // file descriptor
163 fs_offset_t real_length; // uncompressed file size (for files opened in "read" mode)
164 fs_offset_t position; // current position in the file
165 fs_offset_t offset; // offset into the package (0 if external file)
166 int ungetc; // single stored character from ungetc, cleared to EOF when read
169 fs_offset_t buff_ind, buff_len; // buffer current index and length
170 unsigned char buff [FILE_BUFF_SIZE];
177 // ------ PK3 files on disk ------ //
179 // You can get the complete ZIP format description from PKWARE website
181 typedef struct pk3_endOfCentralDir_s
183 unsigned int signature;
184 unsigned short disknum;
185 unsigned short cdir_disknum; // number of the disk with the start of the central directory
186 unsigned short localentries; // number of entries in the central directory on this disk
187 unsigned short nbentries; // total number of entries in the central directory on this disk
188 unsigned int cdir_size; // size of the central directory
189 unsigned int cdir_offset; // with respect to the starting disk number
190 unsigned short comment_size;
191 } pk3_endOfCentralDir_t;
194 // ------ PAK files on disk ------ //
195 typedef struct dpackfile_s
198 int filepos, filelen;
201 typedef struct dpackheader_s
209 // Packages in memory
210 // the offset in packfile_t is the true contents offset
211 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
212 // file compressed using the deflate algorithm
213 #define PACKFILE_FLAG_DEFLATED (1 << 1)
215 typedef struct packfile_s
217 char name [MAX_QPATH];
220 fs_offset_t packsize; // size in the package
221 fs_offset_t realsize; // real file size (uncompressed)
224 typedef struct pack_s
226 char filename [MAX_OSPATH];
228 int ignorecase; // PK3 ignores case
234 // Search paths for files (including packages)
235 typedef struct searchpath_s
237 // only one of filename / pack will be used
238 char filename[MAX_OSPATH];
240 struct searchpath_s *next;
245 =============================================================================
249 =============================================================================
255 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
256 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
257 fs_offset_t offset, fs_offset_t packsize,
258 fs_offset_t realsize, int flags);
262 =============================================================================
266 =============================================================================
269 mempool_t *fs_mempool;
271 searchpath_t *fs_searchpaths = NULL;
273 #define MAX_FILES_IN_PACK 65536
275 char fs_gamedir[MAX_OSPATH];
276 char fs_basedir[MAX_OSPATH];
278 // list of active game directories (empty if not running a mod)
279 int fs_numgamedirs = 0;
280 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
282 cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running)"};
283 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"};
287 =============================================================================
289 PRIVATE FUNCTIONS - PK3 HANDLING
291 =============================================================================
294 // Functions exported from zlib
295 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
296 # define ZEXPORT WINAPI
301 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
302 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
303 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
304 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
306 #define qz_inflateInit2(strm, windowBits) \
307 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
309 static dllfunction_t zlibfuncs[] =
311 {"inflate", (void **) &qz_inflate},
312 {"inflateEnd", (void **) &qz_inflateEnd},
313 {"inflateInit2_", (void **) &qz_inflateInit2_},
314 {"inflateReset", (void **) &qz_inflateReset},
318 // Handle for Zlib DLL
319 static dllhandle_t zlib_dll = NULL;
329 void PK3_CloseLibrary (void)
331 Sys_UnloadLibrary (&zlib_dll);
339 Try to load the Zlib DLL
342 qboolean PK3_OpenLibrary (void)
344 const char* dllnames [] =
349 # ifdef ZLIB_USES_WINAPI
355 #elif defined(MACOSX)
369 return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
375 PK3_GetEndOfCentralDir
377 Extract the end of the central directory from a PK3 package
380 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
382 fs_offset_t filesize, maxsize;
383 unsigned char *buffer, *ptr;
386 // Get the package size
387 filesize = lseek (packhandle, 0, SEEK_END);
388 if (filesize < ZIP_END_CDIR_SIZE)
391 // Load the end of the file in memory
392 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
395 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
396 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
397 lseek (packhandle, filesize - maxsize, SEEK_SET);
398 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
404 // Look for the end of central dir signature around the end of the file
405 maxsize -= ZIP_END_CDIR_SIZE;
406 ptr = &buffer[maxsize];
408 while (BuffBigLong (ptr) != ZIP_END_HEADER)
420 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
421 eocd->signature = LittleLong (eocd->signature);
422 eocd->disknum = LittleShort (eocd->disknum);
423 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
424 eocd->localentries = LittleShort (eocd->localentries);
425 eocd->nbentries = LittleShort (eocd->nbentries);
426 eocd->cdir_size = LittleLong (eocd->cdir_size);
427 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
428 eocd->comment_size = LittleShort (eocd->comment_size);
440 Extract the file list from a PK3 file
443 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
445 unsigned char *central_dir, *ptr;
447 fs_offset_t remaining;
449 // Load the central directory in memory
450 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
451 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
452 read (pack->handle, central_dir, eocd->cdir_size);
454 // Extract the files properties
455 // The parsing is done "by hand" because some fields have variable sizes and
456 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
457 remaining = eocd->cdir_size;
460 for (ind = 0; ind < eocd->nbentries; ind++)
462 fs_offset_t namesize, count;
464 // Checking the remaining size
465 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
467 Mem_Free (central_dir);
470 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
473 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
475 Mem_Free (central_dir);
479 namesize = BuffLittleShort (&ptr[28]); // filename length
481 // Check encryption, compression, and attributes
482 // 1st uint8 : general purpose bit flag
483 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
484 // 2nd uint8 : external file attributes
485 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
486 if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
488 // Still enough bytes for the name?
489 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
491 Mem_Free (central_dir);
495 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
496 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
498 char filename [sizeof (pack->files[0].name)];
499 fs_offset_t offset, packsize, realsize;
502 // Extract the name (strip it if necessary)
503 namesize = min(namesize, (int)sizeof (filename) - 1);
504 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
505 filename[namesize] = '\0';
507 if (BuffLittleShort (&ptr[10]))
508 flags = PACKFILE_FLAG_DEFLATED;
511 offset = BuffLittleLong (&ptr[42]);
512 packsize = BuffLittleLong (&ptr[20]);
513 realsize = BuffLittleLong (&ptr[24]);
514 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
518 // Skip the name, additionnal field, and comment
519 // 1er uint16 : extra field length
520 // 2eme uint16 : file comment length
521 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
522 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
526 // If the package is empty, central_dir is NULL here
527 if (central_dir != NULL)
528 Mem_Free (central_dir);
529 return pack->numfiles;
537 Create a package entry associated with a PK3 file
540 pack_t *FS_LoadPackPK3 (const char *packfile)
543 pk3_endOfCentralDir_t eocd;
547 packhandle = open (packfile, O_RDONLY | O_BINARY);
551 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
553 Con_Printf ("%s is not a PK3 file\n", packfile);
558 // Multi-volume ZIP archives are NOT allowed
559 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
561 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
566 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
567 // since eocd.nbentries is an unsigned 16 bits integer
568 #if MAX_FILES_IN_PACK < 65535
569 if (eocd.nbentries > MAX_FILES_IN_PACK)
571 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
577 // Create a package structure in memory
578 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
579 pack->ignorecase = true; // PK3 ignores case
580 strlcpy (pack->filename, packfile, sizeof (pack->filename));
581 pack->handle = packhandle;
582 pack->numfiles = eocd.nbentries;
583 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
585 real_nb_files = PK3_BuildFileList (pack, &eocd);
586 if (real_nb_files < 0)
588 Con_Printf ("%s is not a valid PK3 file\n", packfile);
594 Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
601 PK3_GetTrueFileOffset
603 Find where the true file data offset is
606 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
608 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
612 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
615 // Load the local file description
616 lseek (pack->handle, pfile->offset, SEEK_SET);
617 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
618 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
620 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
624 // Skip name and extra field
625 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
627 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
633 =============================================================================
635 OTHER PRIVATE FUNCTIONS
637 =============================================================================
645 Add a file to the list of files contained into a package
648 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
649 fs_offset_t offset, fs_offset_t packsize,
650 fs_offset_t realsize, int flags)
652 int (*strcmp_funct) (const char* str1, const char* str2);
653 int left, right, middle;
656 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
658 // Look for the slot we should put that file into (binary search)
660 right = pack->numfiles - 1;
661 while (left <= right)
665 middle = (left + right) / 2;
666 diff = strcmp_funct (pack->files[middle].name, name);
668 // If we found the file, there's a problem
670 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
672 // If we're too far in the list
679 // We have to move the right of the list by one slot to free the one we need
680 pfile = &pack->files[left];
681 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
684 strlcpy (pfile->name, name, sizeof (pfile->name));
685 pfile->offset = offset;
686 pfile->packsize = packsize;
687 pfile->realsize = realsize;
688 pfile->flags = flags;
698 Only used for FS_Open.
701 void FS_CreatePath (char *path)
705 for (ofs = path+1 ; *ofs ; ofs++)
707 if (*ofs == '/' || *ofs == '\\')
709 // create the directory
725 void FS_Path_f (void)
729 Con_Print("Current search path:\n");
730 for (s=fs_searchpaths ; s ; s=s->next)
733 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
735 Con_Printf("%s\n", s->filename);
744 Takes an explicit (not game tree related) path to a pak file.
746 Loads the header and directory, adding the files at the beginning
747 of the list so they override previous pack files.
750 pack_t *FS_LoadPackPAK (const char *packfile)
752 dpackheader_t header;
758 packhandle = open (packfile, O_RDONLY | O_BINARY);
761 read (packhandle, (void *)&header, sizeof(header));
762 if (memcmp(header.id, "PACK", 4))
764 Con_Printf ("%s is not a packfile\n", packfile);
768 header.dirofs = LittleLong (header.dirofs);
769 header.dirlen = LittleLong (header.dirlen);
771 if (header.dirlen % sizeof(dpackfile_t))
773 Con_Printf ("%s has an invalid directory size\n", packfile);
778 numpackfiles = header.dirlen / sizeof(dpackfile_t);
780 if (numpackfiles > MAX_FILES_IN_PACK)
782 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
787 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
788 lseek (packhandle, header.dirofs, SEEK_SET);
789 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
791 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
797 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
798 pack->ignorecase = false; // PAK is case sensitive
799 strlcpy (pack->filename, packfile, sizeof (pack->filename));
800 pack->handle = packhandle;
802 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
804 // parse the directory
805 for (i = 0;i < numpackfiles;i++)
807 fs_offset_t offset = LittleLong (info[i].filepos);
808 fs_offset_t size = LittleLong (info[i].filelen);
810 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
815 Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
823 Adds the given pack to the search path.
824 The pack type is autodetected by the file extension.
826 Returns true if the file was successfully added to the
827 search path or if it was already included.
829 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
833 static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
835 searchpath_t *search;
837 const char *ext = FS_FileExtension(pakfile);
839 for(search = fs_searchpaths; search; search = search->next)
841 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
844 *already_loaded = true;
845 return true; // already loaded
850 *already_loaded = false;
852 if(!strcasecmp(ext, "pak"))
853 pak = FS_LoadPackPAK (pakfile);
854 else if(!strcasecmp(ext, "pk3"))
855 pak = FS_LoadPackPK3 (pakfile);
857 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
863 // find the first item whose next one is a pack or NULL
864 searchpath_t *insertion_point = 0;
865 if(fs_searchpaths && !fs_searchpaths->pack)
867 insertion_point = fs_searchpaths;
870 if(!insertion_point->next)
872 if(insertion_point->next->pack)
874 insertion_point = insertion_point->next;
877 // If insertion_point is NULL, this means that either there is no
878 // item in the list yet, or that the very first item is a pack. In
879 // that case, we want to insert at the beginning...
882 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
884 search->next = fs_searchpaths;
885 fs_searchpaths = search;
888 // otherwise we want to append directly after insertion_point.
890 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
892 search->next = insertion_point->next;
893 insertion_point->next = search;
898 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
900 search->next = fs_searchpaths;
901 fs_searchpaths = search;
907 Con_Printf("unable to load pak \"%s\"\n", pakfile);
917 Adds the given pack to the search path and searches for it in the game path.
918 The pack type is autodetected by the file extension.
920 Returns true if the file was successfully added to the
921 search path or if it was already included.
923 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
927 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
929 char fullpath[MAX_QPATH];
931 searchpath_t *search;
934 *already_loaded = false;
936 // then find the real name...
937 search = FS_FindFile(pakfile, &index, true);
938 if(!search || search->pack)
940 Con_Printf("could not find pak \"%s\"\n", pakfile);
944 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
946 return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
954 Sets fs_gamedir, adds the directory to the head of the path,
955 then loads and adds pak1.pak pak2.pak ...
958 void FS_AddGameDirectory (const char *dir)
962 searchpath_t *search;
964 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
966 stringlistinit(&list);
967 listdirectory(&list, "", dir);
968 stringlistsort(&list);
970 // add any PAK package in the directory
971 for (i = 0;i < list.numstrings;i++)
973 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
975 FS_AddPack_Fullpath(list.strings[i], NULL, false);
979 // add any PK3 package in the directory
980 for (i = 0;i < list.numstrings;i++)
982 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
984 FS_AddPack_Fullpath(list.strings[i], NULL, false);
988 stringlistfreecontents(&list);
990 // Add the directory to the search path
991 // (unpacked files have the priority over packed files)
992 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
993 strlcpy (search->filename, dir, sizeof (search->filename));
994 search->next = fs_searchpaths;
995 fs_searchpaths = search;
1004 void FS_AddGameHierarchy (const char *dir)
1007 char userdir[MAX_QPATH];
1009 TCHAR mydocsdir[MAX_PATH + 1];
1011 const char *homedir;
1014 // Add the common game directory
1015 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1019 // Add the personal game directory
1021 if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1022 dpsnprintf(userdir, sizeof(userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1024 homedir = getenv ("HOME");
1026 dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
1030 if(!COM_CheckParm("-mygames"))
1032 int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1036 *userdir = 0; // we have write access to the game dir, so let's use it
1041 if(COM_CheckParm("-nohome"))
1044 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1045 dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
1048 FS_AddGameDirectory(va("%s%s/", userdir, dir));
1057 const char *FS_FileExtension (const char *in)
1059 const char *separator, *backslash, *colon, *dot;
1061 separator = strrchr(in, '/');
1062 backslash = strrchr(in, '\\');
1063 if (!separator || separator < backslash)
1064 separator = backslash;
1065 colon = strrchr(in, ':');
1066 if (!separator || separator < colon)
1069 dot = strrchr(in, '.');
1070 if (dot == NULL || (separator && (dot < separator)))
1082 const char *FS_FileWithoutPath (const char *in)
1084 const char *separator, *backslash, *colon;
1086 separator = strrchr(in, '/');
1087 backslash = strrchr(in, '\\');
1088 if (!separator || separator < backslash)
1089 separator = backslash;
1090 colon = strrchr(in, ':');
1091 if (!separator || separator < colon)
1093 return separator ? separator + 1 : in;
1102 void FS_ClearSearchPath (void)
1104 // unload all packs and directory information, close all pack files
1105 // (if a qfile is still reading a pack it won't be harmed because it used
1106 // dup() to get its own handle already)
1107 while (fs_searchpaths)
1109 searchpath_t *search = fs_searchpaths;
1110 fs_searchpaths = search->next;
1114 close(search->pack->handle);
1115 // free any memory associated with it
1116 if (search->pack->files)
1117 Mem_Free(search->pack->files);
1118 Mem_Free(search->pack);
1130 void FS_Rescan (void)
1133 qboolean fs_modified = false;
1135 FS_ClearSearchPath();
1137 // add the game-specific paths
1138 // gamedirname1 (typically id1)
1139 FS_AddGameHierarchy (gamedirname1);
1140 // update the com_modname (used for server info)
1141 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1143 // add the game-specific path, if any
1144 // (only used for mission packs and the like, which should set fs_modified)
1148 FS_AddGameHierarchy (gamedirname2);
1152 // Adds basedir/gamedir as an override game
1153 // LordHavoc: now supports multiple -game directories
1154 // set the com_modname (reported in server info)
1155 for (i = 0;i < fs_numgamedirs;i++)
1158 FS_AddGameHierarchy (fs_gamedirs[i]);
1159 // update the com_modname (used server info)
1160 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1163 // set the default screenshot name to either the mod name or the
1164 // gamemode screenshot name
1165 if (strcmp(com_modname, gamedirname1))
1166 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1168 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1170 // If "-condebug" is in the command line, remove the previous log file
1171 if (COM_CheckParm ("-condebug") != 0)
1172 unlink (va("%s/qconsole.log", fs_gamedir));
1174 // look for the pop.lmp file and set registered to true if it is found
1175 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1178 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1180 Con_Print("Playing shareware version.\n");
1184 Cvar_Set ("registered", "1");
1185 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1186 Con_Print("Playing registered version.\n");
1189 // unload all wads so that future queries will return the new data
1193 void FS_Rescan_f(void)
1203 extern void Host_SaveConfig (void);
1204 extern void Host_LoadConfig_f (void);
1205 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1209 if (fs_numgamedirs == numgamedirs)
1211 for (i = 0;i < numgamedirs;i++)
1212 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1214 if (i == numgamedirs)
1215 return true; // already using this set of gamedirs, do nothing
1218 if (numgamedirs > MAX_GAMEDIRS)
1221 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1222 return false; // too many gamedirs
1225 for (i = 0;i < numgamedirs;i++)
1227 // if string is nasty, reject it
1228 if(FS_CheckNastyPath(gamedirs[i], true))
1231 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1232 return false; // nasty gamedirs
1236 for (i = 0;i < numgamedirs;i++)
1238 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1241 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1242 return false; // missing gamedirs
1246 // halt demo playback to close the file
1251 fs_numgamedirs = numgamedirs;
1252 for (i = 0;i < fs_numgamedirs;i++)
1253 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1255 // reinitialize filesystem to detect the new paks
1258 // exec the new config
1259 Host_LoadConfig_f();
1261 // unload all sounds so they will be reloaded from the new files as needed
1262 S_UnloadAllSounds_f();
1264 // reinitialize renderer (this reloads hud/console background/etc)
1265 R_Modules_Restart();
1275 void FS_GameDir_f (void)
1279 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1283 Con_Printf("gamedirs active:");
1284 for (i = 0;i < fs_numgamedirs;i++)
1285 Con_Printf(" %s", fs_gamedirs[i]);
1290 numgamedirs = Cmd_Argc() - 1;
1291 if (numgamedirs > MAX_GAMEDIRS)
1293 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1297 for (i = 0;i < numgamedirs;i++)
1298 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1300 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1302 // actually, changing during game would work fine, but would be stupid
1303 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1307 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1316 qboolean FS_CheckGameDir(const char *gamedir)
1320 stringlistinit(&list);
1321 listdirectory(&list, va("%s%s/", fs_basedir, gamedir), "");
1322 success = list.numstrings > 0;
1323 stringlistfreecontents(&list);
1337 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1339 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1341 // If the base directory is explicitly defined by the compilation process
1342 #ifdef DP_FS_BASEDIR
1343 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1345 strlcpy(fs_basedir, "", sizeof(fs_basedir));
1348 // FIXME: is there a better way to find the directory outside the .app?
1349 if (strstr(com_argv[0], ".app/"))
1353 split = strstr(com_argv[0], ".app/");
1354 while (split > com_argv[0] && *split != '/')
1356 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1357 fs_basedir[split - com_argv[0]] = 0;
1365 // Overrides the system supplied base directory (under GAMENAME)
1366 // 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)
1367 i = COM_CheckParm ("-basedir");
1368 if (i && i < com_argc-1)
1370 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1371 i = (int)strlen (fs_basedir);
1372 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1373 fs_basedir[i-1] = 0;
1376 // add a path separator to the end of the basedir if it lacks one
1377 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1378 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1380 if (!FS_CheckGameDir(gamedirname1))
1381 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1383 if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1384 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1387 // Adds basedir/gamedir as an override game
1388 // LordHavoc: now supports multiple -game directories
1389 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1393 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1396 if (FS_CheckNastyPath(com_argv[i], true))
1397 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1398 if (!FS_CheckGameDir(com_argv[i]))
1399 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1400 // add the gamedir to the list of active gamedirs
1401 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1406 // generate the searchpath
1410 void FS_Init_Commands(void)
1412 Cvar_RegisterVariable (&scr_screenshot_name);
1413 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1415 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1416 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1417 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1418 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1419 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1427 void FS_Shutdown (void)
1429 // close all pack files and such
1430 // (hopefully there aren't any other open files, but they'll be cleaned up
1431 // by the OS anyway)
1432 FS_ClearSearchPath();
1433 Mem_FreePool (&fs_mempool);
1437 ====================
1440 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1441 ====================
1443 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1449 // Parse the mode string
1458 opt = O_CREAT | O_TRUNC;
1462 opt = O_CREAT | O_APPEND;
1465 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1468 for (ind = 1; mode[ind] != '\0'; ind++)
1479 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1480 filepath, mode, mode[ind]);
1487 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1488 memset (file, 0, sizeof (*file));
1491 file->handle = open (filepath, mod | opt, 0666);
1492 if (file->handle < 0)
1498 file->real_length = lseek (file->handle, 0, SEEK_END);
1500 // For files opened in append mode, we start at the end of the file
1502 file->position = file->real_length;
1504 lseek (file->handle, 0, SEEK_SET);
1514 Open a packed file using its package file descriptor
1517 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1523 pfile = &pack->files[pack_ind];
1525 // If we don't have the true offset, get it now
1526 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1527 if (!PK3_GetTrueFileOffset (pfile, pack))
1530 // No Zlib DLL = no compressed files
1531 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1533 Con_Printf("WARNING: can't open the compressed file %s\n"
1534 "You need the Zlib DLL to use compressed files\n",
1539 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1540 // the dup() call to avoid having to close the dup_handle on error here
1541 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1543 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1544 pfile->name, pack->filename, (int) pfile->offset);
1548 dup_handle = dup (pack->handle);
1551 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1555 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1556 memset (file, 0, sizeof (*file));
1557 file->handle = dup_handle;
1558 file->flags = QFILE_FLAG_PACKED;
1559 file->real_length = pfile->realsize;
1560 file->offset = pfile->offset;
1564 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1568 file->flags |= QFILE_FLAG_DEFLATED;
1570 // We need some more variables
1571 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1573 ztk->comp_length = pfile->packsize;
1575 // Initialize zlib stream
1576 ztk->zstream.next_in = ztk->input;
1577 ztk->zstream.avail_in = 0;
1579 /* From Zlib's "unzip.c":
1581 * windowBits is passed < 0 to tell that there is no zlib header.
1582 * Note that in this case inflate *requires* an extra "dummy" byte
1583 * after the compressed stream in order to complete decompression and
1584 * return Z_STREAM_END.
1585 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1586 * size of both compressed and uncompressed data
1588 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1590 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1596 ztk->zstream.next_out = file->buff;
1597 ztk->zstream.avail_out = sizeof (file->buff);
1606 ====================
1609 Return true if the path should be rejected due to one of the following:
1610 1: path elements that are non-portable
1611 2: path elements that would allow access to files outside the game directory,
1612 or are just not a good idea for a mod to be using.
1613 ====================
1615 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1617 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1621 // Windows: don't allow \ in filenames (windows-only), period.
1622 // (on Windows \ is a directory separator, but / is also supported)
1623 if (strstr(path, "\\"))
1624 return 1; // non-portable
1626 // Mac: don't allow Mac-only filenames - : is a directory separator
1627 // instead of /, but we rely on / working already, so there's no reason to
1628 // support a Mac-only path
1629 // Amiga and Windows: : tries to go to root of drive
1630 if (strstr(path, ":"))
1631 return 1; // non-portable attempt to go to root of drive
1633 // Amiga: // is parent directory
1634 if (strstr(path, "//"))
1635 return 1; // non-portable attempt to go to parent directory
1637 // all: don't allow going to parent directory (../ or /../)
1638 if (strstr(path, ".."))
1639 return 2; // attempt to go outside the game directory
1641 // Windows and UNIXes: don't allow absolute paths
1643 return 2; // attempt to go outside the game directory
1645 // 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
1646 if (strchr(path, '.'))
1650 // gamedir is entirely path elements, so simply forbid . entirely
1653 if (strchr(path, '.') < strrchr(path, '/'))
1654 return 2; // possible attempt to go outside the game directory
1657 // all: forbid trailing slash on gamedir
1658 if (isgamedir && path[strlen(path)-1] == '/')
1661 // all: forbid leading dot on any filename for any reason
1662 if (strstr(path, "/."))
1663 return 2; // attempt to go outside the game directory
1665 // after all these checks we're pretty sure it's a / separated filename
1666 // and won't do much if any harm
1672 ====================
1675 Look for a file in the packages and in the filesystem
1677 Return the searchpath where the file was found (or NULL)
1678 and the file index in the package if relevant
1679 ====================
1681 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1683 searchpath_t *search;
1686 // search through the path, one element at a time
1687 for (search = fs_searchpaths;search;search = search->next)
1689 // is the element a pak file?
1692 int (*strcmp_funct) (const char* str1, const char* str2);
1693 int left, right, middle;
1696 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1698 // Look for the file (binary search)
1700 right = pak->numfiles - 1;
1701 while (left <= right)
1705 middle = (left + right) / 2;
1706 diff = strcmp_funct (pak->files[middle].name, name);
1711 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1713 // yes, but the first one is empty so we treat it as not being there
1714 if (!quiet && developer.integer >= 10)
1715 Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1722 if (!quiet && developer.integer >= 10)
1723 Con_Printf("FS_FindFile: %s in %s\n",
1724 pak->files[middle].name, pak->filename);
1731 // If we're too far in the list
1740 char netpath[MAX_OSPATH];
1741 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1742 if (FS_SysFileExists (netpath))
1744 if (!quiet && developer.integer >= 10)
1745 Con_Printf("FS_FindFile: %s\n", netpath);
1754 if (!quiet && developer.integer >= 10)
1755 Con_Printf("FS_FindFile: can't find %s\n", name);
1767 Look for a file in the search paths and open it in read-only mode
1770 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1772 searchpath_t *search;
1775 search = FS_FindFile (filename, &pack_ind, quiet);
1781 // Found in the filesystem?
1784 char path [MAX_OSPATH];
1785 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1786 return FS_SysOpen (path, "rb", nonblocking);
1789 // So, we found it in a package...
1790 return FS_OpenPackedFile (search->pack, pack_ind);
1795 =============================================================================
1797 MAIN PUBLIC FUNCTIONS
1799 =============================================================================
1803 ====================
1806 Open a file. The syntax is the same as fopen
1807 ====================
1809 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1812 char fixedFileName[MAX_QPATH];
1814 strlcpy( fixedFileName, filepath, MAX_QPATH );
1815 // try to fix common mistakes (\ instead of /)
1816 for( d = fixedFileName ; *d ; d++ )
1819 filepath = fixedFileName;
1822 if (FS_CheckNastyPath(filepath, false))
1824 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1828 // If the file is opened in "write", "append", or "read/write" mode
1829 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1831 char real_path [MAX_OSPATH];
1833 // Open the file on disk directly
1834 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1836 // Create directories up to the file
1837 FS_CreatePath (real_path);
1839 return FS_SysOpen (real_path, mode, nonblocking);
1841 // Else, we look at the various search paths and open the file in read-only mode
1843 return FS_OpenReadFile (filepath, quiet, nonblocking);
1848 ====================
1852 ====================
1854 int FS_Close (qfile_t* file)
1856 if (close (file->handle))
1861 qz_inflateEnd (&file->ztk->zstream);
1862 Mem_Free (file->ztk);
1871 ====================
1874 Write "datasize" bytes into a file
1875 ====================
1877 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1881 // If necessary, seek to the exact file position we're supposed to be
1882 if (file->buff_ind != file->buff_len)
1883 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1885 // Purge cached data
1888 // Write the buffer and update the position
1889 result = write (file->handle, data, (fs_offset_t)datasize);
1890 file->position = lseek (file->handle, 0, SEEK_CUR);
1891 if (file->real_length < file->position)
1892 file->real_length = file->position;
1902 ====================
1905 Read up to "buffersize" bytes from a file
1906 ====================
1908 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1910 fs_offset_t count, done;
1912 if (buffersize == 0)
1915 // Get rid of the ungetc character
1916 if (file->ungetc != EOF)
1918 ((char*)buffer)[0] = file->ungetc;
1926 // First, we copy as many bytes as we can from "buff"
1927 if (file->buff_ind < file->buff_len)
1929 count = file->buff_len - file->buff_ind;
1930 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1932 memcpy (buffer, &file->buff[file->buff_ind], count);
1933 file->buff_ind += count;
1935 buffersize -= count;
1936 if (buffersize == 0)
1940 // NOTE: at this point, the read buffer is always empty
1942 // If the file isn't compressed
1943 if (! (file->flags & QFILE_FLAG_DEFLATED))
1947 // We must take care to not read after the end of the file
1948 count = file->real_length - file->position;
1950 // If we have a lot of data to get, put them directly into "buffer"
1951 if (buffersize > sizeof (file->buff) / 2)
1953 if (count > (fs_offset_t)buffersize)
1954 count = (fs_offset_t)buffersize;
1955 lseek (file->handle, file->offset + file->position, SEEK_SET);
1956 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1960 file->position += nb;
1962 // Purge cached data
1968 if (count > (fs_offset_t)sizeof (file->buff))
1969 count = (fs_offset_t)sizeof (file->buff);
1970 lseek (file->handle, file->offset + file->position, SEEK_SET);
1971 nb = read (file->handle, file->buff, count);
1974 file->buff_len = nb;
1975 file->position += nb;
1977 // Copy the requested data in "buffer" (as much as we can)
1978 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1979 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1980 file->buff_ind = count;
1988 // If the file is compressed, it's more complicated...
1989 // We cycle through a few operations until we have read enough data
1990 while (buffersize > 0)
1992 ztoolkit_t *ztk = file->ztk;
1995 // NOTE: at this point, the read buffer is always empty
1997 // If "input" is also empty, we need to refill it
1998 if (ztk->in_ind == ztk->in_len)
2000 // If we are at the end of the file
2001 if (file->position == file->real_length)
2004 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2005 if (count > (fs_offset_t)sizeof (ztk->input))
2006 count = (fs_offset_t)sizeof (ztk->input);
2007 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2008 if (read (file->handle, ztk->input, count) != count)
2010 Con_Printf ("FS_Read: unexpected end of file\n");
2015 ztk->in_len = count;
2016 ztk->in_position += count;
2019 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2020 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2022 // Now that we are sure we have compressed data available, we need to determine
2023 // if it's better to inflate it in "file->buff" or directly in "buffer"
2025 // Inflate the data in "file->buff"
2026 if (buffersize < sizeof (file->buff) / 2)
2028 ztk->zstream.next_out = file->buff;
2029 ztk->zstream.avail_out = sizeof (file->buff);
2030 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2031 if (error != Z_OK && error != Z_STREAM_END)
2033 Con_Printf ("FS_Read: Can't inflate file\n");
2036 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2038 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2039 file->position += file->buff_len;
2041 // Copy the requested data in "buffer" (as much as we can)
2042 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2043 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2044 file->buff_ind = count;
2047 // Else, we inflate directly in "buffer"
2050 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2051 ztk->zstream.avail_out = (unsigned int)buffersize;
2052 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2053 if (error != Z_OK && error != Z_STREAM_END)
2055 Con_Printf ("FS_Read: Can't inflate file\n");
2058 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2060 // How much data did it inflate?
2061 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2062 file->position += count;
2064 // Purge cached data
2069 buffersize -= count;
2077 ====================
2080 Print a string into a file
2081 ====================
2083 int FS_Print (qfile_t* file, const char *msg)
2085 return (int)FS_Write (file, msg, strlen (msg));
2089 ====================
2092 Print a string into a file
2093 ====================
2095 int FS_Printf(qfile_t* file, const char* format, ...)
2100 va_start (args, format);
2101 result = FS_VPrintf (file, format, args);
2109 ====================
2112 Print a string into a file
2113 ====================
2115 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2118 fs_offset_t buff_size = MAX_INPUTLINE;
2123 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2124 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2125 if (len >= 0 && len < buff_size)
2127 Mem_Free (tempbuff);
2131 len = write (file->handle, tempbuff, len);
2132 Mem_Free (tempbuff);
2139 ====================
2142 Get the next character of a file
2143 ====================
2145 int FS_Getc (qfile_t* file)
2149 if (FS_Read (file, &c, 1) != 1)
2157 ====================
2160 Put a character back into the read buffer (only supports one character!)
2161 ====================
2163 int FS_UnGetc (qfile_t* file, unsigned char c)
2165 // If there's already a character waiting to be read
2166 if (file->ungetc != EOF)
2175 ====================
2178 Move the position index in a file
2179 ====================
2181 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2184 unsigned char* buffer;
2185 fs_offset_t buffersize;
2187 // Compute the file offset
2191 offset += file->position - file->buff_len + file->buff_ind;
2198 offset += file->real_length;
2204 if (offset < 0 || offset > file->real_length)
2207 // If we have the data in our read buffer, we don't need to actually seek
2208 if (file->position - file->buff_len <= offset && offset <= file->position)
2210 file->buff_ind = offset + file->buff_len - file->position;
2214 // Purge cached data
2217 // Unpacked or uncompressed files can seek directly
2218 if (! (file->flags & QFILE_FLAG_DEFLATED))
2220 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2222 file->position = offset;
2226 // Seeking in compressed files is more a hack than anything else,
2227 // but we need to support it, so here we go.
2230 // If we have to go back in the file, we need to restart from the beginning
2231 if (offset <= file->position)
2235 ztk->in_position = 0;
2237 lseek (file->handle, file->offset, SEEK_SET);
2239 // Reset the Zlib stream
2240 ztk->zstream.next_in = ztk->input;
2241 ztk->zstream.avail_in = 0;
2242 qz_inflateReset (&ztk->zstream);
2245 // We need a big buffer to force inflating into it directly
2246 buffersize = 2 * sizeof (file->buff);
2247 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2249 // Skip all data until we reach the requested offset
2250 while (offset > file->position)
2252 fs_offset_t diff = offset - file->position;
2253 fs_offset_t count, len;
2255 count = (diff > buffersize) ? buffersize : diff;
2256 len = FS_Read (file, buffer, count);
2270 ====================
2273 Give the current position in a file
2274 ====================
2276 fs_offset_t FS_Tell (qfile_t* file)
2278 return file->position - file->buff_len + file->buff_ind;
2283 ====================
2286 Give the total size of a file
2287 ====================
2289 fs_offset_t FS_FileSize (qfile_t* file)
2291 return file->real_length;
2296 ====================
2299 Erases any buffered input or output data
2300 ====================
2302 void FS_Purge (qfile_t* file)
2314 Filename are relative to the quake directory.
2315 Always appends a 0 byte.
2318 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2321 unsigned char *buf = NULL;
2322 fs_offset_t filesize = 0;
2324 file = FS_Open (path, "rb", quiet, false);
2327 filesize = file->real_length;
2328 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2329 buf[filesize] = '\0';
2330 FS_Read (file, buf, filesize);
2332 if (developer_loadfile.integer)
2333 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2336 if (filesizepointer)
2337 *filesizepointer = filesize;
2346 The filename will be prefixed by the current game directory
2349 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2353 file = FS_Open (filename, "wb", false, false);
2356 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2360 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2361 FS_Write (file, data, len);
2368 =============================================================================
2370 OTHERS PUBLIC FUNCTIONS
2372 =============================================================================
2380 void FS_StripExtension (const char *in, char *out, size_t size_out)
2388 while ((currentchar = *in) && size_out > 1)
2390 if (currentchar == '.')
2392 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2394 *out++ = currentchar;
2410 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2414 // if path doesn't have a .EXT, append extension
2415 // (extension should include the .)
2416 src = path + strlen(path) - 1;
2418 while (*src != '/' && src != path)
2421 return; // it has an extension
2425 strlcat (path, extension, size_path);
2433 Look for a file in the packages and in the filesystem
2436 int FS_FileType (const char *filename)
2438 searchpath_t *search;
2439 char fullpath[MAX_QPATH];
2441 search = FS_FindFile (filename, NULL, true);
2443 return FS_FILETYPE_NONE;
2446 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2448 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2449 return FS_SysFileType(fullpath);
2457 Look for a file in the packages and in the filesystem
2460 qboolean FS_FileExists (const char *filename)
2462 return (FS_FindFile (filename, NULL, true) != NULL);
2470 Look for a file in the filesystem only
2473 int FS_SysFileType (const char *path)
2476 DWORD result = GetFileAttributes(path);
2478 if(result == INVALID_FILE_ATTRIBUTES)
2479 return FS_FILETYPE_NONE;
2481 if(result & FILE_ATTRIBUTE_DIRECTORY)
2482 return FS_FILETYPE_DIRECTORY;
2484 return FS_FILETYPE_FILE;
2488 if (stat (path,&buf) == -1)
2489 return FS_FILETYPE_NONE;
2491 if(S_ISDIR(buf.st_mode))
2492 return FS_FILETYPE_DIRECTORY;
2494 return FS_FILETYPE_FILE;
2498 qboolean FS_SysFileExists (const char *path)
2500 return FS_SysFileType (path) != FS_FILETYPE_NONE;
2503 void FS_mkdir (const char *path)
2516 Allocate and fill a search structure with information on matching filenames.
2519 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2522 searchpath_t *searchpath;
2524 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2525 stringlist_t resultlist;
2526 stringlist_t dirlist;
2527 const char *slash, *backslash, *colon, *separator;
2529 char temp[MAX_OSPATH];
2531 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2536 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2540 stringlistinit(&resultlist);
2541 stringlistinit(&dirlist);
2543 slash = strrchr(pattern, '/');
2544 backslash = strrchr(pattern, '\\');
2545 colon = strrchr(pattern, ':');
2546 separator = max(slash, backslash);
2547 separator = max(separator, colon);
2548 basepathlength = separator ? (separator + 1 - pattern) : 0;
2549 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2551 memcpy(basepath, pattern, basepathlength);
2552 basepath[basepathlength] = 0;
2554 // search through the path, one element at a time
2555 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2557 // is the element a pak file?
2558 if (searchpath->pack)
2560 // look through all the pak file elements
2561 pak = searchpath->pack;
2562 for (i = 0;i < pak->numfiles;i++)
2564 strlcpy(temp, pak->files[i].name, sizeof(temp));
2567 if (matchpattern(temp, (char *)pattern, true))
2569 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2570 if (!strcmp(resultlist.strings[resultlistindex], temp))
2572 if (resultlistindex == resultlist.numstrings)
2574 stringlistappend(&resultlist, temp);
2575 if (!quiet && developer_loading.integer)
2576 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
2579 // strip off one path element at a time until empty
2580 // this way directories are added to the listing if they match the pattern
2581 slash = strrchr(temp, '/');
2582 backslash = strrchr(temp, '\\');
2583 colon = strrchr(temp, ':');
2585 if (separator < slash)
2587 if (separator < backslash)
2588 separator = backslash;
2589 if (separator < colon)
2591 *((char *)separator) = 0;
2597 stringlist_t matchedSet, foundSet;
2598 const char *start = pattern;
2600 stringlistinit(&matchedSet);
2601 stringlistinit(&foundSet);
2602 // add a first entry to the set
2603 stringlistappend(&matchedSet, "");
2604 // iterate through pattern's path
2607 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
2608 char subpath[MAX_OSPATH];
2609 char subpattern[MAX_OSPATH];
2611 // find the next wildcard
2612 wildcard = strchr(start, '?');
2613 asterisk = strchr(start, '*');
2614 if (asterisk && (!wildcard || asterisk < wildcard))
2616 wildcard = asterisk;
2621 nextseparator = strchr( wildcard, '/' );
2625 nextseparator = NULL;
2628 if( !nextseparator ) {
2629 nextseparator = start + strlen( start );
2632 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
2633 // copy everything up except nextseperator
2634 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
2635 // find the last '/' before the wildcard
2636 prevseparator = strrchr( subpattern, '/' ) + 1;
2639 prevseparator = subpattern;
2641 // copy everything from start to the previous including the '/' (before the wildcard)
2642 // everything up to start is already included in the path of matchedSet's entries
2643 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
2645 // for each entry in matchedSet try to open the subdirectories specified in subpath
2646 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
2647 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
2648 strlcat( temp, subpath, sizeof(temp) );
2649 listdirectory( &foundSet, searchpath->filename, temp );
2651 if( dirlistindex == 0 ) {
2654 // reset the current result set
2655 stringlistfreecontents( &matchedSet );
2656 // match against the pattern
2657 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
2658 const char *direntry = foundSet.strings[ dirlistindex ];
2659 if (matchpattern(direntry, subpattern, true)) {
2660 stringlistappend( &matchedSet, direntry );
2663 stringlistfreecontents( &foundSet );
2665 start = nextseparator;
2668 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
2670 const char *temp = matchedSet.strings[dirlistindex];
2671 if (matchpattern(temp, (char *)pattern, true))
2673 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2674 if (!strcmp(resultlist.strings[resultlistindex], temp))
2676 if (resultlistindex == resultlist.numstrings)
2678 stringlistappend(&resultlist, temp);
2679 if (!quiet && developer_loading.integer)
2680 Con_Printf("SearchDirFile: %s\n", temp);
2684 stringlistfreecontents( &matchedSet );
2688 if (resultlist.numstrings)
2690 stringlistsort(&resultlist);
2691 numfiles = resultlist.numstrings;
2693 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2694 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2695 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2696 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2697 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2698 search->numfilenames = (int)numfiles;
2701 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2704 search->filenames[numfiles] = search->filenamesbuffer + numchars;
2705 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2706 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2708 numchars += (int)textlen;
2711 stringlistfreecontents(&resultlist);
2717 void FS_FreeSearch(fssearch_t *search)
2722 extern int con_linewidth;
2723 int FS_ListDirectory(const char *pattern, int oneperline)
2732 char linebuf[MAX_INPUTLINE];
2734 search = FS_Search(pattern, true, true);
2737 numfiles = search->numfilenames;
2740 // FIXME: the names could be added to one column list and then
2741 // gradually shifted into the next column if they fit, and then the
2742 // next to make a compact variable width listing but it's a lot more
2744 // find width for columns
2746 for (i = 0;i < numfiles;i++)
2748 l = (int)strlen(search->filenames[i]);
2749 if (columnwidth < l)
2752 // count the spacing character
2754 // calculate number of columns
2755 numcolumns = con_linewidth / columnwidth;
2756 // don't bother with the column printing if it's only one column
2757 if (numcolumns >= 2)
2759 numlines = (numfiles + numcolumns - 1) / numcolumns;
2760 for (i = 0;i < numlines;i++)
2763 for (k = 0;k < numcolumns;k++)
2765 l = i * numcolumns + k;
2768 name = search->filenames[l];
2769 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2770 linebuf[linebufpos++] = name[j];
2771 // space out name unless it's the last on the line
2772 if (k + 1 < numcolumns && l + 1 < numfiles)
2773 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2774 linebuf[linebufpos++] = ' ';
2777 linebuf[linebufpos] = 0;
2778 Con_Printf("%s\n", linebuf);
2785 for (i = 0;i < numfiles;i++)
2786 Con_Printf("%s\n", search->filenames[i]);
2787 FS_FreeSearch(search);
2788 return (int)numfiles;
2791 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2793 const char *pattern;
2796 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2799 if (Cmd_Argc() == 2)
2800 pattern = Cmd_Argv(1);
2803 if (!FS_ListDirectory(pattern, oneperline))
2804 Con_Print("No files found.\n");
2809 FS_ListDirectoryCmd("dir", true);
2814 FS_ListDirectoryCmd("ls", false);
2817 const char *FS_WhichPack(const char *filename)
2820 searchpath_t *sp = FS_FindFile(filename, &index, true);
2822 return sp->pack->filename;
2828 ====================
2829 FS_IsRegisteredQuakePack
2831 Look for a proof of purchase file file in the requested package
2833 If it is found, this file should NOT be downloaded.
2834 ====================
2836 qboolean FS_IsRegisteredQuakePack(const char *name)
2838 searchpath_t *search;
2841 // search through the path, one element at a time
2842 for (search = fs_searchpaths;search;search = search->next)
2844 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2846 int (*strcmp_funct) (const char* str1, const char* str2);
2847 int left, right, middle;
2850 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2852 // Look for the file (binary search)
2854 right = pak->numfiles - 1;
2855 while (left <= right)
2859 middle = (left + right) / 2;
2860 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2866 // If we're too far in the list
2873 // we found the requested pack but it is not registered quake
2881 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2884 unsigned char *filedata;
2885 fs_offset_t filesize;
2886 if (filesizepointer)
2887 *filesizepointer = 0;
2888 if (!filename || !*filename)
2890 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2893 if (filesizepointer)
2894 *filesizepointer = filesize;
2895 crc = CRC_Block(filedata, filesize);