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
25 // on UNIX platforms we need to define this so that video saving does not cause a SIGFSZ (file size) signal when a video clip exceeds 2GB
26 #define _FILE_OFFSET_BITS 64
38 # include <sys/stat.h>
45 // Win32 requires us to add O_BINARY, but the other OSes don't have it
50 // In case the system doesn't support the O_NONBLOCK flag
58 All of Quake's data access is through a hierchal file system, but the contents
59 of the file system can be transparently merged from several sources.
61 The "base directory" is the path to the directory holding the quake.exe and
62 all game directories. The sys_* files pass this to host_init in
63 quakeparms_t->basedir. This can be overridden with the "-basedir" command
64 line parm to allow code debugging in a different directory. The base
65 directory is only used during filesystem initialization.
67 The "game directory" is the first tree on the search path and directory that
68 all generated files (savegames, screenshots, demos, config files) will be
69 saved to. This can be overridden with the "-game" command line parameter.
70 The game directory can never be changed while quake is executing. This is a
71 precaution against having a malicious server instruct clients to write files
72 over areas they shouldn't.
78 =============================================================================
82 =============================================================================
85 // Magic numbers of a ZIP file (big-endian format)
86 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
87 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
88 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
90 // Other constants for ZIP files
91 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
92 #define ZIP_END_CDIR_SIZE 22
93 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
94 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
96 // Zlib constants (from zlib.h)
97 #define Z_SYNC_FLUSH 2
100 #define Z_STREAM_END 1
101 #define ZLIB_VERSION "1.2.3"
103 // Uncomment the following line if the zlib DLL you have still uses
104 // the 1.1.x series calling convention on Win32 (WINAPI)
105 //#define ZLIB_USES_WINAPI
109 =============================================================================
113 =============================================================================
116 // Zlib stream (from zlib.h)
117 // Warning: some pointers we don't use directly have
118 // been cast to "void*" for a matter of simplicity
121 unsigned char *next_in; // next input byte
122 unsigned int avail_in; // number of bytes available at next_in
123 unsigned long total_in; // total nb of input bytes read so far
125 unsigned char *next_out; // next output byte should be put there
126 unsigned int avail_out; // remaining free space at next_out
127 unsigned long total_out; // total nb of bytes output so far
129 char *msg; // last error message, NULL if no error
130 void *state; // not visible by applications
132 void *zalloc; // used to allocate the internal state
133 void *zfree; // used to free the internal state
134 void *opaque; // private data object passed to zalloc and zfree
136 int data_type; // best guess about the data type: ascii or binary
137 unsigned long adler; // adler32 value of the uncompressed data
138 unsigned long reserved; // reserved for future use
142 // inside a package (PAK or PK3)
143 #define QFILE_FLAG_PACKED (1 << 0)
144 // file is compressed using the deflate algorithm (PK3 only)
145 #define QFILE_FLAG_DEFLATED (1 << 1)
147 #define FILE_BUFF_SIZE 2048
151 size_t comp_length; // length of the compressed file
152 size_t in_ind, in_len; // input buffer current index and length
153 size_t in_position; // position in the compressed file
154 unsigned char input [FILE_BUFF_SIZE];
160 int handle; // file descriptor
161 fs_offset_t real_length; // uncompressed file size (for files opened in "read" mode)
162 fs_offset_t position; // current position in the file
163 fs_offset_t offset; // offset into the package (0 if external file)
164 int ungetc; // single stored character from ungetc, cleared to EOF when read
167 fs_offset_t buff_ind, buff_len; // buffer current index and length
168 unsigned char buff [FILE_BUFF_SIZE];
175 // ------ PK3 files on disk ------ //
177 // You can get the complete ZIP format description from PKWARE website
179 typedef struct pk3_endOfCentralDir_s
181 unsigned int signature;
182 unsigned short disknum;
183 unsigned short cdir_disknum; // number of the disk with the start of the central directory
184 unsigned short localentries; // number of entries in the central directory on this disk
185 unsigned short nbentries; // total number of entries in the central directory on this disk
186 unsigned int cdir_size; // size of the central directory
187 unsigned int cdir_offset; // with respect to the starting disk number
188 unsigned short comment_size;
189 } pk3_endOfCentralDir_t;
192 // ------ PAK files on disk ------ //
193 typedef struct dpackfile_s
196 int filepos, filelen;
199 typedef struct dpackheader_s
207 // Packages in memory
208 // the offset in packfile_t is the true contents offset
209 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
210 // file compressed using the deflate algorithm
211 #define PACKFILE_FLAG_DEFLATED (1 << 1)
213 typedef struct packfile_s
215 char name [MAX_QPATH];
218 fs_offset_t packsize; // size in the package
219 fs_offset_t realsize; // real file size (uncompressed)
222 typedef struct pack_s
224 char filename [MAX_OSPATH];
226 int ignorecase; // PK3 ignores case
232 // Search paths for files (including packages)
233 typedef struct searchpath_s
235 // only one of filename / pack will be used
236 char filename[MAX_OSPATH];
238 struct searchpath_s *next;
243 =============================================================================
247 =============================================================================
253 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
254 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
255 fs_offset_t offset, fs_offset_t packsize,
256 fs_offset_t realsize, int flags);
260 =============================================================================
264 =============================================================================
267 mempool_t *fs_mempool;
269 searchpath_t *fs_searchpaths = NULL;
271 #define MAX_FILES_IN_PACK 65536
273 char fs_gamedir[MAX_OSPATH];
274 char fs_basedir[MAX_OSPATH];
276 // list of active game directories (empty if not running a mod)
277 int fs_numgamedirs = 0;
278 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
280 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)"};
281 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"};
285 =============================================================================
287 PRIVATE FUNCTIONS - PK3 HANDLING
289 =============================================================================
292 // Functions exported from zlib
293 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
294 # define ZEXPORT WINAPI
299 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
300 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
301 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
302 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
304 #define qz_inflateInit2(strm, windowBits) \
305 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
307 static dllfunction_t zlibfuncs[] =
309 {"inflate", (void **) &qz_inflate},
310 {"inflateEnd", (void **) &qz_inflateEnd},
311 {"inflateInit2_", (void **) &qz_inflateInit2_},
312 {"inflateReset", (void **) &qz_inflateReset},
316 // Handle for Zlib DLL
317 static dllhandle_t zlib_dll = NULL;
327 void PK3_CloseLibrary (void)
329 Sys_UnloadLibrary (&zlib_dll);
337 Try to load the Zlib DLL
340 qboolean PK3_OpenLibrary (void)
342 const char* dllnames [] =
347 # ifdef ZLIB_USES_WINAPI
353 #elif defined(MACOSX)
367 if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
369 Con_Printf ("Compressed files support disabled\n");
373 Con_Printf ("Compressed files support enabled\n");
380 PK3_GetEndOfCentralDir
382 Extract the end of the central directory from a PK3 package
385 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
387 fs_offset_t filesize, maxsize;
388 unsigned char *buffer, *ptr;
391 // Get the package size
392 filesize = lseek (packhandle, 0, SEEK_END);
393 if (filesize < ZIP_END_CDIR_SIZE)
396 // Load the end of the file in memory
397 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
400 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
401 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
402 lseek (packhandle, filesize - maxsize, SEEK_SET);
403 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
409 // Look for the end of central dir signature around the end of the file
410 maxsize -= ZIP_END_CDIR_SIZE;
411 ptr = &buffer[maxsize];
413 while (BuffBigLong (ptr) != ZIP_END_HEADER)
425 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
426 eocd->signature = LittleLong (eocd->signature);
427 eocd->disknum = LittleShort (eocd->disknum);
428 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
429 eocd->localentries = LittleShort (eocd->localentries);
430 eocd->nbentries = LittleShort (eocd->nbentries);
431 eocd->cdir_size = LittleLong (eocd->cdir_size);
432 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
433 eocd->comment_size = LittleShort (eocd->comment_size);
445 Extract the file list from a PK3 file
448 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
450 unsigned char *central_dir, *ptr;
452 fs_offset_t remaining;
454 // Load the central directory in memory
455 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
456 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
457 read (pack->handle, central_dir, eocd->cdir_size);
459 // Extract the files properties
460 // The parsing is done "by hand" because some fields have variable sizes and
461 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
462 remaining = eocd->cdir_size;
465 for (ind = 0; ind < eocd->nbentries; ind++)
467 fs_offset_t namesize, count;
469 // Checking the remaining size
470 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
472 Mem_Free (central_dir);
475 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
478 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
480 Mem_Free (central_dir);
484 namesize = BuffLittleShort (&ptr[28]); // filename length
486 // Check encryption, compression, and attributes
487 // 1st uint8 : general purpose bit flag
488 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
489 // 2nd uint8 : external file attributes
490 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
491 if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
493 // Still enough bytes for the name?
494 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
496 Mem_Free (central_dir);
500 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
501 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
503 char filename [sizeof (pack->files[0].name)];
504 fs_offset_t offset, packsize, realsize;
507 // Extract the name (strip it if necessary)
508 namesize = min(namesize, (int)sizeof (filename) - 1);
509 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
510 filename[namesize] = '\0';
512 if (BuffLittleShort (&ptr[10]))
513 flags = PACKFILE_FLAG_DEFLATED;
516 offset = BuffLittleLong (&ptr[42]);
517 packsize = BuffLittleLong (&ptr[20]);
518 realsize = BuffLittleLong (&ptr[24]);
519 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
523 // Skip the name, additionnal field, and comment
524 // 1er uint16 : extra field length
525 // 2eme uint16 : file comment length
526 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
527 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
531 // If the package is empty, central_dir is NULL here
532 if (central_dir != NULL)
533 Mem_Free (central_dir);
534 return pack->numfiles;
542 Create a package entry associated with a PK3 file
545 pack_t *FS_LoadPackPK3 (const char *packfile)
548 pk3_endOfCentralDir_t eocd;
552 packhandle = open (packfile, O_RDONLY | O_BINARY);
556 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
558 Con_Printf ("%s is not a PK3 file\n", packfile);
563 // Multi-volume ZIP archives are NOT allowed
564 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
566 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
571 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
572 // since eocd.nbentries is an unsigned 16 bits integer
573 #if MAX_FILES_IN_PACK < 65535
574 if (eocd.nbentries > MAX_FILES_IN_PACK)
576 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
582 // Create a package structure in memory
583 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
584 pack->ignorecase = true; // PK3 ignores case
585 strlcpy (pack->filename, packfile, sizeof (pack->filename));
586 pack->handle = packhandle;
587 pack->numfiles = eocd.nbentries;
588 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
590 real_nb_files = PK3_BuildFileList (pack, &eocd);
591 if (real_nb_files < 0)
593 Con_Printf ("%s is not a valid PK3 file\n", packfile);
599 Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
606 PK3_GetTrueFileOffset
608 Find where the true file data offset is
611 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
613 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
617 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
620 // Load the local file description
621 lseek (pack->handle, pfile->offset, SEEK_SET);
622 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
623 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
625 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
629 // Skip name and extra field
630 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
632 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
638 =============================================================================
640 OTHER PRIVATE FUNCTIONS
642 =============================================================================
650 Add a file to the list of files contained into a package
653 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
654 fs_offset_t offset, fs_offset_t packsize,
655 fs_offset_t realsize, int flags)
657 int (*strcmp_funct) (const char* str1, const char* str2);
658 int left, right, middle;
661 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
663 // Look for the slot we should put that file into (binary search)
665 right = pack->numfiles - 1;
666 while (left <= right)
670 middle = (left + right) / 2;
671 diff = strcmp_funct (pack->files[middle].name, name);
673 // If we found the file, there's a problem
675 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
677 // If we're too far in the list
684 // We have to move the right of the list by one slot to free the one we need
685 pfile = &pack->files[left];
686 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
689 strlcpy (pfile->name, name, sizeof (pfile->name));
690 pfile->offset = offset;
691 pfile->packsize = packsize;
692 pfile->realsize = realsize;
693 pfile->flags = flags;
703 Only used for FS_Open.
706 void FS_CreatePath (char *path)
710 for (ofs = path+1 ; *ofs ; ofs++)
712 if (*ofs == '/' || *ofs == '\\')
714 // create the directory
730 void FS_Path_f (void)
734 Con_Print("Current search path:\n");
735 for (s=fs_searchpaths ; s ; s=s->next)
738 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
740 Con_Printf("%s\n", s->filename);
749 Takes an explicit (not game tree related) path to a pak file.
751 Loads the header and directory, adding the files at the beginning
752 of the list so they override previous pack files.
755 pack_t *FS_LoadPackPAK (const char *packfile)
757 dpackheader_t header;
763 packhandle = open (packfile, O_RDONLY | O_BINARY);
766 read (packhandle, (void *)&header, sizeof(header));
767 if (memcmp(header.id, "PACK", 4))
769 Con_Printf ("%s is not a packfile\n", packfile);
773 header.dirofs = LittleLong (header.dirofs);
774 header.dirlen = LittleLong (header.dirlen);
776 if (header.dirlen % sizeof(dpackfile_t))
778 Con_Printf ("%s has an invalid directory size\n", packfile);
783 numpackfiles = header.dirlen / sizeof(dpackfile_t);
785 if (numpackfiles > MAX_FILES_IN_PACK)
787 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
792 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
793 lseek (packhandle, header.dirofs, SEEK_SET);
794 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
796 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
802 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
803 pack->ignorecase = false; // PAK is case sensitive
804 strlcpy (pack->filename, packfile, sizeof (pack->filename));
805 pack->handle = packhandle;
807 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
809 // parse the directory
810 for (i = 0;i < numpackfiles;i++)
812 fs_offset_t offset = LittleLong (info[i].filepos);
813 fs_offset_t size = LittleLong (info[i].filelen);
815 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
820 Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
828 Adds the given pack to the search path.
829 The pack type is autodetected by the file extension.
831 Returns true if the file was successfully added to the
832 search path or if it was already included.
834 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
838 static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
840 searchpath_t *search;
842 const char *ext = FS_FileExtension(pakfile);
844 for(search = fs_searchpaths; search; search = search->next)
846 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
849 *already_loaded = true;
850 return true; // already loaded
855 *already_loaded = false;
857 if(!strcasecmp(ext, "pak"))
858 pak = FS_LoadPackPAK (pakfile);
859 else if(!strcasecmp(ext, "pk3"))
860 pak = FS_LoadPackPK3 (pakfile);
862 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
868 // find the first item whose next one is a pack or NULL
869 searchpath_t *insertion_point = 0;
870 if(fs_searchpaths && !fs_searchpaths->pack)
872 insertion_point = fs_searchpaths;
875 if(!insertion_point->next)
877 if(insertion_point->next->pack)
879 insertion_point = insertion_point->next;
882 // If insertion_point is NULL, this means that either there is no
883 // item in the list yet, or that the very first item is a pack. In
884 // that case, we want to insert at the beginning...
887 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
889 search->next = fs_searchpaths;
890 fs_searchpaths = search;
893 // otherwise we want to append directly after insertion_point.
895 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
897 search->next = insertion_point->next;
898 insertion_point->next = search;
903 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
905 search->next = fs_searchpaths;
906 fs_searchpaths = search;
912 Con_Printf("unable to load pak \"%s\"\n", pakfile);
922 Adds the given pack to the search path and searches for it in the game path.
923 The pack type is autodetected by the file extension.
925 Returns true if the file was successfully added to the
926 search path or if it was already included.
928 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
932 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
934 char fullpath[MAX_QPATH];
936 searchpath_t *search;
939 *already_loaded = false;
941 // then find the real name...
942 search = FS_FindFile(pakfile, &index, true);
943 if(!search || search->pack)
945 Con_Printf("could not find pak \"%s\"\n", pakfile);
949 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
951 return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
959 Sets fs_gamedir, adds the directory to the head of the path,
960 then loads and adds pak1.pak pak2.pak ...
963 void FS_AddGameDirectory (const char *dir)
967 searchpath_t *search;
968 char pakfile[MAX_OSPATH];
970 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
972 stringlistinit(&list);
973 listdirectory(&list, dir);
974 stringlistsort(&list);
976 // add any PAK package in the directory
977 for (i = 0;i < list.numstrings;i++)
979 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
981 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
982 FS_AddPack_Fullpath(pakfile, NULL, false);
986 // add any PK3 package in the directory
987 for (i = 0;i < list.numstrings;i++)
989 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
991 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
992 FS_AddPack_Fullpath(pakfile, NULL, false);
996 stringlistfreecontents(&list);
998 // Add the directory to the search path
999 // (unpacked files have the priority over packed files)
1000 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1001 strlcpy (search->filename, dir, sizeof (search->filename));
1002 search->next = fs_searchpaths;
1003 fs_searchpaths = search;
1012 void FS_AddGameHierarchy (const char *dir)
1015 const char *homedir;
1018 // Add the common game directory
1019 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1022 // Add the personal game directory
1023 homedir = getenv ("HOME");
1024 if (homedir != NULL && homedir[0] != '\0')
1025 FS_AddGameDirectory (va("%s/.%s/%s/", homedir, gameuserdirname, dir));
1035 const char *FS_FileExtension (const char *in)
1037 const char *separator, *backslash, *colon, *dot;
1039 separator = strrchr(in, '/');
1040 backslash = strrchr(in, '\\');
1041 if (!separator || separator < backslash)
1042 separator = backslash;
1043 colon = strrchr(in, ':');
1044 if (!separator || separator < colon)
1047 dot = strrchr(in, '.');
1048 if (dot == NULL || (separator && (dot < separator)))
1060 const char *FS_FileWithoutPath (const char *in)
1062 const char *separator, *backslash, *colon;
1064 separator = strrchr(in, '/');
1065 backslash = strrchr(in, '\\');
1066 if (!separator || separator < backslash)
1067 separator = backslash;
1068 colon = strrchr(in, ':');
1069 if (!separator || separator < colon)
1071 return separator ? separator + 1 : in;
1080 void FS_ClearSearchPath (void)
1082 // unload all packs and directory information, close all pack files
1083 // (if a qfile is still reading a pack it won't be harmed because it used
1084 // dup() to get its own handle already)
1085 while (fs_searchpaths)
1087 searchpath_t *search = fs_searchpaths;
1088 fs_searchpaths = search->next;
1092 close(search->pack->handle);
1093 // free any memory associated with it
1094 if (search->pack->files)
1095 Mem_Free(search->pack->files);
1096 Mem_Free(search->pack);
1108 void FS_Rescan (void)
1111 qboolean fs_modified = false;
1113 FS_ClearSearchPath();
1115 // add the game-specific paths
1116 // gamedirname1 (typically id1)
1117 FS_AddGameHierarchy (gamedirname1);
1118 // update the com_modname (used for server info)
1119 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1121 // add the game-specific path, if any
1122 // (only used for mission packs and the like, which should set fs_modified)
1126 FS_AddGameHierarchy (gamedirname2);
1130 // Adds basedir/gamedir as an override game
1131 // LordHavoc: now supports multiple -game directories
1132 // set the com_modname (reported in server info)
1133 for (i = 0;i < fs_numgamedirs;i++)
1136 FS_AddGameHierarchy (fs_gamedirs[i]);
1137 // update the com_modname (used server info)
1138 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1141 // set the default screenshot name to either the mod name or the
1142 // gamemode screenshot name
1143 if (strcmp(com_modname, gamedirname1))
1144 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1146 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1148 // If "-condebug" is in the command line, remove the previous log file
1149 if (COM_CheckParm ("-condebug") != 0)
1150 unlink (va("%s/qconsole.log", fs_gamedir));
1152 // look for the pop.lmp file and set registered to true if it is found
1153 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1156 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1158 Con_Print("Playing shareware version.\n");
1162 Cvar_Set ("registered", "1");
1163 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1164 Con_Print("Playing registered version.\n");
1167 // unload all wads so that future queries will return the new data
1171 void FS_Rescan_f(void)
1181 extern void Host_SaveConfig_f (void);
1182 extern void Host_LoadConfig_f (void);
1183 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1187 if (fs_numgamedirs == numgamedirs)
1189 for (i = 0;i < numgamedirs;i++)
1190 if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1192 if (i == numgamedirs)
1193 return true; // already using this set of gamedirs, do nothing
1196 if (numgamedirs > MAX_GAMEDIRS)
1199 Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1200 return false; // too many gamedirs
1203 for (i = 0;i < numgamedirs;i++)
1205 // if string is nasty, reject it
1206 if(FS_CheckNastyPath(gamedirs[i], true))
1209 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1210 return false; // nasty gamedirs
1214 for (i = 0;i < numgamedirs;i++)
1216 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1219 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1220 return false; // missing gamedirs
1224 // halt demo playback to close the file
1227 Host_SaveConfig_f();
1229 fs_numgamedirs = numgamedirs;
1230 for (i = 0;i < fs_numgamedirs;i++)
1231 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1233 // reinitialize filesystem to detect the new paks
1236 // exec the new config
1237 Host_LoadConfig_f();
1239 // unload all sounds so they will be reloaded from the new files as needed
1240 S_UnloadAllSounds_f();
1242 // reinitialize renderer (this reloads hud/console background/etc)
1243 R_Modules_Restart();
1253 void FS_GameDir_f (void)
1257 char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1261 Con_Printf("gamedirs active:");
1262 for (i = 0;i < fs_numgamedirs;i++)
1263 Con_Printf(" %s", fs_gamedirs[i]);
1268 numgamedirs = Cmd_Argc() - 1;
1269 if (numgamedirs > MAX_GAMEDIRS)
1271 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1275 for (i = 0;i < numgamedirs;i++)
1276 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1278 if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1280 // actually, changing during game would work fine, but would be stupid
1281 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1285 FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1294 qboolean FS_CheckGameDir(const char *gamedir)
1298 stringlistinit(&list);
1299 listdirectory(&list, va("%s%s/", fs_basedir, gamedir));
1300 success = list.numstrings > 0;
1301 stringlistfreecontents(&list);
1315 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1317 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1319 // If the base directory is explicitly defined by the compilation process
1320 #ifdef DP_FS_BASEDIR
1321 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1323 strlcpy(fs_basedir, "", sizeof(fs_basedir));
1326 // FIXME: is there a better way to find the directory outside the .app?
1327 if (strstr(com_argv[0], ".app/"))
1331 split = strstr(com_argv[0], ".app/");
1332 while (split > com_argv[0] && *split != '/')
1334 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1335 fs_basedir[split - com_argv[0]] = 0;
1343 // Overrides the system supplied base directory (under GAMENAME)
1344 // 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)
1345 i = COM_CheckParm ("-basedir");
1346 if (i && i < com_argc-1)
1348 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1349 i = (int)strlen (fs_basedir);
1350 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1351 fs_basedir[i-1] = 0;
1354 // add a path separator to the end of the basedir if it lacks one
1355 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1356 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1358 if (!FS_CheckGameDir(gamedirname1))
1359 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1361 if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1362 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1365 // Adds basedir/gamedir as an override game
1366 // LordHavoc: now supports multiple -game directories
1367 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1371 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1374 if (FS_CheckNastyPath(com_argv[i], true))
1375 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1376 if (!FS_CheckGameDir(com_argv[i]))
1377 Sys_Error("-game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1378 // add the gamedir to the list of active gamedirs
1379 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1384 // generate the searchpath
1388 void FS_Init_Commands(void)
1390 Cvar_RegisterVariable (&scr_screenshot_name);
1391 Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1393 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1394 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1395 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1396 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1397 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1405 void FS_Shutdown (void)
1407 // close all pack files and such
1408 // (hopefully there aren't any other open files, but they'll be cleaned up
1409 // by the OS anyway)
1410 FS_ClearSearchPath();
1411 Mem_FreePool (&fs_mempool);
1415 ====================
1418 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1419 ====================
1421 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1427 // Parse the mode string
1436 opt = O_CREAT | O_TRUNC;
1440 opt = O_CREAT | O_APPEND;
1443 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1446 for (ind = 1; mode[ind] != '\0'; ind++)
1457 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1458 filepath, mode, mode[ind]);
1465 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1466 memset (file, 0, sizeof (*file));
1469 file->handle = open (filepath, mod | opt, 0666);
1470 if (file->handle < 0)
1476 file->real_length = lseek (file->handle, 0, SEEK_END);
1478 // For files opened in append mode, we start at the end of the file
1480 file->position = file->real_length;
1482 lseek (file->handle, 0, SEEK_SET);
1492 Open a packed file using its package file descriptor
1495 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1501 pfile = &pack->files[pack_ind];
1503 // If we don't have the true offset, get it now
1504 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1505 if (!PK3_GetTrueFileOffset (pfile, pack))
1508 // No Zlib DLL = no compressed files
1509 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1511 Con_Printf("WARNING: can't open the compressed file %s\n"
1512 "You need the Zlib DLL to use compressed files\n",
1517 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1518 // the dup() call to avoid having to close the dup_handle on error here
1519 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1521 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1522 pfile->name, pack->filename, (int) pfile->offset);
1526 dup_handle = dup (pack->handle);
1529 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1533 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1534 memset (file, 0, sizeof (*file));
1535 file->handle = dup_handle;
1536 file->flags = QFILE_FLAG_PACKED;
1537 file->real_length = pfile->realsize;
1538 file->offset = pfile->offset;
1542 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1546 file->flags |= QFILE_FLAG_DEFLATED;
1548 // We need some more variables
1549 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1551 ztk->comp_length = pfile->packsize;
1553 // Initialize zlib stream
1554 ztk->zstream.next_in = ztk->input;
1555 ztk->zstream.avail_in = 0;
1557 /* From Zlib's "unzip.c":
1559 * windowBits is passed < 0 to tell that there is no zlib header.
1560 * Note that in this case inflate *requires* an extra "dummy" byte
1561 * after the compressed stream in order to complete decompression and
1562 * return Z_STREAM_END.
1563 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1564 * size of both compressed and uncompressed data
1566 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1568 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1574 ztk->zstream.next_out = file->buff;
1575 ztk->zstream.avail_out = sizeof (file->buff);
1584 ====================
1587 Return true if the path should be rejected due to one of the following:
1588 1: path elements that are non-portable
1589 2: path elements that would allow access to files outside the game directory,
1590 or are just not a good idea for a mod to be using.
1591 ====================
1593 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1595 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1599 // Windows: don't allow \ in filenames (windows-only), period.
1600 // (on Windows \ is a directory separator, but / is also supported)
1601 if (strstr(path, "\\"))
1602 return 1; // non-portable
1604 // Mac: don't allow Mac-only filenames - : is a directory separator
1605 // instead of /, but we rely on / working already, so there's no reason to
1606 // support a Mac-only path
1607 // Amiga and Windows: : tries to go to root of drive
1608 if (strstr(path, ":"))
1609 return 1; // non-portable attempt to go to root of drive
1611 // Amiga: // is parent directory
1612 if (strstr(path, "//"))
1613 return 1; // non-portable attempt to go to parent directory
1615 // all: don't allow going to parent directory (../ or /../)
1616 if (strstr(path, ".."))
1617 return 2; // attempt to go outside the game directory
1619 // Windows and UNIXes: don't allow absolute paths
1621 return 2; // attempt to go outside the game directory
1623 // 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
1624 if (strchr(path, '.'))
1628 // gamedir is entirely path elements, so simply forbid . entirely
1631 if (strchr(path, '.') < strrchr(path, '/'))
1632 return 2; // possible attempt to go outside the game directory
1635 // all: forbid trailing slash on gamedir
1636 if (isgamedir && path[strlen(path)-1] == '/')
1639 // all: forbid leading dot on any filename for any reason
1640 if (strstr(path, "/."))
1641 return 2; // attempt to go outside the game directory
1643 // after all these checks we're pretty sure it's a / separated filename
1644 // and won't do much if any harm
1650 ====================
1653 Look for a file in the packages and in the filesystem
1655 Return the searchpath where the file was found (or NULL)
1656 and the file index in the package if relevant
1657 ====================
1659 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1661 searchpath_t *search;
1664 // search through the path, one element at a time
1665 for (search = fs_searchpaths;search;search = search->next)
1667 // is the element a pak file?
1670 int (*strcmp_funct) (const char* str1, const char* str2);
1671 int left, right, middle;
1674 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1676 // Look for the file (binary search)
1678 right = pak->numfiles - 1;
1679 while (left <= right)
1683 middle = (left + right) / 2;
1684 diff = strcmp_funct (pak->files[middle].name, name);
1689 if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1691 // yes, but the first one is empty so we treat it as not being there
1692 if (!quiet && developer.integer >= 10)
1693 Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1700 if (!quiet && developer.integer >= 10)
1701 Con_Printf("FS_FindFile: %s in %s\n",
1702 pak->files[middle].name, pak->filename);
1709 // If we're too far in the list
1718 char netpath[MAX_OSPATH];
1719 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1720 if (FS_SysFileExists (netpath))
1722 if (!quiet && developer.integer >= 10)
1723 Con_Printf("FS_FindFile: %s\n", netpath);
1732 if (!quiet && developer.integer >= 10)
1733 Con_Printf("FS_FindFile: can't find %s\n", name);
1745 Look for a file in the search paths and open it in read-only mode
1748 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1750 searchpath_t *search;
1753 search = FS_FindFile (filename, &pack_ind, quiet);
1759 // Found in the filesystem?
1762 char path [MAX_OSPATH];
1763 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1764 return FS_SysOpen (path, "rb", nonblocking);
1767 // So, we found it in a package...
1768 return FS_OpenPackedFile (search->pack, pack_ind);
1773 =============================================================================
1775 MAIN PUBLIC FUNCTIONS
1777 =============================================================================
1781 ====================
1784 Open a file. The syntax is the same as fopen
1785 ====================
1787 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1789 if (FS_CheckNastyPath(filepath, false))
1791 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1795 // If the file is opened in "write", "append", or "read/write" mode
1796 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1798 char real_path [MAX_OSPATH];
1800 // Open the file on disk directly
1801 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1803 // Create directories up to the file
1804 FS_CreatePath (real_path);
1806 return FS_SysOpen (real_path, mode, nonblocking);
1808 // Else, we look at the various search paths and open the file in read-only mode
1810 return FS_OpenReadFile (filepath, quiet, nonblocking);
1815 ====================
1819 ====================
1821 int FS_Close (qfile_t* file)
1823 if (close (file->handle))
1828 qz_inflateEnd (&file->ztk->zstream);
1829 Mem_Free (file->ztk);
1838 ====================
1841 Write "datasize" bytes into a file
1842 ====================
1844 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1848 // If necessary, seek to the exact file position we're supposed to be
1849 if (file->buff_ind != file->buff_len)
1850 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1852 // Purge cached data
1855 // Write the buffer and update the position
1856 result = write (file->handle, data, (fs_offset_t)datasize);
1857 file->position = lseek (file->handle, 0, SEEK_CUR);
1858 if (file->real_length < file->position)
1859 file->real_length = file->position;
1869 ====================
1872 Read up to "buffersize" bytes from a file
1873 ====================
1875 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1877 fs_offset_t count, done;
1879 if (buffersize == 0)
1882 // Get rid of the ungetc character
1883 if (file->ungetc != EOF)
1885 ((char*)buffer)[0] = file->ungetc;
1893 // First, we copy as many bytes as we can from "buff"
1894 if (file->buff_ind < file->buff_len)
1896 count = file->buff_len - file->buff_ind;
1897 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1899 memcpy (buffer, &file->buff[file->buff_ind], count);
1900 file->buff_ind += count;
1902 buffersize -= count;
1903 if (buffersize == 0)
1907 // NOTE: at this point, the read buffer is always empty
1909 // If the file isn't compressed
1910 if (! (file->flags & QFILE_FLAG_DEFLATED))
1914 // We must take care to not read after the end of the file
1915 count = file->real_length - file->position;
1917 // If we have a lot of data to get, put them directly into "buffer"
1918 if (buffersize > sizeof (file->buff) / 2)
1920 if (count > (fs_offset_t)buffersize)
1921 count = (fs_offset_t)buffersize;
1922 lseek (file->handle, file->offset + file->position, SEEK_SET);
1923 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1927 file->position += nb;
1929 // Purge cached data
1935 if (count > (fs_offset_t)sizeof (file->buff))
1936 count = (fs_offset_t)sizeof (file->buff);
1937 lseek (file->handle, file->offset + file->position, SEEK_SET);
1938 nb = read (file->handle, file->buff, count);
1941 file->buff_len = nb;
1942 file->position += nb;
1944 // Copy the requested data in "buffer" (as much as we can)
1945 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1946 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1947 file->buff_ind = count;
1955 // If the file is compressed, it's more complicated...
1956 // We cycle through a few operations until we have read enough data
1957 while (buffersize > 0)
1959 ztoolkit_t *ztk = file->ztk;
1962 // NOTE: at this point, the read buffer is always empty
1964 // If "input" is also empty, we need to refill it
1965 if (ztk->in_ind == ztk->in_len)
1967 // If we are at the end of the file
1968 if (file->position == file->real_length)
1971 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
1972 if (count > (fs_offset_t)sizeof (ztk->input))
1973 count = (fs_offset_t)sizeof (ztk->input);
1974 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
1975 if (read (file->handle, ztk->input, count) != count)
1977 Con_Printf ("FS_Read: unexpected end of file\n");
1982 ztk->in_len = count;
1983 ztk->in_position += count;
1986 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
1987 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
1989 // Now that we are sure we have compressed data available, we need to determine
1990 // if it's better to inflate it in "file->buff" or directly in "buffer"
1992 // Inflate the data in "file->buff"
1993 if (buffersize < sizeof (file->buff) / 2)
1995 ztk->zstream.next_out = file->buff;
1996 ztk->zstream.avail_out = sizeof (file->buff);
1997 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
1998 if (error != Z_OK && error != Z_STREAM_END)
2000 Con_Printf ("FS_Read: Can't inflate file\n");
2003 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2005 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2006 file->position += file->buff_len;
2008 // Copy the requested data in "buffer" (as much as we can)
2009 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2010 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2011 file->buff_ind = count;
2014 // Else, we inflate directly in "buffer"
2017 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2018 ztk->zstream.avail_out = (unsigned int)buffersize;
2019 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2020 if (error != Z_OK && error != Z_STREAM_END)
2022 Con_Printf ("FS_Read: Can't inflate file\n");
2025 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2027 // How much data did it inflate?
2028 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2029 file->position += count;
2031 // Purge cached data
2036 buffersize -= count;
2044 ====================
2047 Print a string into a file
2048 ====================
2050 int FS_Print (qfile_t* file, const char *msg)
2052 return (int)FS_Write (file, msg, strlen (msg));
2056 ====================
2059 Print a string into a file
2060 ====================
2062 int FS_Printf(qfile_t* file, const char* format, ...)
2067 va_start (args, format);
2068 result = FS_VPrintf (file, format, args);
2076 ====================
2079 Print a string into a file
2080 ====================
2082 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2085 fs_offset_t buff_size = MAX_INPUTLINE;
2090 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2091 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2092 if (len >= 0 && len < buff_size)
2094 Mem_Free (tempbuff);
2098 len = write (file->handle, tempbuff, len);
2099 Mem_Free (tempbuff);
2106 ====================
2109 Get the next character of a file
2110 ====================
2112 int FS_Getc (qfile_t* file)
2116 if (FS_Read (file, &c, 1) != 1)
2124 ====================
2127 Put a character back into the read buffer (only supports one character!)
2128 ====================
2130 int FS_UnGetc (qfile_t* file, unsigned char c)
2132 // If there's already a character waiting to be read
2133 if (file->ungetc != EOF)
2142 ====================
2145 Move the position index in a file
2146 ====================
2148 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2151 unsigned char* buffer;
2152 fs_offset_t buffersize;
2154 // Compute the file offset
2158 offset += file->position - file->buff_len + file->buff_ind;
2165 offset += file->real_length;
2171 if (offset < 0 || offset > (long) file->real_length)
2174 // If we have the data in our read buffer, we don't need to actually seek
2175 if (file->position - file->buff_len <= offset && offset <= file->position)
2177 file->buff_ind = offset + file->buff_len - file->position;
2181 // Purge cached data
2184 // Unpacked or uncompressed files can seek directly
2185 if (! (file->flags & QFILE_FLAG_DEFLATED))
2187 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2189 file->position = offset;
2193 // Seeking in compressed files is more a hack than anything else,
2194 // but we need to support it, so here we go.
2197 // If we have to go back in the file, we need to restart from the beginning
2198 if (offset <= file->position)
2202 ztk->in_position = 0;
2204 lseek (file->handle, file->offset, SEEK_SET);
2206 // Reset the Zlib stream
2207 ztk->zstream.next_in = ztk->input;
2208 ztk->zstream.avail_in = 0;
2209 qz_inflateReset (&ztk->zstream);
2212 // We need a big buffer to force inflating into it directly
2213 buffersize = 2 * sizeof (file->buff);
2214 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2216 // Skip all data until we reach the requested offset
2217 while (offset > file->position)
2219 fs_offset_t diff = offset - file->position;
2220 fs_offset_t count, len;
2222 count = (diff > buffersize) ? buffersize : diff;
2223 len = FS_Read (file, buffer, count);
2237 ====================
2240 Give the current position in a file
2241 ====================
2243 fs_offset_t FS_Tell (qfile_t* file)
2245 return file->position - file->buff_len + file->buff_ind;
2250 ====================
2253 Give the total size of a file
2254 ====================
2256 fs_offset_t FS_FileSize (qfile_t* file)
2258 return file->real_length;
2263 ====================
2266 Erases any buffered input or output data
2267 ====================
2269 void FS_Purge (qfile_t* file)
2281 Filename are relative to the quake directory.
2282 Always appends a 0 byte.
2285 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2288 unsigned char *buf = NULL;
2289 fs_offset_t filesize = 0;
2291 file = FS_Open (path, "rb", quiet, false);
2294 filesize = file->real_length;
2295 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2296 buf[filesize] = '\0';
2297 FS_Read (file, buf, filesize);
2301 if (filesizepointer)
2302 *filesizepointer = filesize;
2311 The filename will be prefixed by the current game directory
2314 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2318 file = FS_Open (filename, "wb", false, false);
2321 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2325 Con_DPrintf("FS_WriteFile: %s\n", filename);
2326 FS_Write (file, data, len);
2333 =============================================================================
2335 OTHERS PUBLIC FUNCTIONS
2337 =============================================================================
2345 void FS_StripExtension (const char *in, char *out, size_t size_out)
2353 while ((currentchar = *in) && size_out > 1)
2355 if (currentchar == '.')
2357 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2359 *out++ = currentchar;
2375 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2379 // if path doesn't have a .EXT, append extension
2380 // (extension should include the .)
2381 src = path + strlen(path) - 1;
2383 while (*src != '/' && src != path)
2386 return; // it has an extension
2390 strlcat (path, extension, size_path);
2398 Look for a file in the packages and in the filesystem
2401 qboolean FS_FileExists (const char *filename)
2403 return (FS_FindFile (filename, NULL, true) != NULL);
2411 Look for a file in the filesystem only
2414 qboolean FS_SysFileExists (const char *path)
2419 // TODO: use another function instead, to avoid opening the file
2420 desc = open (path, O_RDONLY | O_BINARY);
2429 if (stat (path,&buf) == -1)
2436 void FS_mkdir (const char *path)
2449 Allocate and fill a search structure with information on matching filenames.
2452 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2455 searchpath_t *searchpath;
2457 int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2458 stringlist_t resultlist;
2459 stringlist_t dirlist;
2460 const char *slash, *backslash, *colon, *separator;
2462 char netpath[MAX_OSPATH];
2463 char temp[MAX_OSPATH];
2465 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2470 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2474 stringlistinit(&resultlist);
2475 stringlistinit(&dirlist);
2477 slash = strrchr(pattern, '/');
2478 backslash = strrchr(pattern, '\\');
2479 colon = strrchr(pattern, ':');
2480 separator = max(slash, backslash);
2481 separator = max(separator, colon);
2482 basepathlength = separator ? (separator + 1 - pattern) : 0;
2483 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2485 memcpy(basepath, pattern, basepathlength);
2486 basepath[basepathlength] = 0;
2488 // search through the path, one element at a time
2489 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2491 // is the element a pak file?
2492 if (searchpath->pack)
2494 // look through all the pak file elements
2495 pak = searchpath->pack;
2496 for (i = 0;i < pak->numfiles;i++)
2498 strlcpy(temp, pak->files[i].name, sizeof(temp));
2501 if (matchpattern(temp, (char *)pattern, true))
2503 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2504 if (!strcmp(resultlist.strings[resultlistindex], temp))
2506 if (resultlistindex == resultlist.numstrings)
2508 stringlistappend(&resultlist, temp);
2510 Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
2513 // strip off one path element at a time until empty
2514 // this way directories are added to the listing if they match the pattern
2515 slash = strrchr(temp, '/');
2516 backslash = strrchr(temp, '\\');
2517 colon = strrchr(temp, ':');
2519 if (separator < slash)
2521 if (separator < backslash)
2522 separator = backslash;
2523 if (separator < colon)
2525 *((char *)separator) = 0;
2531 // get a directory listing and look at each name
2532 dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2533 stringlistinit(&dirlist);
2534 listdirectory(&dirlist, netpath);
2535 for (dirlistindex = 0;dirlistindex < dirlist.numstrings;dirlistindex++)
2537 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirlist.strings[dirlistindex]);
2538 if (matchpattern(temp, (char *)pattern, true))
2540 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2541 if (!strcmp(resultlist.strings[resultlistindex], temp))
2543 if (resultlistindex == resultlist.numstrings)
2545 stringlistappend(&resultlist, temp);
2547 Con_DPrintf("SearchDirFile: %s\n", temp);
2551 stringlistfreecontents(&dirlist);
2555 if (resultlist.numstrings)
2557 stringlistsort(&resultlist);
2558 numfiles = resultlist.numstrings;
2560 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2561 numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2562 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2563 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2564 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2565 search->numfilenames = (int)numfiles;
2568 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2571 search->filenames[numfiles] = search->filenamesbuffer + numchars;
2572 textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2573 memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2575 numchars += (int)textlen;
2578 stringlistfreecontents(&resultlist);
2584 void FS_FreeSearch(fssearch_t *search)
2589 extern int con_linewidth;
2590 int FS_ListDirectory(const char *pattern, int oneperline)
2599 char linebuf[MAX_INPUTLINE];
2601 search = FS_Search(pattern, true, true);
2604 numfiles = search->numfilenames;
2607 // FIXME: the names could be added to one column list and then
2608 // gradually shifted into the next column if they fit, and then the
2609 // next to make a compact variable width listing but it's a lot more
2611 // find width for columns
2613 for (i = 0;i < numfiles;i++)
2615 l = (int)strlen(search->filenames[i]);
2616 if (columnwidth < l)
2619 // count the spacing character
2621 // calculate number of columns
2622 numcolumns = con_linewidth / columnwidth;
2623 // don't bother with the column printing if it's only one column
2624 if (numcolumns >= 2)
2626 numlines = (numfiles + numcolumns - 1) / numcolumns;
2627 for (i = 0;i < numlines;i++)
2630 for (k = 0;k < numcolumns;k++)
2632 l = i * numcolumns + k;
2635 name = search->filenames[l];
2636 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2637 linebuf[linebufpos++] = name[j];
2638 // space out name unless it's the last on the line
2639 if (k + 1 < numcolumns && l + 1 < numfiles)
2640 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2641 linebuf[linebufpos++] = ' ';
2644 linebuf[linebufpos] = 0;
2645 Con_Printf("%s\n", linebuf);
2652 for (i = 0;i < numfiles;i++)
2653 Con_Printf("%s\n", search->filenames[i]);
2654 FS_FreeSearch(search);
2655 return (int)numfiles;
2658 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2660 const char *pattern;
2663 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2666 if (Cmd_Argc() == 2)
2667 pattern = Cmd_Argv(1);
2670 if (!FS_ListDirectory(pattern, oneperline))
2671 Con_Print("No files found.\n");
2676 FS_ListDirectoryCmd("dir", true);
2681 FS_ListDirectoryCmd("ls", false);
2684 const char *FS_WhichPack(const char *filename)
2687 searchpath_t *sp = FS_FindFile(filename, &index, true);
2689 return sp->pack->filename;
2695 ====================
2696 FS_IsRegisteredQuakePack
2698 Look for a proof of purchase file file in the requested package
2700 If it is found, this file should NOT be downloaded.
2701 ====================
2703 qboolean FS_IsRegisteredQuakePack(const char *name)
2705 searchpath_t *search;
2708 // search through the path, one element at a time
2709 for (search = fs_searchpaths;search;search = search->next)
2711 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2713 int (*strcmp_funct) (const char* str1, const char* str2);
2714 int left, right, middle;
2717 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2719 // Look for the file (binary search)
2721 right = pak->numfiles - 1;
2722 while (left <= right)
2726 middle = (left + right) / 2;
2727 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2733 // If we're too far in the list
2740 // we found the requested pack but it is not registered quake
2748 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2751 unsigned char *filedata;
2752 fs_offset_t filesize;
2753 if (filesizepointer)
2754 *filesizepointer = 0;
2755 if (!filename || !*filename)
2757 filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2760 if (filesizepointer)
2761 *filesizepointer = filesize;
2762 crc = CRC_Block(filedata, filesize);