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 qboolean fs_modified; // set true if using non-id files
278 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)"};
282 =============================================================================
284 PRIVATE FUNCTIONS - PK3 HANDLING
286 =============================================================================
289 // Functions exported from zlib
290 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
291 # define ZEXPORT WINAPI
296 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
297 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
298 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
299 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
301 #define qz_inflateInit2(strm, windowBits) \
302 qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
304 static dllfunction_t zlibfuncs[] =
306 {"inflate", (void **) &qz_inflate},
307 {"inflateEnd", (void **) &qz_inflateEnd},
308 {"inflateInit2_", (void **) &qz_inflateInit2_},
309 {"inflateReset", (void **) &qz_inflateReset},
313 // Handle for Zlib DLL
314 static dllhandle_t zlib_dll = NULL;
324 void PK3_CloseLibrary (void)
326 Sys_UnloadLibrary (&zlib_dll);
334 Try to load the Zlib DLL
337 qboolean PK3_OpenLibrary (void)
339 const char* dllnames [] =
344 # ifdef ZLIB_USES_WINAPI
350 #elif defined(MACOSX)
364 if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
366 Con_Printf ("Compressed files support disabled\n");
370 Con_Printf ("Compressed files support enabled\n");
377 PK3_GetEndOfCentralDir
379 Extract the end of the central directory from a PK3 package
382 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
384 fs_offset_t filesize, maxsize;
385 unsigned char *buffer, *ptr;
388 // Get the package size
389 filesize = lseek (packhandle, 0, SEEK_END);
390 if (filesize < ZIP_END_CDIR_SIZE)
393 // Load the end of the file in memory
394 if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
397 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
398 buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
399 lseek (packhandle, filesize - maxsize, SEEK_SET);
400 if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
406 // Look for the end of central dir signature around the end of the file
407 maxsize -= ZIP_END_CDIR_SIZE;
408 ptr = &buffer[maxsize];
410 while (BuffBigLong (ptr) != ZIP_END_HEADER)
422 memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
423 eocd->signature = LittleLong (eocd->signature);
424 eocd->disknum = LittleShort (eocd->disknum);
425 eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
426 eocd->localentries = LittleShort (eocd->localentries);
427 eocd->nbentries = LittleShort (eocd->nbentries);
428 eocd->cdir_size = LittleLong (eocd->cdir_size);
429 eocd->cdir_offset = LittleLong (eocd->cdir_offset);
430 eocd->comment_size = LittleShort (eocd->comment_size);
442 Extract the file list from a PK3 file
445 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
447 unsigned char *central_dir, *ptr;
449 fs_offset_t remaining;
451 // Load the central directory in memory
452 central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
453 lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
454 read (pack->handle, central_dir, eocd->cdir_size);
456 // Extract the files properties
457 // The parsing is done "by hand" because some fields have variable sizes and
458 // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
459 remaining = eocd->cdir_size;
462 for (ind = 0; ind < eocd->nbentries; ind++)
464 fs_offset_t namesize, count;
466 // Checking the remaining size
467 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
469 Mem_Free (central_dir);
472 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
475 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
477 Mem_Free (central_dir);
481 namesize = BuffLittleShort (&ptr[28]); // filename length
483 // Check encryption, compression, and attributes
484 // 1st uint8 : general purpose bit flag
485 // Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
486 // 2nd uint8 : external file attributes
487 // Check bits 3 (file is a directory) and 5 (file is a volume (?))
488 if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
490 // Still enough bytes for the name?
491 if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
493 Mem_Free (central_dir);
497 // WinZip doesn't use the "directory" attribute, so we need to check the name directly
498 if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
500 char filename [sizeof (pack->files[0].name)];
501 fs_offset_t offset, packsize, realsize;
504 // Extract the name (strip it if necessary)
505 namesize = min(namesize, (int)sizeof (filename) - 1);
506 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
507 filename[namesize] = '\0';
509 if (BuffLittleShort (&ptr[10]))
510 flags = PACKFILE_FLAG_DEFLATED;
513 offset = BuffLittleLong (&ptr[42]);
514 packsize = BuffLittleLong (&ptr[20]);
515 realsize = BuffLittleLong (&ptr[24]);
516 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
520 // Skip the name, additionnal field, and comment
521 // 1er uint16 : extra field length
522 // 2eme uint16 : file comment length
523 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
524 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
528 // If the package is empty, central_dir is NULL here
529 if (central_dir != NULL)
530 Mem_Free (central_dir);
531 return pack->numfiles;
539 Create a package entry associated with a PK3 file
542 pack_t *FS_LoadPackPK3 (const char *packfile)
545 pk3_endOfCentralDir_t eocd;
549 packhandle = open (packfile, O_RDONLY | O_BINARY);
553 if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
555 Con_Printf ("%s is not a PK3 file\n", packfile);
560 // Multi-volume ZIP archives are NOT allowed
561 if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
563 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
568 // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
569 // since eocd.nbentries is an unsigned 16 bits integer
570 #if MAX_FILES_IN_PACK < 65535
571 if (eocd.nbentries > MAX_FILES_IN_PACK)
573 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
579 // Create a package structure in memory
580 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
581 pack->ignorecase = true; // PK3 ignores case
582 strlcpy (pack->filename, packfile, sizeof (pack->filename));
583 pack->handle = packhandle;
584 pack->numfiles = eocd.nbentries;
585 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
587 real_nb_files = PK3_BuildFileList (pack, &eocd);
588 if (real_nb_files < 0)
590 Con_Printf ("%s is not a valid PK3 file\n", packfile);
596 Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
603 PK3_GetTrueFileOffset
605 Find where the true file data offset is
608 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
610 unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
614 if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
617 // Load the local file description
618 lseek (pack->handle, pfile->offset, SEEK_SET);
619 count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
620 if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
622 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
626 // Skip name and extra field
627 pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
629 pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
635 =============================================================================
637 OTHER PRIVATE FUNCTIONS
639 =============================================================================
647 Add a file to the list of files contained into a package
650 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
651 fs_offset_t offset, fs_offset_t packsize,
652 fs_offset_t realsize, int flags)
654 int (*strcmp_funct) (const char* str1, const char* str2);
655 int left, right, middle;
658 strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
660 // Look for the slot we should put that file into (binary search)
662 right = pack->numfiles - 1;
663 while (left <= right)
667 middle = (left + right) / 2;
668 diff = strcmp_funct (pack->files[middle].name, name);
670 // If we found the file, there's a problem
672 Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
674 // If we're too far in the list
681 // We have to move the right of the list by one slot to free the one we need
682 pfile = &pack->files[left];
683 memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
686 strlcpy (pfile->name, name, sizeof (pfile->name));
687 pfile->offset = offset;
688 pfile->packsize = packsize;
689 pfile->realsize = realsize;
690 pfile->flags = flags;
700 Only used for FS_Open.
703 void FS_CreatePath (char *path)
707 for (ofs = path+1 ; *ofs ; ofs++)
709 if (*ofs == '/' || *ofs == '\\')
711 // create the directory
727 void FS_Path_f (void)
731 Con_Print("Current search path:\n");
732 for (s=fs_searchpaths ; s ; s=s->next)
735 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
737 Con_Printf("%s\n", s->filename);
746 Takes an explicit (not game tree related) path to a pak file.
748 Loads the header and directory, adding the files at the beginning
749 of the list so they override previous pack files.
752 pack_t *FS_LoadPackPAK (const char *packfile)
754 dpackheader_t header;
760 packhandle = open (packfile, O_RDONLY | O_BINARY);
763 read (packhandle, (void *)&header, sizeof(header));
764 if (memcmp(header.id, "PACK", 4))
766 Con_Printf ("%s is not a packfile\n", packfile);
770 header.dirofs = LittleLong (header.dirofs);
771 header.dirlen = LittleLong (header.dirlen);
773 if (header.dirlen % sizeof(dpackfile_t))
775 Con_Printf ("%s has an invalid directory size\n", packfile);
780 numpackfiles = header.dirlen / sizeof(dpackfile_t);
782 if (numpackfiles > MAX_FILES_IN_PACK)
784 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
789 info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
790 lseek (packhandle, header.dirofs, SEEK_SET);
791 if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
793 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
799 pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
800 pack->ignorecase = false; // PAK is case sensitive
801 strlcpy (pack->filename, packfile, sizeof (pack->filename));
802 pack->handle = packhandle;
804 pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
806 // parse the directory
807 for (i = 0;i < numpackfiles;i++)
809 fs_offset_t offset = LittleLong (info[i].filepos);
810 fs_offset_t size = LittleLong (info[i].filelen);
812 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
817 Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
825 Adds the given pack to the search path.
826 The pack type is autodetected by the file extension.
828 Returns true if the file was successfully added to the
829 search path or if it was already included.
831 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
835 static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
837 searchpath_t *search;
839 const char *ext = FS_FileExtension(pakfile);
841 for(search = fs_searchpaths; search; search = search->next)
843 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
846 *already_loaded = true;
847 return true; // already loaded
852 *already_loaded = false;
854 if(!strcasecmp(ext, "pak"))
855 pak = FS_LoadPackPAK (pakfile);
856 else if(!strcasecmp(ext, "pk3"))
857 pak = FS_LoadPackPK3 (pakfile);
859 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
865 // find the first item whose next one is a pack or NULL
866 searchpath_t *insertion_point = 0;
867 if(fs_searchpaths && !fs_searchpaths->pack)
869 insertion_point = fs_searchpaths;
872 if(!insertion_point->next)
874 if(insertion_point->next->pack)
876 insertion_point = insertion_point->next;
879 // If insertion_point is NULL, this means that either there is no
880 // item in the list yet, or that the very first item is a pack. In
881 // that case, we want to insert at the beginning...
884 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
886 search->next = fs_searchpaths;
887 fs_searchpaths = search;
890 // otherwise we want to append directly after insertion_point.
892 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
894 search->next = insertion_point->next;
895 insertion_point->next = search;
900 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
902 search->next = fs_searchpaths;
903 fs_searchpaths = search;
909 Con_Printf("unable to load pak \"%s\"\n", pakfile);
919 Adds the given pack to the search path and searches for it in the game path.
920 The pack type is autodetected by the file extension.
922 Returns true if the file was successfully added to the
923 search path or if it was already included.
925 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
929 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
931 char fullpath[MAX_QPATH];
933 searchpath_t *search;
936 *already_loaded = false;
938 // then find the real name...
939 search = FS_FindFile(pakfile, &index, true);
940 if(!search || search->pack)
942 Con_Printf("could not find pak \"%s\"\n", pakfile);
946 dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
948 return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
956 Sets fs_gamedir, adds the directory to the head of the path,
957 then loads and adds pak1.pak pak2.pak ...
960 void FS_AddGameDirectory (const char *dir)
962 stringlist_t *list, *current;
963 searchpath_t *search;
964 char pakfile[MAX_OSPATH];
966 strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
968 list = listdirectory(dir);
970 // add any PAK package in the directory
971 for (current = list;current;current = current->next)
973 if (!strcasecmp(FS_FileExtension(current->text), "pak"))
975 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
976 FS_AddPack_Fullpath(pakfile, NULL, false);
980 // add any PK3 package in the director
981 for (current = list;current;current = current->next)
983 if (!strcasecmp(FS_FileExtension(current->text), "pk3"))
985 dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, current->text);
986 FS_AddPack_Fullpath(pakfile, NULL, false);
991 // Add the directory to the search path
992 // (unpacked files have the priority over packed files)
993 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
994 strlcpy (search->filename, dir, sizeof (search->filename));
995 search->next = fs_searchpaths;
996 fs_searchpaths = search;
1005 void FS_AddGameHierarchy (const char *dir)
1008 const char *homedir;
1011 // Add the common game directory
1012 FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1015 // Add the personal game directory
1016 homedir = getenv ("HOME");
1017 if (homedir != NULL && homedir[0] != '\0')
1018 FS_AddGameDirectory (va("%s/.%s/%s/", homedir, gameuserdirname, dir));
1028 static const char *FS_FileExtension (const char *in)
1030 const char *separator, *backslash, *colon, *dot;
1032 separator = strrchr(in, '/');
1033 backslash = strrchr(in, '\\');
1034 if (!separator || separator < backslash)
1035 separator = backslash;
1036 colon = strrchr(in, ':');
1037 if (!separator || separator < colon)
1040 dot = strrchr(in, '.');
1041 if (dot == NULL || (separator && (dot < separator)))
1056 searchpath_t *search;
1058 fs_mempool = Mem_AllocPool("file management", 0, NULL);
1060 strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1062 // If the base directory is explicitly defined by the compilation process
1063 #ifdef DP_FS_BASEDIR
1064 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1066 strlcpy(fs_basedir, "", sizeof(fs_basedir));
1069 // FIXME: is there a better way to find the directory outside the .app?
1070 if (strstr(com_argv[0], ".app/"))
1074 split = strstr(com_argv[0], ".app/");
1075 while (split > com_argv[0] && *split != '/')
1077 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1078 fs_basedir[split - com_argv[0]] = 0;
1086 // Overrides the system supplied base directory (under GAMENAME)
1087 // 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)
1088 i = COM_CheckParm ("-basedir");
1089 if (i && i < com_argc-1)
1091 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1092 i = (int)strlen (fs_basedir);
1093 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1094 fs_basedir[i-1] = 0;
1097 // add a path separator to the end of the basedir if it lacks one
1098 if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1099 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1101 // -path <dir or packfile> [<dir or packfile>] ...
1102 // Fully specifies the exact search path, overriding the generated one
1103 // COMMANDLINEOPTION: Filesystem: -path <path ..> specifies the full search path manually, overriding the generated one, example: -path c:\quake\id1 c:\quake\pak0.pak c:\quake\pak1.pak (not recommended)
1104 i = COM_CheckParm ("-path");
1108 while (++i < com_argc)
1110 if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1113 if(!FS_AddPack_Fullpath(com_argv[i], NULL, false))
1115 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1116 strlcpy (search->filename, com_argv[i], sizeof (search->filename));
1117 search->next = fs_searchpaths;
1118 fs_searchpaths = search;
1124 // add the game-specific paths
1125 // gamedirname1 (typically id1)
1126 FS_AddGameHierarchy (gamedirname1);
1128 // add the game-specific path, if any
1132 FS_AddGameHierarchy (gamedirname2);
1135 // set the com_modname (reported in server info)
1136 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1139 // Adds basedir/gamedir as an override game
1140 // LordHavoc: now supports multiple -game directories
1141 for (i = 1;i < com_argc;i++)
1145 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1149 FS_AddGameHierarchy (com_argv[i]);
1150 // update the com_modname
1151 strlcpy (com_modname, com_argv[i], sizeof (com_modname));
1155 // If "-condebug" is in the command line, remove the previous log file
1156 if (COM_CheckParm ("-condebug") != 0)
1157 unlink (va("%s/qconsole.log", fs_gamedir));
1160 // look for the pop.lmp file and set registered to true if it is found
1161 if (gamemode == GAME_NORMAL && !FS_FileExists("gfx/pop.lmp"))
1164 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1166 Con_Print("Playing shareware version.\n");
1170 Cvar_Set ("registered", "1");
1171 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1172 Con_Print("Playing registered version.\n");
1175 // set the default screenshot name to either the mod name or the
1176 // gamemode screenshot name
1178 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1180 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1183 void FS_Init_Commands(void)
1185 Cvar_RegisterVariable (&scr_screenshot_name);
1187 Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1188 Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1189 Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1197 void FS_Shutdown (void)
1199 Mem_FreePool (&fs_mempool);
1203 ====================
1206 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1207 ====================
1209 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1215 // Parse the mode string
1224 opt = O_CREAT | O_TRUNC;
1228 opt = O_CREAT | O_APPEND;
1231 Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1234 for (ind = 1; mode[ind] != '\0'; ind++)
1245 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1246 filepath, mode, mode[ind]);
1253 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1254 memset (file, 0, sizeof (*file));
1257 file->handle = open (filepath, mod | opt, 0666);
1258 if (file->handle < 0)
1264 file->real_length = lseek (file->handle, 0, SEEK_END);
1266 // For files opened in append mode, we start at the end of the file
1268 file->position = file->real_length;
1270 lseek (file->handle, 0, SEEK_SET);
1280 Open a packed file using its package file descriptor
1283 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1289 pfile = &pack->files[pack_ind];
1291 // If we don't have the true offset, get it now
1292 if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1293 if (!PK3_GetTrueFileOffset (pfile, pack))
1296 // No Zlib DLL = no compressed files
1297 if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1299 Con_Printf("WARNING: can't open the compressed file %s\n"
1300 "You need the Zlib DLL to use compressed files\n",
1305 // LordHavoc: lseek affects all duplicates of a handle so we do it before
1306 // the dup() call to avoid having to close the dup_handle on error here
1307 if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1309 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1310 pfile->name, pack->filename, pfile->offset);
1314 dup_handle = dup (pack->handle);
1317 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1321 file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1322 memset (file, 0, sizeof (*file));
1323 file->handle = dup_handle;
1324 file->flags = QFILE_FLAG_PACKED;
1325 file->real_length = pfile->realsize;
1326 file->offset = pfile->offset;
1330 if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1334 file->flags |= QFILE_FLAG_DEFLATED;
1336 // We need some more variables
1337 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1339 ztk->comp_length = pfile->packsize;
1341 // Initialize zlib stream
1342 ztk->zstream.next_in = ztk->input;
1343 ztk->zstream.avail_in = 0;
1345 /* From Zlib's "unzip.c":
1347 * windowBits is passed < 0 to tell that there is no zlib header.
1348 * Note that in this case inflate *requires* an extra "dummy" byte
1349 * after the compressed stream in order to complete decompression and
1350 * return Z_STREAM_END.
1351 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1352 * size of both compressed and uncompressed data
1354 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1356 Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1362 ztk->zstream.next_out = file->buff;
1363 ztk->zstream.avail_out = sizeof (file->buff);
1372 ====================
1375 Return true if the path should be rejected due to one of the following:
1376 1: path elements that are non-portable
1377 2: path elements that would allow access to files outside the game directory,
1378 or are just not a good idea for a mod to be using.
1379 ====================
1381 int FS_CheckNastyPath (const char *path)
1383 // Windows: don't allow \ in filenames (windows-only), period.
1384 // (on Windows \ is a directory separator, but / is also supported)
1385 if (strstr(path, "\\"))
1386 return 1; // non-portable
1388 // Mac: don't allow Mac-only filenames - : is a directory separator
1389 // instead of /, but we rely on / working already, so there's no reason to
1390 // support a Mac-only path
1391 // Amiga and Windows: : tries to go to root of drive
1392 if (strstr(path, ":"))
1393 return 1; // non-portable attempt to go to root of drive
1395 // Amiga: // is parent directory
1396 if (strstr(path, "//"))
1397 return 1; // non-portable attempt to go to parent directory
1399 // all: don't allow going to current directory (./) or parent directory (../ or /../)
1400 if (strstr(path, "./"))
1401 return 2; // attempt to go outside the game directory
1403 // Windows and UNIXes: don't allow absolute paths
1405 return 2; // attempt to go outside the game directory
1407 // after all these checks we're pretty sure it's a / separated filename
1408 // and won't do much if any harm
1414 ====================
1417 Look for a file in the packages and in the filesystem
1419 Return the searchpath where the file was found (or NULL)
1420 and the file index in the package if relevant
1421 ====================
1423 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1425 searchpath_t *search;
1428 // search through the path, one element at a time
1429 for (search = fs_searchpaths;search;search = search->next)
1431 // is the element a pak file?
1434 int (*strcmp_funct) (const char* str1, const char* str2);
1435 int left, right, middle;
1438 strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1440 // Look for the file (binary search)
1442 right = pak->numfiles - 1;
1443 while (left <= right)
1447 middle = (left + right) / 2;
1448 diff = strcmp_funct (pak->files[middle].name, name);
1453 if (!quiet && developer.integer >= 10)
1454 Con_Printf("FS_FindFile: %s in %s\n",
1455 pak->files[middle].name, pak->filename);
1462 // If we're too far in the list
1471 char netpath[MAX_OSPATH];
1472 dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1473 if (FS_SysFileExists (netpath))
1475 if (!quiet && developer.integer >= 10)
1476 Con_Printf("FS_FindFile: %s\n", netpath);
1485 if (!quiet && developer.integer >= 10)
1486 Con_Printf("FS_FindFile: can't find %s\n", name);
1498 Look for a file in the search paths and open it in read-only mode
1501 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1503 searchpath_t *search;
1506 search = FS_FindFile (filename, &pack_ind, quiet);
1512 // Found in the filesystem?
1515 char path [MAX_OSPATH];
1516 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1517 return FS_SysOpen (path, "rb", nonblocking);
1520 // So, we found it in a package...
1521 return FS_OpenPackedFile (search->pack, pack_ind);
1526 =============================================================================
1528 MAIN PUBLIC FUNCTIONS
1530 =============================================================================
1534 ====================
1537 Open a file. The syntax is the same as fopen
1538 ====================
1540 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1542 if (FS_CheckNastyPath(filepath))
1544 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1548 // If the file is opened in "write", "append", or "read/write" mode
1549 if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1551 char real_path [MAX_OSPATH];
1553 // Open the file on disk directly
1554 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1556 // Create directories up to the file
1557 FS_CreatePath (real_path);
1559 return FS_SysOpen (real_path, mode, nonblocking);
1561 // Else, we look at the various search paths and open the file in read-only mode
1563 return FS_OpenReadFile (filepath, quiet, nonblocking);
1568 ====================
1572 ====================
1574 int FS_Close (qfile_t* file)
1576 if (close (file->handle))
1581 qz_inflateEnd (&file->ztk->zstream);
1582 Mem_Free (file->ztk);
1591 ====================
1594 Write "datasize" bytes into a file
1595 ====================
1597 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1601 // If necessary, seek to the exact file position we're supposed to be
1602 if (file->buff_ind != file->buff_len)
1603 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1605 // Purge cached data
1608 // Write the buffer and update the position
1609 result = write (file->handle, data, (fs_offset_t)datasize);
1610 file->position = lseek (file->handle, 0, SEEK_CUR);
1611 if (file->real_length < file->position)
1612 file->real_length = file->position;
1622 ====================
1625 Read up to "buffersize" bytes from a file
1626 ====================
1628 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1630 fs_offset_t count, done;
1632 if (buffersize == 0)
1635 // Get rid of the ungetc character
1636 if (file->ungetc != EOF)
1638 ((char*)buffer)[0] = file->ungetc;
1646 // First, we copy as many bytes as we can from "buff"
1647 if (file->buff_ind < file->buff_len)
1649 count = file->buff_len - file->buff_ind;
1651 done += ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1652 memcpy (buffer, &file->buff[file->buff_ind], done);
1653 file->buff_ind += done;
1656 if (buffersize == 0)
1660 // NOTE: at this point, the read buffer is always empty
1662 // If the file isn't compressed
1663 if (! (file->flags & QFILE_FLAG_DEFLATED))
1667 // We must take care to not read after the end of the file
1668 count = file->real_length - file->position;
1670 // If we have a lot of data to get, put them directly into "buffer"
1671 if (buffersize > sizeof (file->buff) / 2)
1673 if (count > (fs_offset_t)buffersize)
1674 count = (fs_offset_t)buffersize;
1675 lseek (file->handle, file->offset + file->position, SEEK_SET);
1676 nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1680 file->position += nb;
1682 // Purge cached data
1688 if (count > (fs_offset_t)sizeof (file->buff))
1689 count = (fs_offset_t)sizeof (file->buff);
1690 lseek (file->handle, file->offset + file->position, SEEK_SET);
1691 nb = read (file->handle, file->buff, count);
1694 file->buff_len = nb;
1695 file->position += nb;
1697 // Copy the requested data in "buffer" (as much as we can)
1698 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1699 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1700 file->buff_ind = count;
1708 // If the file is compressed, it's more complicated...
1709 // We cycle through a few operations until we have read enough data
1710 while (buffersize > 0)
1712 ztoolkit_t *ztk = file->ztk;
1715 // NOTE: at this point, the read buffer is always empty
1717 // If "input" is also empty, we need to refill it
1718 if (ztk->in_ind == ztk->in_len)
1720 // If we are at the end of the file
1721 if (file->position == file->real_length)
1724 count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
1725 if (count > (fs_offset_t)sizeof (ztk->input))
1726 count = (fs_offset_t)sizeof (ztk->input);
1727 lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
1728 if (read (file->handle, ztk->input, count) != count)
1730 Con_Printf ("FS_Read: unexpected end of file\n");
1735 ztk->in_len = count;
1736 ztk->in_position += count;
1739 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
1740 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
1742 // Now that we are sure we have compressed data available, we need to determine
1743 // if it's better to inflate it in "file->buff" or directly in "buffer"
1745 // Inflate the data in "file->buff"
1746 if (buffersize < sizeof (file->buff) / 2)
1748 ztk->zstream.next_out = file->buff;
1749 ztk->zstream.avail_out = sizeof (file->buff);
1750 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
1751 if (error != Z_OK && error != Z_STREAM_END)
1753 Con_Printf ("FS_Read: Can't inflate file\n");
1756 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
1758 file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
1759 file->position += file->buff_len;
1761 // Copy the requested data in "buffer" (as much as we can)
1762 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1763 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1764 file->buff_ind = count;
1767 // Else, we inflate directly in "buffer"
1770 ztk->zstream.next_out = &((unsigned char*)buffer)[done];
1771 ztk->zstream.avail_out = (unsigned int)buffersize;
1772 error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
1773 if (error != Z_OK && error != Z_STREAM_END)
1775 Con_Printf ("FS_Read: Can't inflate file\n");
1778 ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
1780 // How much data did it inflate?
1781 count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
1782 file->position += count;
1784 // Purge cached data
1789 buffersize -= count;
1797 ====================
1800 Print a string into a file
1801 ====================
1803 int FS_Print (qfile_t* file, const char *msg)
1805 return (int)FS_Write (file, msg, strlen (msg));
1809 ====================
1812 Print a string into a file
1813 ====================
1815 int FS_Printf(qfile_t* file, const char* format, ...)
1820 va_start (args, format);
1821 result = FS_VPrintf (file, format, args);
1829 ====================
1832 Print a string into a file
1833 ====================
1835 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
1838 fs_offset_t buff_size = MAX_INPUTLINE;
1843 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
1844 len = dpvsnprintf (tempbuff, buff_size, format, ap);
1845 if (len >= 0 && len < buff_size)
1847 Mem_Free (tempbuff);
1851 len = write (file->handle, tempbuff, len);
1852 Mem_Free (tempbuff);
1859 ====================
1862 Get the next character of a file
1863 ====================
1865 int FS_Getc (qfile_t* file)
1869 if (FS_Read (file, &c, 1) != 1)
1877 ====================
1880 Put a character back into the read buffer (only supports one character!)
1881 ====================
1883 int FS_UnGetc (qfile_t* file, unsigned char c)
1885 // If there's already a character waiting to be read
1886 if (file->ungetc != EOF)
1895 ====================
1898 Move the position index in a file
1899 ====================
1901 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
1904 unsigned char* buffer;
1905 fs_offset_t buffersize;
1907 // Compute the file offset
1911 offset += file->position - file->buff_len + file->buff_ind;
1918 offset += file->real_length;
1924 if (offset < 0 || offset > (long) file->real_length)
1927 // If we have the data in our read buffer, we don't need to actually seek
1928 if (file->position - file->buff_len <= offset && offset <= file->position)
1930 file->buff_ind = offset + file->buff_len - file->position;
1934 // Purge cached data
1937 // Unpacked or uncompressed files can seek directly
1938 if (! (file->flags & QFILE_FLAG_DEFLATED))
1940 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
1942 file->position = offset;
1946 // Seeking in compressed files is more a hack than anything else,
1947 // but we need to support it, so here we go.
1950 // If we have to go back in the file, we need to restart from the beginning
1951 if (offset <= file->position)
1955 ztk->in_position = 0;
1957 lseek (file->handle, file->offset, SEEK_SET);
1959 // Reset the Zlib stream
1960 ztk->zstream.next_in = ztk->input;
1961 ztk->zstream.avail_in = 0;
1962 qz_inflateReset (&ztk->zstream);
1965 // We need a big buffer to force inflating into it directly
1966 buffersize = 2 * sizeof (file->buff);
1967 buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
1969 // Skip all data until we reach the requested offset
1970 while (offset > file->position)
1972 fs_offset_t diff = offset - file->position;
1973 fs_offset_t count, len;
1975 count = (diff > buffersize) ? buffersize : diff;
1976 len = FS_Read (file, buffer, count);
1990 ====================
1993 Give the current position in a file
1994 ====================
1996 fs_offset_t FS_Tell (qfile_t* file)
1998 return file->position - file->buff_len + file->buff_ind;
2003 ====================
2006 Erases any buffered input or output data
2007 ====================
2009 void FS_Purge (qfile_t* file)
2021 Filename are relative to the quake directory.
2022 Always appends a 0 byte.
2025 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2028 unsigned char *buf = NULL;
2029 fs_offset_t filesize = 0;
2031 file = FS_Open (path, "rb", quiet, false);
2034 filesize = file->real_length;
2035 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2036 buf[filesize] = '\0';
2037 FS_Read (file, buf, filesize);
2041 if (filesizepointer)
2042 *filesizepointer = filesize;
2051 The filename will be prefixed by the current game directory
2054 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2058 file = FS_Open (filename, "wb", false, false);
2061 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2065 Con_DPrintf("FS_WriteFile: %s\n", filename);
2066 FS_Write (file, data, len);
2073 =============================================================================
2075 OTHERS PUBLIC FUNCTIONS
2077 =============================================================================
2085 void FS_StripExtension (const char *in, char *out, size_t size_out)
2093 while ((currentchar = *in) && size_out > 1)
2095 if (currentchar == '.')
2097 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2099 *out++ = currentchar;
2115 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2119 // if path doesn't have a .EXT, append extension
2120 // (extension should include the .)
2121 src = path + strlen(path) - 1;
2123 while (*src != '/' && src != path)
2126 return; // it has an extension
2130 strlcat (path, extension, size_path);
2138 Look for a file in the packages and in the filesystem
2141 qboolean FS_FileExists (const char *filename)
2143 return (FS_FindFile (filename, NULL, true) != NULL);
2151 Look for a file in the filesystem only
2154 qboolean FS_SysFileExists (const char *path)
2159 // TODO: use another function instead, to avoid opening the file
2160 desc = open (path, O_RDONLY | O_BINARY);
2169 if (stat (path,&buf) == -1)
2176 void FS_mkdir (const char *path)
2189 Allocate and fill a search structure with information on matching filenames.
2192 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2195 searchpath_t *searchpath;
2197 int i, basepathlength, numfiles, numchars;
2198 stringlist_t *dir, *dirfile, *liststart, *listcurrent, *listtemp;
2199 const char *slash, *backslash, *colon, *separator;
2201 char netpath[MAX_OSPATH];
2202 char temp[MAX_OSPATH];
2204 for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2209 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2217 slash = strrchr(pattern, '/');
2218 backslash = strrchr(pattern, '\\');
2219 colon = strrchr(pattern, ':');
2220 separator = max(slash, backslash);
2221 separator = max(separator, colon);
2222 basepathlength = separator ? (separator + 1 - pattern) : 0;
2223 basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2225 memcpy(basepath, pattern, basepathlength);
2226 basepath[basepathlength] = 0;
2228 // search through the path, one element at a time
2229 for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2231 // is the element a pak file?
2232 if (searchpath->pack)
2234 // look through all the pak file elements
2235 pak = searchpath->pack;
2236 for (i = 0;i < pak->numfiles;i++)
2238 strlcpy(temp, pak->files[i].name, sizeof(temp));
2241 if (matchpattern(temp, (char *)pattern, true))
2243 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2244 if (!strcmp(listtemp->text, temp))
2246 if (listtemp == NULL)
2248 listcurrent = stringlistappend(listcurrent, temp);
2249 if (liststart == NULL)
2250 liststart = listcurrent;
2252 Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
2255 // strip off one path element at a time until empty
2256 // this way directories are added to the listing if they match the pattern
2257 slash = strrchr(temp, '/');
2258 backslash = strrchr(temp, '\\');
2259 colon = strrchr(temp, ':');
2261 if (separator < slash)
2263 if (separator < backslash)
2264 separator = backslash;
2265 if (separator < colon)
2267 *((char *)separator) = 0;
2273 // get a directory listing and look at each name
2274 dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2275 if ((dir = listdirectory(netpath)))
2277 for (dirfile = dir;dirfile;dirfile = dirfile->next)
2279 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirfile->text);
2280 if (matchpattern(temp, (char *)pattern, true))
2282 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2283 if (!strcmp(listtemp->text, temp))
2285 if (listtemp == NULL)
2287 listcurrent = stringlistappend(listcurrent, temp);
2288 if (liststart == NULL)
2289 liststart = listcurrent;
2291 Con_DPrintf("SearchDirFile: %s\n", temp);
2302 liststart = stringlistsort(liststart);
2305 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2308 numchars += (int)strlen(listtemp->text) + 1;
2310 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2311 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2312 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2313 search->numfilenames = (int)numfiles;
2316 for (listtemp = liststart;listtemp;listtemp = listtemp->next)
2319 search->filenames[numfiles] = search->filenamesbuffer + numchars;
2320 textlen = strlen(listtemp->text) + 1;
2321 memcpy(search->filenames[numfiles], listtemp->text, textlen);
2323 numchars += (int)textlen;
2326 stringlistfree(liststart);
2333 void FS_FreeSearch(fssearch_t *search)
2338 extern int con_linewidth;
2339 int FS_ListDirectory(const char *pattern, int oneperline)
2348 char linebuf[MAX_INPUTLINE];
2350 search = FS_Search(pattern, true, true);
2353 numfiles = search->numfilenames;
2356 // FIXME: the names could be added to one column list and then
2357 // gradually shifted into the next column if they fit, and then the
2358 // next to make a compact variable width listing but it's a lot more
2360 // find width for columns
2362 for (i = 0;i < numfiles;i++)
2364 l = (int)strlen(search->filenames[i]);
2365 if (columnwidth < l)
2368 // count the spacing character
2370 // calculate number of columns
2371 numcolumns = con_linewidth / columnwidth;
2372 // don't bother with the column printing if it's only one column
2373 if (numcolumns >= 2)
2375 numlines = (numfiles + numcolumns - 1) / numcolumns;
2376 for (i = 0;i < numlines;i++)
2379 for (k = 0;k < numcolumns;k++)
2381 l = i * numcolumns + k;
2384 name = search->filenames[l];
2385 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2386 linebuf[linebufpos++] = name[j];
2387 // space out name unless it's the last on the line
2388 if (k + 1 < numcolumns && l + 1 < numfiles)
2389 for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2390 linebuf[linebufpos++] = ' ';
2393 linebuf[linebufpos] = 0;
2394 Con_Printf("%s\n", linebuf);
2401 for (i = 0;i < numfiles;i++)
2402 Con_Printf("%s\n", search->filenames[i]);
2403 FS_FreeSearch(search);
2404 return (int)numfiles;
2407 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2409 const char *pattern;
2412 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2415 if (Cmd_Argc() == 2)
2416 pattern = Cmd_Argv(1);
2419 if (!FS_ListDirectory(pattern, oneperline))
2420 Con_Print("No files found.\n");
2425 FS_ListDirectoryCmd("dir", true);
2430 FS_ListDirectoryCmd("ls", false);
2433 const char *FS_WhichPack(const char *filename)
2436 searchpath_t *sp = FS_FindFile(filename, &index, true);
2438 return sp->pack->filename;