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);
1023 fprintf(stderr, "userdir = %s\n", userdir);
1025 homedir = getenv ("HOME");
1027 dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
1031 if(!COM_CheckParm("-mygames"))
1033 int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1037 *userdir = 0; // we have write access to the game dir, so let's use it
1042 if(COM_CheckParm("-nohome"))
1045 if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1046 dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
1049 FS_AddGameDirectory(va("%s%s/", userdir, dir));
1058 const char *FS_FileExtension (const char *in)
1060 const char *separator, *backslash, *colon, *dot;
1062 separator = strrchr(in, '/');
1063 backslash = strrchr(in, '\\');
1064 if (!separator || separator < backslash)
1065 separator = backslash;
1066 colon = strrchr(in, ':');
1067 if (!separator || separator < colon)
1070 dot = strrchr(in, '.');
1071 if (dot == NULL || (separator && (dot < separator)))
1083 const char *FS_FileWithoutPath (const char *in)
1085 const char *separator, *backslash, *colon;
1087 separator = strrchr(in, '/');
1088 backslash = strrchr(in, '\\');
1089 if (!separator || separator < backslash)
1090 separator = backslash;
1091 colon = strrchr(in, ':');
1092 if (!separator || separator < colon)
1094 return separator ? separator + 1 : in;
1103 void FS_ClearSearchPath (void)
1105 // unload all packs and directory information, close all pack files
1106 // (if a qfile is still reading a pack it won't be harmed because it used
1107 // dup() to get its own handle already)
1108 while (fs_searchpaths)
1110 searchpath_t *search = fs_searchpaths;
1111 fs_searchpaths = search->next;
1115 close(search->pack->handle);
1116 // free any memory associated with it
1117 if (search->pack->files)
1118 Mem_Free(search->pack->files);
1119 Mem_Free(search->pack);
1131 void FS_Rescan (void)
1134 qboolean fs_modified = false;
1136 FS_ClearSearchPath();
1138 // add the game-specific paths
1139 // gamedirname1 (typically id1)
1140 FS_AddGameHierarchy (gamedirname1);
1141 // update the com_modname (used for server info)
1142 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1144 // add the game-specific path, if any
1145 // (only used for mission packs and the like, which should set fs_modified)
1149 FS_AddGameHierarchy (gamedirname2);
1153 // Adds basedir/gamedir as an override game
1154 // LordHavoc: now supports multiple -game directories
1155 // set the com_modname (reported in server info)
1156 for (i = 0;i < fs_numgamedirs;i++)
1159 FS_AddGameHierarchy (fs_gamedirs[i]);
1160 // update the com_modname (used server info)
1161 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1164 // set the default screenshot name to either the mod name or the
1165 // gamemode screenshot name
1166 if (strcmp(com_modname, gamedirname1))
1167 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1169 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1171 // If "-condebug" is in the command line, remove the previous log file
1172 if (COM_CheckParm ("-condebug") != 0)
1173 unlink (va("%s/qconsole.log", fs_gamedir));
1175 // look for the pop.lmp file and set registered to true if it is found
1176 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1179 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1181 Con_Print("Playing shareware version.\n");
1185 Cvar_Set ("registered", "1");
1186 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1187 Con_Print("Playing registered version.\n");
1190 // unload all wads so that future queries will return the new data
1194 void FS_Rescan_f(void)
1204 extern void Host_SaveConfig (void);
1205 extern void Host_LoadConfig_f (void);
1206 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1210 if (fs_numgamedirs == numgamedirs)
1212 for (i = 0;i < numgamedirs;i++)
1213 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1215 if (i == numgamedirs)
1216 return true; // already using this set of gamedirs, do nothing
1219 if (numgamedirs > MAX_GAMEDIRS)
1222 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1223 return false; // too many gamedirs
1226 for (i = 0;i < numgamedirs;i++)
1228 // if string is nasty, reject it
1229 if(FS_CheckNastyPath(gamedirs[i], true))
1232 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1233 return false; // nasty gamedirs
1237 for (i = 0;i < numgamedirs;i++)
1239 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1242 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1243 return false; // missing gamedirs
1247 // halt demo playback to close the file
1252 fs_numgamedirs = numgamedirs;
1253 for (i = 0;i < fs_numgamedirs;i++)
1254 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1256 // reinitialize filesystem to detect the new paks
1259 // exec the new config
1260 Host_LoadConfig_f();
1262 // unload all sounds so they will be reloaded from the new files as needed
1263 S_UnloadAllSounds_f();
1265 // reinitialize renderer (this reloads hud/console background/etc)
1266 R_Modules_Restart();
1276 void FS_GameDir_f (void)
1280 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1284 Con_Printf("gamedirs active:");
1285 for (i = 0;i < fs_numgamedirs;i++)
1286 Con_Printf(" %s", fs_gamedirs[i]);
1291 numgamedirs = Cmd_Argc() - 1;
1292 if (numgamedirs > MAX_GAMEDIRS)
1294 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1298 for (i = 0;i < numgamedirs;i++)
1299 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1301 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1303 // actually, changing during game would work fine, but would be stupid
1304 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1308 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1317 qboolean FS_CheckGameDir(const char *gamedir)
1321 stringlistinit(&list);
1322 listdirectory(&list, va("%s%s/", fs_basedir, gamedir), "");
1323 success = list.numstrings > 0;
1324 stringlistfreecontents(&list);
1338 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1340 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1342 // If the base directory is explicitly defined by the compilation process
1343 #ifdef DP_FS_BASEDIR
1344 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1346 strlcpy(fs_basedir, "", sizeof(fs_basedir));
1349 // FIXME: is there a better way to find the directory outside the .app?
1350 if (strstr(com_argv[0], ".app/"))
1354 split = strstr(com_argv[0], ".app/");
1355 while (split > com_argv[0] && *split != '/')
1357 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1358 fs_basedir[split - com_argv[0]] = 0;
1366 // Overrides the system supplied base directory (under GAMENAME)
1367 // 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)
1368 i = COM_CheckParm ("-basedir");
1369 if (i && i < com_argc-1)
1371 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1372 i = (int)strlen (fs_basedir);
1373 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1374 fs_basedir[i-1] = 0;
1377 // add a path separator to the end of the basedir if it lacks one
1378 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1379 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1381 if (!FS_CheckGameDir(gamedirname1))
1382 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1384 if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1385 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1388 // Adds basedir/gamedir as an override game
1389 // LordHavoc: now supports multiple -game directories
1390 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1394 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1397 if (FS_CheckNastyPath(com_argv[i], true))
1398 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1399 if (!FS_CheckGameDir(com_argv[i]))
1400 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1401 // add the gamedir to the list of active gamedirs
1402 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1407 // generate the searchpath
1411 void FS_Init_Commands(void)
1413 Cvar_RegisterVariable (&scr_screenshot_name);
1414 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1416 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1417 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1418 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1419 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1420 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1428 void FS_Shutdown (void)
1430 // close all pack files and such
1431 // (hopefully there aren't any other open files, but they'll be cleaned up
1432 // by the OS anyway)
1433 FS_ClearSearchPath();
1434 Mem_FreePool (&fs_mempool);
1438 ====================
1441 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1442 ====================
1444 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1450 // Parse the mode string
1459 opt = O_CREAT | O_TRUNC;
1463 opt = O_CREAT | O_APPEND;
1466 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1469 for (ind = 1; mode[ind] != '\0'; ind++)
1480 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1481 filepath, mode, mode[ind]);
1488 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1489 memset (file, 0, sizeof (*file));
1492 file->handle = open (filepath, mod | opt, 0666);
1493 if (file->handle < 0)
1499 file->real_length = lseek (file->handle, 0, SEEK_END);
1501 // For files opened in append mode, we start at the end of the file
1503 file->position = file->real_length;
1505 lseek (file->handle, 0, SEEK_SET);
1515 Open a packed file using its package file descriptor
1518 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1524 pfile = &pack->files[pack_ind];
1526 // If we don't have the true offset, get it now
1527 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1528 if (!PK3_GetTrueFileOffset (pfile, pack))
1531 // No Zlib DLL = no compressed files
1532 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1534 Con_Printf("WARNING: can't open the compressed file %s\n"
1535 "You need the Zlib DLL to use compressed files\n",
1540 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1541 // the dup() call to avoid having to close the dup_handle on error here
1542 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1544 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1545 pfile->name, pack->filename, (int) pfile->offset);
1549 dup_handle = dup (pack->handle);
1552 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1556 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1557 memset (file, 0, sizeof (*file));
1558 file->handle = dup_handle;
1559 file->flags = QFILE_FLAG_PACKED;
1560 file->real_length = pfile->realsize;
1561 file->offset = pfile->offset;
1565 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1569 file->flags |= QFILE_FLAG_DEFLATED;
1571 // We need some more variables
1572 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1574 ztk->comp_length = pfile->packsize;
1576 // Initialize zlib stream
1577 ztk->zstream.next_in = ztk->input;
1578 ztk->zstream.avail_in = 0;
1580 /* From Zlib's "unzip.c":
1582 * windowBits is passed < 0 to tell that there is no zlib header.
1583 * Note that in this case inflate *requires* an extra "dummy" byte
1584 * after the compressed stream in order to complete decompression and
1585 * return Z_STREAM_END.
1586 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1587 * size of both compressed and uncompressed data
1589 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1591 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1597 ztk->zstream.next_out = file->buff;
1598 ztk->zstream.avail_out = sizeof (file->buff);
1607 ====================
1610 Return true if the path should be rejected due to one of the following:
1611 1: path elements that are non-portable
1612 2: path elements that would allow access to files outside the game directory,
1613 or are just not a good idea for a mod to be using.
1614 ====================
1616 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1618 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1622 // Windows: don't allow \ in filenames (windows-only), period.
1623 // (on Windows \ is a directory separator, but / is also supported)
1624 if (strstr(path, "\\"))
1625 return 1; // non-portable
1627 // Mac: don't allow Mac-only filenames - : is a directory separator
1628 // instead of /, but we rely on / working already, so there's no reason to
1629 // support a Mac-only path
1630 // Amiga and Windows: : tries to go to root of drive
1631 if (strstr(path, ":"))
1632 return 1; // non-portable attempt to go to root of drive
1634 // Amiga: // is parent directory
1635 if (strstr(path, "//"))
1636 return 1; // non-portable attempt to go to parent directory
1638 // all: don't allow going to parent directory (../ or /../)
1639 if (strstr(path, ".."))
1640 return 2; // attempt to go outside the game directory
1642 // Windows and UNIXes: don't allow absolute paths
1644 return 2; // attempt to go outside the game directory
1646 // 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
1647 if (strchr(path, '.'))
1651 // gamedir is entirely path elements, so simply forbid . entirely
1654 if (strchr(path, '.') < strrchr(path, '/'))
1655 return 2; // possible attempt to go outside the game directory
1658 // all: forbid trailing slash on gamedir
1659 if (isgamedir && path[strlen(path)-1] == '/')
1662 // all: forbid leading dot on any filename for any reason
1663 if (strstr(path, "/."))
1664 return 2; // attempt to go outside the game directory
1666 // after all these checks we're pretty sure it's a / separated filename
1667 // and won't do much if any harm
1673 ====================
1676 Look for a file in the packages and in the filesystem
1678 Return the searchpath where the file was found (or NULL)
1679 and the file index in the package if relevant
1680 ====================
1682 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1684 searchpath_t *search;
1687 // search through the path, one element at a time
1688 for (search = fs_searchpaths;search;search = search->next)
1690 // is the element a pak file?
1693 int (*strcmp_funct) (const char* str1, const char* str2);
1694 int left, right, middle;
1697 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1699 // Look for the file (binary search)
1701 right = pak->numfiles - 1;
1702 while (left <= right)
1706 middle = (left + right) / 2;
1707 diff = strcmp_funct (pak->files[middle].name, name);
1712 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1714 // yes, but the first one is empty so we treat it as not being there
1715 if (!quiet && developer.integer >= 10)
1716 Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1723 if (!quiet && developer.integer >= 10)
1724 Con_Printf("FS_FindFile: %s in %s\n",
1725 pak->files[middle].name, pak->filename);
1732 // If we're too far in the list
1741 char netpath[MAX_OSPATH];
1742 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1743 if (FS_SysFileExists (netpath))
1745 if (!quiet && developer.integer >= 10)
1746 Con_Printf("FS_FindFile: %s\n", netpath);
1755 if (!quiet && developer.integer >= 10)
1756 Con_Printf("FS_FindFile: can't find %s\n", name);
1768 Look for a file in the search paths and open it in read-only mode
1771 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1773 searchpath_t *search;
1776 search = FS_FindFile (filename, &pack_ind, quiet);
1782 // Found in the filesystem?
1785 char path [MAX_OSPATH];
1786 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1787 return FS_SysOpen (path, "rb", nonblocking);
1790 // So, we found it in a package...
1791 return FS_OpenPackedFile (search->pack, pack_ind);
1796 =============================================================================
1798 MAIN PUBLIC FUNCTIONS
1800 =============================================================================
1804 ====================
1807 Open a file. The syntax is the same as fopen
1808 ====================
1810 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1813 char fixedFileName[MAX_QPATH];
1815 strlcpy( fixedFileName, filepath, MAX_QPATH );
1816 // try to fix common mistakes (\ instead of /)
1817 for( d = fixedFileName ; *d ; d++ )
1820 filepath = fixedFileName;
1823 if (FS_CheckNastyPath(filepath, false))
1825 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1829 // If the file is opened in "write", "append", or "read/write" mode
1830 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1832 char real_path [MAX_OSPATH];
1834 // Open the file on disk directly
1835 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1837 // Create directories up to the file
1838 FS_CreatePath (real_path);
1840 return FS_SysOpen (real_path, mode, nonblocking);
1842 // Else, we look at the various search paths and open the file in read-only mode
1844 return FS_OpenReadFile (filepath, quiet, nonblocking);
1849 ====================
1853 ====================
1855 int FS_Close (qfile_t* file)
1857 if (close (file->handle))
1862 qz_inflateEnd (&file->ztk->zstream);
1863 Mem_Free (file->ztk);
1872 ====================
1875 Write "datasize" bytes into a file
1876 ====================
1878 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1882 // If necessary, seek to the exact file position we're supposed to be
1883 if (file->buff_ind != file->buff_len)
1884 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1886 // Purge cached data
1889 // Write the buffer and update the position
1890 result = write (file->handle, data, (fs_offset_t)datasize);
1891 file->position = lseek (file->handle, 0, SEEK_CUR);
1892 if (file->real_length < file->position)
1893 file->real_length = file->position;
1903 ====================
1906 Read up to "buffersize" bytes from a file
1907 ====================
1909 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1911 fs_offset_t count, done;
1913 if (buffersize == 0)
1916 // Get rid of the ungetc character
1917 if (file->ungetc != EOF)
1919 ((char*)buffer)[0] = file->ungetc;
1927 // First, we copy as many bytes as we can from "buff"
1928 if (file->buff_ind < file->buff_len)
1930 count = file->buff_len - file->buff_ind;
1931 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1933 memcpy (buffer, &file->buff[file->buff_ind], count);
1934 file->buff_ind += count;
1936 buffersize -= count;
1937 if (buffersize == 0)
1941 // NOTE: at this point, the read buffer is always empty
1943 // If the file isn't compressed
1944 if (! (file->flags & QFILE_FLAG_DEFLATED))
1948 // We must take care to not read after the end of the file
1949 count = file->real_length - file->position;
1951 // If we have a lot of data to get, put them directly into "buffer"
1952 if (buffersize > sizeof (file->buff) / 2)
1954 if (count > (fs_offset_t)buffersize)
1955 count = (fs_offset_t)buffersize;
1956 lseek (file->handle, file->offset + file->position, SEEK_SET);
1957 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1961 file->position += nb;
1963 // Purge cached data
1969 if (count > (fs_offset_t)sizeof (file->buff))
1970 count = (fs_offset_t)sizeof (file->buff);
1971 lseek (file->handle, file->offset + file->position, SEEK_SET);
1972 nb = read (file->handle, file->buff, count);
1975 file->buff_len = nb;
1976 file->position += nb;
1978 // Copy the requested data in "buffer" (as much as we can)
1979 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1980 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1981 file->buff_ind = count;
1989 // If the file is compressed, it's more complicated...
1990 // We cycle through a few operations until we have read enough data
1991 while (buffersize > 0)
1993 ztoolkit_t *ztk = file->ztk;
1996 // NOTE: at this point, the read buffer is always empty
1998 // If "input" is also empty, we need to refill it
1999 if (ztk->in_ind == ztk->in_len)
2001 // If we are at the end of the file
2002 if (file->position == file->real_length)
2005 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2006 if (count > (fs_offset_t)sizeof (ztk->input))
2007 count = (fs_offset_t)sizeof (ztk->input);
2008 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2009 if (read (file->handle, ztk->input, count) != count)
2011 Con_Printf ("FS_Read: unexpected end of file\n");
2016 ztk->in_len = count;
2017 ztk->in_position += count;
2020 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2021 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2023 // Now that we are sure we have compressed data available, we need to determine
2024 // if it's better to inflate it in "file->buff" or directly in "buffer"
2026 // Inflate the data in "file->buff"
2027 if (buffersize < sizeof (file->buff) / 2)
2029 ztk->zstream.next_out = file->buff;
2030 ztk->zstream.avail_out = sizeof (file->buff);
2031 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2032 if (error != Z_OK && error != Z_STREAM_END)
2034 Con_Printf ("FS_Read: Can't inflate file\n");
2037 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2039 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2040 file->position += file->buff_len;
2042 // Copy the requested data in "buffer" (as much as we can)
2043 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2044 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2045 file->buff_ind = count;
2048 // Else, we inflate directly in "buffer"
2051 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2052 ztk->zstream.avail_out = (unsigned int)buffersize;
2053 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2054 if (error != Z_OK && error != Z_STREAM_END)
2056 Con_Printf ("FS_Read: Can't inflate file\n");
2059 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2061 // How much data did it inflate?
2062 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2063 file->position += count;
2065 // Purge cached data
2070 buffersize -= count;
2078 ====================
2081 Print a string into a file
2082 ====================
2084 int FS_Print (qfile_t* file, const char *msg)
2086 return (int)FS_Write (file, msg, strlen (msg));
2090 ====================
2093 Print a string into a file
2094 ====================
2096 int FS_Printf(qfile_t* file, const char* format, ...)
2101 va_start (args, format);
2102 result = FS_VPrintf (file, format, args);
2110 ====================
2113 Print a string into a file
2114 ====================
2116 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2119 fs_offset_t buff_size = MAX_INPUTLINE;
2124 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2125 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2126 if (len >= 0 && len < buff_size)
2128 Mem_Free (tempbuff);
2132 len = write (file->handle, tempbuff, len);
2133 Mem_Free (tempbuff);
2140 ====================
2143 Get the next character of a file
2144 ====================
2146 int FS_Getc (qfile_t* file)
2150 if (FS_Read (file, &c, 1) != 1)
2158 ====================
2161 Put a character back into the read buffer (only supports one character!)
2162 ====================
2164 int FS_UnGetc (qfile_t* file, unsigned char c)
2166 // If there's already a character waiting to be read
2167 if (file->ungetc != EOF)
2176 ====================
2179 Move the position index in a file
2180 ====================
2182 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2185 unsigned char* buffer;
2186 fs_offset_t buffersize;
2188 // Compute the file offset
2192 offset += file->position - file->buff_len + file->buff_ind;
2199 offset += file->real_length;
2205 if (offset < 0 || offset > file->real_length)
2208 // If we have the data in our read buffer, we don't need to actually seek
2209 if (file->position - file->buff_len <= offset && offset <= file->position)
2211 file->buff_ind = offset + file->buff_len - file->position;
2215 // Purge cached data
2218 // Unpacked or uncompressed files can seek directly
2219 if (! (file->flags & QFILE_FLAG_DEFLATED))
2221 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2223 file->position = offset;
2227 // Seeking in compressed files is more a hack than anything else,
2228 // but we need to support it, so here we go.
2231 // If we have to go back in the file, we need to restart from the beginning
2232 if (offset <= file->position)
2236 ztk->in_position = 0;
2238 lseek (file->handle, file->offset, SEEK_SET);
2240 // Reset the Zlib stream
2241 ztk->zstream.next_in = ztk->input;
2242 ztk->zstream.avail_in = 0;
2243 qz_inflateReset (&ztk->zstream);
2246 // We need a big buffer to force inflating into it directly
2247 buffersize = 2 * sizeof (file->buff);
2248 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2250 // Skip all data until we reach the requested offset
2251 while (offset > file->position)
2253 fs_offset_t diff = offset - file->position;
2254 fs_offset_t count, len;
2256 count = (diff > buffersize) ? buffersize : diff;
2257 len = FS_Read (file, buffer, count);
2271 ====================
2274 Give the current position in a file
2275 ====================
2277 fs_offset_t FS_Tell (qfile_t* file)
2279 return file->position - file->buff_len + file->buff_ind;
2284 ====================
2287 Give the total size of a file
2288 ====================
2290 fs_offset_t FS_FileSize (qfile_t* file)
2292 return file->real_length;
2297 ====================
2300 Erases any buffered input or output data
2301 ====================
2303 void FS_Purge (qfile_t* file)
2315 Filename are relative to the quake directory.
2316 Always appends a 0 byte.
2319 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2322 unsigned char *buf = NULL;
2323 fs_offset_t filesize = 0;
2325 file = FS_Open (path, "rb", quiet, false);
2328 filesize = file->real_length;
2329 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2330 buf[filesize] = '\0';
2331 FS_Read (file, buf, filesize);
2333 if (developer_loadfile.integer)
2334 Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2337 if (filesizepointer)
2338 *filesizepointer = filesize;
2347 The filename will be prefixed by the current game directory
2350 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2354 file = FS_Open (filename, "wb", false, false);
2357 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2361 Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2362 FS_Write (file, data, len);
2369 =============================================================================
2371 OTHERS PUBLIC FUNCTIONS
2373 =============================================================================
2381 void FS_StripExtension (const char *in, char *out, size_t size_out)
2389 while ((currentchar = *in) && size_out > 1)
2391 if (currentchar == '.')
2393 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2395 *out++ = currentchar;
2411 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2415 // if path doesn't have a .EXT, append extension
2416 // (extension should include the .)
2417 src = path + strlen(path) - 1;
2419 while (*src != '/' && src != path)
2422 return; // it has an extension
2426 strlcat (path, extension, size_path);
2434 Look for a file in the packages and in the filesystem
2437 int FS_FileType (const char *filename)
2439 searchpath_t *search;
2440 char fullpath[MAX_QPATH];
2442 search = FS_FindFile (filename, NULL, true);
2444 return FS_FILETYPE_NONE;
2447 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2449 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2450 return FS_SysFileType(fullpath);
2458 Look for a file in the packages and in the filesystem
2461 qboolean FS_FileExists (const char *filename)
2463 return (FS_FindFile (filename, NULL, true) != NULL);
2471 Look for a file in the filesystem only
2474 int FS_SysFileType (const char *path)
2477 DWORD result = GetFileAttributes(path);
2479 if(result == INVALID_FILE_ATTRIBUTES)
2480 return FS_FILETYPE_NONE;
2482 if(result & FILE_ATTRIBUTE_DIRECTORY)
2483 return FS_FILETYPE_DIRECTORY;
2485 return FS_FILETYPE_FILE;
2489 if (stat (path,&buf) == -1)
2490 return FS_FILETYPE_NONE;
2492 if(S_ISDIR(buf.st_mode))
2493 return FS_FILETYPE_DIRECTORY;
2495 return FS_FILETYPE_FILE;
2499 qboolean FS_SysFileExists (const char *path)
2501 return FS_SysFileType (path) != FS_FILETYPE_NONE;
2504 void FS_mkdir (const char *path)
2517 Allocate and fill a search structure with information on matching filenames.
2520 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2523 searchpath_t *searchpath;
2525 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2526 stringlist_t resultlist;
2527 stringlist_t dirlist;
2528 const char *slash, *backslash, *colon, *separator;
2530 char temp[MAX_OSPATH];
2532 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2537 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2541 stringlistinit(&resultlist);
2542 stringlistinit(&dirlist);
2544 slash = strrchr(pattern, '/');
2545 backslash = strrchr(pattern, '\\');
2546 colon = strrchr(pattern, ':');
2547 separator = max(slash, backslash);
2548 separator = max(separator, colon);
2549 basepathlength = separator ? (separator + 1 - pattern) : 0;
2550 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2552 memcpy(basepath, pattern, basepathlength);
2553 basepath[basepathlength] = 0;
2555 // search through the path, one element at a time
2556 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2558 // is the element a pak file?
2559 if (searchpath->pack)
2561 // look through all the pak file elements
2562 pak = searchpath->pack;
2563 for (i = 0;i < pak->numfiles;i++)
2565 strlcpy(temp, pak->files[i].name, sizeof(temp));
2568 if (matchpattern(temp, (char *)pattern, true))
2570 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2571 if (!strcmp(resultlist.strings[resultlistindex], temp))
2573 if (resultlistindex == resultlist.numstrings)
2575 stringlistappend(&resultlist, temp);
2576 if (!quiet && developer_loading.integer)
2577 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
2580 // strip off one path element at a time until empty
2581 // this way directories are added to the listing if they match the pattern
2582 slash = strrchr(temp, '/');
2583 backslash = strrchr(temp, '\\');
2584 colon = strrchr(temp, ':');
2586 if (separator < slash)
2588 if (separator < backslash)
2589 separator = backslash;
2590 if (separator < colon)
2592 *((char *)separator) = 0;
2598 stringlist_t matchedSet, foundSet;
2599 const char *start = pattern;
2601 stringlistinit(&matchedSet);
2602 stringlistinit(&foundSet);
2603 // add a first entry to the set
2604 stringlistappend(&matchedSet, "");
2605 // iterate through pattern's path
2608 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
2609 char subpath[MAX_OSPATH];
2610 char subpattern[MAX_OSPATH];
2612 // find the next wildcard
2613 wildcard = strchr(start, '?');
2614 asterisk = strchr(start, '*');
2615 if (asterisk && (!wildcard || asterisk < wildcard))
2617 wildcard = asterisk;
2622 nextseparator = strchr( wildcard, '/' );
2626 nextseparator = NULL;
2629 if( !nextseparator ) {
2630 nextseparator = start + strlen( start );
2633 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
2634 // copy everything up except nextseperator
2635 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
2636 // find the last '/' before the wildcard
2637 prevseparator = strrchr( subpattern, '/' ) + 1;
2640 prevseparator = subpattern;
2642 // copy everything from start to the previous including the '/' (before the wildcard)
2643 // everything up to start is already included in the path of matchedSet's entries
2644 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
2646 // for each entry in matchedSet try to open the subdirectories specified in subpath
2647 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
2648 strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
2649 strlcat( temp, subpath, sizeof(temp) );
2650 listdirectory( &foundSet, searchpath->filename, temp );
2652 if( dirlistindex == 0 ) {
2655 // reset the current result set
2656 stringlistfreecontents( &matchedSet );
2657 // match against the pattern
2658 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
2659 const char *direntry = foundSet.strings[ dirlistindex ];
2660 if (matchpattern(direntry, subpattern, true)) {
2661 stringlistappend( &matchedSet, direntry );
2664 stringlistfreecontents( &foundSet );
2666 start = nextseparator;
2669 for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
2671 const char *temp = matchedSet.strings[dirlistindex];
2672 if (matchpattern(temp, (char *)pattern, true))
2674 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2675 if (!strcmp(resultlist.strings[resultlistindex], temp))
2677 if (resultlistindex == resultlist.numstrings)
2679 stringlistappend(&resultlist, temp);
2680 if (!quiet && developer_loading.integer)
2681 Con_Printf("SearchDirFile: %s\n", temp);
2685 stringlistfreecontents( &matchedSet );
2689 if (resultlist.numstrings)
2691 stringlistsort(&resultlist);
2692 numfiles = resultlist.numstrings;
2694 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2695 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2696 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2697 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2698 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2699 search->numfilenames = (int)numfiles;
2702 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2705 search->filenames[numfiles] = search->filenamesbuffer + numchars;
2706 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2707 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2709 numchars += (int)textlen;
2712 stringlistfreecontents(&resultlist);
2718 void FS_FreeSearch(fssearch_t *search)
2723 extern int con_linewidth;
2724 int FS_ListDirectory(const char *pattern, int oneperline)
2733 char linebuf[MAX_INPUTLINE];
2735 search = FS_Search(pattern, true, true);
2738 numfiles = search->numfilenames;
2741 // FIXME: the names could be added to one column list and then
2742 // gradually shifted into the next column if they fit, and then the
2743 // next to make a compact variable width listing but it's a lot more
2745 // find width for columns
2747 for (i = 0;i < numfiles;i++)
2749 l = (int)strlen(search->filenames[i]);
2750 if (columnwidth < l)
2753 // count the spacing character
2755 // calculate number of columns
2756 numcolumns = con_linewidth / columnwidth;
2757 // don't bother with the column printing if it's only one column
2758 if (numcolumns >= 2)
2760 numlines = (numfiles + numcolumns - 1) / numcolumns;
2761 for (i = 0;i < numlines;i++)
2764 for (k = 0;k < numcolumns;k++)
2766 l = i * numcolumns + k;
2769 name = search->filenames[l];
2770 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2771 linebuf[linebufpos++] = name[j];
2772 // space out name unless it's the last on the line
2773 if (k + 1 < numcolumns && l + 1 < numfiles)
2774 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2775 linebuf[linebufpos++] = ' ';
2778 linebuf[linebufpos] = 0;
2779 Con_Printf("%s\n", linebuf);
2786 for (i = 0;i < numfiles;i++)
2787 Con_Printf("%s\n", search->filenames[i]);
2788 FS_FreeSearch(search);
2789 return (int)numfiles;
2792 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2794 const char *pattern;
2797 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2800 if (Cmd_Argc() == 2)
2801 pattern = Cmd_Argv(1);
2804 if (!FS_ListDirectory(pattern, oneperline))
2805 Con_Print("No files found.\n");
2810 FS_ListDirectoryCmd("dir", true);
2815 FS_ListDirectoryCmd("ls", false);
2818 const char *FS_WhichPack(const char *filename)
2821 searchpath_t *sp = FS_FindFile(filename, &index, true);
2823 return sp->pack->filename;
2829 ====================
2830 FS_IsRegisteredQuakePack
2832 Look for a proof of purchase file file in the requested package
2834 If it is found, this file should NOT be downloaded.
2835 ====================
2837 qboolean FS_IsRegisteredQuakePack(const char *name)
2839 searchpath_t *search;
2842 // search through the path, one element at a time
2843 for (search = fs_searchpaths;search;search = search->next)
2845 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2847 int (*strcmp_funct) (const char* str1, const char* str2);
2848 int left, right, middle;
2851 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2853 // Look for the file (binary search)
2855 right = pak->numfiles - 1;
2856 while (left <= right)
2860 middle = (left + right) / 2;
2861 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2867 // If we're too far in the list
2874 // we found the requested pack but it is not registered quake
2882 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2885 unsigned char *filedata;
2886 fs_offset_t filesize;
2887 if (filesizepointer)
2888 *filesizepointer = 0;
2889 if (!filename || !*filename)
2891 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2894 if (filesizepointer)
2895 *filesizepointer = filesize;
2896 crc = CRC_Block(filedata, filesize);