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>
44 // Win32 requires us to add O_BINARY, but the other OSes don't have it
49 // In case the system doesn't support the O_NONBLOCK flag
57 All of Quake's data access is through a hierchal file system, but the contents
58 of the file system can be transparently merged from several sources.
60 The "base directory" is the path to the directory holding the quake.exe and
61 all game directories. The sys_* files pass this to host_init in
62 quakeparms_t->basedir. This can be overridden with the "-basedir" command
63 line parm to allow code debugging in a different directory. The base
64 directory is only used during filesystem initialization.
66 The "game directory" is the first tree on the search path and directory that
67 all generated files (savegames, screenshots, demos, config files) will be
68 saved to. This can be overridden with the "-game" command line parameter.
69 The game directory can never be changed while quake is executing. This is a
70 precaution against having a malicious server instruct clients to write files
71 over areas they shouldn't.
77 =============================================================================
81 =============================================================================
84 // Magic numbers of a ZIP file (big-endian format)
85 #define ZIP_DATA_HEADER 0x504B0304 // "PK\3\4"
86 #define ZIP_CDIR_HEADER 0x504B0102 // "PK\1\2"
87 #define ZIP_END_HEADER 0x504B0506 // "PK\5\6"
89 // Other constants for ZIP files
90 #define ZIP_MAX_COMMENTS_SIZE ((unsigned short)0xFFFF)
91 #define ZIP_END_CDIR_SIZE 22
92 #define ZIP_CDIR_CHUNK_BASE_SIZE 46
93 #define ZIP_LOCAL_CHUNK_BASE_SIZE 30
95 // Zlib constants (from zlib.h)
96 #define Z_SYNC_FLUSH 2
99 #define Z_STREAM_END 1
100 #define ZLIB_VERSION "1.2.3"
102 // Uncomment the following line if the zlib DLL you have still uses
103 // the 1.1.x series calling convention on Win32 (WINAPI)
104 //#define ZLIB_USES_WINAPI
108 =============================================================================
112 =============================================================================
115 // Zlib stream (from zlib.h)
116 // Warning: some pointers we don't use directly have
117 // been cast to "void*" for a matter of simplicity
120 unsigned char *next_in; // next input byte
121 unsigned int avail_in; // number of bytes available at next_in
122 unsigned long total_in; // total nb of input bytes read so far
124 unsigned char *next_out; // next output byte should be put there
125 unsigned int avail_out; // remaining free space at next_out
126 unsigned long total_out; // total nb of bytes output so far
128 char *msg; // last error message, NULL if no error
129 void *state; // not visible by applications
131 void *zalloc; // used to allocate the internal state
132 void *zfree; // used to free the internal state
133 void *opaque; // private data object passed to zalloc and zfree
135 int data_type; // best guess about the data type: ascii or binary
136 unsigned long adler; // adler32 value of the uncompressed data
137 unsigned long reserved; // reserved for future use
141 // inside a package (PAK or PK3)
142 #define QFILE_FLAG_PACKED (1 << 0)
143 // file is compressed using the deflate algorithm (PK3 only)
144 #define QFILE_FLAG_DEFLATED (1 << 1)
146 #define FILE_BUFF_SIZE 2048
150 size_t comp_length; // length of the compressed file
151 size_t in_ind, in_len; // input buffer current index and length
152 size_t in_position; // position in the compressed file
153 unsigned char input [FILE_BUFF_SIZE];
159 int handle; // file descriptor
160 fs_offset_t real_length; // uncompressed file size (for files opened in "read" mode)
161 fs_offset_t position; // current position in the file
162 fs_offset_t offset; // offset into the package (0 if external file)
163 int ungetc; // single stored character from ungetc, cleared to EOF when read
166 fs_offset_t buff_ind, buff_len; // buffer current index and length
167 unsigned char buff [FILE_BUFF_SIZE];
174 // ------ PK3 files on disk ------ //
176 // You can get the complete ZIP format description from PKWARE website
178 typedef struct pk3_endOfCentralDir_s
180 unsigned int signature;
181 unsigned short disknum;
182 unsigned short cdir_disknum; // number of the disk with the start of the central directory
183 unsigned short localentries; // number of entries in the central directory on this disk
184 unsigned short nbentries; // total number of entries in the central directory on this disk
185 unsigned int cdir_size; // size of the central directory
186 unsigned int cdir_offset; // with respect to the starting disk number
187 unsigned short comment_size;
188 } pk3_endOfCentralDir_t;
191 // ------ PAK files on disk ------ //
192 typedef struct dpackfile_s
195 int filepos, filelen;
198 typedef struct dpackheader_s
206 // Packages in memory
207 // the offset in packfile_t is the true contents offset
208 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
209 // file compressed using the deflate algorithm
210 #define PACKFILE_FLAG_DEFLATED (1 << 1)
212 typedef struct packfile_s
214 char name [MAX_QPATH];
217 fs_offset_t packsize; // size in the package
218 fs_offset_t realsize; // real file size (uncompressed)
221 typedef struct pack_s
223 char filename [MAX_OSPATH];
225 int ignorecase; // PK3 ignores case
231 // Search paths for files (including packages)
232 typedef struct searchpath_s
234 // only one of filename / pack will be used
235 char filename[MAX_OSPATH];
237 struct searchpath_s *next;
242 =============================================================================
246 =============================================================================
252 static const char *FS_FileExtension (const char *in);
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 #define MAX_GAMEDIRS 16
278 int fs_numgamedirs = 0;
279 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
281 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)"};
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)
965 stringlist_t *list, *current;
966 searchpath_t *search;
967 char pakfile[MAX_OSPATH];
969 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
971 list = listdirectory(dir);
973 // add any PAK package in the directory
974 for (current = list;current;current = current->next)
976 if (!strcasecmp(FS_FileExtension(current->text), "pak"))
978 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
979 FS_AddPack_Fullpath(pakfile, NULL, false);
983 // add any PK3 package in the director
984 for (current = list;current;current = current->next)
986 if (!strcasecmp(FS_FileExtension(current->text), "pk3"))
988 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
989 FS_AddPack_Fullpath(pakfile, NULL, false);
994 // Add the directory to the search path
995 // (unpacked files have the priority over packed files)
996 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
997 strlcpy (search->filename, dir, sizeof (search->filename));
998 search->next = fs_searchpaths;
999 fs_searchpaths = search;
1008 void FS_AddGameHierarchy (const char *dir)
1011 const char *homedir;
1014 // Add the common game directory
1015 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1018 // Add the personal game directory
1019 homedir = getenv ("HOME");
1020 if (homedir != NULL && homedir[0] != '\0')
1021 FS_AddGameDirectory (va("%s/.%s/%s/", homedir, gameuserdirname, dir));
1031 static const char *FS_FileExtension (const char *in)
1033 const char *separator, *backslash, *colon, *dot;
1035 separator = strrchr(in, '/');
1036 backslash = strrchr(in, '\\');
1037 if (!separator || separator < backslash)
1038 separator = backslash;
1039 colon = strrchr(in, ':');
1040 if (!separator || separator < colon)
1043 dot = strrchr(in, '.');
1044 if (dot == NULL || (separator && (dot < separator)))
1056 void FS_ClearSearchPath (void)
1058 while (fs_searchpaths)
1060 searchpath_t *search = fs_searchpaths;
1061 fs_searchpaths = search->next;
1064 if (search->pack->files)
1065 Mem_Free(search->pack->files);
1066 Mem_Free(search->pack);
1078 void FS_Rescan_f (void)
1081 qboolean fs_modified = false;
1083 FS_ClearSearchPath();
1085 // add the game-specific paths
1086 // gamedirname1 (typically id1)
1087 FS_AddGameHierarchy (gamedirname1);
1088 // update the com_modname (used for server info)
1089 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1091 // add the game-specific path, if any
1092 // (only used for mission packs and the like, which should set fs_modified)
1096 FS_AddGameHierarchy (gamedirname2);
1100 // Adds basedir/gamedir as an override game
1101 // LordHavoc: now supports multiple -game directories
1102 // set the com_modname (reported in server info)
1103 for (i = 0;i < fs_numgamedirs;i++)
1106 FS_AddGameHierarchy (fs_gamedirs[i]);
1107 // update the com_modname (used server info)
1108 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1111 // set the default screenshot name to either the mod name or the
1112 // gamemode screenshot name
1113 if (strcmp(com_modname, gamedirname1))
1114 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1116 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1118 // If "-condebug" is in the command line, remove the previous log file
1119 if (COM_CheckParm ("-condebug") != 0)
1120 unlink (va("%s/qconsole.log", fs_gamedir));
1122 // look for the pop.lmp file and set registered to true if it is found
1123 if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1126 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1128 Con_Print("Playing shareware version.\n");
1132 Cvar_Set ("registered", "1");
1133 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1134 Con_Print("Playing registered version.\n");
1144 void Host_SaveConfig_f (void);
1145 void Host_LoadConfig_f (void);
1146 int FS_CheckNastyPath (const char *path, qboolean isgamedir);
1147 qboolean FS_ChangeGameDir(const char *string)
1149 // if already using the requested gamedir, do nothing
1150 if (fs_numgamedirs == 1 && !strcmp(fs_gamedirs[0], string))
1153 // if string is nasty, reject it
1154 if(FS_CheckNastyPath(string, true)) // overflowed or nasty?
1156 Con_Printf("FS_ChangeGameDir(\"%s\"): nasty filename rejected\n", string);
1160 // save the current config
1161 Host_SaveConfig_f();
1163 // change to the new gamedir
1165 strlcpy(fs_gamedirs[0], string, sizeof(fs_gamedirs[0]));
1167 // reinitialize filesystem to detect the new paks
1170 // exec the new config
1171 Host_LoadConfig_f();
1173 // reinitialize the loaded sounds
1176 // reinitialize renderer (this reloads hud/console background/etc)
1177 R_Modules_Restart();
1187 void FS_GameDir_f (void)
1193 Con_Printf("gamedirs active:");
1194 for (i = 0;i < fs_numgamedirs;i++)
1195 Con_Printf(" %s", fs_gamedirs[i]);
1200 if (cls.state != ca_disconnected || sv.active)
1202 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1206 Host_SaveConfig_f();
1209 for (i = 1;i < Cmd_Argc() && fs_numgamedirs < MAX_GAMEDIRS;i++)
1211 // if string is nasty, reject it
1212 if(FS_CheckNastyPath(Cmd_Argv(i), true)) // overflowed or nasty?
1214 Con_Printf("FS_GameDir_f(\"%s\"): nasty filename rejected\n", Cmd_Argv(i));
1218 strlcpy(fs_gamedirs[fs_numgamedirs], Cmd_Argv(i), sizeof(fs_gamedirs[fs_numgamedirs]));
1222 // reinitialize filesystem to detect the new paks
1225 // exec the new config
1226 Host_LoadConfig_f();
1228 // reinitialize the loaded sounds
1231 // reinitialize renderer (this reloads hud/console background/etc)
1232 R_Modules_Restart();
1245 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1247 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1249 // If the base directory is explicitly defined by the compilation process
1250 #ifdef DP_FS_BASEDIR
1251 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1253 strlcpy(fs_basedir, "", sizeof(fs_basedir));
1256 // FIXME: is there a better way to find the directory outside the .app?
1257 if (strstr(com_argv[0], ".app/"))
1261 split = strstr(com_argv[0], ".app/");
1262 while (split > com_argv[0] && *split != '/')
1264 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1265 fs_basedir[split - com_argv[0]] = 0;
1273 // Overrides the system supplied base directory (under GAMENAME)
1274 // 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)
1275 i = COM_CheckParm ("-basedir");
1276 if (i && i < com_argc-1)
1278 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1279 i = (int)strlen (fs_basedir);
1280 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1281 fs_basedir[i-1] = 0;
1284 // add a path separator to the end of the basedir if it lacks one
1285 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1286 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1289 // Adds basedir/gamedir as an override game
1290 // LordHavoc: now supports multiple -game directories
1291 for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1295 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1298 // add the gamedir to the list of active gamedirs
1299 strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1304 // update the searchpath
1308 void FS_Init_Commands(void)
1310 Cvar_RegisterVariable (&scr_screenshot_name);
1312 Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1313 Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1314 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1315 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1316 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1324 void FS_Shutdown (void)
1326 Mem_FreePool (&fs_mempool);
1330 ====================
1333 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1334 ====================
1336 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1342 // Parse the mode string
1351 opt = O_CREAT | O_TRUNC;
1355 opt = O_CREAT | O_APPEND;
1358 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1361 for (ind = 1; mode[ind] != '\0'; ind++)
1372 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1373 filepath, mode, mode[ind]);
1380 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1381 memset (file, 0, sizeof (*file));
1384 file->handle = open (filepath, mod | opt, 0666);
1385 if (file->handle < 0)
1391 file->real_length = lseek (file->handle, 0, SEEK_END);
1393 // For files opened in append mode, we start at the end of the file
1395 file->position = file->real_length;
1397 lseek (file->handle, 0, SEEK_SET);
1407 Open a packed file using its package file descriptor
1410 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1416 pfile = &pack->files[pack_ind];
1418 // If we don't have the true offset, get it now
1419 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1420 if (!PK3_GetTrueFileOffset (pfile, pack))
1423 // No Zlib DLL = no compressed files
1424 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1426 Con_Printf("WARNING: can't open the compressed file %s\n"
1427 "You need the Zlib DLL to use compressed files\n",
1432 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1433 // the dup() call to avoid having to close the dup_handle on error here
1434 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1436 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1437 pfile->name, pack->filename, pfile->offset);
1441 dup_handle = dup (pack->handle);
1444 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1448 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1449 memset (file, 0, sizeof (*file));
1450 file->handle = dup_handle;
1451 file->flags = QFILE_FLAG_PACKED;
1452 file->real_length = pfile->realsize;
1453 file->offset = pfile->offset;
1457 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1461 file->flags |= QFILE_FLAG_DEFLATED;
1463 // We need some more variables
1464 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1466 ztk->comp_length = pfile->packsize;
1468 // Initialize zlib stream
1469 ztk->zstream.next_in = ztk->input;
1470 ztk->zstream.avail_in = 0;
1472 /* From Zlib's "unzip.c":
1474 * windowBits is passed < 0 to tell that there is no zlib header.
1475 * Note that in this case inflate *requires* an extra "dummy" byte
1476 * after the compressed stream in order to complete decompression and
1477 * return Z_STREAM_END.
1478 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1479 * size of both compressed and uncompressed data
1481 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1483 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1489 ztk->zstream.next_out = file->buff;
1490 ztk->zstream.avail_out = sizeof (file->buff);
1499 ====================
1502 Return true if the path should be rejected due to one of the following:
1503 1: path elements that are non-portable
1504 2: path elements that would allow access to files outside the game directory,
1505 or are just not a good idea for a mod to be using.
1506 ====================
1508 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1510 // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1514 // Windows: don't allow \ in filenames (windows-only), period.
1515 // (on Windows \ is a directory separator, but / is also supported)
1516 if (strstr(path, "\\"))
1517 return 1; // non-portable
1519 // Mac: don't allow Mac-only filenames - : is a directory separator
1520 // instead of /, but we rely on / working already, so there's no reason to
1521 // support a Mac-only path
1522 // Amiga and Windows: : tries to go to root of drive
1523 if (strstr(path, ":"))
1524 return 1; // non-portable attempt to go to root of drive
1526 // Amiga: // is parent directory
1527 if (strstr(path, "//"))
1528 return 1; // non-portable attempt to go to parent directory
1530 // all: don't allow going to parent directory (../ or /../)
1531 if (strstr(path, ".."))
1532 return 2; // attempt to go outside the game directory
1534 // Windows and UNIXes: don't allow absolute paths
1536 return 2; // attempt to go outside the game directory
1538 // 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
1539 if (strchr(path, '.'))
1543 // gamedir is entirely path elements, so simply forbid . entirely
1546 if (strchr(path, '.') < strrchr(path, '/'))
1547 return 2; // possible attempt to go outside the game directory
1550 // all: forbid trailing slash on gamedir
1551 if (isgamedir && path[strlen(path)-1] == '/')
1554 // all: forbid leading dot on any filename for any reason
1555 if (strstr(path, "/."))
1556 return 2; // attempt to go outside the game directory
1558 // after all these checks we're pretty sure it's a / separated filename
1559 // and won't do much if any harm
1565 ====================
1568 Look for a file in the packages and in the filesystem
1570 Return the searchpath where the file was found (or NULL)
1571 and the file index in the package if relevant
1572 ====================
1574 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1576 searchpath_t *search;
1579 // search through the path, one element at a time
1580 for (search = fs_searchpaths;search;search = search->next)
1582 // is the element a pak file?
1585 int (*strcmp_funct) (const char* str1, const char* str2);
1586 int left, right, middle;
1589 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1591 // Look for the file (binary search)
1593 right = pak->numfiles - 1;
1594 while (left <= right)
1598 middle = (left + right) / 2;
1599 diff = strcmp_funct (pak->files[middle].name, name);
1604 if (!quiet && developer.integer >= 10)
1605 Con_Printf("FS_FindFile: %s in %s\n",
1606 pak->files[middle].name, pak->filename);
1613 // If we're too far in the list
1622 char netpath[MAX_OSPATH];
1623 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1624 if (FS_SysFileExists (netpath))
1626 if (!quiet && developer.integer >= 10)
1627 Con_Printf("FS_FindFile: %s\n", netpath);
1636 if (!quiet && developer.integer >= 10)
1637 Con_Printf("FS_FindFile: can't find %s\n", name);
1649 Look for a file in the search paths and open it in read-only mode
1652 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1654 searchpath_t *search;
1657 search = FS_FindFile (filename, &pack_ind, quiet);
1663 // Found in the filesystem?
1666 char path [MAX_OSPATH];
1667 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1668 return FS_SysOpen (path, "rb", nonblocking);
1671 // So, we found it in a package...
1672 return FS_OpenPackedFile (search->pack, pack_ind);
1677 =============================================================================
1679 MAIN PUBLIC FUNCTIONS
1681 =============================================================================
1685 ====================
1688 Open a file. The syntax is the same as fopen
1689 ====================
1691 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1693 if (FS_CheckNastyPath(filepath, false))
1695 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1699 // If the file is opened in "write", "append", or "read/write" mode
1700 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1702 char real_path [MAX_OSPATH];
1704 // Open the file on disk directly
1705 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1707 // Create directories up to the file
1708 FS_CreatePath (real_path);
1710 return FS_SysOpen (real_path, mode, nonblocking);
1712 // Else, we look at the various search paths and open the file in read-only mode
1714 return FS_OpenReadFile (filepath, quiet, nonblocking);
1719 ====================
1723 ====================
1725 int FS_Close (qfile_t* file)
1727 if (close (file->handle))
1732 qz_inflateEnd (&file->ztk->zstream);
1733 Mem_Free (file->ztk);
1742 ====================
1745 Write "datasize" bytes into a file
1746 ====================
1748 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1752 // If necessary, seek to the exact file position we're supposed to be
1753 if (file->buff_ind != file->buff_len)
1754 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1756 // Purge cached data
1759 // Write the buffer and update the position
1760 result = write (file->handle, data, (fs_offset_t)datasize);
1761 file->position = lseek (file->handle, 0, SEEK_CUR);
1762 if (file->real_length < file->position)
1763 file->real_length = file->position;
1773 ====================
1776 Read up to "buffersize" bytes from a file
1777 ====================
1779 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1781 fs_offset_t count, done;
1783 if (buffersize == 0)
1786 // Get rid of the ungetc character
1787 if (file->ungetc != EOF)
1789 ((char*)buffer)[0] = file->ungetc;
1797 // First, we copy as many bytes as we can from "buff"
1798 if (file->buff_ind < file->buff_len)
1800 count = file->buff_len - file->buff_ind;
1802 done += ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1803 memcpy (buffer, &file->buff[file->buff_ind], done);
1804 file->buff_ind += done;
1807 if (buffersize == 0)
1811 // NOTE: at this point, the read buffer is always empty
1813 // If the file isn't compressed
1814 if (! (file->flags & QFILE_FLAG_DEFLATED))
1818 // We must take care to not read after the end of the file
1819 count = file->real_length - file->position;
1821 // If we have a lot of data to get, put them directly into "buffer"
1822 if (buffersize > sizeof (file->buff) / 2)
1824 if (count > (fs_offset_t)buffersize)
1825 count = (fs_offset_t)buffersize;
1826 lseek (file->handle, file->offset + file->position, SEEK_SET);
1827 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1831 file->position += nb;
1833 // Purge cached data
1839 if (count > (fs_offset_t)sizeof (file->buff))
1840 count = (fs_offset_t)sizeof (file->buff);
1841 lseek (file->handle, file->offset + file->position, SEEK_SET);
1842 nb = read (file->handle, file->buff, count);
1845 file->buff_len = nb;
1846 file->position += nb;
1848 // Copy the requested data in "buffer" (as much as we can)
1849 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1850 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1851 file->buff_ind = count;
1859 // If the file is compressed, it's more complicated...
1860 // We cycle through a few operations until we have read enough data
1861 while (buffersize > 0)
1863 ztoolkit_t *ztk = file->ztk;
1866 // NOTE: at this point, the read buffer is always empty
1868 // If "input" is also empty, we need to refill it
1869 if (ztk->in_ind == ztk->in_len)
1871 // If we are at the end of the file
1872 if (file->position == file->real_length)
1875 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
1876 if (count > (fs_offset_t)sizeof (ztk->input))
1877 count = (fs_offset_t)sizeof (ztk->input);
1878 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
1879 if (read (file->handle, ztk->input, count) != count)
1881 Con_Printf ("FS_Read: unexpected end of file\n");
1886 ztk->in_len = count;
1887 ztk->in_position += count;
1890 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
1891 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
1893 // Now that we are sure we have compressed data available, we need to determine
1894 // if it's better to inflate it in "file->buff" or directly in "buffer"
1896 // Inflate the data in "file->buff"
1897 if (buffersize < sizeof (file->buff) / 2)
1899 ztk->zstream.next_out = file->buff;
1900 ztk->zstream.avail_out = sizeof (file->buff);
1901 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
1902 if (error != Z_OK && error != Z_STREAM_END)
1904 Con_Printf ("FS_Read: Can't inflate file\n");
1907 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
1909 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
1910 file->position += file->buff_len;
1912 // Copy the requested data in "buffer" (as much as we can)
1913 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1914 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1915 file->buff_ind = count;
1918 // Else, we inflate directly in "buffer"
1921 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
1922 ztk->zstream.avail_out = (unsigned int)buffersize;
1923 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
1924 if (error != Z_OK && error != Z_STREAM_END)
1926 Con_Printf ("FS_Read: Can't inflate file\n");
1929 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
1931 // How much data did it inflate?
1932 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
1933 file->position += count;
1935 // Purge cached data
1940 buffersize -= count;
1948 ====================
1951 Print a string into a file
1952 ====================
1954 int FS_Print (qfile_t* file, const char *msg)
1956 return (int)FS_Write (file, msg, strlen (msg));
1960 ====================
1963 Print a string into a file
1964 ====================
1966 int FS_Printf(qfile_t* file, const char* format, ...)
1971 va_start (args, format);
1972 result = FS_VPrintf (file, format, args);
1980 ====================
1983 Print a string into a file
1984 ====================
1986 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
1989 fs_offset_t buff_size = MAX_INPUTLINE;
1994 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
1995 len = dpvsnprintf (tempbuff, buff_size, format, ap);
1996 if (len >= 0 && len < buff_size)
1998 Mem_Free (tempbuff);
2002 len = write (file->handle, tempbuff, len);
2003 Mem_Free (tempbuff);
2010 ====================
2013 Get the next character of a file
2014 ====================
2016 int FS_Getc (qfile_t* file)
2020 if (FS_Read (file, &c, 1) != 1)
2028 ====================
2031 Put a character back into the read buffer (only supports one character!)
2032 ====================
2034 int FS_UnGetc (qfile_t* file, unsigned char c)
2036 // If there's already a character waiting to be read
2037 if (file->ungetc != EOF)
2046 ====================
2049 Move the position index in a file
2050 ====================
2052 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2055 unsigned char* buffer;
2056 fs_offset_t buffersize;
2058 // Compute the file offset
2062 offset += file->position - file->buff_len + file->buff_ind;
2069 offset += file->real_length;
2075 if (offset < 0 || offset > (long) file->real_length)
2078 // If we have the data in our read buffer, we don't need to actually seek
2079 if (file->position - file->buff_len <= offset && offset <= file->position)
2081 file->buff_ind = offset + file->buff_len - file->position;
2085 // Purge cached data
2088 // Unpacked or uncompressed files can seek directly
2089 if (! (file->flags & QFILE_FLAG_DEFLATED))
2091 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2093 file->position = offset;
2097 // Seeking in compressed files is more a hack than anything else,
2098 // but we need to support it, so here we go.
2101 // If we have to go back in the file, we need to restart from the beginning
2102 if (offset <= file->position)
2106 ztk->in_position = 0;
2108 lseek (file->handle, file->offset, SEEK_SET);
2110 // Reset the Zlib stream
2111 ztk->zstream.next_in = ztk->input;
2112 ztk->zstream.avail_in = 0;
2113 qz_inflateReset (&ztk->zstream);
2116 // We need a big buffer to force inflating into it directly
2117 buffersize = 2 * sizeof (file->buff);
2118 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2120 // Skip all data until we reach the requested offset
2121 while (offset > file->position)
2123 fs_offset_t diff = offset - file->position;
2124 fs_offset_t count, len;
2126 count = (diff > buffersize) ? buffersize : diff;
2127 len = FS_Read (file, buffer, count);
2141 ====================
2144 Give the current position in a file
2145 ====================
2147 fs_offset_t FS_Tell (qfile_t* file)
2149 return file->position - file->buff_len + file->buff_ind;
2154 ====================
2157 Erases any buffered input or output data
2158 ====================
2160 void FS_Purge (qfile_t* file)
2172 Filename are relative to the quake directory.
2173 Always appends a 0 byte.
2176 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2179 unsigned char *buf = NULL;
2180 fs_offset_t filesize = 0;
2182 file = FS_Open (path, "rb", quiet, false);
2185 filesize = file->real_length;
2186 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2187 buf[filesize] = '\0';
2188 FS_Read (file, buf, filesize);
2192 if (filesizepointer)
2193 *filesizepointer = filesize;
2202 The filename will be prefixed by the current game directory
2205 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2209 file = FS_Open (filename, "wb", false, false);
2212 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2216 Con_DPrintf("FS_WriteFile: %s\n", filename);
2217 FS_Write (file, data, len);
2224 =============================================================================
2226 OTHERS PUBLIC FUNCTIONS
2228 =============================================================================
2236 void FS_StripExtension (const char *in, char *out, size_t size_out)
2244 while ((currentchar = *in) && size_out > 1)
2246 if (currentchar == '.')
2248 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2250 *out++ = currentchar;
2266 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2270 // if path doesn't have a .EXT, append extension
2271 // (extension should include the .)
2272 src = path + strlen(path) - 1;
2274 while (*src != '/' && src != path)
2277 return; // it has an extension
2281 strlcat (path, extension, size_path);
2289 Look for a file in the packages and in the filesystem
2292 qboolean FS_FileExists (const char *filename)
2294 return (FS_FindFile (filename, NULL, true) != NULL);
2302 Look for a file in the filesystem only
2305 qboolean FS_SysFileExists (const char *path)
2310 // TODO: use another function instead, to avoid opening the file
2311 desc = open (path, O_RDONLY | O_BINARY);
2320 if (stat (path,&buf) == -1)
2327 void FS_mkdir (const char *path)
2340 Allocate and fill a search structure with information on matching filenames.
2343 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2346 searchpath_t *searchpath;
2348 int i, basepathlength, numfiles, numchars;
2349 stringlist_t *dir, *dirfile, *liststart, *listcurrent, *listtemp;
2350 const char *slash, *backslash, *colon, *separator;
2352 char netpath[MAX_OSPATH];
2353 char temp[MAX_OSPATH];
2355 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2360 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2368 slash = strrchr(pattern, '/');
2369 backslash = strrchr(pattern, '\\');
2370 colon = strrchr(pattern, ':');
2371 separator = max(slash, backslash);
2372 separator = max(separator, colon);
2373 basepathlength = separator ? (separator + 1 - pattern) : 0;
2374 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2376 memcpy(basepath, pattern, basepathlength);
2377 basepath[basepathlength] = 0;
2379 // search through the path, one element at a time
2380 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2382 // is the element a pak file?
2383 if (searchpath->pack)
2385 // look through all the pak file elements
2386 pak = searchpath->pack;
2387 for (i = 0;i < pak->numfiles;i++)
2389 strlcpy(temp, pak->files[i].name, sizeof(temp));
2392 if (matchpattern(temp, (char *)pattern, true))
2394 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2395 if (!strcmp(listtemp->text, temp))
2397 if (listtemp == NULL)
2399 listcurrent = stringlistappend(listcurrent, temp);
2400 if (liststart == NULL)
2401 liststart = listcurrent;
2403 Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
2406 // strip off one path element at a time until empty
2407 // this way directories are added to the listing if they match the pattern
2408 slash = strrchr(temp, '/');
2409 backslash = strrchr(temp, '\\');
2410 colon = strrchr(temp, ':');
2412 if (separator < slash)
2414 if (separator < backslash)
2415 separator = backslash;
2416 if (separator < colon)
2418 *((char *)separator) = 0;
2424 // get a directory listing and look at each name
2425 dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2426 if ((dir = listdirectory(netpath)))
2428 for (dirfile = dir;dirfile;dirfile = dirfile->next)
2430 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirfile->text);
2431 if (matchpattern(temp, (char *)pattern, true))
2433 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2434 if (!strcmp(listtemp->text, temp))
2436 if (listtemp == NULL)
2438 listcurrent = stringlistappend(listcurrent, temp);
2439 if (liststart == NULL)
2440 liststart = listcurrent;
2442 Con_DPrintf("SearchDirFile: %s\n", temp);
2453 liststart = stringlistsort(liststart);
2456 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2459 numchars += (int)strlen(listtemp->text) + 1;
2461 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2462 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2463 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2464 search->numfilenames = (int)numfiles;
2467 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2470 search->filenames[numfiles] = search->filenamesbuffer + numchars;
2471 textlen = strlen(listtemp->text) + 1;
2472 memcpy(search->filenames[numfiles], listtemp->text, textlen);
2474 numchars += (int)textlen;
2477 stringlistfree(liststart);
2484 void FS_FreeSearch(fssearch_t *search)
2489 extern int con_linewidth;
2490 int FS_ListDirectory(const char *pattern, int oneperline)
2499 char linebuf[MAX_INPUTLINE];
2501 search = FS_Search(pattern, true, true);
2504 numfiles = search->numfilenames;
2507 // FIXME: the names could be added to one column list and then
2508 // gradually shifted into the next column if they fit, and then the
2509 // next to make a compact variable width listing but it's a lot more
2511 // find width for columns
2513 for (i = 0;i < numfiles;i++)
2515 l = (int)strlen(search->filenames[i]);
2516 if (columnwidth < l)
2519 // count the spacing character
2521 // calculate number of columns
2522 numcolumns = con_linewidth / columnwidth;
2523 // don't bother with the column printing if it's only one column
2524 if (numcolumns >= 2)
2526 numlines = (numfiles + numcolumns - 1) / numcolumns;
2527 for (i = 0;i < numlines;i++)
2530 for (k = 0;k < numcolumns;k++)
2532 l = i * numcolumns + k;
2535 name = search->filenames[l];
2536 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2537 linebuf[linebufpos++] = name[j];
2538 // space out name unless it's the last on the line
2539 if (k + 1 < numcolumns && l + 1 < numfiles)
2540 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2541 linebuf[linebufpos++] = ' ';
2544 linebuf[linebufpos] = 0;
2545 Con_Printf("%s\n", linebuf);
2552 for (i = 0;i < numfiles;i++)
2553 Con_Printf("%s\n", search->filenames[i]);
2554 FS_FreeSearch(search);
2555 return (int)numfiles;
2558 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2560 const char *pattern;
2563 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2566 if (Cmd_Argc() == 2)
2567 pattern = Cmd_Argv(1);
2570 if (!FS_ListDirectory(pattern, oneperline))
2571 Con_Print("No files found.\n");
2576 FS_ListDirectoryCmd("dir", true);
2581 FS_ListDirectoryCmd("ls", false);
2584 const char *FS_WhichPack(const char *filename)
2587 searchpath_t *sp = FS_FindFile(filename, &index, true);
2589 return sp->pack->filename;