remove -appdata option... make -mygames option instead (easier to find for users...
[divverent/darkplaces.git] / fs.c
1 /*
2         DarkPlaces file system
3
4         Copyright (C) 2003-2006 Mathieu Olivier
5
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.
10
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.
14
15         See the GNU General Public License for more details.
16
17         You should have received a copy of the GNU General Public License
18         along with this program; if not, write to:
19
20                 Free Software Foundation, Inc.
21                 59 Temple Place - Suite 330
22                 Boston, MA  02111-1307, USA
23 */
24
25 #include "quakedef.h"
26
27 #include <limits.h>
28 #include <fcntl.h>
29
30 #ifdef WIN32
31 # include <direct.h>
32 # include <io.h>
33 # include <shlobj.h>
34 #else
35 # include <pwd.h>
36 # include <sys/stat.h>
37 # include <unistd.h>
38 #endif
39
40 #include "fs.h"
41 #include "wad.h"
42
43 // Win32 requires us to add O_BINARY, but the other OSes don't have it
44 #ifndef O_BINARY
45 # define O_BINARY 0
46 #endif
47
48 // In case the system doesn't support the O_NONBLOCK flag
49 #ifndef O_NONBLOCK
50 # define O_NONBLOCK 0
51 #endif
52
53 // largefile support for Win32
54 #ifdef WIN32
55 # define lseek _lseeki64
56 #endif
57
58 /*
59
60 All of Quake's data access is through a hierchal file system, but the contents
61 of the file system can be transparently merged from several sources.
62
63 The "base directory" is the path to the directory holding the quake.exe and
64 all game directories.  The sys_* files pass this to host_init in
65 quakeparms_t->basedir.  This can be overridden with the "-basedir" command
66 line parm to allow code debugging in a different directory.  The base
67 directory is only used during filesystem initialization.
68
69 The "game directory" is the first tree on the search path and directory that
70 all generated files (savegames, screenshots, demos, config files) will be
71 saved to.  This can be overridden with the "-game" command line parameter.
72 The game directory can never be changed while quake is executing.  This is a
73 precaution against having a malicious server instruct clients to write files
74 over areas they shouldn't.
75
76 */
77
78
79 /*
80 =============================================================================
81
82 CONSTANTS
83
84 =============================================================================
85 */
86
87 // Magic numbers of a ZIP file (big-endian format)
88 #define ZIP_DATA_HEADER 0x504B0304  // "PK\3\4"
89 #define ZIP_CDIR_HEADER 0x504B0102  // "PK\1\2"
90 #define ZIP_END_HEADER  0x504B0506  // "PK\5\6"
91
92 // Other constants for ZIP files
93 #define ZIP_MAX_COMMENTS_SIZE           ((unsigned short)0xFFFF)
94 #define ZIP_END_CDIR_SIZE                       22
95 #define ZIP_CDIR_CHUNK_BASE_SIZE        46
96 #define ZIP_LOCAL_CHUNK_BASE_SIZE       30
97
98 // Zlib constants (from zlib.h)
99 #define Z_SYNC_FLUSH    2
100 #define MAX_WBITS               15
101 #define Z_OK                    0
102 #define Z_STREAM_END    1
103 #define ZLIB_VERSION    "1.2.3"
104
105 // Uncomment the following line if the zlib DLL you have still uses
106 // the 1.1.x series calling convention on Win32 (WINAPI)
107 //#define ZLIB_USES_WINAPI
108
109
110 /*
111 =============================================================================
112
113 TYPES
114
115 =============================================================================
116 */
117
118 // Zlib stream (from zlib.h)
119 // Warning: some pointers we don't use directly have
120 // been cast to "void*" for a matter of simplicity
121 typedef struct
122 {
123         unsigned char                   *next_in;       // next input byte
124         unsigned int    avail_in;       // number of bytes available at next_in
125         unsigned long   total_in;       // total nb of input bytes read so far
126
127         unsigned char                   *next_out;      // next output byte should be put there
128         unsigned int    avail_out;      // remaining free space at next_out
129         unsigned long   total_out;      // total nb of bytes output so far
130
131         char                    *msg;           // last error message, NULL if no error
132         void                    *state;         // not visible by applications
133
134         void                    *zalloc;        // used to allocate the internal state
135         void                    *zfree;         // used to free the internal state
136         void                    *opaque;        // private data object passed to zalloc and zfree
137
138         int                             data_type;      // best guess about the data type: ascii or binary
139         unsigned long   adler;          // adler32 value of the uncompressed data
140         unsigned long   reserved;       // reserved for future use
141 } z_stream;
142
143
144 // inside a package (PAK or PK3)
145 #define QFILE_FLAG_PACKED (1 << 0)
146 // file is compressed using the deflate algorithm (PK3 only)
147 #define QFILE_FLAG_DEFLATED (1 << 1)
148
149 #define FILE_BUFF_SIZE 2048
150 typedef struct
151 {
152         z_stream        zstream;
153         size_t          comp_length;                    // length of the compressed file
154         size_t          in_ind, in_len;                 // input buffer current index and length
155         size_t          in_position;                    // position in the compressed file
156         unsigned char           input [FILE_BUFF_SIZE];
157 } ztoolkit_t;
158
159 struct qfile_s
160 {
161         int                             flags;
162         int                             handle;                                 // file descriptor
163         fs_offset_t             real_length;                    // uncompressed file size (for files opened in "read" mode)
164         fs_offset_t             position;                               // current position in the file
165         fs_offset_t             offset;                                 // offset into the package (0 if external file)
166         int                             ungetc;                                 // single stored character from ungetc, cleared to EOF when read
167
168         // Contents buffer
169         fs_offset_t             buff_ind, buff_len;             // buffer current index and length
170         unsigned char                   buff [FILE_BUFF_SIZE];
171
172         // For zipped files
173         ztoolkit_t*             ztk;
174 };
175
176
177 // ------ PK3 files on disk ------ //
178
179 // You can get the complete ZIP format description from PKWARE website
180
181 typedef struct pk3_endOfCentralDir_s
182 {
183         unsigned int signature;
184         unsigned short disknum;
185         unsigned short cdir_disknum;    // number of the disk with the start of the central directory
186         unsigned short localentries;    // number of entries in the central directory on this disk
187         unsigned short nbentries;               // total number of entries in the central directory on this disk
188         unsigned int cdir_size;                 // size of the central directory
189         unsigned int cdir_offset;               // with respect to the starting disk number
190         unsigned short comment_size;
191 } pk3_endOfCentralDir_t;
192
193
194 // ------ PAK files on disk ------ //
195 typedef struct dpackfile_s
196 {
197         char name[56];
198         int filepos, filelen;
199 } dpackfile_t;
200
201 typedef struct dpackheader_s
202 {
203         char id[4];
204         int dirofs;
205         int dirlen;
206 } dpackheader_t;
207
208
209 // Packages in memory
210 // the offset in packfile_t is the true contents offset
211 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
212 // file compressed using the deflate algorithm
213 #define PACKFILE_FLAG_DEFLATED (1 << 1)
214
215 typedef struct packfile_s
216 {
217         char name [MAX_QPATH];
218         int flags;
219         fs_offset_t offset;
220         fs_offset_t packsize;   // size in the package
221         fs_offset_t realsize;   // real file size (uncompressed)
222 } packfile_t;
223
224 typedef struct pack_s
225 {
226         char filename [MAX_OSPATH];
227         int handle;
228         int ignorecase;  // PK3 ignores case
229         int numfiles;
230         packfile_t *files;
231 } pack_t;
232
233
234 // Search paths for files (including packages)
235 typedef struct searchpath_s
236 {
237         // only one of filename / pack will be used
238         char filename[MAX_OSPATH];
239         pack_t *pack;
240         struct searchpath_s *next;
241 } searchpath_t;
242
243
244 /*
245 =============================================================================
246
247 FUNCTION PROTOTYPES
248
249 =============================================================================
250 */
251
252 void FS_Dir_f(void);
253 void FS_Ls_f(void);
254
255 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
256 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
257                                                                         fs_offset_t offset, fs_offset_t packsize,
258                                                                         fs_offset_t realsize, int flags);
259
260
261 /*
262 =============================================================================
263
264 VARIABLES
265
266 =============================================================================
267 */
268
269 mempool_t *fs_mempool;
270
271 searchpath_t *fs_searchpaths = NULL;
272
273 #define MAX_FILES_IN_PACK       65536
274
275 char fs_gamedir[MAX_OSPATH];
276 char fs_basedir[MAX_OSPATH];
277
278 // list of active game directories (empty if not running a mod)
279 int fs_numgamedirs = 0;
280 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
281
282 cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running)"};
283 cvar_t fs_empty_files_in_pack_mark_deletions = {0, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
284
285
286 /*
287 =============================================================================
288
289 PRIVATE FUNCTIONS - PK3 HANDLING
290
291 =============================================================================
292 */
293
294 // Functions exported from zlib
295 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
296 # define ZEXPORT WINAPI
297 #else
298 # define ZEXPORT
299 #endif
300
301 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
302 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
303 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
304 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
305
306 #define qz_inflateInit2(strm, windowBits) \
307         qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
308
309 static dllfunction_t zlibfuncs[] =
310 {
311         {"inflate",                     (void **) &qz_inflate},
312         {"inflateEnd",          (void **) &qz_inflateEnd},
313         {"inflateInit2_",       (void **) &qz_inflateInit2_},
314         {"inflateReset",        (void **) &qz_inflateReset},
315         {NULL, NULL}
316 };
317
318 // Handle for Zlib DLL
319 static dllhandle_t zlib_dll = NULL;
320
321
322 /*
323 ====================
324 PK3_CloseLibrary
325
326 Unload the Zlib DLL
327 ====================
328 */
329 void PK3_CloseLibrary (void)
330 {
331         Sys_UnloadLibrary (&zlib_dll);
332 }
333
334
335 /*
336 ====================
337 PK3_OpenLibrary
338
339 Try to load the Zlib DLL
340 ====================
341 */
342 qboolean PK3_OpenLibrary (void)
343 {
344         const char* dllnames [] =
345         {
346 #if defined(WIN64)
347                 "zlib64.dll",
348 #elif defined(WIN32)
349 # ifdef ZLIB_USES_WINAPI
350                 "zlibwapi.dll",
351                 "zlib.dll",
352 # else
353                 "zlib1.dll",
354 # endif
355 #elif defined(MACOSX)
356                 "libz.dylib",
357 #else
358                 "libz.so.1",
359                 "libz.so",
360 #endif
361                 NULL
362         };
363
364         // Already loaded?
365         if (zlib_dll)
366                 return true;
367
368         // Load the DLL
369         if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
370         {
371                 Con_Printf ("Compressed files support disabled\n");
372                 return false;
373         }
374
375         Con_Printf ("Compressed files support enabled\n");
376         return true;
377 }
378
379
380 /*
381 ====================
382 PK3_GetEndOfCentralDir
383
384 Extract the end of the central directory from a PK3 package
385 ====================
386 */
387 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
388 {
389         fs_offset_t filesize, maxsize;
390         unsigned char *buffer, *ptr;
391         int ind;
392
393         // Get the package size
394         filesize = lseek (packhandle, 0, SEEK_END);
395         if (filesize < ZIP_END_CDIR_SIZE)
396                 return false;
397
398         // Load the end of the file in memory
399         if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
400                 maxsize = filesize;
401         else
402                 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
403         buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
404         lseek (packhandle, filesize - maxsize, SEEK_SET);
405         if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
406         {
407                 Mem_Free (buffer);
408                 return false;
409         }
410
411         // Look for the end of central dir signature around the end of the file
412         maxsize -= ZIP_END_CDIR_SIZE;
413         ptr = &buffer[maxsize];
414         ind = 0;
415         while (BuffBigLong (ptr) != ZIP_END_HEADER)
416         {
417                 if (ind == maxsize)
418                 {
419                         Mem_Free (buffer);
420                         return false;
421                 }
422
423                 ind++;
424                 ptr--;
425         }
426
427         memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
428         eocd->signature = LittleLong (eocd->signature);
429         eocd->disknum = LittleShort (eocd->disknum);
430         eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
431         eocd->localentries = LittleShort (eocd->localentries);
432         eocd->nbentries = LittleShort (eocd->nbentries);
433         eocd->cdir_size = LittleLong (eocd->cdir_size);
434         eocd->cdir_offset = LittleLong (eocd->cdir_offset);
435         eocd->comment_size = LittleShort (eocd->comment_size);
436
437         Mem_Free (buffer);
438
439         return true;
440 }
441
442
443 /*
444 ====================
445 PK3_BuildFileList
446
447 Extract the file list from a PK3 file
448 ====================
449 */
450 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
451 {
452         unsigned char *central_dir, *ptr;
453         unsigned int ind;
454         fs_offset_t remaining;
455
456         // Load the central directory in memory
457         central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
458         lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
459         read (pack->handle, central_dir, eocd->cdir_size);
460
461         // Extract the files properties
462         // The parsing is done "by hand" because some fields have variable sizes and
463         // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
464         remaining = eocd->cdir_size;
465         pack->numfiles = 0;
466         ptr = central_dir;
467         for (ind = 0; ind < eocd->nbentries; ind++)
468         {
469                 fs_offset_t namesize, count;
470
471                 // Checking the remaining size
472                 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
473                 {
474                         Mem_Free (central_dir);
475                         return -1;
476                 }
477                 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
478
479                 // Check header
480                 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
481                 {
482                         Mem_Free (central_dir);
483                         return -1;
484                 }
485
486                 namesize = BuffLittleShort (&ptr[28]);  // filename length
487
488                 // Check encryption, compression, and attributes
489                 // 1st uint8  : general purpose bit flag
490                 //    Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
491                 // 2nd uint8 : external file attributes
492                 //    Check bits 3 (file is a directory) and 5 (file is a volume (?))
493                 if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
494                 {
495                         // Still enough bytes for the name?
496                         if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
497                         {
498                                 Mem_Free (central_dir);
499                                 return -1;
500                         }
501
502                         // WinZip doesn't use the "directory" attribute, so we need to check the name directly
503                         if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
504                         {
505                                 char filename [sizeof (pack->files[0].name)];
506                                 fs_offset_t offset, packsize, realsize;
507                                 int flags;
508
509                                 // Extract the name (strip it if necessary)
510                                 namesize = min(namesize, (int)sizeof (filename) - 1);
511                                 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
512                                 filename[namesize] = '\0';
513
514                                 if (BuffLittleShort (&ptr[10]))
515                                         flags = PACKFILE_FLAG_DEFLATED;
516                                 else
517                                         flags = 0;
518                                 offset = BuffLittleLong (&ptr[42]);
519                                 packsize = BuffLittleLong (&ptr[20]);
520                                 realsize = BuffLittleLong (&ptr[24]);
521                                 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
522                         }
523                 }
524
525                 // Skip the name, additionnal field, and comment
526                 // 1er uint16 : extra field length
527                 // 2eme uint16 : file comment length
528                 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
529                 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
530                 remaining -= count;
531         }
532
533         // If the package is empty, central_dir is NULL here
534         if (central_dir != NULL)
535                 Mem_Free (central_dir);
536         return pack->numfiles;
537 }
538
539
540 /*
541 ====================
542 FS_LoadPackPK3
543
544 Create a package entry associated with a PK3 file
545 ====================
546 */
547 pack_t *FS_LoadPackPK3 (const char *packfile)
548 {
549         int packhandle;
550         pk3_endOfCentralDir_t eocd;
551         pack_t *pack;
552         int real_nb_files;
553
554         packhandle = open (packfile, O_RDONLY | O_BINARY);
555         if (packhandle < 0)
556                 return NULL;
557
558         if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
559         {
560                 Con_Printf ("%s is not a PK3 file\n", packfile);
561                 close(packhandle);
562                 return NULL;
563         }
564
565         // Multi-volume ZIP archives are NOT allowed
566         if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
567         {
568                 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
569                 close(packhandle);
570                 return NULL;
571         }
572
573         // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
574         // since eocd.nbentries is an unsigned 16 bits integer
575 #if MAX_FILES_IN_PACK < 65535
576         if (eocd.nbentries > MAX_FILES_IN_PACK)
577         {
578                 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
579                 close(packhandle);
580                 return NULL;
581         }
582 #endif
583
584         // Create a package structure in memory
585         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
586         pack->ignorecase = true; // PK3 ignores case
587         strlcpy (pack->filename, packfile, sizeof (pack->filename));
588         pack->handle = packhandle;
589         pack->numfiles = eocd.nbentries;
590         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
591
592         real_nb_files = PK3_BuildFileList (pack, &eocd);
593         if (real_nb_files < 0)
594         {
595                 Con_Printf ("%s is not a valid PK3 file\n", packfile);
596                 close(pack->handle);
597                 Mem_Free(pack);
598                 return NULL;
599         }
600
601         Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
602         return pack;
603 }
604
605
606 /*
607 ====================
608 PK3_GetTrueFileOffset
609
610 Find where the true file data offset is
611 ====================
612 */
613 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
614 {
615         unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
616         fs_offset_t count;
617
618         // Already found?
619         if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
620                 return true;
621
622         // Load the local file description
623         lseek (pack->handle, pfile->offset, SEEK_SET);
624         count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
625         if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
626         {
627                 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
628                 return false;
629         }
630
631         // Skip name and extra field
632         pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
633
634         pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
635         return true;
636 }
637
638
639 /*
640 =============================================================================
641
642 OTHER PRIVATE FUNCTIONS
643
644 =============================================================================
645 */
646
647
648 /*
649 ====================
650 FS_AddFileToPack
651
652 Add a file to the list of files contained into a package
653 ====================
654 */
655 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
656                                                                          fs_offset_t offset, fs_offset_t packsize,
657                                                                          fs_offset_t realsize, int flags)
658 {
659         int (*strcmp_funct) (const char* str1, const char* str2);
660         int left, right, middle;
661         packfile_t *pfile;
662
663         strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
664
665         // Look for the slot we should put that file into (binary search)
666         left = 0;
667         right = pack->numfiles - 1;
668         while (left <= right)
669         {
670                 int diff;
671
672                 middle = (left + right) / 2;
673                 diff = strcmp_funct (pack->files[middle].name, name);
674
675                 // If we found the file, there's a problem
676                 if (!diff)
677                         Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
678
679                 // If we're too far in the list
680                 if (diff > 0)
681                         right = middle - 1;
682                 else
683                         left = middle + 1;
684         }
685
686         // We have to move the right of the list by one slot to free the one we need
687         pfile = &pack->files[left];
688         memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
689         pack->numfiles++;
690
691         strlcpy (pfile->name, name, sizeof (pfile->name));
692         pfile->offset = offset;
693         pfile->packsize = packsize;
694         pfile->realsize = realsize;
695         pfile->flags = flags;
696
697         return pfile;
698 }
699
700
701 /*
702 ============
703 FS_CreatePath
704
705 Only used for FS_Open.
706 ============
707 */
708 void FS_CreatePath (char *path)
709 {
710         char *ofs, save;
711
712         for (ofs = path+1 ; *ofs ; ofs++)
713         {
714                 if (*ofs == '/' || *ofs == '\\')
715                 {
716                         // create the directory
717                         save = *ofs;
718                         *ofs = 0;
719                         FS_mkdir (path);
720                         *ofs = save;
721                 }
722         }
723 }
724
725
726 /*
727 ============
728 FS_Path_f
729
730 ============
731 */
732 void FS_Path_f (void)
733 {
734         searchpath_t *s;
735
736         Con_Print("Current search path:\n");
737         for (s=fs_searchpaths ; s ; s=s->next)
738         {
739                 if (s->pack)
740                         Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
741                 else
742                         Con_Printf("%s\n", s->filename);
743         }
744 }
745
746
747 /*
748 =================
749 FS_LoadPackPAK
750
751 Takes an explicit (not game tree related) path to a pak file.
752
753 Loads the header and directory, adding the files at the beginning
754 of the list so they override previous pack files.
755 =================
756 */
757 pack_t *FS_LoadPackPAK (const char *packfile)
758 {
759         dpackheader_t header;
760         int i, numpackfiles;
761         int packhandle;
762         pack_t *pack;
763         dpackfile_t *info;
764
765         packhandle = open (packfile, O_RDONLY | O_BINARY);
766         if (packhandle < 0)
767                 return NULL;
768         read (packhandle, (void *)&header, sizeof(header));
769         if (memcmp(header.id, "PACK", 4))
770         {
771                 Con_Printf ("%s is not a packfile\n", packfile);
772                 close(packhandle);
773                 return NULL;
774         }
775         header.dirofs = LittleLong (header.dirofs);
776         header.dirlen = LittleLong (header.dirlen);
777
778         if (header.dirlen % sizeof(dpackfile_t))
779         {
780                 Con_Printf ("%s has an invalid directory size\n", packfile);
781                 close(packhandle);
782                 return NULL;
783         }
784
785         numpackfiles = header.dirlen / sizeof(dpackfile_t);
786
787         if (numpackfiles > MAX_FILES_IN_PACK)
788         {
789                 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
790                 close(packhandle);
791                 return NULL;
792         }
793
794         info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
795         lseek (packhandle, header.dirofs, SEEK_SET);
796         if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
797         {
798                 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
799                 Mem_Free(info);
800                 close(packhandle);
801                 return NULL;
802         }
803
804         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
805         pack->ignorecase = false; // PAK is case sensitive
806         strlcpy (pack->filename, packfile, sizeof (pack->filename));
807         pack->handle = packhandle;
808         pack->numfiles = 0;
809         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
810
811         // parse the directory
812         for (i = 0;i < numpackfiles;i++)
813         {
814                 fs_offset_t offset = LittleLong (info[i].filepos);
815                 fs_offset_t size = LittleLong (info[i].filelen);
816
817                 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
818         }
819
820         Mem_Free(info);
821
822         Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
823         return pack;
824 }
825
826 /*
827 ================
828 FS_AddPack_Fullpath
829
830 Adds the given pack to the search path.
831 The pack type is autodetected by the file extension.
832
833 Returns true if the file was successfully added to the
834 search path or if it was already included.
835
836 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
837 plain directories.
838 ================
839 */
840 static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
841 {
842         searchpath_t *search;
843         pack_t *pak = NULL;
844         const char *ext = FS_FileExtension(pakfile);
845
846         for(search = fs_searchpaths; search; search = search->next)
847         {
848                 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
849                 {
850                         if(already_loaded)
851                                 *already_loaded = true;
852                         return true; // already loaded
853                 }
854         }
855
856         if(already_loaded)
857                 *already_loaded = false;
858
859         if(!strcasecmp(ext, "pak"))
860                 pak = FS_LoadPackPAK (pakfile);
861         else if(!strcasecmp(ext, "pk3"))
862                 pak = FS_LoadPackPK3 (pakfile);
863         else
864                 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
865
866         if (pak)
867         {
868                 if(keep_plain_dirs)
869                 {
870                         // find the first item whose next one is a pack or NULL
871                         searchpath_t *insertion_point = 0;
872                         if(fs_searchpaths && !fs_searchpaths->pack)
873                         {
874                                 insertion_point = fs_searchpaths;
875                                 for(;;)
876                                 {
877                                         if(!insertion_point->next)
878                                                 break;
879                                         if(insertion_point->next->pack)
880                                                 break;
881                                         insertion_point = insertion_point->next;
882                                 }
883                         }
884                         // If insertion_point is NULL, this means that either there is no
885                         // item in the list yet, or that the very first item is a pack. In
886                         // that case, we want to insert at the beginning...
887                         if(!insertion_point)
888                         {
889                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
890                                 search->pack = pak;
891                                 search->next = fs_searchpaths;
892                                 fs_searchpaths = search;
893                         }
894                         else
895                         // otherwise we want to append directly after insertion_point.
896                         {
897                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
898                                 search->pack = pak;
899                                 search->next = insertion_point->next;
900                                 insertion_point->next = search;
901                         }
902                 }
903                 else
904                 {
905                         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
906                         search->pack = pak;
907                         search->next = fs_searchpaths;
908                         fs_searchpaths = search;
909                 }
910                 return true;
911         }
912         else
913         {
914                 Con_Printf("unable to load pak \"%s\"\n", pakfile);
915                 return false;
916         }
917 }
918
919
920 /*
921 ================
922 FS_AddPack
923
924 Adds the given pack to the search path and searches for it in the game path.
925 The pack type is autodetected by the file extension.
926
927 Returns true if the file was successfully added to the
928 search path or if it was already included.
929
930 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
931 plain directories.
932 ================
933 */
934 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
935 {
936         char fullpath[MAX_QPATH];
937         int index;
938         searchpath_t *search;
939
940         if(already_loaded)
941                 *already_loaded = false;
942
943         // then find the real name...
944         search = FS_FindFile(pakfile, &index, true);
945         if(!search || search->pack)
946         {
947                 Con_Printf("could not find pak \"%s\"\n", pakfile);
948                 return false;
949         }
950
951         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
952
953         return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
954 }
955
956
957 /*
958 ================
959 FS_AddGameDirectory
960
961 Sets fs_gamedir, adds the directory to the head of the path,
962 then loads and adds pak1.pak pak2.pak ...
963 ================
964 */
965 void FS_AddGameDirectory (const char *dir)
966 {
967         int i;
968         stringlist_t list;
969         searchpath_t *search;
970         char pakfile[MAX_OSPATH];
971
972         strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
973
974         stringlistinit(&list);
975         listdirectory(&list, dir);
976         stringlistsort(&list);
977
978         // add any PAK package in the directory
979         for (i = 0;i < list.numstrings;i++)
980         {
981                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
982                 {
983                         dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
984                         FS_AddPack_Fullpath(pakfile, NULL, false);
985                 }
986         }
987
988         // add any PK3 package in the directory
989         for (i = 0;i < list.numstrings;i++)
990         {
991                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
992                 {
993                         dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
994                         FS_AddPack_Fullpath(pakfile, NULL, false);
995                 }
996         }
997
998         stringlistfreecontents(&list);
999
1000         // Add the directory to the search path
1001         // (unpacked files have the priority over packed files)
1002         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1003         strlcpy (search->filename, dir, sizeof (search->filename));
1004         search->next = fs_searchpaths;
1005         fs_searchpaths = search;
1006 }
1007
1008
1009 /*
1010 ================
1011 FS_AddGameHierarchy
1012 ================
1013 */
1014 void FS_AddGameHierarchy (const char *dir)
1015 {
1016         int i;
1017         char userdir[MAX_QPATH];
1018 #ifdef WIN32
1019         TCHAR mydocsdir[MAX_PATH + 1];
1020 #else
1021         const char *homedir;
1022 #endif
1023
1024         // Add the common game directory
1025         FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1026
1027         *userdir = 0;
1028
1029         // Add the personal game directory
1030 #ifdef WIN32
1031         if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1032                 dpsnprintf(userdir, sizeof(userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1033         fprintf(stderr, "userdir = %s\n", userdir);
1034 #else
1035         homedir = getenv ("HOME");
1036         if(homedir)
1037                 dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
1038 #endif
1039
1040 #ifdef WIN32
1041         if(!COM_CheckParm("-mygames"))
1042         {
1043                 int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1044                 if(fd >= 0)
1045                 {
1046                         close(fd);
1047                         *userdir = 0; // we have write access to the game dir, so let's use it
1048                 }
1049         }
1050 #endif
1051
1052         if(COM_CheckParm("-nohome"))
1053                 *userdir = 0;
1054         
1055         if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1056                 dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
1057
1058         if (*userdir)
1059                 FS_AddGameDirectory(va("%s%s/", userdir, dir));
1060 }
1061
1062
1063 /*
1064 ============
1065 FS_FileExtension
1066 ============
1067 */
1068 const char *FS_FileExtension (const char *in)
1069 {
1070         const char *separator, *backslash, *colon, *dot;
1071
1072         separator = strrchr(in, '/');
1073         backslash = strrchr(in, '\\');
1074         if (!separator || separator < backslash)
1075                 separator = backslash;
1076         colon = strrchr(in, ':');
1077         if (!separator || separator < colon)
1078                 separator = colon;
1079
1080         dot = strrchr(in, '.');
1081         if (dot == NULL || (separator && (dot < separator)))
1082                 return "";
1083
1084         return dot + 1;
1085 }
1086
1087
1088 /*
1089 ============
1090 FS_FileWithoutPath
1091 ============
1092 */
1093 const char *FS_FileWithoutPath (const char *in)
1094 {
1095         const char *separator, *backslash, *colon;
1096
1097         separator = strrchr(in, '/');
1098         backslash = strrchr(in, '\\');
1099         if (!separator || separator < backslash)
1100                 separator = backslash;
1101         colon = strrchr(in, ':');
1102         if (!separator || separator < colon)
1103                 separator = colon;
1104         return separator ? separator + 1 : in;
1105 }
1106
1107
1108 /*
1109 ================
1110 FS_ClearSearchPath
1111 ================
1112 */
1113 void FS_ClearSearchPath (void)
1114 {
1115         // unload all packs and directory information, close all pack files
1116         // (if a qfile is still reading a pack it won't be harmed because it used
1117         //  dup() to get its own handle already)
1118         while (fs_searchpaths)
1119         {
1120                 searchpath_t *search = fs_searchpaths;
1121                 fs_searchpaths = search->next;
1122                 if (search->pack)
1123                 {
1124                         // close the file
1125                         close(search->pack->handle);
1126                         // free any memory associated with it
1127                         if (search->pack->files)
1128                                 Mem_Free(search->pack->files);
1129                         Mem_Free(search->pack);
1130                 }
1131                 Mem_Free(search);
1132         }
1133 }
1134
1135
1136 /*
1137 ================
1138 FS_Rescan
1139 ================
1140 */
1141 void FS_Rescan (void)
1142 {
1143         int i;
1144         qboolean fs_modified = false;
1145
1146         FS_ClearSearchPath();
1147
1148         // add the game-specific paths
1149         // gamedirname1 (typically id1)
1150         FS_AddGameHierarchy (gamedirname1);
1151         // update the com_modname (used for server info)
1152         strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1153
1154         // add the game-specific path, if any
1155         // (only used for mission packs and the like, which should set fs_modified)
1156         if (gamedirname2)
1157         {
1158                 fs_modified = true;
1159                 FS_AddGameHierarchy (gamedirname2);
1160         }
1161
1162         // -game <gamedir>
1163         // Adds basedir/gamedir as an override game
1164         // LordHavoc: now supports multiple -game directories
1165         // set the com_modname (reported in server info)
1166         for (i = 0;i < fs_numgamedirs;i++)
1167         {
1168                 fs_modified = true;
1169                 FS_AddGameHierarchy (fs_gamedirs[i]);
1170                 // update the com_modname (used server info)
1171                 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1172         }
1173
1174         // set the default screenshot name to either the mod name or the
1175         // gamemode screenshot name
1176         if (strcmp(com_modname, gamedirname1))
1177                 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1178         else
1179                 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1180
1181         // If "-condebug" is in the command line, remove the previous log file
1182         if (COM_CheckParm ("-condebug") != 0)
1183                 unlink (va("%s/qconsole.log", fs_gamedir));
1184
1185         // look for the pop.lmp file and set registered to true if it is found
1186         if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1187         {
1188                 if (fs_modified)
1189                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1190                 else
1191                         Con_Print("Playing shareware version.\n");
1192         }
1193         else
1194         {
1195                 Cvar_Set ("registered", "1");
1196                 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1197                         Con_Print("Playing registered version.\n");
1198         }
1199
1200         // unload all wads so that future queries will return the new data
1201         W_UnloadAll();
1202 }
1203
1204 void FS_Rescan_f(void)
1205 {
1206         FS_Rescan();
1207 }
1208
1209 /*
1210 ================
1211 FS_ChangeGameDirs
1212 ================
1213 */
1214 extern void Host_SaveConfig (void);
1215 extern void Host_LoadConfig_f (void);
1216 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1217 {
1218         int i;
1219
1220         if (fs_numgamedirs == numgamedirs)
1221         {
1222                 for (i = 0;i < numgamedirs;i++)
1223                         if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1224                                 break;
1225                 if (i == numgamedirs)
1226                         return true; // already using this set of gamedirs, do nothing
1227         }
1228
1229         if (numgamedirs > MAX_GAMEDIRS)
1230         {
1231                 if (complain)
1232                         Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1233                 return false; // too many gamedirs
1234         }
1235
1236         for (i = 0;i < numgamedirs;i++)
1237         {
1238                 // if string is nasty, reject it
1239                 if(FS_CheckNastyPath(gamedirs[i], true))
1240                 {
1241                         if (complain)
1242                                 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1243                         return false; // nasty gamedirs
1244                 }
1245         }
1246
1247         for (i = 0;i < numgamedirs;i++)
1248         {
1249                 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1250                 {
1251                         if (complain)
1252                                 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1253                         return false; // missing gamedirs
1254                 }
1255         }
1256
1257         // halt demo playback to close the file
1258         CL_Disconnect();
1259
1260         Host_SaveConfig();
1261
1262         fs_numgamedirs = numgamedirs;
1263         for (i = 0;i < fs_numgamedirs;i++)
1264                 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1265
1266         // reinitialize filesystem to detect the new paks
1267         FS_Rescan();
1268
1269         // exec the new config
1270         Host_LoadConfig_f();
1271
1272         // unload all sounds so they will be reloaded from the new files as needed
1273         S_UnloadAllSounds_f();
1274
1275         // reinitialize renderer (this reloads hud/console background/etc)
1276         R_Modules_Restart();
1277
1278         return true;
1279 }
1280
1281 /*
1282 ================
1283 FS_GameDir_f
1284 ================
1285 */
1286 void FS_GameDir_f (void)
1287 {
1288         int i;
1289         int numgamedirs;
1290         char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1291
1292         if (Cmd_Argc() < 2)
1293         {
1294                 Con_Printf("gamedirs active:");
1295                 for (i = 0;i < fs_numgamedirs;i++)
1296                         Con_Printf(" %s", fs_gamedirs[i]);
1297                 Con_Printf("\n");
1298                 return;
1299         }
1300
1301         numgamedirs = Cmd_Argc() - 1;
1302         if (numgamedirs > MAX_GAMEDIRS)
1303         {
1304                 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1305                 return;
1306         }
1307
1308         for (i = 0;i < numgamedirs;i++)
1309                 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1310
1311         if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1312         {
1313                 // actually, changing during game would work fine, but would be stupid
1314                 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1315                 return;
1316         }
1317
1318         FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1319 }
1320
1321
1322 /*
1323 ================
1324 FS_CheckGameDir
1325 ================
1326 */
1327 qboolean FS_CheckGameDir(const char *gamedir)
1328 {
1329         qboolean success;
1330         stringlist_t list;
1331         stringlistinit(&list);
1332         listdirectory(&list, va("%s%s/", fs_basedir, gamedir));
1333         success = list.numstrings > 0;
1334         stringlistfreecontents(&list);
1335         return success;
1336 }
1337
1338
1339 /*
1340 ================
1341 FS_Init
1342 ================
1343 */
1344 void FS_Init (void)
1345 {
1346         int i;
1347
1348         fs_mempool = Mem_AllocPool("file management", 0, NULL);
1349
1350         strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1351
1352 // If the base directory is explicitly defined by the compilation process
1353 #ifdef DP_FS_BASEDIR
1354         strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1355 #else
1356         strlcpy(fs_basedir, "", sizeof(fs_basedir));
1357
1358 #ifdef MACOSX
1359         // FIXME: is there a better way to find the directory outside the .app?
1360         if (strstr(com_argv[0], ".app/"))
1361         {
1362                 char *split;
1363
1364                 split = strstr(com_argv[0], ".app/");
1365                 while (split > com_argv[0] && *split != '/')
1366                         split--;
1367                 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1368                 fs_basedir[split - com_argv[0]] = 0;
1369         }
1370 #endif
1371 #endif
1372
1373         PK3_OpenLibrary ();
1374
1375         // -basedir <path>
1376         // Overrides the system supplied base directory (under GAMENAME)
1377 // 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)
1378         i = COM_CheckParm ("-basedir");
1379         if (i && i < com_argc-1)
1380         {
1381                 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1382                 i = (int)strlen (fs_basedir);
1383                 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1384                         fs_basedir[i-1] = 0;
1385         }
1386
1387         // add a path separator to the end of the basedir if it lacks one
1388         if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1389                 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1390
1391         if (!FS_CheckGameDir(gamedirname1))
1392                 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1393
1394         if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1395                 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1396
1397         // -game <gamedir>
1398         // Adds basedir/gamedir as an override game
1399         // LordHavoc: now supports multiple -game directories
1400         for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1401         {
1402                 if (!com_argv[i])
1403                         continue;
1404                 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1405                 {
1406                         i++;
1407                         if (FS_CheckNastyPath(com_argv[i], true))
1408                                 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1409                         if (!FS_CheckGameDir(com_argv[i]))
1410                                 Sys_Error("-game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1411                         // add the gamedir to the list of active gamedirs
1412                         strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1413                         fs_numgamedirs++;
1414                 }
1415         }
1416
1417         // generate the searchpath
1418         FS_Rescan();
1419 }
1420
1421 void FS_Init_Commands(void)
1422 {
1423         Cvar_RegisterVariable (&scr_screenshot_name);
1424         Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1425
1426         Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1427         Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1428         Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1429         Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1430         Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1431 }
1432
1433 /*
1434 ================
1435 FS_Shutdown
1436 ================
1437 */
1438 void FS_Shutdown (void)
1439 {
1440         // close all pack files and such
1441         // (hopefully there aren't any other open files, but they'll be cleaned up
1442         //  by the OS anyway)
1443         FS_ClearSearchPath();
1444         Mem_FreePool (&fs_mempool);
1445 }
1446
1447 /*
1448 ====================
1449 FS_SysOpen
1450
1451 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1452 ====================
1453 */
1454 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1455 {
1456         qfile_t* file;
1457         int mod, opt;
1458         unsigned int ind;
1459
1460         // Parse the mode string
1461         switch (mode[0])
1462         {
1463                 case 'r':
1464                         mod = O_RDONLY;
1465                         opt = 0;
1466                         break;
1467                 case 'w':
1468                         mod = O_WRONLY;
1469                         opt = O_CREAT | O_TRUNC;
1470                         break;
1471                 case 'a':
1472                         mod = O_WRONLY;
1473                         opt = O_CREAT | O_APPEND;
1474                         break;
1475                 default:
1476                         Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1477                         return NULL;
1478         }
1479         for (ind = 1; mode[ind] != '\0'; ind++)
1480         {
1481                 switch (mode[ind])
1482                 {
1483                         case '+':
1484                                 mod = O_RDWR;
1485                                 break;
1486                         case 'b':
1487                                 opt |= O_BINARY;
1488                                 break;
1489                         default:
1490                                 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1491                                                         filepath, mode, mode[ind]);
1492                 }
1493         }
1494
1495         if (nonblocking)
1496                 opt |= O_NONBLOCK;
1497
1498         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1499         memset (file, 0, sizeof (*file));
1500         file->ungetc = EOF;
1501
1502         file->handle = open (filepath, mod | opt, 0666);
1503         if (file->handle < 0)
1504         {
1505                 Mem_Free (file);
1506                 return NULL;
1507         }
1508
1509         file->real_length = lseek (file->handle, 0, SEEK_END);
1510
1511         // For files opened in append mode, we start at the end of the file
1512         if (mod & O_APPEND)
1513                 file->position = file->real_length;
1514         else
1515                 lseek (file->handle, 0, SEEK_SET);
1516
1517         return file;
1518 }
1519
1520
1521 /*
1522 ===========
1523 FS_OpenPackedFile
1524
1525 Open a packed file using its package file descriptor
1526 ===========
1527 */
1528 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1529 {
1530         packfile_t *pfile;
1531         int dup_handle;
1532         qfile_t* file;
1533
1534         pfile = &pack->files[pack_ind];
1535
1536         // If we don't have the true offset, get it now
1537         if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1538                 if (!PK3_GetTrueFileOffset (pfile, pack))
1539                         return NULL;
1540
1541         // No Zlib DLL = no compressed files
1542         if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1543         {
1544                 Con_Printf("WARNING: can't open the compressed file %s\n"
1545                                         "You need the Zlib DLL to use compressed files\n",
1546                                         pfile->name);
1547                 return NULL;
1548         }
1549
1550         // LordHavoc: lseek affects all duplicates of a handle so we do it before
1551         // the dup() call to avoid having to close the dup_handle on error here
1552         if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1553         {
1554                 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1555                                         pfile->name, pack->filename, (int) pfile->offset);
1556                 return NULL;
1557         }
1558
1559         dup_handle = dup (pack->handle);
1560         if (dup_handle < 0)
1561         {
1562                 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1563                 return NULL;
1564         }
1565
1566         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1567         memset (file, 0, sizeof (*file));
1568         file->handle = dup_handle;
1569         file->flags = QFILE_FLAG_PACKED;
1570         file->real_length = pfile->realsize;
1571         file->offset = pfile->offset;
1572         file->position = 0;
1573         file->ungetc = EOF;
1574
1575         if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1576         {
1577                 ztoolkit_t *ztk;
1578
1579                 file->flags |= QFILE_FLAG_DEFLATED;
1580
1581                 // We need some more variables
1582                 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1583
1584                 ztk->comp_length = pfile->packsize;
1585
1586                 // Initialize zlib stream
1587                 ztk->zstream.next_in = ztk->input;
1588                 ztk->zstream.avail_in = 0;
1589
1590                 /* From Zlib's "unzip.c":
1591                  *
1592                  * windowBits is passed < 0 to tell that there is no zlib header.
1593                  * Note that in this case inflate *requires* an extra "dummy" byte
1594                  * after the compressed stream in order to complete decompression and
1595                  * return Z_STREAM_END.
1596                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1597                  * size of both compressed and uncompressed data
1598                  */
1599                 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1600                 {
1601                         Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1602                         close(dup_handle);
1603                         Mem_Free(file);
1604                         return NULL;
1605                 }
1606
1607                 ztk->zstream.next_out = file->buff;
1608                 ztk->zstream.avail_out = sizeof (file->buff);
1609
1610                 file->ztk = ztk;
1611         }
1612
1613         return file;
1614 }
1615
1616 /*
1617 ====================
1618 FS_CheckNastyPath
1619
1620 Return true if the path should be rejected due to one of the following:
1621 1: path elements that are non-portable
1622 2: path elements that would allow access to files outside the game directory,
1623    or are just not a good idea for a mod to be using.
1624 ====================
1625 */
1626 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1627 {
1628         // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1629         if (!path[0])
1630                 return 2;
1631
1632         // Windows: don't allow \ in filenames (windows-only), period.
1633         // (on Windows \ is a directory separator, but / is also supported)
1634         if (strstr(path, "\\"))
1635                 return 1; // non-portable
1636
1637         // Mac: don't allow Mac-only filenames - : is a directory separator
1638         // instead of /, but we rely on / working already, so there's no reason to
1639         // support a Mac-only path
1640         // Amiga and Windows: : tries to go to root of drive
1641         if (strstr(path, ":"))
1642                 return 1; // non-portable attempt to go to root of drive
1643
1644         // Amiga: // is parent directory
1645         if (strstr(path, "//"))
1646                 return 1; // non-portable attempt to go to parent directory
1647
1648         // all: don't allow going to parent directory (../ or /../)
1649         if (strstr(path, ".."))
1650                 return 2; // attempt to go outside the game directory
1651
1652         // Windows and UNIXes: don't allow absolute paths
1653         if (path[0] == '/')
1654                 return 2; // attempt to go outside the game directory
1655
1656         // 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
1657         if (strchr(path, '.'))
1658         {
1659                 if (isgamedir)
1660                 {
1661                         // gamedir is entirely path elements, so simply forbid . entirely
1662                         return 2;
1663                 }
1664                 if (strchr(path, '.') < strrchr(path, '/'))
1665                         return 2; // possible attempt to go outside the game directory
1666         }
1667
1668         // all: forbid trailing slash on gamedir
1669         if (isgamedir && path[strlen(path)-1] == '/')
1670                 return 2;
1671
1672         // all: forbid leading dot on any filename for any reason
1673         if (strstr(path, "/."))
1674                 return 2; // attempt to go outside the game directory
1675
1676         // after all these checks we're pretty sure it's a / separated filename
1677         // and won't do much if any harm
1678         return false;
1679 }
1680
1681
1682 /*
1683 ====================
1684 FS_FindFile
1685
1686 Look for a file in the packages and in the filesystem
1687
1688 Return the searchpath where the file was found (or NULL)
1689 and the file index in the package if relevant
1690 ====================
1691 */
1692 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1693 {
1694         searchpath_t *search;
1695         pack_t *pak;
1696
1697         // search through the path, one element at a time
1698         for (search = fs_searchpaths;search;search = search->next)
1699         {
1700                 // is the element a pak file?
1701                 if (search->pack)
1702                 {
1703                         int (*strcmp_funct) (const char* str1, const char* str2);
1704                         int left, right, middle;
1705
1706                         pak = search->pack;
1707                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1708
1709                         // Look for the file (binary search)
1710                         left = 0;
1711                         right = pak->numfiles - 1;
1712                         while (left <= right)
1713                         {
1714                                 int diff;
1715
1716                                 middle = (left + right) / 2;
1717                                 diff = strcmp_funct (pak->files[middle].name, name);
1718
1719                                 // Found it
1720                                 if (!diff)
1721                                 {
1722                                         if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1723                                         {
1724                                                 // yes, but the first one is empty so we treat it as not being there
1725                                                 if (!quiet && developer.integer >= 10)
1726                                                         Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1727
1728                                                 if (index != NULL)
1729                                                         *index = -1;
1730                                                 return NULL;
1731                                         }
1732
1733                                         if (!quiet && developer.integer >= 10)
1734                                                 Con_Printf("FS_FindFile: %s in %s\n",
1735                                                                         pak->files[middle].name, pak->filename);
1736
1737                                         if (index != NULL)
1738                                                 *index = middle;
1739                                         return search;
1740                                 }
1741
1742                                 // If we're too far in the list
1743                                 if (diff > 0)
1744                                         right = middle - 1;
1745                                 else
1746                                         left = middle + 1;
1747                         }
1748                 }
1749                 else
1750                 {
1751                         char netpath[MAX_OSPATH];
1752                         dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1753                         if (FS_SysFileExists (netpath))
1754                         {
1755                                 if (!quiet && developer.integer >= 10)
1756                                         Con_Printf("FS_FindFile: %s\n", netpath);
1757
1758                                 if (index != NULL)
1759                                         *index = -1;
1760                                 return search;
1761                         }
1762                 }
1763         }
1764
1765         if (!quiet && developer.integer >= 10)
1766                 Con_Printf("FS_FindFile: can't find %s\n", name);
1767
1768         if (index != NULL)
1769                 *index = -1;
1770         return NULL;
1771 }
1772
1773
1774 /*
1775 ===========
1776 FS_OpenReadFile
1777
1778 Look for a file in the search paths and open it in read-only mode
1779 ===========
1780 */
1781 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1782 {
1783         searchpath_t *search;
1784         int pack_ind;
1785
1786         search = FS_FindFile (filename, &pack_ind, quiet);
1787
1788         // Not found?
1789         if (search == NULL)
1790                 return NULL;
1791
1792         // Found in the filesystem?
1793         if (pack_ind < 0)
1794         {
1795                 char path [MAX_OSPATH];
1796                 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1797                 return FS_SysOpen (path, "rb", nonblocking);
1798         }
1799
1800         // So, we found it in a package...
1801         return FS_OpenPackedFile (search->pack, pack_ind);
1802 }
1803
1804
1805 /*
1806 =============================================================================
1807
1808 MAIN PUBLIC FUNCTIONS
1809
1810 =============================================================================
1811 */
1812
1813 /*
1814 ====================
1815 FS_Open
1816
1817 Open a file. The syntax is the same as fopen
1818 ====================
1819 */
1820 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1821 {
1822         if (FS_CheckNastyPath(filepath, false))
1823         {
1824                 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1825                 return NULL;
1826         }
1827
1828         // If the file is opened in "write", "append", or "read/write" mode
1829         if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1830         {
1831                 char real_path [MAX_OSPATH];
1832
1833                 // Open the file on disk directly
1834                 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1835
1836                 // Create directories up to the file
1837                 FS_CreatePath (real_path);
1838
1839                 return FS_SysOpen (real_path, mode, nonblocking);
1840         }
1841         // Else, we look at the various search paths and open the file in read-only mode
1842         else
1843                 return FS_OpenReadFile (filepath, quiet, nonblocking);
1844 }
1845
1846
1847 /*
1848 ====================
1849 FS_Close
1850
1851 Close a file
1852 ====================
1853 */
1854 int FS_Close (qfile_t* file)
1855 {
1856         if (close (file->handle))
1857                 return EOF;
1858
1859         if (file->ztk)
1860         {
1861                 qz_inflateEnd (&file->ztk->zstream);
1862                 Mem_Free (file->ztk);
1863         }
1864
1865         Mem_Free (file);
1866         return 0;
1867 }
1868
1869
1870 /*
1871 ====================
1872 FS_Write
1873
1874 Write "datasize" bytes into a file
1875 ====================
1876 */
1877 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1878 {
1879         fs_offset_t result;
1880
1881         // If necessary, seek to the exact file position we're supposed to be
1882         if (file->buff_ind != file->buff_len)
1883                 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1884
1885         // Purge cached data
1886         FS_Purge (file);
1887
1888         // Write the buffer and update the position
1889         result = write (file->handle, data, (fs_offset_t)datasize);
1890         file->position = lseek (file->handle, 0, SEEK_CUR);
1891         if (file->real_length < file->position)
1892                 file->real_length = file->position;
1893
1894         if (result < 0)
1895                 return 0;
1896
1897         return result;
1898 }
1899
1900
1901 /*
1902 ====================
1903 FS_Read
1904
1905 Read up to "buffersize" bytes from a file
1906 ====================
1907 */
1908 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1909 {
1910         fs_offset_t count, done;
1911
1912         if (buffersize == 0)
1913                 return 0;
1914
1915         // Get rid of the ungetc character
1916         if (file->ungetc != EOF)
1917         {
1918                 ((char*)buffer)[0] = file->ungetc;
1919                 buffersize--;
1920                 file->ungetc = EOF;
1921                 done = 1;
1922         }
1923         else
1924                 done = 0;
1925
1926         // First, we copy as many bytes as we can from "buff"
1927         if (file->buff_ind < file->buff_len)
1928         {
1929                 count = file->buff_len - file->buff_ind;
1930                 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1931                 done += count;
1932                 memcpy (buffer, &file->buff[file->buff_ind], count);
1933                 file->buff_ind += count;
1934
1935                 buffersize -= count;
1936                 if (buffersize == 0)
1937                         return done;
1938         }
1939
1940         // NOTE: at this point, the read buffer is always empty
1941
1942         // If the file isn't compressed
1943         if (! (file->flags & QFILE_FLAG_DEFLATED))
1944         {
1945                 fs_offset_t nb;
1946
1947                 // We must take care to not read after the end of the file
1948                 count = file->real_length - file->position;
1949
1950                 // If we have a lot of data to get, put them directly into "buffer"
1951                 if (buffersize > sizeof (file->buff) / 2)
1952                 {
1953                         if (count > (fs_offset_t)buffersize)
1954                                 count = (fs_offset_t)buffersize;
1955                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1956                         nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1957                         if (nb > 0)
1958                         {
1959                                 done += nb;
1960                                 file->position += nb;
1961
1962                                 // Purge cached data
1963                                 FS_Purge (file);
1964                         }
1965                 }
1966                 else
1967                 {
1968                         if (count > (fs_offset_t)sizeof (file->buff))
1969                                 count = (fs_offset_t)sizeof (file->buff);
1970                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1971                         nb = read (file->handle, file->buff, count);
1972                         if (nb > 0)
1973                         {
1974                                 file->buff_len = nb;
1975                                 file->position += nb;
1976
1977                                 // Copy the requested data in "buffer" (as much as we can)
1978                                 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1979                                 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1980                                 file->buff_ind = count;
1981                                 done += count;
1982                         }
1983                 }
1984
1985                 return done;
1986         }
1987
1988         // If the file is compressed, it's more complicated...
1989         // We cycle through a few operations until we have read enough data
1990         while (buffersize > 0)
1991         {
1992                 ztoolkit_t *ztk = file->ztk;
1993                 int error;
1994
1995                 // NOTE: at this point, the read buffer is always empty
1996
1997                 // If "input" is also empty, we need to refill it
1998                 if (ztk->in_ind == ztk->in_len)
1999                 {
2000                         // If we are at the end of the file
2001                         if (file->position == file->real_length)
2002                                 return done;
2003
2004                         count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2005                         if (count > (fs_offset_t)sizeof (ztk->input))
2006                                 count = (fs_offset_t)sizeof (ztk->input);
2007                         lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2008                         if (read (file->handle, ztk->input, count) != count)
2009                         {
2010                                 Con_Printf ("FS_Read: unexpected end of file\n");
2011                                 break;
2012                         }
2013
2014                         ztk->in_ind = 0;
2015                         ztk->in_len = count;
2016                         ztk->in_position += count;
2017                 }
2018
2019                 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2020                 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2021
2022                 // Now that we are sure we have compressed data available, we need to determine
2023                 // if it's better to inflate it in "file->buff" or directly in "buffer"
2024
2025                 // Inflate the data in "file->buff"
2026                 if (buffersize < sizeof (file->buff) / 2)
2027                 {
2028                         ztk->zstream.next_out = file->buff;
2029                         ztk->zstream.avail_out = sizeof (file->buff);
2030                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2031                         if (error != Z_OK && error != Z_STREAM_END)
2032                         {
2033                                 Con_Printf ("FS_Read: Can't inflate file\n");
2034                                 break;
2035                         }
2036                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2037
2038                         file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2039                         file->position += file->buff_len;
2040
2041                         // Copy the requested data in "buffer" (as much as we can)
2042                         count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2043                         memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2044                         file->buff_ind = count;
2045                 }
2046
2047                 // Else, we inflate directly in "buffer"
2048                 else
2049                 {
2050                         ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2051                         ztk->zstream.avail_out = (unsigned int)buffersize;
2052                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2053                         if (error != Z_OK && error != Z_STREAM_END)
2054                         {
2055                                 Con_Printf ("FS_Read: Can't inflate file\n");
2056                                 break;
2057                         }
2058                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2059
2060                         // How much data did it inflate?
2061                         count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2062                         file->position += count;
2063
2064                         // Purge cached data
2065                         FS_Purge (file);
2066                 }
2067
2068                 done += count;
2069                 buffersize -= count;
2070         }
2071
2072         return done;
2073 }
2074
2075
2076 /*
2077 ====================
2078 FS_Print
2079
2080 Print a string into a file
2081 ====================
2082 */
2083 int FS_Print (qfile_t* file, const char *msg)
2084 {
2085         return (int)FS_Write (file, msg, strlen (msg));
2086 }
2087
2088 /*
2089 ====================
2090 FS_Printf
2091
2092 Print a string into a file
2093 ====================
2094 */
2095 int FS_Printf(qfile_t* file, const char* format, ...)
2096 {
2097         int result;
2098         va_list args;
2099
2100         va_start (args, format);
2101         result = FS_VPrintf (file, format, args);
2102         va_end (args);
2103
2104         return result;
2105 }
2106
2107
2108 /*
2109 ====================
2110 FS_VPrintf
2111
2112 Print a string into a file
2113 ====================
2114 */
2115 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2116 {
2117         int len;
2118         fs_offset_t buff_size = MAX_INPUTLINE;
2119         char *tempbuff;
2120
2121         for (;;)
2122         {
2123                 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2124                 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2125                 if (len >= 0 && len < buff_size)
2126                         break;
2127                 Mem_Free (tempbuff);
2128                 buff_size *= 2;
2129         }
2130
2131         len = write (file->handle, tempbuff, len);
2132         Mem_Free (tempbuff);
2133
2134         return len;
2135 }
2136
2137
2138 /*
2139 ====================
2140 FS_Getc
2141
2142 Get the next character of a file
2143 ====================
2144 */
2145 int FS_Getc (qfile_t* file)
2146 {
2147         unsigned char c;
2148
2149         if (FS_Read (file, &c, 1) != 1)
2150                 return EOF;
2151
2152         return c;
2153 }
2154
2155
2156 /*
2157 ====================
2158 FS_UnGetc
2159
2160 Put a character back into the read buffer (only supports one character!)
2161 ====================
2162 */
2163 int FS_UnGetc (qfile_t* file, unsigned char c)
2164 {
2165         // If there's already a character waiting to be read
2166         if (file->ungetc != EOF)
2167                 return EOF;
2168
2169         file->ungetc = c;
2170         return c;
2171 }
2172
2173
2174 /*
2175 ====================
2176 FS_Seek
2177
2178 Move the position index in a file
2179 ====================
2180 */
2181 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2182 {
2183         ztoolkit_t *ztk;
2184         unsigned char* buffer;
2185         fs_offset_t buffersize;
2186
2187         // Compute the file offset
2188         switch (whence)
2189         {
2190                 case SEEK_CUR:
2191                         offset += file->position - file->buff_len + file->buff_ind;
2192                         break;
2193
2194                 case SEEK_SET:
2195                         break;
2196
2197                 case SEEK_END:
2198                         offset += file->real_length;
2199                         break;
2200
2201                 default:
2202                         return -1;
2203         }
2204         if (offset < 0 || offset > file->real_length)
2205                 return -1;
2206
2207         // If we have the data in our read buffer, we don't need to actually seek
2208         if (file->position - file->buff_len <= offset && offset <= file->position)
2209         {
2210                 file->buff_ind = offset + file->buff_len - file->position;
2211                 return 0;
2212         }
2213
2214         // Purge cached data
2215         FS_Purge (file);
2216
2217         // Unpacked or uncompressed files can seek directly
2218         if (! (file->flags & QFILE_FLAG_DEFLATED))
2219         {
2220                 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2221                         return -1;
2222                 file->position = offset;
2223                 return 0;
2224         }
2225
2226         // Seeking in compressed files is more a hack than anything else,
2227         // but we need to support it, so here we go.
2228         ztk = file->ztk;
2229
2230         // If we have to go back in the file, we need to restart from the beginning
2231         if (offset <= file->position)
2232         {
2233                 ztk->in_ind = 0;
2234                 ztk->in_len = 0;
2235                 ztk->in_position = 0;
2236                 file->position = 0;
2237                 lseek (file->handle, file->offset, SEEK_SET);
2238
2239                 // Reset the Zlib stream
2240                 ztk->zstream.next_in = ztk->input;
2241                 ztk->zstream.avail_in = 0;
2242                 qz_inflateReset (&ztk->zstream);
2243         }
2244
2245         // We need a big buffer to force inflating into it directly
2246         buffersize = 2 * sizeof (file->buff);
2247         buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2248
2249         // Skip all data until we reach the requested offset
2250         while (offset > file->position)
2251         {
2252                 fs_offset_t diff = offset - file->position;
2253                 fs_offset_t count, len;
2254
2255                 count = (diff > buffersize) ? buffersize : diff;
2256                 len = FS_Read (file, buffer, count);
2257                 if (len != count)
2258                 {
2259                         Mem_Free (buffer);
2260                         return -1;
2261                 }
2262         }
2263
2264         Mem_Free (buffer);
2265         return 0;
2266 }
2267
2268
2269 /*
2270 ====================
2271 FS_Tell
2272
2273 Give the current position in a file
2274 ====================
2275 */
2276 fs_offset_t FS_Tell (qfile_t* file)
2277 {
2278         return file->position - file->buff_len + file->buff_ind;
2279 }
2280
2281
2282 /*
2283 ====================
2284 FS_FileSize
2285
2286 Give the total size of a file
2287 ====================
2288 */
2289 fs_offset_t FS_FileSize (qfile_t* file)
2290 {
2291         return file->real_length;
2292 }
2293
2294
2295 /*
2296 ====================
2297 FS_Purge
2298
2299 Erases any buffered input or output data
2300 ====================
2301 */
2302 void FS_Purge (qfile_t* file)
2303 {
2304         file->buff_len = 0;
2305         file->buff_ind = 0;
2306         file->ungetc = EOF;
2307 }
2308
2309
2310 /*
2311 ============
2312 FS_LoadFile
2313
2314 Filename are relative to the quake directory.
2315 Always appends a 0 byte.
2316 ============
2317 */
2318 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2319 {
2320         qfile_t *file;
2321         unsigned char *buf = NULL;
2322         fs_offset_t filesize = 0;
2323
2324         file = FS_Open (path, "rb", quiet, false);
2325         if (file)
2326         {
2327                 filesize = file->real_length;
2328                 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2329                 buf[filesize] = '\0';
2330                 FS_Read (file, buf, filesize);
2331                 FS_Close (file);
2332         }
2333
2334         if (filesizepointer)
2335                 *filesizepointer = filesize;
2336         return buf;
2337 }
2338
2339
2340 /*
2341 ============
2342 FS_WriteFile
2343
2344 The filename will be prefixed by the current game directory
2345 ============
2346 */
2347 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2348 {
2349         qfile_t *file;
2350
2351         file = FS_Open (filename, "wb", false, false);
2352         if (!file)
2353         {
2354                 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2355                 return false;
2356         }
2357
2358         Con_DPrintf("FS_WriteFile: %s\n", filename);
2359         FS_Write (file, data, len);
2360         FS_Close (file);
2361         return true;
2362 }
2363
2364
2365 /*
2366 =============================================================================
2367
2368 OTHERS PUBLIC FUNCTIONS
2369
2370 =============================================================================
2371 */
2372
2373 /*
2374 ============
2375 FS_StripExtension
2376 ============
2377 */
2378 void FS_StripExtension (const char *in, char *out, size_t size_out)
2379 {
2380         char *last = NULL;
2381         char currentchar;
2382
2383         if (size_out == 0)
2384                 return;
2385
2386         while ((currentchar = *in) && size_out > 1)
2387         {
2388                 if (currentchar == '.')
2389                         last = out;
2390                 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2391                         last = NULL;
2392                 *out++ = currentchar;
2393                 in++;
2394                 size_out--;
2395         }
2396         if (last)
2397                 *last = 0;
2398         else
2399                 *out = 0;
2400 }
2401
2402
2403 /*
2404 ==================
2405 FS_DefaultExtension
2406 ==================
2407 */
2408 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2409 {
2410         const char *src;
2411
2412         // if path doesn't have a .EXT, append extension
2413         // (extension should include the .)
2414         src = path + strlen(path) - 1;
2415
2416         while (*src != '/' && src != path)
2417         {
2418                 if (*src == '.')
2419                         return;                 // it has an extension
2420                 src--;
2421         }
2422
2423         strlcat (path, extension, size_path);
2424 }
2425
2426
2427 /*
2428 ==================
2429 FS_FileExists
2430
2431 Look for a file in the packages and in the filesystem
2432 ==================
2433 */
2434 qboolean FS_FileExists (const char *filename)
2435 {
2436         return (FS_FindFile (filename, NULL, true) != NULL);
2437 }
2438
2439
2440 /*
2441 ==================
2442 FS_SysFileExists
2443
2444 Look for a file in the filesystem only
2445 ==================
2446 */
2447 qboolean FS_SysFileExists (const char *path)
2448 {
2449 #if WIN32
2450         int desc;
2451
2452         // TODO: use another function instead, to avoid opening the file
2453         desc = open (path, O_RDONLY | O_BINARY);
2454         if (desc < 0)
2455                 return false;
2456
2457         close (desc);
2458         return true;
2459 #else
2460         struct stat buf;
2461
2462         if (stat (path,&buf) == -1)
2463                 return false;
2464
2465         return true;
2466 #endif
2467 }
2468
2469 void FS_mkdir (const char *path)
2470 {
2471 #if WIN32
2472         _mkdir (path);
2473 #else
2474         mkdir (path, 0777);
2475 #endif
2476 }
2477
2478 /*
2479 ===========
2480 FS_Search
2481
2482 Allocate and fill a search structure with information on matching filenames.
2483 ===========
2484 */
2485 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2486 {
2487         fssearch_t *search;
2488         searchpath_t *searchpath;
2489         pack_t *pak;
2490         int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2491         stringlist_t resultlist;
2492         stringlist_t dirlist;
2493         const char *slash, *backslash, *colon, *separator;
2494         char *basepath;
2495         char netpath[MAX_OSPATH];
2496         char temp[MAX_OSPATH];
2497
2498         for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2499                 ;
2500
2501         if (i > 0)
2502         {
2503                 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2504                 return NULL;
2505         }
2506
2507         stringlistinit(&resultlist);
2508         stringlistinit(&dirlist);
2509         search = NULL;
2510         slash = strrchr(pattern, '/');
2511         backslash = strrchr(pattern, '\\');
2512         colon = strrchr(pattern, ':');
2513         separator = max(slash, backslash);
2514         separator = max(separator, colon);
2515         basepathlength = separator ? (separator + 1 - pattern) : 0;
2516         basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2517         if (basepathlength)
2518                 memcpy(basepath, pattern, basepathlength);
2519         basepath[basepathlength] = 0;
2520
2521         // search through the path, one element at a time
2522         for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2523         {
2524                 // is the element a pak file?
2525                 if (searchpath->pack)
2526                 {
2527                         // look through all the pak file elements
2528                         pak = searchpath->pack;
2529                         for (i = 0;i < pak->numfiles;i++)
2530                         {
2531                                 strlcpy(temp, pak->files[i].name, sizeof(temp));
2532                                 while (temp[0])
2533                                 {
2534                                         if (matchpattern(temp, (char *)pattern, true))
2535                                         {
2536                                                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2537                                                         if (!strcmp(resultlist.strings[resultlistindex], temp))
2538                                                                 break;
2539                                                 if (resultlistindex == resultlist.numstrings)
2540                                                 {
2541                                                         stringlistappend(&resultlist, temp);
2542                                                         if (!quiet)
2543                                                                 Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
2544                                                 }
2545                                         }
2546                                         // strip off one path element at a time until empty
2547                                         // this way directories are added to the listing if they match the pattern
2548                                         slash = strrchr(temp, '/');
2549                                         backslash = strrchr(temp, '\\');
2550                                         colon = strrchr(temp, ':');
2551                                         separator = temp;
2552                                         if (separator < slash)
2553                                                 separator = slash;
2554                                         if (separator < backslash)
2555                                                 separator = backslash;
2556                                         if (separator < colon)
2557                                                 separator = colon;
2558                                         *((char *)separator) = 0;
2559                                 }
2560                         }
2561                 }
2562                 else
2563                 {
2564                         // get a directory listing and look at each name
2565                         dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2566                         stringlistinit(&dirlist);
2567                         listdirectory(&dirlist, netpath);
2568                         for (dirlistindex = 0;dirlistindex < dirlist.numstrings;dirlistindex++)
2569                         {
2570                                 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirlist.strings[dirlistindex]);
2571                                 if (matchpattern(temp, (char *)pattern, true))
2572                                 {
2573                                         for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2574                                                 if (!strcmp(resultlist.strings[resultlistindex], temp))
2575                                                         break;
2576                                         if (resultlistindex == resultlist.numstrings)
2577                                         {
2578                                                 stringlistappend(&resultlist, temp);
2579                                                 if (!quiet)
2580                                                         Con_DPrintf("SearchDirFile: %s\n", temp);
2581                                         }
2582                                 }
2583                         }
2584                         stringlistfreecontents(&dirlist);
2585                 }
2586         }
2587
2588         if (resultlist.numstrings)
2589         {
2590                 stringlistsort(&resultlist);
2591                 numfiles = resultlist.numstrings;
2592                 numchars = 0;
2593                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2594                         numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2595                 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2596                 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2597                 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2598                 search->numfilenames = (int)numfiles;
2599                 numfiles = 0;
2600                 numchars = 0;
2601                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2602                 {
2603                         size_t textlen;
2604                         search->filenames[numfiles] = search->filenamesbuffer + numchars;
2605                         textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2606                         memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2607                         numfiles++;
2608                         numchars += (int)textlen;
2609                 }
2610         }
2611         stringlistfreecontents(&resultlist);
2612
2613         Mem_Free(basepath);
2614         return search;
2615 }
2616
2617 void FS_FreeSearch(fssearch_t *search)
2618 {
2619         Z_Free(search);
2620 }
2621
2622 extern int con_linewidth;
2623 int FS_ListDirectory(const char *pattern, int oneperline)
2624 {
2625         int numfiles;
2626         int numcolumns;
2627         int numlines;
2628         int columnwidth;
2629         int linebufpos;
2630         int i, j, k, l;
2631         const char *name;
2632         char linebuf[MAX_INPUTLINE];
2633         fssearch_t *search;
2634         search = FS_Search(pattern, true, true);
2635         if (!search)
2636                 return 0;
2637         numfiles = search->numfilenames;
2638         if (!oneperline)
2639         {
2640                 // FIXME: the names could be added to one column list and then
2641                 // gradually shifted into the next column if they fit, and then the
2642                 // next to make a compact variable width listing but it's a lot more
2643                 // complicated...
2644                 // find width for columns
2645                 columnwidth = 0;
2646                 for (i = 0;i < numfiles;i++)
2647                 {
2648                         l = (int)strlen(search->filenames[i]);
2649                         if (columnwidth < l)
2650                                 columnwidth = l;
2651                 }
2652                 // count the spacing character
2653                 columnwidth++;
2654                 // calculate number of columns
2655                 numcolumns = con_linewidth / columnwidth;
2656                 // don't bother with the column printing if it's only one column
2657                 if (numcolumns >= 2)
2658                 {
2659                         numlines = (numfiles + numcolumns - 1) / numcolumns;
2660                         for (i = 0;i < numlines;i++)
2661                         {
2662                                 linebufpos = 0;
2663                                 for (k = 0;k < numcolumns;k++)
2664                                 {
2665                                         l = i * numcolumns + k;
2666                                         if (l < numfiles)
2667                                         {
2668                                                 name = search->filenames[l];
2669                                                 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2670                                                         linebuf[linebufpos++] = name[j];
2671                                                 // space out name unless it's the last on the line
2672                                                 if (k + 1 < numcolumns && l + 1 < numfiles)
2673                                                         for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2674                                                                 linebuf[linebufpos++] = ' ';
2675                                         }
2676                                 }
2677                                 linebuf[linebufpos] = 0;
2678                                 Con_Printf("%s\n", linebuf);
2679                         }
2680                 }
2681                 else
2682                         oneperline = true;
2683         }
2684         if (oneperline)
2685                 for (i = 0;i < numfiles;i++)
2686                         Con_Printf("%s\n", search->filenames[i]);
2687         FS_FreeSearch(search);
2688         return (int)numfiles;
2689 }
2690
2691 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2692 {
2693         const char *pattern;
2694         if (Cmd_Argc() > 3)
2695         {
2696                 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2697                 return;
2698         }
2699         if (Cmd_Argc() == 2)
2700                 pattern = Cmd_Argv(1);
2701         else
2702                 pattern = "*";
2703         if (!FS_ListDirectory(pattern, oneperline))
2704                 Con_Print("No files found.\n");
2705 }
2706
2707 void FS_Dir_f(void)
2708 {
2709         FS_ListDirectoryCmd("dir", true);
2710 }
2711
2712 void FS_Ls_f(void)
2713 {
2714         FS_ListDirectoryCmd("ls", false);
2715 }
2716
2717 const char *FS_WhichPack(const char *filename)
2718 {
2719         int index;
2720         searchpath_t *sp = FS_FindFile(filename, &index, true);
2721         if(sp && sp->pack)
2722                 return sp->pack->filename;
2723         else
2724                 return 0;
2725 }
2726
2727 /*
2728 ====================
2729 FS_IsRegisteredQuakePack
2730
2731 Look for a proof of purchase file file in the requested package
2732
2733 If it is found, this file should NOT be downloaded.
2734 ====================
2735 */
2736 qboolean FS_IsRegisteredQuakePack(const char *name)
2737 {
2738         searchpath_t *search;
2739         pack_t *pak;
2740
2741         // search through the path, one element at a time
2742         for (search = fs_searchpaths;search;search = search->next)
2743         {
2744                 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2745                 {
2746                         int (*strcmp_funct) (const char* str1, const char* str2);
2747                         int left, right, middle;
2748
2749                         pak = search->pack;
2750                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2751
2752                         // Look for the file (binary search)
2753                         left = 0;
2754                         right = pak->numfiles - 1;
2755                         while (left <= right)
2756                         {
2757                                 int diff;
2758
2759                                 middle = (left + right) / 2;
2760                                 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2761
2762                                 // Found it
2763                                 if (!diff)
2764                                         return true;
2765
2766                                 // If we're too far in the list
2767                                 if (diff > 0)
2768                                         right = middle - 1;
2769                                 else
2770                                         left = middle + 1;
2771                         }
2772
2773                         // we found the requested pack but it is not registered quake
2774                         return false;
2775                 }
2776         }
2777
2778         return false;
2779 }
2780
2781 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2782 {
2783         int crc = -1;
2784         unsigned char *filedata;
2785         fs_offset_t filesize;
2786         if (filesizepointer)
2787                 *filesizepointer = 0;
2788         if (!filename || !*filename)
2789                 return crc;
2790         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2791         if (filedata)
2792         {
2793                 if (filesizepointer)
2794                         *filesizepointer = filesize;
2795                 crc = CRC_Block(filedata, filesize);
2796                 Mem_Free(filedata);
2797         }
2798         return crc;
2799 }
2800