whichpack: distinguish file not found from file is physical.
[xonotic/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 #ifdef __APPLE__
26 // include SDL for IPHONEOS code
27 # include <TargetConditionals.h>
28 # if TARGET_OS_IPHONE
29 #  include <SDL.h>
30 # endif
31 #endif
32
33 #include <limits.h>
34 #include <fcntl.h>
35
36 #ifdef WIN32
37 # include <direct.h>
38 # include <io.h>
39 # include <shlobj.h>
40 # include <sys/stat.h>
41 # include <share.h>
42 #else
43 # include <pwd.h>
44 # include <sys/stat.h>
45 # include <unistd.h>
46 #endif
47
48 #include "quakedef.h"
49 #include "thread.h"
50
51 #include "fs.h"
52 #include "wad.h"
53
54 // Win32 requires us to add O_BINARY, but the other OSes don't have it
55 #ifndef O_BINARY
56 # define O_BINARY 0
57 #endif
58
59 // In case the system doesn't support the O_NONBLOCK flag
60 #ifndef O_NONBLOCK
61 # define O_NONBLOCK 0
62 #endif
63
64 // largefile support for Win32
65 #ifdef WIN32
66 #undef lseek
67 # define lseek _lseeki64
68 #endif
69
70 // suppress deprecated warnings
71 #if _MSC_VER >= 1400
72 # define read _read
73 # define write _write
74 # define close _close
75 # define unlink _unlink
76 # define dup _dup
77 #endif
78
79 /** \page fs File System
80
81 All of Quake's data access is through a hierchal file system, but the contents
82 of the file system can be transparently merged from several sources.
83
84 The "base directory" is the path to the directory holding the quake.exe and
85 all game directories.  The sys_* files pass this to host_init in
86 quakeparms_t->basedir.  This can be overridden with the "-basedir" command
87 line parm to allow code debugging in a different directory.  The base
88 directory is only used during filesystem initialization.
89
90 The "game directory" is the first tree on the search path and directory that
91 all generated files (savegames, screenshots, demos, config files) will be
92 saved to.  This can be overridden with the "-game" command line parameter.
93 The game directory can never be changed while quake is executing.  This is a
94 precaution against having a malicious server instruct clients to write files
95 over areas they shouldn't.
96
97 */
98
99
100 /*
101 =============================================================================
102
103 CONSTANTS
104
105 =============================================================================
106 */
107
108 // Magic numbers of a ZIP file (big-endian format)
109 #define ZIP_DATA_HEADER 0x504B0304  // "PK\3\4"
110 #define ZIP_CDIR_HEADER 0x504B0102  // "PK\1\2"
111 #define ZIP_END_HEADER  0x504B0506  // "PK\5\6"
112
113 // Other constants for ZIP files
114 #define ZIP_MAX_COMMENTS_SIZE           ((unsigned short)0xFFFF)
115 #define ZIP_END_CDIR_SIZE                       22
116 #define ZIP_CDIR_CHUNK_BASE_SIZE        46
117 #define ZIP_LOCAL_CHUNK_BASE_SIZE       30
118
119 #ifdef LINK_TO_ZLIB
120 #include <zlib.h>
121
122 #define qz_inflate inflate
123 #define qz_inflateEnd inflateEnd
124 #define qz_inflateInit2_ inflateInit2_
125 #define qz_inflateReset inflateReset
126 #define qz_deflateInit2_ deflateInit2_
127 #define qz_deflateEnd deflateEnd
128 #define qz_deflate deflate
129 #define Z_MEMLEVEL_DEFAULT 8
130 #else
131
132 // Zlib constants (from zlib.h)
133 #define Z_SYNC_FLUSH    2
134 #define MAX_WBITS               15
135 #define Z_OK                    0
136 #define Z_STREAM_END    1
137 #define Z_STREAM_ERROR  (-2)
138 #define Z_DATA_ERROR    (-3)
139 #define Z_MEM_ERROR     (-4)
140 #define Z_BUF_ERROR     (-5)
141 #define ZLIB_VERSION    "1.2.3"
142
143 #define Z_BINARY 0
144 #define Z_DEFLATED 8
145 #define Z_MEMLEVEL_DEFAULT 8
146
147 #define Z_NULL 0
148 #define Z_DEFAULT_COMPRESSION (-1)
149 #define Z_NO_FLUSH 0
150 #define Z_SYNC_FLUSH 2
151 #define Z_FULL_FLUSH 3
152 #define Z_FINISH 4
153
154 // Uncomment the following line if the zlib DLL you have still uses
155 // the 1.1.x series calling convention on Win32 (WINAPI)
156 //#define ZLIB_USES_WINAPI
157
158
159 /*
160 =============================================================================
161
162 TYPES
163
164 =============================================================================
165 */
166
167 /*! Zlib stream (from zlib.h)
168  * \warning: some pointers we don't use directly have
169  * been cast to "void*" for a matter of simplicity
170  */
171 typedef struct
172 {
173         unsigned char                   *next_in;       ///< next input byte
174         unsigned int    avail_in;       ///< number of bytes available at next_in
175         unsigned long   total_in;       ///< total nb of input bytes read so far
176
177         unsigned char                   *next_out;      ///< next output byte should be put there
178         unsigned int    avail_out;      ///< remaining free space at next_out
179         unsigned long   total_out;      ///< total nb of bytes output so far
180
181         char                    *msg;           ///< last error message, NULL if no error
182         void                    *state;         ///< not visible by applications
183
184         void                    *zalloc;        ///< used to allocate the internal state
185         void                    *zfree;         ///< used to free the internal state
186         void                    *opaque;        ///< private data object passed to zalloc and zfree
187
188         int                             data_type;      ///< best guess about the data type: ascii or binary
189         unsigned long   adler;          ///< adler32 value of the uncompressed data
190         unsigned long   reserved;       ///< reserved for future use
191 } z_stream;
192 #endif
193
194
195 /// inside a package (PAK or PK3)
196 #define QFILE_FLAG_PACKED (1 << 0)
197 /// file is compressed using the deflate algorithm (PK3 only)
198 #define QFILE_FLAG_DEFLATED (1 << 1)
199 /// file is actually already loaded data
200 #define QFILE_FLAG_DATA (1 << 2)
201 /// real file will be removed on close
202 #define QFILE_FLAG_REMOVE (1 << 3)
203
204 #define FILE_BUFF_SIZE 2048
205 typedef struct
206 {
207         z_stream        zstream;
208         size_t          comp_length;                    ///< length of the compressed file
209         size_t          in_ind, in_len;                 ///< input buffer current index and length
210         size_t          in_position;                    ///< position in the compressed file
211         unsigned char           input [FILE_BUFF_SIZE];
212 } ztoolkit_t;
213
214 struct qfile_s
215 {
216         int                             flags;
217         int                             handle;                                 ///< file descriptor
218         fs_offset_t             real_length;                    ///< uncompressed file size (for files opened in "read" mode)
219         fs_offset_t             position;                               ///< current position in the file
220         fs_offset_t             offset;                                 ///< offset into the package (0 if external file)
221         int                             ungetc;                                 ///< single stored character from ungetc, cleared to EOF when read
222
223         // Contents buffer
224         fs_offset_t             buff_ind, buff_len;             ///< buffer current index and length
225         unsigned char                   buff [FILE_BUFF_SIZE];
226
227         ztoolkit_t*             ztk;    ///< For zipped files.
228
229         const unsigned char *data;      ///< For data files.
230
231         const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
232 };
233
234
235 // ------ PK3 files on disk ------ //
236
237 // You can get the complete ZIP format description from PKWARE website
238
239 typedef struct pk3_endOfCentralDir_s
240 {
241         unsigned int signature;
242         unsigned short disknum;
243         unsigned short cdir_disknum;    ///< number of the disk with the start of the central directory
244         unsigned short localentries;    ///< number of entries in the central directory on this disk
245         unsigned short nbentries;               ///< total number of entries in the central directory on this disk
246         unsigned int cdir_size;                 ///< size of the central directory
247         unsigned int cdir_offset;               ///< with respect to the starting disk number
248         unsigned short comment_size;
249         fs_offset_t prepended_garbage;
250 } pk3_endOfCentralDir_t;
251
252
253 // ------ PAK files on disk ------ //
254 typedef struct dpackfile_s
255 {
256         char name[56];
257         int filepos, filelen;
258 } dpackfile_t;
259
260 typedef struct dpackheader_s
261 {
262         char id[4];
263         int dirofs;
264         int dirlen;
265 } dpackheader_t;
266
267
268 /*! \name Packages in memory
269  * @{
270  */
271 /// the offset in packfile_t is the true contents offset
272 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
273 /// file compressed using the deflate algorithm
274 #define PACKFILE_FLAG_DEFLATED (1 << 1)
275 /// file is a symbolic link
276 #define PACKFILE_FLAG_SYMLINK (1 << 2)
277
278 typedef struct packfile_s
279 {
280         char name [MAX_QPATH];
281         int flags;
282         fs_offset_t offset;
283         fs_offset_t packsize;   ///< size in the package
284         fs_offset_t realsize;   ///< real file size (uncompressed)
285 } packfile_t;
286
287 typedef struct pack_s
288 {
289         char filename [MAX_OSPATH];
290         char shortname [MAX_QPATH];
291         int handle;
292         int ignorecase;  ///< PK3 ignores case
293         int numfiles;
294         qboolean vpack;
295         packfile_t *files;
296 } pack_t;
297 //@}
298
299 /// Search paths for files (including packages)
300 typedef struct searchpath_s
301 {
302         // only one of filename / pack will be used
303         char filename[MAX_OSPATH];
304         pack_t *pack;
305         struct searchpath_s *next;
306 } searchpath_t;
307
308
309 /*
310 =============================================================================
311
312 FUNCTION PROTOTYPES
313
314 =============================================================================
315 */
316
317 void FS_Dir_f(void);
318 void FS_Ls_f(void);
319 void FS_Which_f(void);
320
321 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
322 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
323                                                                         fs_offset_t offset, fs_offset_t packsize,
324                                                                         fs_offset_t realsize, int flags);
325
326
327 /*
328 =============================================================================
329
330 VARIABLES
331
332 =============================================================================
333 */
334
335 mempool_t *fs_mempool;
336 void *fs_mutex = NULL;
337
338 searchpath_t *fs_searchpaths = NULL;
339 const char *const fs_checkgamedir_missing = "missing";
340
341 #define MAX_FILES_IN_PACK       65536
342
343 char fs_userdir[MAX_OSPATH];
344 char fs_gamedir[MAX_OSPATH];
345 char fs_basedir[MAX_OSPATH];
346 static pack_t *fs_selfpack = NULL;
347
348 // list of active game directories (empty if not running a mod)
349 int fs_numgamedirs = 0;
350 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
351
352 // list of all gamedirs with modinfo.txt
353 gamedir_t *fs_all_gamedirs = NULL;
354 int fs_all_gamedirs_count = 0;
355
356 cvar_t scr_screenshot_name = {CVAR_NORESETTODEFAULTS, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
357 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"};
358 cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
359
360
361 /*
362 =============================================================================
363
364 PRIVATE FUNCTIONS - PK3 HANDLING
365
366 =============================================================================
367 */
368
369 #ifndef LINK_TO_ZLIB
370 // Functions exported from zlib
371 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
372 # define ZEXPORT WINAPI
373 #else
374 # define ZEXPORT
375 #endif
376
377 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
378 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
379 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
380 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
381 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
382 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
383 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
384 #endif
385
386 #define qz_inflateInit2(strm, windowBits) \
387         qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
388 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
389         qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
390
391 #ifndef LINK_TO_ZLIB
392 //        qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
393
394 static dllfunction_t zlibfuncs[] =
395 {
396         {"inflate",                     (void **) &qz_inflate},
397         {"inflateEnd",          (void **) &qz_inflateEnd},
398         {"inflateInit2_",       (void **) &qz_inflateInit2_},
399         {"inflateReset",        (void **) &qz_inflateReset},
400         {"deflateInit2_",   (void **) &qz_deflateInit2_},
401         {"deflateEnd",      (void **) &qz_deflateEnd},
402         {"deflate",         (void **) &qz_deflate},
403         {NULL, NULL}
404 };
405
406 /// Handle for Zlib DLL
407 static dllhandle_t zlib_dll = NULL;
408 #endif
409
410 #ifdef WIN32
411 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
412 static dllfunction_t shfolderfuncs[] =
413 {
414         {"SHGetFolderPathA", (void **) &qSHGetFolderPath},
415         {NULL, NULL}
416 };
417 static const char* shfolderdllnames [] =
418 {
419         "shfolder.dll",  // IE 4, or Win NT and higher
420         NULL
421 };
422 static dllhandle_t shfolder_dll = NULL;
423
424 const GUID qFOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}}; 
425 #define qREFKNOWNFOLDERID const GUID *
426 #define qKF_FLAG_CREATE 0x8000
427 #define qKF_FLAG_NO_ALIAS 0x1000
428 static HRESULT (WINAPI *qSHGetKnownFolderPath) (qREFKNOWNFOLDERID rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
429 static dllfunction_t shell32funcs[] =
430 {
431         {"SHGetKnownFolderPath", (void **) &qSHGetKnownFolderPath},
432         {NULL, NULL}
433 };
434 static const char* shell32dllnames [] =
435 {
436         "shell32.dll",  // Vista and higher
437         NULL
438 };
439 static dllhandle_t shell32_dll = NULL;
440
441 static HRESULT (WINAPI *qCoInitializeEx)(LPVOID pvReserved, DWORD dwCoInit);
442 static void (WINAPI *qCoUninitialize)(void);
443 static void (WINAPI *qCoTaskMemFree)(LPVOID pv);
444 static dllfunction_t ole32funcs[] =
445 {
446         {"CoInitializeEx", (void **) &qCoInitializeEx},
447         {"CoUninitialize", (void **) &qCoUninitialize},
448         {"CoTaskMemFree", (void **) &qCoTaskMemFree},
449         {NULL, NULL}
450 };
451 static const char* ole32dllnames [] =
452 {
453         "ole32.dll", // 2000 and higher
454         NULL
455 };
456 static dllhandle_t ole32_dll = NULL;
457 #endif
458
459 /*
460 ====================
461 PK3_CloseLibrary
462
463 Unload the Zlib DLL
464 ====================
465 */
466 static void PK3_CloseLibrary (void)
467 {
468 #ifndef LINK_TO_ZLIB
469         Sys_UnloadLibrary (&zlib_dll);
470 #endif
471 }
472
473
474 /*
475 ====================
476 PK3_OpenLibrary
477
478 Try to load the Zlib DLL
479 ====================
480 */
481 static qboolean PK3_OpenLibrary (void)
482 {
483 #ifdef LINK_TO_ZLIB
484         return true;
485 #else
486         const char* dllnames [] =
487         {
488 #if defined(WIN32)
489 # ifdef ZLIB_USES_WINAPI
490                 "zlibwapi.dll",
491                 "zlib.dll",
492 # else
493                 "zlib1.dll",
494 # endif
495 #elif defined(MACOSX)
496                 "libz.dylib",
497 #else
498                 "libz.so.1",
499                 "libz.so",
500 #endif
501                 NULL
502         };
503
504         // Already loaded?
505         if (zlib_dll)
506                 return true;
507
508         // Load the DLL
509         return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
510 #endif
511 }
512
513 /*
514 ====================
515 FS_HasZlib
516
517 See if zlib is available
518 ====================
519 */
520 qboolean FS_HasZlib(void)
521 {
522 #ifdef LINK_TO_ZLIB
523         return true;
524 #else
525         PK3_OpenLibrary(); // to be safe
526         return (zlib_dll != 0);
527 #endif
528 }
529
530 /*
531 ====================
532 PK3_GetEndOfCentralDir
533
534 Extract the end of the central directory from a PK3 package
535 ====================
536 */
537 static qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
538 {
539         fs_offset_t filesize, maxsize;
540         unsigned char *buffer, *ptr;
541         int ind;
542
543         // Get the package size
544         filesize = lseek (packhandle, 0, SEEK_END);
545         if (filesize < ZIP_END_CDIR_SIZE)
546                 return false;
547
548         // Load the end of the file in memory
549         if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
550                 maxsize = filesize;
551         else
552                 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
553         buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
554         lseek (packhandle, filesize - maxsize, SEEK_SET);
555         if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
556         {
557                 Mem_Free (buffer);
558                 return false;
559         }
560
561         // Look for the end of central dir signature around the end of the file
562         maxsize -= ZIP_END_CDIR_SIZE;
563         ptr = &buffer[maxsize];
564         ind = 0;
565         while (BuffBigLong (ptr) != ZIP_END_HEADER)
566         {
567                 if (ind == maxsize)
568                 {
569                         Mem_Free (buffer);
570                         return false;
571                 }
572
573                 ind++;
574                 ptr--;
575         }
576
577         memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
578         eocd->signature = LittleLong (eocd->signature);
579         eocd->disknum = LittleShort (eocd->disknum);
580         eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
581         eocd->localentries = LittleShort (eocd->localentries);
582         eocd->nbentries = LittleShort (eocd->nbentries);
583         eocd->cdir_size = LittleLong (eocd->cdir_size);
584         eocd->cdir_offset = LittleLong (eocd->cdir_offset);
585         eocd->comment_size = LittleShort (eocd->comment_size);
586         eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
587         eocd->cdir_offset += eocd->prepended_garbage;
588
589         Mem_Free (buffer);
590
591         return true;
592 }
593
594
595 /*
596 ====================
597 PK3_BuildFileList
598
599 Extract the file list from a PK3 file
600 ====================
601 */
602 static int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
603 {
604         unsigned char *central_dir, *ptr;
605         unsigned int ind;
606         fs_offset_t remaining;
607
608         // Load the central directory in memory
609         central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
610         lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
611         if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
612         {
613                 Mem_Free (central_dir);
614                 return -1;
615         }
616
617         // Extract the files properties
618         // The parsing is done "by hand" because some fields have variable sizes and
619         // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
620         remaining = eocd->cdir_size;
621         pack->numfiles = 0;
622         ptr = central_dir;
623         for (ind = 0; ind < eocd->nbentries; ind++)
624         {
625                 fs_offset_t namesize, count;
626
627                 // Checking the remaining size
628                 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
629                 {
630                         Mem_Free (central_dir);
631                         return -1;
632                 }
633                 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
634
635                 // Check header
636                 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
637                 {
638                         Mem_Free (central_dir);
639                         return -1;
640                 }
641
642                 namesize = BuffLittleShort (&ptr[28]);  // filename length
643
644                 // Check encryption, compression, and attributes
645                 // 1st uint8  : general purpose bit flag
646                 //    Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
647                 //
648                 // LordHavoc: bit 3 would be a problem if we were scanning the archive
649                 // but is not a problem in the central directory where the values are
650                 // always real.
651                 //
652                 // bit 3 seems to always be set by the standard Mac OSX zip maker
653                 //
654                 // 2nd uint8 : external file attributes
655                 //    Check bits 3 (file is a directory) and 5 (file is a volume (?))
656                 if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
657                 {
658                         // Still enough bytes for the name?
659                         if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
660                         {
661                                 Mem_Free (central_dir);
662                                 return -1;
663                         }
664
665                         // WinZip doesn't use the "directory" attribute, so we need to check the name directly
666                         if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
667                         {
668                                 char filename [sizeof (pack->files[0].name)];
669                                 fs_offset_t offset, packsize, realsize;
670                                 int flags;
671
672                                 // Extract the name (strip it if necessary)
673                                 namesize = min(namesize, (int)sizeof (filename) - 1);
674                                 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
675                                 filename[namesize] = '\0';
676
677                                 if (BuffLittleShort (&ptr[10]))
678                                         flags = PACKFILE_FLAG_DEFLATED;
679                                 else
680                                         flags = 0;
681                                 offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
682                                 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
683                                 realsize = (unsigned int)BuffLittleLong (&ptr[24]);
684
685                                 switch(ptr[5]) // C_VERSION_MADE_BY_1
686                                 {
687                                         case 3: // UNIX_
688                                         case 2: // VMS_
689                                         case 16: // BEOS_
690                                                 if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
691                                                         // can't use S_ISLNK here, as this has to compile on non-UNIX too
692                                                         flags |= PACKFILE_FLAG_SYMLINK;
693                                                 break;
694                                 }
695
696                                 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
697                         }
698                 }
699
700                 // Skip the name, additionnal field, and comment
701                 // 1er uint16 : extra field length
702                 // 2eme uint16 : file comment length
703                 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
704                 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
705                 remaining -= count;
706         }
707
708         // If the package is empty, central_dir is NULL here
709         if (central_dir != NULL)
710                 Mem_Free (central_dir);
711         return pack->numfiles;
712 }
713
714
715 /*
716 ====================
717 FS_LoadPackPK3
718
719 Create a package entry associated with a PK3 file
720 ====================
721 */
722 static pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
723 {
724         pk3_endOfCentralDir_t eocd;
725         pack_t *pack;
726         int real_nb_files;
727
728         if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
729         {
730                 if(!silent)
731                         Con_Printf ("%s is not a PK3 file\n", packfile);
732                 close(packhandle);
733                 return NULL;
734         }
735
736         // Multi-volume ZIP archives are NOT allowed
737         if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
738         {
739                 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
740                 close(packhandle);
741                 return NULL;
742         }
743
744         // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
745         // since eocd.nbentries is an unsigned 16 bits integer
746 #if MAX_FILES_IN_PACK < 65535
747         if (eocd.nbentries > MAX_FILES_IN_PACK)
748         {
749                 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
750                 close(packhandle);
751                 return NULL;
752         }
753 #endif
754
755         // Create a package structure in memory
756         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
757         pack->ignorecase = true; // PK3 ignores case
758         strlcpy (pack->filename, packfile, sizeof (pack->filename));
759         pack->handle = packhandle;
760         pack->numfiles = eocd.nbentries;
761         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
762
763         real_nb_files = PK3_BuildFileList (pack, &eocd);
764         if (real_nb_files < 0)
765         {
766                 Con_Printf ("%s is not a valid PK3 file\n", packfile);
767                 close(pack->handle);
768                 Mem_Free(pack);
769                 return NULL;
770         }
771
772         Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
773         return pack;
774 }
775 static pack_t *FS_LoadPackPK3 (const char *packfile)
776 {
777         int packhandle;
778         packhandle = FS_SysOpenFD (packfile, "rb", false);
779         if (packhandle < 0)
780                 return NULL;
781         return FS_LoadPackPK3FromFD(packfile, packhandle, false);
782 }
783
784
785 /*
786 ====================
787 PK3_GetTrueFileOffset
788
789 Find where the true file data offset is
790 ====================
791 */
792 static qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
793 {
794         unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
795         fs_offset_t count;
796
797         // Already found?
798         if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
799                 return true;
800
801         // Load the local file description
802         lseek (pack->handle, pfile->offset, SEEK_SET);
803         count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
804         if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
805         {
806                 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
807                 return false;
808         }
809
810         // Skip name and extra field
811         pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
812
813         pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
814         return true;
815 }
816
817
818 /*
819 =============================================================================
820
821 OTHER PRIVATE FUNCTIONS
822
823 =============================================================================
824 */
825
826
827 /*
828 ====================
829 FS_AddFileToPack
830
831 Add a file to the list of files contained into a package
832 ====================
833 */
834 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
835                                                                          fs_offset_t offset, fs_offset_t packsize,
836                                                                          fs_offset_t realsize, int flags)
837 {
838         int (*strcmp_funct) (const char* str1, const char* str2);
839         int left, right, middle;
840         packfile_t *pfile;
841
842         strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
843
844         // Look for the slot we should put that file into (binary search)
845         left = 0;
846         right = pack->numfiles - 1;
847         while (left <= right)
848         {
849                 int diff;
850
851                 middle = (left + right) / 2;
852                 diff = strcmp_funct (pack->files[middle].name, name);
853
854                 // If we found the file, there's a problem
855                 if (!diff)
856                         Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
857
858                 // If we're too far in the list
859                 if (diff > 0)
860                         right = middle - 1;
861                 else
862                         left = middle + 1;
863         }
864
865         // We have to move the right of the list by one slot to free the one we need
866         pfile = &pack->files[left];
867         memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
868         pack->numfiles++;
869
870         strlcpy (pfile->name, name, sizeof (pfile->name));
871         pfile->offset = offset;
872         pfile->packsize = packsize;
873         pfile->realsize = realsize;
874         pfile->flags = flags;
875
876         return pfile;
877 }
878
879
880 /*
881 ============
882 FS_CreatePath
883
884 Only used for FS_OpenRealFile.
885 ============
886 */
887 void FS_CreatePath (char *path)
888 {
889         char *ofs, save;
890
891         for (ofs = path+1 ; *ofs ; ofs++)
892         {
893                 if (*ofs == '/' || *ofs == '\\')
894                 {
895                         // create the directory
896                         save = *ofs;
897                         *ofs = 0;
898                         FS_mkdir (path);
899                         *ofs = save;
900                 }
901         }
902 }
903
904
905 /*
906 ============
907 FS_Path_f
908
909 ============
910 */
911 static void FS_Path_f (void)
912 {
913         searchpath_t *s;
914
915         Con_Print("Current search path:\n");
916         for (s=fs_searchpaths ; s ; s=s->next)
917         {
918                 if (s->pack)
919                 {
920                         if(s->pack->vpack)
921                                 Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
922                         else
923                                 Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
924                 }
925                 else
926                         Con_Printf("%s\n", s->filename);
927         }
928 }
929
930
931 /*
932 =================
933 FS_LoadPackPAK
934 =================
935 */
936 /*! Takes an explicit (not game tree related) path to a pak file.
937  *Loads the header and directory, adding the files at the beginning
938  *of the list so they override previous pack files.
939  */
940 static pack_t *FS_LoadPackPAK (const char *packfile)
941 {
942         dpackheader_t header;
943         int i, numpackfiles;
944         int packhandle;
945         pack_t *pack;
946         dpackfile_t *info;
947
948         packhandle = FS_SysOpenFD(packfile, "rb", false);
949         if (packhandle < 0)
950                 return NULL;
951         if(read (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
952         {
953                 Con_Printf ("%s is not a packfile\n", packfile);
954                 close(packhandle);
955                 return NULL;
956         }
957         if (memcmp(header.id, "PACK", 4))
958         {
959                 Con_Printf ("%s is not a packfile\n", packfile);
960                 close(packhandle);
961                 return NULL;
962         }
963         header.dirofs = LittleLong (header.dirofs);
964         header.dirlen = LittleLong (header.dirlen);
965
966         if (header.dirlen % sizeof(dpackfile_t))
967         {
968                 Con_Printf ("%s has an invalid directory size\n", packfile);
969                 close(packhandle);
970                 return NULL;
971         }
972
973         numpackfiles = header.dirlen / sizeof(dpackfile_t);
974
975         if (numpackfiles > MAX_FILES_IN_PACK)
976         {
977                 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
978                 close(packhandle);
979                 return NULL;
980         }
981
982         info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
983         lseek (packhandle, header.dirofs, SEEK_SET);
984         if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
985         {
986                 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
987                 Mem_Free(info);
988                 close(packhandle);
989                 return NULL;
990         }
991
992         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
993         pack->ignorecase = false; // PAK is case sensitive
994         strlcpy (pack->filename, packfile, sizeof (pack->filename));
995         pack->handle = packhandle;
996         pack->numfiles = 0;
997         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
998
999         // parse the directory
1000         for (i = 0;i < numpackfiles;i++)
1001         {
1002                 fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
1003                 fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
1004
1005                 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
1006         }
1007
1008         Mem_Free(info);
1009
1010         Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
1011         return pack;
1012 }
1013
1014 /*
1015 ====================
1016 FS_LoadPackVirtual
1017
1018 Create a package entry associated with a directory file
1019 ====================
1020 */
1021 static pack_t *FS_LoadPackVirtual (const char *dirname)
1022 {
1023         pack_t *pack;
1024         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
1025         pack->vpack = true;
1026         pack->ignorecase = false;
1027         strlcpy (pack->filename, dirname, sizeof(pack->filename));
1028         pack->handle = -1;
1029         pack->numfiles = -1;
1030         pack->files = NULL;
1031         Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
1032         return pack;
1033 }
1034
1035 /*
1036 ================
1037 FS_AddPack_Fullpath
1038 ================
1039 */
1040 /*! Adds the given pack to the search path.
1041  * The pack type is autodetected by the file extension.
1042  *
1043  * Returns true if the file was successfully added to the
1044  * search path or if it was already included.
1045  *
1046  * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1047  * plain directories.
1048  *
1049  */
1050 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
1051 {
1052         searchpath_t *search;
1053         pack_t *pak = NULL;
1054         const char *ext = FS_FileExtension(pakfile);
1055         size_t l;
1056
1057         for(search = fs_searchpaths; search; search = search->next)
1058         {
1059                 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
1060                 {
1061                         if(already_loaded)
1062                                 *already_loaded = true;
1063                         return true; // already loaded
1064                 }
1065         }
1066
1067         if(already_loaded)
1068                 *already_loaded = false;
1069
1070         if(!strcasecmp(ext, "pk3dir"))
1071                 pak = FS_LoadPackVirtual (pakfile);
1072         else if(!strcasecmp(ext, "pak"))
1073                 pak = FS_LoadPackPAK (pakfile);
1074         else if(!strcasecmp(ext, "pk3"))
1075                 pak = FS_LoadPackPK3 (pakfile);
1076         else if(!strcasecmp(ext, "obb")) // android apk expansion
1077                 pak = FS_LoadPackPK3 (pakfile);
1078         else
1079                 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
1080
1081         if(pak)
1082         {
1083                 strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
1084
1085                 //Con_DPrintf("  Registered pack with short name %s\n", shortname);
1086                 if(keep_plain_dirs)
1087                 {
1088                         // find the first item whose next one is a pack or NULL
1089                         searchpath_t *insertion_point = 0;
1090                         if(fs_searchpaths && !fs_searchpaths->pack)
1091                         {
1092                                 insertion_point = fs_searchpaths;
1093                                 for(;;)
1094                                 {
1095                                         if(!insertion_point->next)
1096                                                 break;
1097                                         if(insertion_point->next->pack)
1098                                                 break;
1099                                         insertion_point = insertion_point->next;
1100                                 }
1101                         }
1102                         // If insertion_point is NULL, this means that either there is no
1103                         // item in the list yet, or that the very first item is a pack. In
1104                         // that case, we want to insert at the beginning...
1105                         if(!insertion_point)
1106                         {
1107                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1108                                 search->next = fs_searchpaths;
1109                                 fs_searchpaths = search;
1110                         }
1111                         else
1112                         // otherwise we want to append directly after insertion_point.
1113                         {
1114                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1115                                 search->next = insertion_point->next;
1116                                 insertion_point->next = search;
1117                         }
1118                 }
1119                 else
1120                 {
1121                         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1122                         search->next = fs_searchpaths;
1123                         fs_searchpaths = search;
1124                 }
1125                 search->pack = pak;
1126                 if(pak->vpack)
1127                 {
1128                         dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
1129                         // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
1130                         // same goes for the name inside the pack structure
1131                         l = strlen(pak->shortname);
1132                         if(l >= 7)
1133                                 if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
1134                                         pak->shortname[l - 3] = 0;
1135                         l = strlen(pak->filename);
1136                         if(l >= 7)
1137                                 if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
1138                                         pak->filename[l - 3] = 0;
1139                 }
1140                 return true;
1141         }
1142         else
1143         {
1144                 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1145                 return false;
1146         }
1147 }
1148
1149
1150 /*
1151 ================
1152 FS_AddPack
1153 ================
1154 */
1155 /*! Adds the given pack to the search path and searches for it in the game path.
1156  * The pack type is autodetected by the file extension.
1157  *
1158  * Returns true if the file was successfully added to the
1159  * search path or if it was already included.
1160  *
1161  * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
1162  * plain directories.
1163  */
1164 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
1165 {
1166         char fullpath[MAX_OSPATH];
1167         int index;
1168         searchpath_t *search;
1169
1170         if(already_loaded)
1171                 *already_loaded = false;
1172
1173         // then find the real name...
1174         search = FS_FindFile(pakfile, &index, true);
1175         if(!search || search->pack)
1176         {
1177                 Con_Printf("could not find pak \"%s\"\n", pakfile);
1178                 return false;
1179         }
1180
1181         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
1182
1183         return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs);
1184 }
1185
1186
1187 /*
1188 ================
1189 FS_AddGameDirectory
1190
1191 Sets fs_gamedir, adds the directory to the head of the path,
1192 then loads and adds pak1.pak pak2.pak ...
1193 ================
1194 */
1195 static void FS_AddGameDirectory (const char *dir)
1196 {
1197         int i;
1198         stringlist_t list;
1199         searchpath_t *search;
1200
1201         strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
1202
1203         stringlistinit(&list);
1204         listdirectory(&list, "", dir);
1205         stringlistsort(&list, false);
1206
1207         // add any PAK package in the directory
1208         for (i = 0;i < list.numstrings;i++)
1209         {
1210                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
1211                 {
1212                         FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1213                 }
1214         }
1215
1216         // add any PK3 package in the directory
1217         for (i = 0;i < list.numstrings;i++)
1218         {
1219                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
1220                 {
1221                         FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
1222                 }
1223         }
1224
1225         stringlistfreecontents(&list);
1226
1227         // Add the directory to the search path
1228         // (unpacked files have the priority over packed files)
1229         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1230         strlcpy (search->filename, dir, sizeof (search->filename));
1231         search->next = fs_searchpaths;
1232         fs_searchpaths = search;
1233 }
1234
1235
1236 /*
1237 ================
1238 FS_AddGameHierarchy
1239 ================
1240 */
1241 static void FS_AddGameHierarchy (const char *dir)
1242 {
1243         char vabuf[1024];
1244         // Add the common game directory
1245         FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
1246
1247         if (*fs_userdir)
1248                 FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
1249 }
1250
1251
1252 /*
1253 ============
1254 FS_FileExtension
1255 ============
1256 */
1257 const char *FS_FileExtension (const char *in)
1258 {
1259         const char *separator, *backslash, *colon, *dot;
1260
1261         separator = strrchr(in, '/');
1262         backslash = strrchr(in, '\\');
1263         if (!separator || separator < backslash)
1264                 separator = backslash;
1265         colon = strrchr(in, ':');
1266         if (!separator || separator < colon)
1267                 separator = colon;
1268
1269         dot = strrchr(in, '.');
1270         if (dot == NULL || (separator && (dot < separator)))
1271                 return "";
1272
1273         return dot + 1;
1274 }
1275
1276
1277 /*
1278 ============
1279 FS_FileWithoutPath
1280 ============
1281 */
1282 const char *FS_FileWithoutPath (const char *in)
1283 {
1284         const char *separator, *backslash, *colon;
1285
1286         separator = strrchr(in, '/');
1287         backslash = strrchr(in, '\\');
1288         if (!separator || separator < backslash)
1289                 separator = backslash;
1290         colon = strrchr(in, ':');
1291         if (!separator || separator < colon)
1292                 separator = colon;
1293         return separator ? separator + 1 : in;
1294 }
1295
1296
1297 /*
1298 ================
1299 FS_ClearSearchPath
1300 ================
1301 */
1302 static void FS_ClearSearchPath (void)
1303 {
1304         // unload all packs and directory information, close all pack files
1305         // (if a qfile is still reading a pack it won't be harmed because it used
1306         //  dup() to get its own handle already)
1307         while (fs_searchpaths)
1308         {
1309                 searchpath_t *search = fs_searchpaths;
1310                 fs_searchpaths = search->next;
1311                 if (search->pack && search->pack != fs_selfpack)
1312                 {
1313                         if(!search->pack->vpack)
1314                         {
1315                                 // close the file
1316                                 close(search->pack->handle);
1317                                 // free any memory associated with it
1318                                 if (search->pack->files)
1319                                         Mem_Free(search->pack->files);
1320                         }
1321                         Mem_Free(search->pack);
1322                 }
1323                 Mem_Free(search);
1324         }
1325 }
1326
1327 static void FS_AddSelfPack(void)
1328 {
1329         if(fs_selfpack)
1330         {
1331                 searchpath_t *search;
1332                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1333                 search->next = fs_searchpaths;
1334                 search->pack = fs_selfpack;
1335                 fs_searchpaths = search;
1336         }
1337 }
1338
1339
1340 /*
1341 ================
1342 FS_Rescan
1343 ================
1344 */
1345 void FS_Rescan (void)
1346 {
1347         int i;
1348         qboolean fs_modified = false;
1349         qboolean reset = false;
1350         char gamedirbuf[MAX_INPUTLINE];
1351         char vabuf[1024];
1352
1353         if (fs_searchpaths)
1354                 reset = true;
1355         FS_ClearSearchPath();
1356
1357         // automatically activate gamemode for the gamedirs specified
1358         if (reset)
1359                 COM_ChangeGameTypeForGameDirs();
1360
1361         // add the game-specific paths
1362         // gamedirname1 (typically id1)
1363         FS_AddGameHierarchy (gamedirname1);
1364         // update the com_modname (used for server info)
1365         if (gamedirname2 && gamedirname2[0])
1366                 strlcpy(com_modname, gamedirname2, sizeof(com_modname));
1367         else
1368                 strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1369
1370         // add the game-specific path, if any
1371         // (only used for mission packs and the like, which should set fs_modified)
1372         if (gamedirname2 && gamedirname2[0])
1373         {
1374                 fs_modified = true;
1375                 FS_AddGameHierarchy (gamedirname2);
1376         }
1377
1378         // -game <gamedir>
1379         // Adds basedir/gamedir as an override game
1380         // LordHavoc: now supports multiple -game directories
1381         // set the com_modname (reported in server info)
1382         *gamedirbuf = 0;
1383         for (i = 0;i < fs_numgamedirs;i++)
1384         {
1385                 fs_modified = true;
1386                 FS_AddGameHierarchy (fs_gamedirs[i]);
1387                 // update the com_modname (used server info)
1388                 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1389                 if(i)
1390                         strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1391                 else
1392                         strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1393         }
1394         Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1395
1396         // add back the selfpack as new first item
1397         FS_AddSelfPack();
1398
1399         // set the default screenshot name to either the mod name or the
1400         // gamemode screenshot name
1401         if (strcmp(com_modname, gamedirname1))
1402                 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1403         else
1404                 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1405         
1406         if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1407                 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1408
1409         // If "-condebug" is in the command line, remove the previous log file
1410         if (COM_CheckParm ("-condebug") != 0)
1411                 unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
1412
1413         // look for the pop.lmp file and set registered to true if it is found
1414         if (FS_FileExists("gfx/pop.lmp"))
1415                 Cvar_Set ("registered", "1");
1416         switch(gamemode)
1417         {
1418         case GAME_NORMAL:
1419         case GAME_HIPNOTIC:
1420         case GAME_ROGUE:
1421                 if (!registered.integer)
1422                 {
1423                         if (fs_modified)
1424                                 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1425                         else
1426                                 Con_Print("Playing shareware version.\n");
1427                 }
1428                 else
1429                         Con_Print("Playing registered version.\n");
1430                 break;
1431         case GAME_STEELSTORM:
1432                 if (registered.integer)
1433                         Con_Print("Playing registered version.\n");
1434                 else
1435                         Con_Print("Playing shareware version.\n");
1436                 break;
1437         default:
1438                 break;
1439         }
1440
1441         // unload all wads so that future queries will return the new data
1442         W_UnloadAll();
1443 }
1444
1445 static void FS_Rescan_f(void)
1446 {
1447         FS_Rescan();
1448 }
1449
1450 /*
1451 ================
1452 FS_ChangeGameDirs
1453 ================
1454 */
1455 extern qboolean vid_opened;
1456 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1457 {
1458         int i;
1459         const char *p;
1460
1461         if (fs_numgamedirs == numgamedirs)
1462         {
1463                 for (i = 0;i < numgamedirs;i++)
1464                         if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1465                                 break;
1466                 if (i == numgamedirs)
1467                         return true; // already using this set of gamedirs, do nothing
1468         }
1469
1470         if (numgamedirs > MAX_GAMEDIRS)
1471         {
1472                 if (complain)
1473                         Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1474                 return false; // too many gamedirs
1475         }
1476
1477         for (i = 0;i < numgamedirs;i++)
1478         {
1479                 // if string is nasty, reject it
1480                 p = FS_CheckGameDir(gamedirs[i]);
1481                 if(!p)
1482                 {
1483                         if (complain)
1484                                 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1485                         return false; // nasty gamedirs
1486                 }
1487                 if(p == fs_checkgamedir_missing && failmissing)
1488                 {
1489                         if (complain)
1490                                 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1491                         return false; // missing gamedirs
1492                 }
1493         }
1494
1495         Host_SaveConfig();
1496
1497         fs_numgamedirs = numgamedirs;
1498         for (i = 0;i < fs_numgamedirs;i++)
1499                 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1500
1501         // reinitialize filesystem to detect the new paks
1502         FS_Rescan();
1503
1504         if (cls.demoplayback)
1505         {
1506                 CL_Disconnect_f();
1507                 cls.demonum = 0;
1508         }
1509
1510         // unload all sounds so they will be reloaded from the new files as needed
1511         S_UnloadAllSounds_f();
1512
1513         // close down the video subsystem, it will start up again when the config finishes...
1514         VID_Stop();
1515         vid_opened = false;
1516
1517         // restart the video subsystem after the config is executed
1518         Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1519
1520         return true;
1521 }
1522
1523 /*
1524 ================
1525 FS_GameDir_f
1526 ================
1527 */
1528 static void FS_GameDir_f (void)
1529 {
1530         int i;
1531         int numgamedirs;
1532         char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1533
1534         if (Cmd_Argc() < 2)
1535         {
1536                 Con_Printf("gamedirs active:");
1537                 for (i = 0;i < fs_numgamedirs;i++)
1538                         Con_Printf(" %s", fs_gamedirs[i]);
1539                 Con_Printf("\n");
1540                 return;
1541         }
1542
1543         numgamedirs = Cmd_Argc() - 1;
1544         if (numgamedirs > MAX_GAMEDIRS)
1545         {
1546                 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1547                 return;
1548         }
1549
1550         for (i = 0;i < numgamedirs;i++)
1551                 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1552
1553         if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1554         {
1555                 // actually, changing during game would work fine, but would be stupid
1556                 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1557                 return;
1558         }
1559
1560         // halt demo playback to close the file
1561         CL_Disconnect();
1562
1563         FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1564 }
1565
1566 static const char *FS_SysCheckGameDir(const char *gamedir, char *buf, size_t buflength)
1567 {
1568         qboolean success;
1569         qfile_t *f;
1570         stringlist_t list;
1571         fs_offset_t n;
1572         char vabuf[1024];
1573
1574         stringlistinit(&list);
1575         listdirectory(&list, gamedir, "");
1576         success = list.numstrings > 0;
1577         stringlistfreecontents(&list);
1578
1579         if(success)
1580         {
1581                 f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
1582                 if(f)
1583                 {
1584                         n = FS_Read (f, buf, buflength - 1);
1585                         if(n >= 0)
1586                                 buf[n] = 0;
1587                         else
1588                                 *buf = 0;
1589                         FS_Close(f);
1590                 }
1591                 else
1592                         *buf = 0;
1593                 return buf;
1594         }
1595
1596         return NULL;
1597 }
1598
1599 /*
1600 ================
1601 FS_CheckGameDir
1602 ================
1603 */
1604 const char *FS_CheckGameDir(const char *gamedir)
1605 {
1606         const char *ret;
1607         char buf[8192];
1608         char vabuf[1024];
1609
1610         if (FS_CheckNastyPath(gamedir, true))
1611                 return NULL;
1612
1613         ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
1614         if(ret)
1615         {
1616                 if(!*ret)
1617                 {
1618                         // get description from basedir
1619                         ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1620                         if(ret)
1621                                 return ret;
1622                         return "";
1623                 }
1624                 return ret;
1625         }
1626
1627         ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
1628         if(ret)
1629                 return ret;
1630         
1631         return fs_checkgamedir_missing;
1632 }
1633
1634 static void FS_ListGameDirs(void)
1635 {
1636         stringlist_t list, list2;
1637         int i;
1638         const char *info;
1639         char vabuf[1024];
1640
1641         fs_all_gamedirs_count = 0;
1642         if(fs_all_gamedirs)
1643                 Mem_Free(fs_all_gamedirs);
1644
1645         stringlistinit(&list);
1646         listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
1647         listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
1648         stringlistsort(&list, false);
1649
1650         stringlistinit(&list2);
1651         for(i = 0; i < list.numstrings; ++i)
1652         {
1653                 if(i)
1654                         if(!strcmp(list.strings[i-1], list.strings[i]))
1655                                 continue;
1656                 info = FS_CheckGameDir(list.strings[i]);
1657                 if(!info)
1658                         continue;
1659                 if(info == fs_checkgamedir_missing)
1660                         continue;
1661                 if(!*info)
1662                         continue;
1663                 stringlistappend(&list2, list.strings[i]); 
1664         }
1665         stringlistfreecontents(&list);
1666
1667         fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1668         for(i = 0; i < list2.numstrings; ++i)
1669         {
1670                 info = FS_CheckGameDir(list2.strings[i]);
1671                 // all this cannot happen any more, but better be safe than sorry
1672                 if(!info)
1673                         continue;
1674                 if(info == fs_checkgamedir_missing)
1675                         continue;
1676                 if(!*info)
1677                         continue;
1678                 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
1679                 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
1680                 ++fs_all_gamedirs_count;
1681         }
1682 }
1683
1684 /*
1685 #ifdef WIN32
1686 #pragma comment(lib, "shell32.lib")
1687 #include <ShlObj.h>
1688 #endif
1689 */
1690
1691 /*
1692 ================
1693 FS_Init_SelfPack
1694 ================
1695 */
1696 void FS_Init_SelfPack (void)
1697 {
1698         PK3_OpenLibrary ();
1699         fs_mempool = Mem_AllocPool("file management", 0, NULL);
1700         if(com_selffd >= 0)
1701         {
1702                 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1703                 if(fs_selfpack)
1704                 {
1705                         char *buf, *q;
1706                         const char *p;
1707                         FS_AddSelfPack();
1708                         buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1709                         if(buf)
1710                         {
1711                                 const char **new_argv;
1712                                 int i = 0;
1713                                 int args_left = 256;
1714                                 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1715                                 if(com_argc == 0)
1716                                 {
1717                                         new_argv[0] = "dummy";
1718                                         com_argc = 1;
1719                                 }
1720                                 else
1721                                 {
1722                                         memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1723                                 }
1724                                 p = buf;
1725                                 while(COM_ParseToken_Console(&p))
1726                                 {
1727                                         size_t sz = strlen(com_token) + 1; // shut up clang
1728                                         if(i >= args_left)
1729                                                 break;
1730                                         q = (char *)Mem_Alloc(fs_mempool, sz);
1731                                         strlcpy(q, com_token, sz);
1732                                         new_argv[com_argc + i] = q;
1733                                         ++i;
1734                                 }
1735                                 new_argv[i+com_argc] = NULL;
1736                                 com_argv = new_argv;
1737                                 com_argc = com_argc + i;
1738                         }
1739                         Mem_Free(buf);
1740                 }
1741         }
1742 }
1743
1744 static int FS_ChooseUserDir(userdirmode_t userdirmode, char *userdir, size_t userdirsize)
1745 {
1746 #if defined(__IPHONEOS__)
1747         if (userdirmode == USERDIRMODE_HOME)
1748         {
1749                 // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1750                 // fs_userdir stores configurations to the Documents folder of the app
1751                 strlcpy(userdir, "../Documents/", MAX_OSPATH);
1752                 return 1;
1753         }
1754         return -1;
1755
1756 #elif defined(WIN32)
1757         char *homedir;
1758 #if _MSC_VER >= 1400
1759         size_t homedirlen;
1760 #endif
1761         TCHAR mydocsdir[MAX_PATH + 1];
1762         wchar_t *savedgamesdirw;
1763         char savedgamesdir[MAX_OSPATH];
1764         int fd;
1765         char vabuf[1024];
1766
1767         userdir[0] = 0;
1768         switch(userdirmode)
1769         {
1770         default:
1771                 return -1;
1772         case USERDIRMODE_NOHOME:
1773                 strlcpy(userdir, fs_basedir, userdirsize);
1774                 break;
1775         case USERDIRMODE_MYGAMES:
1776                 if (!shfolder_dll)
1777                         Sys_LoadLibrary(shfolderdllnames, &shfolder_dll, shfolderfuncs);
1778                 mydocsdir[0] = 0;
1779                 if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK)
1780                 {
1781                         dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
1782                         break;
1783                 }
1784 #if _MSC_VER >= 1400
1785                 _dupenv_s(&homedir, &homedirlen, "USERPROFILE");
1786                 if(homedir)
1787                 {
1788                         dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1789                         free(homedir);
1790                         break;
1791                 }
1792 #else
1793                 homedir = getenv("USERPROFILE");
1794                 if(homedir)
1795                 {
1796                         dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1797                         break;
1798                 }
1799 #endif
1800                 return -1;
1801         case USERDIRMODE_SAVEDGAMES:
1802                 if (!shell32_dll)
1803                         Sys_LoadLibrary(shell32dllnames, &shell32_dll, shell32funcs);
1804                 if (!ole32_dll)
1805                         Sys_LoadLibrary(ole32dllnames, &ole32_dll, ole32funcs);
1806                 if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
1807                 {
1808                         savedgamesdir[0] = 0;
1809                         qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1810 /*
1811 #ifdef __cplusplus
1812                         if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1813 #else
1814                         if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1815 #endif
1816 */
1817                         if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
1818                         {
1819                                 memset(savedgamesdir, 0, sizeof(savedgamesdir));
1820 #if _MSC_VER >= 1400
1821                                 wcstombs_s(NULL, savedgamesdir, sizeof(savedgamesdir), savedgamesdirw, sizeof(savedgamesdir)-1);
1822 #else
1823                                 wcstombs(savedgamesdir, savedgamesdirw, sizeof(savedgamesdir)-1);
1824 #endif
1825                                 qCoTaskMemFree(savedgamesdirw);
1826                         }
1827                         qCoUninitialize();
1828                         if (savedgamesdir[0])
1829                         {
1830                                 dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
1831                                 break;
1832                         }
1833                 }
1834                 return -1;
1835         }
1836 #else
1837         int fd;
1838         char *homedir;
1839         char vabuf[1024];
1840         userdir[0] = 0;
1841         switch(userdirmode)
1842         {
1843         default:
1844                 return -1;
1845         case USERDIRMODE_NOHOME:
1846                 strlcpy(userdir, fs_basedir, userdirsize);
1847                 break;
1848         case USERDIRMODE_HOME:
1849                 homedir = getenv("HOME");
1850                 if(homedir)
1851                 {
1852                         dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
1853                         break;
1854                 }
1855                 return -1;
1856         case USERDIRMODE_SAVEDGAMES:
1857                 homedir = getenv("HOME");
1858                 if(homedir)
1859                 {
1860 #ifdef MACOSX
1861                         dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1862 #else
1863                         // the XDG say some files would need to go in:
1864                         // XDG_CONFIG_HOME (or ~/.config/%s/)
1865                         // XDG_DATA_HOME (or ~/.local/share/%s/)
1866                         // XDG_CACHE_HOME (or ~/.cache/%s/)
1867                         // and also search the following global locations if defined:
1868                         // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
1869                         // XDG_DATA_DIRS (normally /usr/share/%s/)
1870                         // this would be too complicated...
1871                         return -1;
1872 #endif
1873                         break;
1874                 }
1875                 return -1;
1876         }
1877 #endif
1878
1879
1880 #if !defined(__IPHONEOS__)
1881
1882 #ifdef WIN32
1883         // historical behavior...
1884         if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
1885                 return 0; // don't bother checking if the basedir folder is writable, it's annoying...  unless it is Quake on Windows where NOHOME is the default preferred and we have to check for an error case
1886 #endif
1887
1888         // see if we can write to this path (note: won't create path)
1889 #ifdef WIN32
1890         // no access() here, we must try to open the file for appending
1891         fd = FS_SysOpenFD(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
1892         if(fd >= 0)
1893                 close(fd);
1894 #else
1895         // on Unix, we don't need to ACTUALLY attempt to open the file
1896         if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
1897                 fd = 1;
1898         else
1899                 fd = 0;
1900 #endif
1901         if(fd >= 0)
1902         {
1903                 return 1; // good choice - the path exists and is writable
1904         }
1905         else
1906         {
1907                 if (userdirmode == USERDIRMODE_NOHOME)
1908                         return -1; // path usually already exists, we lack permissions
1909                 else
1910                         return 0; // probably good - failed to write but maybe we need to create path
1911         }
1912 #endif
1913 }
1914
1915 /*
1916 ================
1917 FS_Init
1918 ================
1919 */
1920 void FS_Init (void)
1921 {
1922         const char *p;
1923         int i;
1924
1925         *fs_basedir = 0;
1926         *fs_userdir = 0;
1927         *fs_gamedir = 0;
1928
1929         // -basedir <path>
1930         // Overrides the system supplied base directory (under GAMENAME)
1931 // 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)
1932         i = COM_CheckParm ("-basedir");
1933         if (i && i < com_argc-1)
1934         {
1935                 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1936                 i = (int)strlen (fs_basedir);
1937                 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1938                         fs_basedir[i-1] = 0;
1939         }
1940         else
1941         {
1942 // If the base directory is explicitly defined by the compilation process
1943 #ifdef DP_FS_BASEDIR
1944                 strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1945 #elif defined(__ANDROID__)
1946                 dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
1947 #elif defined(MACOSX)
1948                 // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
1949                 if (strstr(com_argv[0], ".app/"))
1950                 {
1951                         char *split;
1952                         strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1953                         split = strstr(fs_basedir, ".app/");
1954                         if (split)
1955                         {
1956                                 struct stat statresult;
1957                                 char vabuf[1024];
1958                                 // truncate to just after the .app/
1959                                 split[5] = 0;
1960                                 // see if gamedir exists in Resources
1961                                 if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
1962                                 {
1963                                         // found gamedir inside Resources, use it
1964                                         strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
1965                                 }
1966                                 else
1967                                 {
1968                                         // no gamedir found in Resources, gamedir is probably
1969                                         // outside the .app, remove .app part of path
1970                                         while (split > fs_basedir && *split != '/')
1971                                                 split--;
1972                                         *split = 0;
1973                                 }
1974                         }
1975                 }
1976 #endif
1977         }
1978
1979         // make sure the appending of a path separator won't create an unterminated string
1980         memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
1981         // add a path separator to the end of the basedir if it lacks one
1982         if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1983                 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1984
1985         // Add the personal game directory
1986         if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1987                 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1988         else if (COM_CheckParm("-nohome"))
1989                 *fs_userdir = 0; // user wants roaming installation, no userdir
1990         else
1991         {
1992                 int dirmode;
1993                 int highestuserdirmode = USERDIRMODE_COUNT - 1;
1994                 int preferreduserdirmode = USERDIRMODE_COUNT - 1;
1995                 int userdirstatus[USERDIRMODE_COUNT];
1996 #ifdef WIN32
1997                 // historical behavior...
1998                 if (!strcmp(gamedirname1, "id1"))
1999                         preferreduserdirmode = USERDIRMODE_NOHOME;
2000 #endif
2001                 // check what limitations the user wants to impose
2002                 if (COM_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
2003                 if (COM_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
2004                 if (COM_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
2005                 // gather the status of the possible userdirs
2006                 for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
2007                 {
2008                         userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2009                         if (userdirstatus[dirmode] == 1)
2010                                 Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
2011                         else if (userdirstatus[dirmode] == 0)
2012                                 Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
2013                         else
2014                                 Con_DPrintf("userdir %i (not applicable)\n", dirmode);
2015                 }
2016                 // some games may prefer writing to basedir, but if write fails we
2017                 // have to search for a real userdir...
2018                 if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
2019                         preferreduserdirmode = highestuserdirmode;
2020                 // check for an existing userdir and continue using it if possible...
2021                 for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
2022                         if (userdirstatus[dirmode] == 1)
2023                                 break;
2024                 // if no existing userdir found, make a new one...
2025                 if (dirmode == 0 && preferreduserdirmode > 0)
2026                         for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
2027                                 if (userdirstatus[dirmode] >= 0)
2028                                         break;
2029                 // and finally, we picked one...
2030                 FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
2031                 Con_DPrintf("userdir %i is the winner\n", dirmode);
2032         }
2033
2034         // if userdir equal to basedir, clear it to avoid confusion later
2035         if (!strcmp(fs_basedir, fs_userdir))
2036                 fs_userdir[0] = 0;
2037
2038         FS_ListGameDirs();
2039
2040         p = FS_CheckGameDir(gamedirname1);
2041         if(!p || p == fs_checkgamedir_missing)
2042                 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
2043
2044         if(gamedirname2)
2045         {
2046                 p = FS_CheckGameDir(gamedirname2);
2047                 if(!p || p == fs_checkgamedir_missing)
2048                         Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
2049         }
2050
2051         // -game <gamedir>
2052         // Adds basedir/gamedir as an override game
2053         // LordHavoc: now supports multiple -game directories
2054         for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
2055         {
2056                 if (!com_argv[i])
2057                         continue;
2058                 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
2059                 {
2060                         i++;
2061                         p = FS_CheckGameDir(com_argv[i]);
2062                         if(!p)
2063                                 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
2064                         if(p == fs_checkgamedir_missing)
2065                                 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
2066                         // add the gamedir to the list of active gamedirs
2067                         strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
2068                         fs_numgamedirs++;
2069                 }
2070         }
2071
2072         // generate the searchpath
2073         FS_Rescan();
2074
2075         if (Thread_HasThreads())
2076                 fs_mutex = Thread_CreateMutex();
2077 }
2078
2079 void FS_Init_Commands(void)
2080 {
2081         Cvar_RegisterVariable (&scr_screenshot_name);
2082         Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
2083         Cvar_RegisterVariable (&cvar_fs_gamedir);
2084
2085         Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
2086         Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
2087         Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
2088         Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
2089         Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
2090         Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
2091 }
2092
2093 /*
2094 ================
2095 FS_Shutdown
2096 ================
2097 */
2098 void FS_Shutdown (void)
2099 {
2100         // close all pack files and such
2101         // (hopefully there aren't any other open files, but they'll be cleaned up
2102         //  by the OS anyway)
2103         FS_ClearSearchPath();
2104         Mem_FreePool (&fs_mempool);
2105         PK3_CloseLibrary ();
2106
2107 #ifdef WIN32
2108         Sys_UnloadLibrary (&shfolder_dll);
2109         Sys_UnloadLibrary (&shell32_dll);
2110         Sys_UnloadLibrary (&ole32_dll);
2111 #endif
2112
2113         if (fs_mutex)
2114                 Thread_DestroyMutex(fs_mutex);
2115 }
2116
2117 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
2118 {
2119         int handle = -1;
2120         int mod, opt;
2121         unsigned int ind;
2122         qboolean dolock = false;
2123
2124         // Parse the mode string
2125         switch (mode[0])
2126         {
2127                 case 'r':
2128                         mod = O_RDONLY;
2129                         opt = 0;
2130                         break;
2131                 case 'w':
2132                         mod = O_WRONLY;
2133                         opt = O_CREAT | O_TRUNC;
2134                         break;
2135                 case 'a':
2136                         mod = O_WRONLY;
2137                         opt = O_CREAT | O_APPEND;
2138                         break;
2139                 default:
2140                         Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
2141                         return -1;
2142         }
2143         for (ind = 1; mode[ind] != '\0'; ind++)
2144         {
2145                 switch (mode[ind])
2146                 {
2147                         case '+':
2148                                 mod = O_RDWR;
2149                                 break;
2150                         case 'b':
2151                                 opt |= O_BINARY;
2152                                 break;
2153                         case 'l':
2154                                 dolock = true;
2155                                 break;
2156                         default:
2157                                 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
2158                                                         filepath, mode, mode[ind]);
2159                 }
2160         }
2161
2162         if (nonblocking)
2163                 opt |= O_NONBLOCK;
2164
2165         if(COM_CheckParm("-readonly") && mod != O_RDONLY)
2166                 return -1;
2167
2168 #ifdef WIN32
2169 # if _MSC_VER >= 1400
2170         _sopen_s(&handle, filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2171 # else
2172         handle = _sopen (filepath, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
2173 # endif
2174 #else
2175         handle = open (filepath, mod | opt, 0666);
2176         if(handle >= 0 && dolock)
2177         {
2178                 struct flock l;
2179                 l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
2180                 l.l_whence = SEEK_SET;
2181                 l.l_start = 0;
2182                 l.l_len = 0;
2183                 if(fcntl(handle, F_SETLK, &l) == -1)
2184                 {
2185                         close(handle);
2186                         handle = -1;
2187                 }
2188         }
2189 #endif
2190
2191         return handle;
2192 }
2193
2194 /*
2195 ====================
2196 FS_SysOpen
2197
2198 Internal function used to create a qfile_t and open the relevant non-packed file on disk
2199 ====================
2200 */
2201 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
2202 {
2203         qfile_t* file;
2204
2205         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2206         file->ungetc = EOF;
2207         file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
2208         if (file->handle < 0)
2209         {
2210                 Mem_Free (file);
2211                 return NULL;
2212         }
2213
2214         file->filename = Mem_strdup(fs_mempool, filepath);
2215
2216         file->real_length = lseek (file->handle, 0, SEEK_END);
2217
2218         // For files opened in append mode, we start at the end of the file
2219         if (mode[0] == 'a')
2220                 file->position = file->real_length;
2221         else
2222                 lseek (file->handle, 0, SEEK_SET);
2223
2224         return file;
2225 }
2226
2227
2228 /*
2229 ===========
2230 FS_OpenPackedFile
2231
2232 Open a packed file using its package file descriptor
2233 ===========
2234 */
2235 static qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2236 {
2237         packfile_t *pfile;
2238         int dup_handle;
2239         qfile_t* file;
2240
2241         pfile = &pack->files[pack_ind];
2242
2243         // If we don't have the true offset, get it now
2244         if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2245                 if (!PK3_GetTrueFileOffset (pfile, pack))
2246                         return NULL;
2247
2248 #ifndef LINK_TO_ZLIB
2249         // No Zlib DLL = no compressed files
2250         if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2251         {
2252                 Con_Printf("WARNING: can't open the compressed file %s\n"
2253                                         "You need the Zlib DLL to use compressed files\n",
2254                                         pfile->name);
2255                 return NULL;
2256         }
2257 #endif
2258
2259         // LordHavoc: lseek affects all duplicates of a handle so we do it before
2260         // the dup() call to avoid having to close the dup_handle on error here
2261         if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2262         {
2263                 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2264                                         pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2265                 return NULL;
2266         }
2267
2268         dup_handle = dup (pack->handle);
2269         if (dup_handle < 0)
2270         {
2271                 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2272                 return NULL;
2273         }
2274
2275         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2276         memset (file, 0, sizeof (*file));
2277         file->handle = dup_handle;
2278         file->flags = QFILE_FLAG_PACKED;
2279         file->real_length = pfile->realsize;
2280         file->offset = pfile->offset;
2281         file->position = 0;
2282         file->ungetc = EOF;
2283
2284         if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2285         {
2286                 ztoolkit_t *ztk;
2287
2288                 file->flags |= QFILE_FLAG_DEFLATED;
2289
2290                 // We need some more variables
2291                 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2292
2293                 ztk->comp_length = pfile->packsize;
2294
2295                 // Initialize zlib stream
2296                 ztk->zstream.next_in = ztk->input;
2297                 ztk->zstream.avail_in = 0;
2298
2299                 /* From Zlib's "unzip.c":
2300                  *
2301                  * windowBits is passed < 0 to tell that there is no zlib header.
2302                  * Note that in this case inflate *requires* an extra "dummy" byte
2303                  * after the compressed stream in order to complete decompression and
2304                  * return Z_STREAM_END.
2305                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2306                  * size of both compressed and uncompressed data
2307                  */
2308                 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2309                 {
2310                         Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2311                         close(dup_handle);
2312                         Mem_Free(file);
2313                         return NULL;
2314                 }
2315
2316                 ztk->zstream.next_out = file->buff;
2317                 ztk->zstream.avail_out = sizeof (file->buff);
2318
2319                 file->ztk = ztk;
2320         }
2321
2322         return file;
2323 }
2324
2325 /*
2326 ====================
2327 FS_CheckNastyPath
2328
2329 Return true if the path should be rejected due to one of the following:
2330 1: path elements that are non-portable
2331 2: path elements that would allow access to files outside the game directory,
2332    or are just not a good idea for a mod to be using.
2333 ====================
2334 */
2335 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2336 {
2337         // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2338         if (!path[0])
2339                 return 2;
2340
2341         // Windows: don't allow \ in filenames (windows-only), period.
2342         // (on Windows \ is a directory separator, but / is also supported)
2343         if (strstr(path, "\\"))
2344                 return 1; // non-portable
2345
2346         // Mac: don't allow Mac-only filenames - : is a directory separator
2347         // instead of /, but we rely on / working already, so there's no reason to
2348         // support a Mac-only path
2349         // Amiga and Windows: : tries to go to root of drive
2350         if (strstr(path, ":"))
2351                 return 1; // non-portable attempt to go to root of drive
2352
2353         // Amiga: // is parent directory
2354         if (strstr(path, "//"))
2355                 return 1; // non-portable attempt to go to parent directory
2356
2357         // all: don't allow going to parent directory (../ or /../)
2358         if (strstr(path, ".."))
2359                 return 2; // attempt to go outside the game directory
2360
2361         // Windows and UNIXes: don't allow absolute paths
2362         if (path[0] == '/')
2363                 return 2; // attempt to go outside the game directory
2364
2365         // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
2366         if (strstr(path, "./"))
2367                 return 2; // possible attempt to go outside the game directory
2368
2369         // all: forbid trailing slash on gamedir
2370         if (isgamedir && path[strlen(path)-1] == '/')
2371                 return 2;
2372
2373         // all: forbid leading dot on any filename for any reason
2374         if (strstr(path, "/."))
2375                 return 2; // attempt to go outside the game directory
2376
2377         // after all these checks we're pretty sure it's a / separated filename
2378         // and won't do much if any harm
2379         return false;
2380 }
2381
2382
2383 /*
2384 ====================
2385 FS_FindFile
2386
2387 Look for a file in the packages and in the filesystem
2388
2389 Return the searchpath where the file was found (or NULL)
2390 and the file index in the package if relevant
2391 ====================
2392 */
2393 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2394 {
2395         searchpath_t *search;
2396         pack_t *pak;
2397
2398         // search through the path, one element at a time
2399         for (search = fs_searchpaths;search;search = search->next)
2400         {
2401                 // is the element a pak file?
2402                 if (search->pack && !search->pack->vpack)
2403                 {
2404                         int (*strcmp_funct) (const char* str1, const char* str2);
2405                         int left, right, middle;
2406
2407                         pak = search->pack;
2408                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2409
2410                         // Look for the file (binary search)
2411                         left = 0;
2412                         right = pak->numfiles - 1;
2413                         while (left <= right)
2414                         {
2415                                 int diff;
2416
2417                                 middle = (left + right) / 2;
2418                                 diff = strcmp_funct (pak->files[middle].name, name);
2419
2420                                 // Found it
2421                                 if (!diff)
2422                                 {
2423                                         if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2424                                         {
2425                                                 // yes, but the first one is empty so we treat it as not being there
2426                                                 if (!quiet && developer_extra.integer)
2427                                                         Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2428
2429                                                 if (index != NULL)
2430                                                         *index = -1;
2431                                                 return NULL;
2432                                         }
2433
2434                                         if (!quiet && developer_extra.integer)
2435                                                 Con_DPrintf("FS_FindFile: %s in %s\n",
2436                                                                         pak->files[middle].name, pak->filename);
2437
2438                                         if (index != NULL)
2439                                                 *index = middle;
2440                                         return search;
2441                                 }
2442
2443                                 // If we're too far in the list
2444                                 if (diff > 0)
2445                                         right = middle - 1;
2446                                 else
2447                                         left = middle + 1;
2448                         }
2449                 }
2450                 else
2451                 {
2452                         char netpath[MAX_OSPATH];
2453                         dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2454                         if (FS_SysFileExists (netpath))
2455                         {
2456                                 if (!quiet && developer_extra.integer)
2457                                         Con_DPrintf("FS_FindFile: %s\n", netpath);
2458
2459                                 if (index != NULL)
2460                                         *index = -1;
2461                                 return search;
2462                         }
2463                 }
2464         }
2465
2466         if (!quiet && developer_extra.integer)
2467                 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2468
2469         if (index != NULL)
2470                 *index = -1;
2471         return NULL;
2472 }
2473
2474
2475 /*
2476 ===========
2477 FS_OpenReadFile
2478
2479 Look for a file in the search paths and open it in read-only mode
2480 ===========
2481 */
2482 static qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2483 {
2484         searchpath_t *search;
2485         int pack_ind;
2486
2487         search = FS_FindFile (filename, &pack_ind, quiet);
2488
2489         // Not found?
2490         if (search == NULL)
2491                 return NULL;
2492
2493         // Found in the filesystem?
2494         if (pack_ind < 0)
2495         {
2496                 // this works with vpacks, so we are fine
2497                 char path [MAX_OSPATH];
2498                 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2499                 return FS_SysOpen (path, "rb", nonblocking);
2500         }
2501
2502         // So, we found it in a package...
2503
2504         // Is it a PK3 symlink?
2505         // TODO also handle directory symlinks by parsing the whole structure...
2506         // but heck, file symlinks are good enough for now
2507         if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2508         {
2509                 if(symlinkLevels <= 0)
2510                 {
2511                         Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2512                         return NULL;
2513                 }
2514                 else
2515                 {
2516                         char linkbuf[MAX_QPATH];
2517                         fs_offset_t count;
2518                         qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2519                         const char *mergeslash;
2520                         char *mergestart;
2521
2522                         if(!linkfile)
2523                                 return NULL;
2524                         count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2525                         FS_Close(linkfile);
2526                         if(count < 0)
2527                                 return NULL;
2528                         linkbuf[count] = 0;
2529                         
2530                         // Now combine the paths...
2531                         mergeslash = strrchr(filename, '/');
2532                         mergestart = linkbuf;
2533                         if(!mergeslash)
2534                                 mergeslash = filename;
2535                         while(!strncmp(mergestart, "../", 3))
2536                         {
2537                                 mergestart += 3;
2538                                 while(mergeslash > filename)
2539                                 {
2540                                         --mergeslash;
2541                                         if(*mergeslash == '/')
2542                                                 break;
2543                                 }
2544                         }
2545                         // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2546                         if(mergeslash == filename)
2547                         {
2548                                 // Either mergeslash == filename, then we just replace the name (done below)
2549                         }
2550                         else
2551                         {
2552                                 // Or, we append the name after mergeslash;
2553                                 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2554                                 int spaceNeeded = mergeslash - filename + 1;
2555                                 int spaceRemoved = mergestart - linkbuf;
2556                                 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2557                                 {
2558                                         Con_DPrintf("symlink: too long path rejected\n");
2559                                         return NULL;
2560                                 }
2561                                 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2562                                 memcpy(linkbuf, filename, spaceNeeded);
2563                                 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2564                                 mergestart = linkbuf;
2565                         }
2566                         if (!quiet && developer_loading.integer)
2567                                 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2568                         if(FS_CheckNastyPath (mergestart, false))
2569                         {
2570                                 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2571                                 return NULL;
2572                         }
2573                         return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2574                 }
2575         }
2576
2577         return FS_OpenPackedFile (search->pack, pack_ind);
2578 }
2579
2580
2581 /*
2582 =============================================================================
2583
2584 MAIN PUBLIC FUNCTIONS
2585
2586 =============================================================================
2587 */
2588
2589 /*
2590 ====================
2591 FS_OpenRealFile
2592
2593 Open a file in the userpath. The syntax is the same as fopen
2594 Used for savegame scanning in menu, and all file writing.
2595 ====================
2596 */
2597 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2598 {
2599         char real_path [MAX_OSPATH];
2600
2601         if (FS_CheckNastyPath(filepath, false))
2602         {
2603                 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2604                 return NULL;
2605         }
2606
2607         dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2608
2609         // If the file is opened in "write", "append", or "read/write" mode,
2610         // create directories up to the file.
2611         if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2612                 FS_CreatePath (real_path);
2613         return FS_SysOpen (real_path, mode, false);
2614 }
2615
2616
2617 /*
2618 ====================
2619 FS_OpenVirtualFile
2620
2621 Open a file. The syntax is the same as fopen
2622 ====================
2623 */
2624 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2625 {
2626         qfile_t *result = NULL;
2627         if (FS_CheckNastyPath(filepath, false))
2628         {
2629                 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2630                 return NULL;
2631         }
2632
2633         if (fs_mutex) Thread_LockMutex(fs_mutex);
2634         result = FS_OpenReadFile (filepath, quiet, false, 16);
2635         if (fs_mutex) Thread_UnlockMutex(fs_mutex);
2636         return result;
2637 }
2638
2639
2640 /*
2641 ====================
2642 FS_FileFromData
2643
2644 Open a file. The syntax is the same as fopen
2645 ====================
2646 */
2647 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2648 {
2649         qfile_t* file;
2650         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2651         memset (file, 0, sizeof (*file));
2652         file->flags = QFILE_FLAG_DATA;
2653         file->ungetc = EOF;
2654         file->real_length = size;
2655         file->data = data;
2656         return file;
2657 }
2658
2659 /*
2660 ====================
2661 FS_Close
2662
2663 Close a file
2664 ====================
2665 */
2666 int FS_Close (qfile_t* file)
2667 {
2668         if(file->flags & QFILE_FLAG_DATA)
2669         {
2670                 Mem_Free(file);
2671                 return 0;
2672         }
2673
2674         if (close (file->handle))
2675                 return EOF;
2676
2677         if (file->filename)
2678         {
2679                 if (file->flags & QFILE_FLAG_REMOVE)
2680                         remove(file->filename);
2681
2682                 Mem_Free((void *) file->filename);
2683         }
2684
2685         if (file->ztk)
2686         {
2687                 qz_inflateEnd (&file->ztk->zstream);
2688                 Mem_Free (file->ztk);
2689         }
2690
2691         Mem_Free (file);
2692         return 0;
2693 }
2694
2695 void FS_RemoveOnClose(qfile_t* file)
2696 {
2697         file->flags |= QFILE_FLAG_REMOVE;
2698 }
2699
2700 /*
2701 ====================
2702 FS_Write
2703
2704 Write "datasize" bytes into a file
2705 ====================
2706 */
2707 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2708 {
2709         fs_offset_t result;
2710
2711         // If necessary, seek to the exact file position we're supposed to be
2712         if (file->buff_ind != file->buff_len)
2713                 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2714
2715         // Purge cached data
2716         FS_Purge (file);
2717
2718         // Write the buffer and update the position
2719         result = write (file->handle, data, (fs_offset_t)datasize);
2720         file->position = lseek (file->handle, 0, SEEK_CUR);
2721         if (file->real_length < file->position)
2722                 file->real_length = file->position;
2723
2724         if (result < 0)
2725                 return 0;
2726
2727         return result;
2728 }
2729
2730
2731 /*
2732 ====================
2733 FS_Read
2734
2735 Read up to "buffersize" bytes from a file
2736 ====================
2737 */
2738 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2739 {
2740         fs_offset_t count, done;
2741
2742         if (buffersize == 0)
2743                 return 0;
2744
2745         // Get rid of the ungetc character
2746         if (file->ungetc != EOF)
2747         {
2748                 ((char*)buffer)[0] = file->ungetc;
2749                 buffersize--;
2750                 file->ungetc = EOF;
2751                 done = 1;
2752         }
2753         else
2754                 done = 0;
2755
2756         if(file->flags & QFILE_FLAG_DATA)
2757         {
2758                 size_t left = file->real_length - file->position;
2759                 if(buffersize > left)
2760                         buffersize = left;
2761                 memcpy(buffer, file->data + file->position, buffersize);
2762                 file->position += buffersize;
2763                 return buffersize;
2764         }
2765
2766         // First, we copy as many bytes as we can from "buff"
2767         if (file->buff_ind < file->buff_len)
2768         {
2769                 count = file->buff_len - file->buff_ind;
2770                 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2771                 done += count;
2772                 memcpy (buffer, &file->buff[file->buff_ind], count);
2773                 file->buff_ind += count;
2774
2775                 buffersize -= count;
2776                 if (buffersize == 0)
2777                         return done;
2778         }
2779
2780         // NOTE: at this point, the read buffer is always empty
2781
2782         // If the file isn't compressed
2783         if (! (file->flags & QFILE_FLAG_DEFLATED))
2784         {
2785                 fs_offset_t nb;
2786
2787                 // We must take care to not read after the end of the file
2788                 count = file->real_length - file->position;
2789
2790                 // If we have a lot of data to get, put them directly into "buffer"
2791                 if (buffersize > sizeof (file->buff) / 2)
2792                 {
2793                         if (count > (fs_offset_t)buffersize)
2794                                 count = (fs_offset_t)buffersize;
2795                         lseek (file->handle, file->offset + file->position, SEEK_SET);
2796                         nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2797                         if (nb > 0)
2798                         {
2799                                 done += nb;
2800                                 file->position += nb;
2801
2802                                 // Purge cached data
2803                                 FS_Purge (file);
2804                         }
2805                 }
2806                 else
2807                 {
2808                         if (count > (fs_offset_t)sizeof (file->buff))
2809                                 count = (fs_offset_t)sizeof (file->buff);
2810                         lseek (file->handle, file->offset + file->position, SEEK_SET);
2811                         nb = read (file->handle, file->buff, count);
2812                         if (nb > 0)
2813                         {
2814                                 file->buff_len = nb;
2815                                 file->position += nb;
2816
2817                                 // Copy the requested data in "buffer" (as much as we can)
2818                                 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2819                                 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2820                                 file->buff_ind = count;
2821                                 done += count;
2822                         }
2823                 }
2824
2825                 return done;
2826         }
2827
2828         // If the file is compressed, it's more complicated...
2829         // We cycle through a few operations until we have read enough data
2830         while (buffersize > 0)
2831         {
2832                 ztoolkit_t *ztk = file->ztk;
2833                 int error;
2834
2835                 // NOTE: at this point, the read buffer is always empty
2836
2837                 // If "input" is also empty, we need to refill it
2838                 if (ztk->in_ind == ztk->in_len)
2839                 {
2840                         // If we are at the end of the file
2841                         if (file->position == file->real_length)
2842                                 return done;
2843
2844                         count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2845                         if (count > (fs_offset_t)sizeof (ztk->input))
2846                                 count = (fs_offset_t)sizeof (ztk->input);
2847                         lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2848                         if (read (file->handle, ztk->input, count) != count)
2849                         {
2850                                 Con_Printf ("FS_Read: unexpected end of file\n");
2851                                 break;
2852                         }
2853
2854                         ztk->in_ind = 0;
2855                         ztk->in_len = count;
2856                         ztk->in_position += count;
2857                 }
2858
2859                 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2860                 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2861
2862                 // Now that we are sure we have compressed data available, we need to determine
2863                 // if it's better to inflate it in "file->buff" or directly in "buffer"
2864
2865                 // Inflate the data in "file->buff"
2866                 if (buffersize < sizeof (file->buff) / 2)
2867                 {
2868                         ztk->zstream.next_out = file->buff;
2869                         ztk->zstream.avail_out = sizeof (file->buff);
2870                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2871                         if (error != Z_OK && error != Z_STREAM_END)
2872                         {
2873                                 Con_Printf ("FS_Read: Can't inflate file\n");
2874                                 break;
2875                         }
2876                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2877
2878                         file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2879                         file->position += file->buff_len;
2880
2881                         // Copy the requested data in "buffer" (as much as we can)
2882                         count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2883                         memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2884                         file->buff_ind = count;
2885                 }
2886
2887                 // Else, we inflate directly in "buffer"
2888                 else
2889                 {
2890                         ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2891                         ztk->zstream.avail_out = (unsigned int)buffersize;
2892                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2893                         if (error != Z_OK && error != Z_STREAM_END)
2894                         {
2895                                 Con_Printf ("FS_Read: Can't inflate file\n");
2896                                 break;
2897                         }
2898                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2899
2900                         // How much data did it inflate?
2901                         count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2902                         file->position += count;
2903
2904                         // Purge cached data
2905                         FS_Purge (file);
2906                 }
2907
2908                 done += count;
2909                 buffersize -= count;
2910         }
2911
2912         return done;
2913 }
2914
2915
2916 /*
2917 ====================
2918 FS_Print
2919
2920 Print a string into a file
2921 ====================
2922 */
2923 int FS_Print (qfile_t* file, const char *msg)
2924 {
2925         return (int)FS_Write (file, msg, strlen (msg));
2926 }
2927
2928 /*
2929 ====================
2930 FS_Printf
2931
2932 Print a string into a file
2933 ====================
2934 */
2935 int FS_Printf(qfile_t* file, const char* format, ...)
2936 {
2937         int result;
2938         va_list args;
2939
2940         va_start (args, format);
2941         result = FS_VPrintf (file, format, args);
2942         va_end (args);
2943
2944         return result;
2945 }
2946
2947
2948 /*
2949 ====================
2950 FS_VPrintf
2951
2952 Print a string into a file
2953 ====================
2954 */
2955 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2956 {
2957         int len;
2958         fs_offset_t buff_size = MAX_INPUTLINE;
2959         char *tempbuff;
2960
2961         for (;;)
2962         {
2963                 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2964                 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2965                 if (len >= 0 && len < buff_size)
2966                         break;
2967                 Mem_Free (tempbuff);
2968                 buff_size *= 2;
2969         }
2970
2971         len = write (file->handle, tempbuff, len);
2972         Mem_Free (tempbuff);
2973
2974         return len;
2975 }
2976
2977
2978 /*
2979 ====================
2980 FS_Getc
2981
2982 Get the next character of a file
2983 ====================
2984 */
2985 int FS_Getc (qfile_t* file)
2986 {
2987         unsigned char c;
2988
2989         if (FS_Read (file, &c, 1) != 1)
2990                 return EOF;
2991
2992         return c;
2993 }
2994
2995
2996 /*
2997 ====================
2998 FS_UnGetc
2999
3000 Put a character back into the read buffer (only supports one character!)
3001 ====================
3002 */
3003 int FS_UnGetc (qfile_t* file, unsigned char c)
3004 {
3005         // If there's already a character waiting to be read
3006         if (file->ungetc != EOF)
3007                 return EOF;
3008
3009         file->ungetc = c;
3010         return c;
3011 }
3012
3013
3014 /*
3015 ====================
3016 FS_Seek
3017
3018 Move the position index in a file
3019 ====================
3020 */
3021 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
3022 {
3023         ztoolkit_t *ztk;
3024         unsigned char* buffer;
3025         fs_offset_t buffersize;
3026
3027         // Compute the file offset
3028         switch (whence)
3029         {
3030                 case SEEK_CUR:
3031                         offset += file->position - file->buff_len + file->buff_ind;
3032                         break;
3033
3034                 case SEEK_SET:
3035                         break;
3036
3037                 case SEEK_END:
3038                         offset += file->real_length;
3039                         break;
3040
3041                 default:
3042                         return -1;
3043         }
3044         if (offset < 0 || offset > file->real_length)
3045                 return -1;
3046
3047         if(file->flags & QFILE_FLAG_DATA)
3048         {
3049                 file->position = offset;
3050                 return 0;
3051         }
3052
3053         // If we have the data in our read buffer, we don't need to actually seek
3054         if (file->position - file->buff_len <= offset && offset <= file->position)
3055         {
3056                 file->buff_ind = offset + file->buff_len - file->position;
3057                 return 0;
3058         }
3059
3060         // Purge cached data
3061         FS_Purge (file);
3062
3063         // Unpacked or uncompressed files can seek directly
3064         if (! (file->flags & QFILE_FLAG_DEFLATED))
3065         {
3066                 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
3067                         return -1;
3068                 file->position = offset;
3069                 return 0;
3070         }
3071
3072         // Seeking in compressed files is more a hack than anything else,
3073         // but we need to support it, so here we go.
3074         ztk = file->ztk;
3075
3076         // If we have to go back in the file, we need to restart from the beginning
3077         if (offset <= file->position)
3078         {
3079                 ztk->in_ind = 0;
3080                 ztk->in_len = 0;
3081                 ztk->in_position = 0;
3082                 file->position = 0;
3083                 lseek (file->handle, file->offset, SEEK_SET);
3084
3085                 // Reset the Zlib stream
3086                 ztk->zstream.next_in = ztk->input;
3087                 ztk->zstream.avail_in = 0;
3088                 qz_inflateReset (&ztk->zstream);
3089         }
3090
3091         // We need a big buffer to force inflating into it directly
3092         buffersize = 2 * sizeof (file->buff);
3093         buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
3094
3095         // Skip all data until we reach the requested offset
3096         while (offset > file->position)
3097         {
3098                 fs_offset_t diff = offset - file->position;
3099                 fs_offset_t count, len;
3100
3101                 count = (diff > buffersize) ? buffersize : diff;
3102                 len = FS_Read (file, buffer, count);
3103                 if (len != count)
3104                 {
3105                         Mem_Free (buffer);
3106                         return -1;
3107                 }
3108         }
3109
3110         Mem_Free (buffer);
3111         return 0;
3112 }
3113
3114
3115 /*
3116 ====================
3117 FS_Tell
3118
3119 Give the current position in a file
3120 ====================
3121 */
3122 fs_offset_t FS_Tell (qfile_t* file)
3123 {
3124         return file->position - file->buff_len + file->buff_ind;
3125 }
3126
3127
3128 /*
3129 ====================
3130 FS_FileSize
3131
3132 Give the total size of a file
3133 ====================
3134 */
3135 fs_offset_t FS_FileSize (qfile_t* file)
3136 {
3137         return file->real_length;
3138 }
3139
3140
3141 /*
3142 ====================
3143 FS_Purge
3144
3145 Erases any buffered input or output data
3146 ====================
3147 */
3148 void FS_Purge (qfile_t* file)
3149 {
3150         file->buff_len = 0;
3151         file->buff_ind = 0;
3152         file->ungetc = EOF;
3153 }
3154
3155
3156 /*
3157 ============
3158 FS_LoadFile
3159
3160 Filename are relative to the quake directory.
3161 Always appends a 0 byte.
3162 ============
3163 */
3164 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
3165 {
3166         qfile_t *file;
3167         unsigned char *buf = NULL;
3168         fs_offset_t filesize = 0;
3169
3170         file = FS_OpenVirtualFile(path, quiet);
3171         if (file)
3172         {
3173                 filesize = file->real_length;
3174                 if(filesize < 0)
3175                 {
3176                         Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
3177                         FS_Close(file);
3178                         return NULL;
3179                 }
3180
3181                 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
3182                 buf[filesize] = '\0';
3183                 FS_Read (file, buf, filesize);
3184                 FS_Close (file);
3185                 if (developer_loadfile.integer)
3186                         Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
3187         }
3188
3189         if (filesizepointer)
3190                 *filesizepointer = filesize;
3191         return buf;
3192 }
3193
3194
3195 /*
3196 ============
3197 FS_WriteFile
3198
3199 The filename will be prefixed by the current game directory
3200 ============
3201 */
3202 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
3203 {
3204         qfile_t *file;
3205         size_t i;
3206         fs_offset_t lentotal;
3207
3208         file = FS_OpenRealFile(filename, "wb", false);
3209         if (!file)
3210         {
3211                 Con_Printf("FS_WriteFile: failed on %s\n", filename);
3212                 return false;
3213         }
3214
3215         lentotal = 0;
3216         for(i = 0; i < count; ++i)
3217                 lentotal += len[i];
3218         Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
3219         for(i = 0; i < count; ++i)
3220                 FS_Write (file, data[i], len[i]);
3221         FS_Close (file);
3222         return true;
3223 }
3224
3225 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3226 {
3227         return FS_WriteFileInBlocks(filename, &data, &len, 1);
3228 }
3229
3230
3231 /*
3232 =============================================================================
3233
3234 OTHERS PUBLIC FUNCTIONS
3235
3236 =============================================================================
3237 */
3238
3239 /*
3240 ============
3241 FS_StripExtension
3242 ============
3243 */
3244 void FS_StripExtension (const char *in, char *out, size_t size_out)
3245 {
3246         char *last = NULL;
3247         char currentchar;
3248
3249         if (size_out == 0)
3250                 return;
3251
3252         while ((currentchar = *in) && size_out > 1)
3253         {
3254                 if (currentchar == '.')
3255                         last = out;
3256                 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3257                         last = NULL;
3258                 *out++ = currentchar;
3259                 in++;
3260                 size_out--;
3261         }
3262         if (last)
3263                 *last = 0;
3264         else
3265                 *out = 0;
3266 }
3267
3268
3269 /*
3270 ==================
3271 FS_DefaultExtension
3272 ==================
3273 */
3274 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3275 {
3276         const char *src;
3277
3278         // if path doesn't have a .EXT, append extension
3279         // (extension should include the .)
3280         src = path + strlen(path) - 1;
3281
3282         while (*src != '/' && src != path)
3283         {
3284                 if (*src == '.')
3285                         return;                 // it has an extension
3286                 src--;
3287         }
3288
3289         strlcat (path, extension, size_path);
3290 }
3291
3292
3293 /*
3294 ==================
3295 FS_FileType
3296
3297 Look for a file in the packages and in the filesystem
3298 ==================
3299 */
3300 int FS_FileType (const char *filename)
3301 {
3302         searchpath_t *search;
3303         char fullpath[MAX_OSPATH];
3304
3305         search = FS_FindFile (filename, NULL, true);
3306         if(!search)
3307                 return FS_FILETYPE_NONE;
3308
3309         if(search->pack && !search->pack->vpack)
3310                 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3311
3312         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3313         return FS_SysFileType(fullpath);
3314 }
3315
3316
3317 /*
3318 ==================
3319 FS_FileExists
3320
3321 Look for a file in the packages and in the filesystem
3322 ==================
3323 */
3324 qboolean FS_FileExists (const char *filename)
3325 {
3326         return (FS_FindFile (filename, NULL, true) != NULL);
3327 }
3328
3329
3330 /*
3331 ==================
3332 FS_SysFileExists
3333
3334 Look for a file in the filesystem only
3335 ==================
3336 */
3337 int FS_SysFileType (const char *path)
3338 {
3339 #if WIN32
3340 // Sajt - some older sdks are missing this define
3341 # ifndef INVALID_FILE_ATTRIBUTES
3342 #  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3343 # endif
3344
3345         DWORD result = GetFileAttributes(path);
3346
3347         if(result == INVALID_FILE_ATTRIBUTES)
3348                 return FS_FILETYPE_NONE;
3349
3350         if(result & FILE_ATTRIBUTE_DIRECTORY)
3351                 return FS_FILETYPE_DIRECTORY;
3352
3353         return FS_FILETYPE_FILE;
3354 #else
3355         struct stat buf;
3356
3357         if (stat (path,&buf) == -1)
3358                 return FS_FILETYPE_NONE;
3359
3360 #ifndef S_ISDIR
3361 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3362 #endif
3363         if(S_ISDIR(buf.st_mode))
3364                 return FS_FILETYPE_DIRECTORY;
3365
3366         return FS_FILETYPE_FILE;
3367 #endif
3368 }
3369
3370 qboolean FS_SysFileExists (const char *path)
3371 {
3372         return FS_SysFileType (path) != FS_FILETYPE_NONE;
3373 }
3374
3375 void FS_mkdir (const char *path)
3376 {
3377         if(COM_CheckParm("-readonly"))
3378                 return;
3379
3380 #if WIN32
3381         _mkdir (path);
3382 #else
3383         mkdir (path, 0777);
3384 #endif
3385 }
3386
3387 /*
3388 ===========
3389 FS_Search
3390
3391 Allocate and fill a search structure with information on matching filenames.
3392 ===========
3393 */
3394 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3395 {
3396         fssearch_t *search;
3397         searchpath_t *searchpath;
3398         pack_t *pak;
3399         int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3400         stringlist_t resultlist;
3401         stringlist_t dirlist;
3402         const char *slash, *backslash, *colon, *separator;
3403         char *basepath;
3404         char temp[MAX_OSPATH];
3405
3406         for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3407                 ;
3408
3409         if (i > 0)
3410         {
3411                 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3412                 return NULL;
3413         }
3414
3415         stringlistinit(&resultlist);
3416         stringlistinit(&dirlist);
3417         search = NULL;
3418         slash = strrchr(pattern, '/');
3419         backslash = strrchr(pattern, '\\');
3420         colon = strrchr(pattern, ':');
3421         separator = max(slash, backslash);
3422         separator = max(separator, colon);
3423         basepathlength = separator ? (separator + 1 - pattern) : 0;
3424         basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3425         if (basepathlength)
3426                 memcpy(basepath, pattern, basepathlength);
3427         basepath[basepathlength] = 0;
3428
3429         // search through the path, one element at a time
3430         for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3431         {
3432                 // is the element a pak file?
3433                 if (searchpath->pack && !searchpath->pack->vpack)
3434                 {
3435                         // look through all the pak file elements
3436                         pak = searchpath->pack;
3437                         for (i = 0;i < pak->numfiles;i++)
3438                         {
3439                                 strlcpy(temp, pak->files[i].name, sizeof(temp));
3440                                 while (temp[0])
3441                                 {
3442                                         if (matchpattern(temp, (char *)pattern, true))
3443                                         {
3444                                                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3445                                                         if (!strcmp(resultlist.strings[resultlistindex], temp))
3446                                                                 break;
3447                                                 if (resultlistindex == resultlist.numstrings)
3448                                                 {
3449                                                         stringlistappend(&resultlist, temp);
3450                                                         if (!quiet && developer_loading.integer)
3451                                                                 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3452                                                 }
3453                                         }
3454                                         // strip off one path element at a time until empty
3455                                         // this way directories are added to the listing if they match the pattern
3456                                         slash = strrchr(temp, '/');
3457                                         backslash = strrchr(temp, '\\');
3458                                         colon = strrchr(temp, ':');
3459                                         separator = temp;
3460                                         if (separator < slash)
3461                                                 separator = slash;
3462                                         if (separator < backslash)
3463                                                 separator = backslash;
3464                                         if (separator < colon)
3465                                                 separator = colon;
3466                                         *((char *)separator) = 0;
3467                                 }
3468                         }
3469                 }
3470                 else
3471                 {
3472                         stringlist_t matchedSet, foundSet;
3473                         const char *start = pattern;
3474
3475                         stringlistinit(&matchedSet);
3476                         stringlistinit(&foundSet);
3477                         // add a first entry to the set
3478                         stringlistappend(&matchedSet, "");
3479                         // iterate through pattern's path
3480                         while (*start)
3481                         {
3482                                 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3483                                 char subpath[MAX_OSPATH];
3484                                 char subpattern[MAX_OSPATH];
3485
3486                                 // find the next wildcard
3487                                 wildcard = strchr(start, '?');
3488                                 asterisk = strchr(start, '*');
3489                                 if (asterisk && (!wildcard || asterisk < wildcard))
3490                                 {
3491                                         wildcard = asterisk;
3492                                 }
3493
3494                                 if (wildcard)
3495                                 {
3496                                         nextseparator = strchr( wildcard, '/' );
3497                                 }
3498                                 else
3499                                 {
3500                                         nextseparator = NULL;
3501                                 }
3502
3503                                 if( !nextseparator ) {
3504                                         nextseparator = start + strlen( start );
3505                                 }
3506
3507                                 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3508                                 // copy everything up except nextseperator
3509                                 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3510                                 // find the last '/' before the wildcard
3511                                 prevseparator = strrchr( subpattern, '/' );
3512                                 if (!prevseparator)
3513                                         prevseparator = subpattern;
3514                                 else
3515                                         prevseparator++;
3516                                 // copy everything from start to the previous including the '/' (before the wildcard)
3517                                 // everything up to start is already included in the path of matchedSet's entries
3518                                 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3519
3520                                 // for each entry in matchedSet try to open the subdirectories specified in subpath
3521                                 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3522                                         strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3523                                         strlcat( temp, subpath, sizeof(temp) );
3524                                         listdirectory( &foundSet, searchpath->filename, temp );
3525                                 }
3526                                 if( dirlistindex == 0 ) {
3527                                         break;
3528                                 }
3529                                 // reset the current result set
3530                                 stringlistfreecontents( &matchedSet );
3531                                 // match against the pattern
3532                                 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3533                                         const char *direntry = foundSet.strings[ dirlistindex ];
3534                                         if (matchpattern(direntry, subpattern, true)) {
3535                                                 stringlistappend( &matchedSet, direntry );
3536                                         }
3537                                 }
3538                                 stringlistfreecontents( &foundSet );
3539
3540                                 start = nextseparator;
3541                         }
3542
3543                         for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3544                         {
3545                                 const char *temp = matchedSet.strings[dirlistindex];
3546                                 if (matchpattern(temp, (char *)pattern, true))
3547                                 {
3548                                         for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3549                                                 if (!strcmp(resultlist.strings[resultlistindex], temp))
3550                                                         break;
3551                                         if (resultlistindex == resultlist.numstrings)
3552                                         {
3553                                                 stringlistappend(&resultlist, temp);
3554                                                 if (!quiet && developer_loading.integer)
3555                                                         Con_Printf("SearchDirFile: %s\n", temp);
3556                                         }
3557                                 }
3558                         }
3559                         stringlistfreecontents( &matchedSet );
3560                 }
3561         }
3562
3563         if (resultlist.numstrings)
3564         {
3565                 stringlistsort(&resultlist, true);
3566                 numfiles = resultlist.numstrings;
3567                 numchars = 0;
3568                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3569                         numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3570                 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3571                 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3572                 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3573                 search->numfilenames = (int)numfiles;
3574                 numfiles = 0;
3575                 numchars = 0;
3576                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3577                 {
3578                         size_t textlen;
3579                         search->filenames[numfiles] = search->filenamesbuffer + numchars;
3580                         textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3581                         memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3582                         numfiles++;
3583                         numchars += (int)textlen;
3584                 }
3585         }
3586         stringlistfreecontents(&resultlist);
3587
3588         Mem_Free(basepath);
3589         return search;
3590 }
3591
3592 void FS_FreeSearch(fssearch_t *search)
3593 {
3594         Z_Free(search);
3595 }
3596
3597 extern int con_linewidth;
3598 static int FS_ListDirectory(const char *pattern, int oneperline)
3599 {
3600         int numfiles;
3601         int numcolumns;
3602         int numlines;
3603         int columnwidth;
3604         int linebufpos;
3605         int i, j, k, l;
3606         const char *name;
3607         char linebuf[MAX_INPUTLINE];
3608         fssearch_t *search;
3609         search = FS_Search(pattern, true, true);
3610         if (!search)
3611                 return 0;
3612         numfiles = search->numfilenames;
3613         if (!oneperline)
3614         {
3615                 // FIXME: the names could be added to one column list and then
3616                 // gradually shifted into the next column if they fit, and then the
3617                 // next to make a compact variable width listing but it's a lot more
3618                 // complicated...
3619                 // find width for columns
3620                 columnwidth = 0;
3621                 for (i = 0;i < numfiles;i++)
3622                 {
3623                         l = (int)strlen(search->filenames[i]);
3624                         if (columnwidth < l)
3625                                 columnwidth = l;
3626                 }
3627                 // count the spacing character
3628                 columnwidth++;
3629                 // calculate number of columns
3630                 numcolumns = con_linewidth / columnwidth;
3631                 // don't bother with the column printing if it's only one column
3632                 if (numcolumns >= 2)
3633                 {
3634                         numlines = (numfiles + numcolumns - 1) / numcolumns;
3635                         for (i = 0;i < numlines;i++)
3636                         {
3637                                 linebufpos = 0;
3638                                 for (k = 0;k < numcolumns;k++)
3639                                 {
3640                                         l = i * numcolumns + k;
3641                                         if (l < numfiles)
3642                                         {
3643                                                 name = search->filenames[l];
3644                                                 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3645                                                         linebuf[linebufpos++] = name[j];
3646                                                 // space out name unless it's the last on the line
3647                                                 if (k + 1 < numcolumns && l + 1 < numfiles)
3648                                                         for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3649                                                                 linebuf[linebufpos++] = ' ';
3650                                         }
3651                                 }
3652                                 linebuf[linebufpos] = 0;
3653                                 Con_Printf("%s\n", linebuf);
3654                         }
3655                 }
3656                 else
3657                         oneperline = true;
3658         }
3659         if (oneperline)
3660                 for (i = 0;i < numfiles;i++)
3661                         Con_Printf("%s\n", search->filenames[i]);
3662         FS_FreeSearch(search);
3663         return (int)numfiles;
3664 }
3665
3666 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3667 {
3668         const char *pattern;
3669         if (Cmd_Argc() >= 3)
3670         {
3671                 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3672                 return;
3673         }
3674         if (Cmd_Argc() == 2)
3675                 pattern = Cmd_Argv(1);
3676         else
3677                 pattern = "*";
3678         if (!FS_ListDirectory(pattern, oneperline))
3679                 Con_Print("No files found.\n");
3680 }
3681
3682 void FS_Dir_f(void)
3683 {
3684         FS_ListDirectoryCmd("dir", true);
3685 }
3686
3687 void FS_Ls_f(void)
3688 {
3689         FS_ListDirectoryCmd("ls", false);
3690 }
3691
3692 void FS_Which_f(void)
3693 {
3694         const char *filename;
3695         int index;
3696         searchpath_t *sp;
3697         if (Cmd_Argc() != 2)
3698         {
3699                 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3700                 return;
3701         }  
3702         filename = Cmd_Argv(1);
3703         sp = FS_FindFile(filename, &index, true);
3704         if (!sp) {
3705                 Con_Printf("%s isn't anywhere\n", filename);
3706                 return;
3707         }
3708         if (sp->pack)
3709         {
3710                 if(sp->pack->vpack)
3711                         Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3712                 else
3713                         Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3714         }
3715         else
3716                 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3717 }
3718
3719
3720 const char *FS_WhichPack(const char *filename)
3721 {
3722         int index;
3723         searchpath_t *sp = FS_FindFile(filename, &index, true);
3724         if(sp && sp->pack)
3725                 return sp->pack->shortname;
3726         else if(sp)
3727                 return "";
3728         else
3729                 return 0;
3730 }
3731
3732 /*
3733 ====================
3734 FS_IsRegisteredQuakePack
3735
3736 Look for a proof of purchase file file in the requested package
3737
3738 If it is found, this file should NOT be downloaded.
3739 ====================
3740 */
3741 qboolean FS_IsRegisteredQuakePack(const char *name)
3742 {
3743         searchpath_t *search;
3744         pack_t *pak;
3745
3746         // search through the path, one element at a time
3747         for (search = fs_searchpaths;search;search = search->next)
3748         {
3749                 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3750                         // TODO do we want to support vpacks in here too?
3751                 {
3752                         int (*strcmp_funct) (const char* str1, const char* str2);
3753                         int left, right, middle;
3754
3755                         pak = search->pack;
3756                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3757
3758                         // Look for the file (binary search)
3759                         left = 0;
3760                         right = pak->numfiles - 1;
3761                         while (left <= right)
3762                         {
3763                                 int diff;
3764
3765                                 middle = (left + right) / 2;
3766                                 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3767
3768                                 // Found it
3769                                 if (!diff)
3770                                         return true;
3771
3772                                 // If we're too far in the list
3773                                 if (diff > 0)
3774                                         right = middle - 1;
3775                                 else
3776                                         left = middle + 1;
3777                         }
3778
3779                         // we found the requested pack but it is not registered quake
3780                         return false;
3781                 }
3782         }
3783
3784         return false;
3785 }
3786
3787 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3788 {
3789         int crc = -1;
3790         unsigned char *filedata;
3791         fs_offset_t filesize;
3792         if (filesizepointer)
3793                 *filesizepointer = 0;
3794         if (!filename || !*filename)
3795                 return crc;
3796         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3797         if (filedata)
3798         {
3799                 if (filesizepointer)
3800                         *filesizepointer = filesize;
3801                 crc = CRC_Block(filedata, filesize);
3802                 Mem_Free(filedata);
3803         }
3804         return crc;
3805 }
3806
3807 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3808 {
3809         z_stream strm;
3810         unsigned char *out = NULL;
3811         unsigned char *tmp;
3812
3813         *deflated_size = 0;
3814 #ifndef LINK_TO_ZLIB
3815         if(!zlib_dll)
3816                 return NULL;
3817 #endif
3818
3819         memset(&strm, 0, sizeof(strm));
3820         strm.zalloc = Z_NULL;
3821         strm.zfree = Z_NULL;
3822         strm.opaque = Z_NULL;
3823
3824         if(level < 0)
3825                 level = Z_DEFAULT_COMPRESSION;
3826
3827         if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3828         {
3829                 Con_Printf("FS_Deflate: deflate init error!\n");
3830                 return NULL;
3831         }
3832
3833         strm.next_in = (unsigned char*)data;
3834         strm.avail_in = size;
3835
3836         tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3837         if(!tmp)
3838         {
3839                 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3840                 qz_deflateEnd(&strm);
3841                 return NULL;
3842         }
3843
3844         strm.next_out = tmp;
3845         strm.avail_out = size;
3846
3847         if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3848         {
3849                 Con_Printf("FS_Deflate: deflate failed!\n");
3850                 qz_deflateEnd(&strm);
3851                 Mem_Free(tmp);
3852                 return NULL;
3853         }
3854         
3855         if(qz_deflateEnd(&strm) != Z_OK)
3856         {
3857                 Con_Printf("FS_Deflate: deflateEnd failed\n");
3858                 Mem_Free(tmp);
3859                 return NULL;
3860         }
3861
3862         if(strm.total_out >= size)
3863         {
3864                 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3865                 Mem_Free(tmp);
3866                 return NULL;
3867         }
3868
3869         out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3870         if(!out)
3871         {
3872                 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3873                 Mem_Free(tmp);
3874                 return NULL;
3875         }
3876
3877         if(deflated_size)
3878                 *deflated_size = (size_t)strm.total_out;
3879
3880         memcpy(out, tmp, strm.total_out);
3881         Mem_Free(tmp);
3882         
3883         return out;
3884 }
3885
3886 static void AssertBufsize(sizebuf_t *buf, int length)
3887 {
3888         if(buf->cursize + length > buf->maxsize)
3889         {
3890                 int oldsize = buf->maxsize;
3891                 unsigned char *olddata;
3892                 olddata = buf->data;
3893                 buf->maxsize += length;
3894                 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3895                 if(olddata)
3896                 {
3897                         memcpy(buf->data, olddata, oldsize);
3898                         Mem_Free(olddata);
3899                 }
3900         }
3901 }
3902
3903 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3904 {
3905         int ret;
3906         z_stream strm;
3907         unsigned char *out = NULL;
3908         unsigned char tmp[2048];
3909         unsigned int have;
3910         sizebuf_t outbuf;
3911
3912         *inflated_size = 0;
3913 #ifndef LINK_TO_ZLIB
3914         if(!zlib_dll)
3915                 return NULL;
3916 #endif
3917
3918         memset(&outbuf, 0, sizeof(outbuf));
3919         outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3920         outbuf.maxsize = sizeof(tmp);
3921
3922         memset(&strm, 0, sizeof(strm));
3923         strm.zalloc = Z_NULL;
3924         strm.zfree = Z_NULL;
3925         strm.opaque = Z_NULL;
3926
3927         if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3928         {
3929                 Con_Printf("FS_Inflate: inflate init error!\n");
3930                 Mem_Free(outbuf.data);
3931                 return NULL;
3932         }
3933
3934         strm.next_in = (unsigned char*)data;
3935         strm.avail_in = size;
3936
3937         do
3938         {
3939                 strm.next_out = tmp;
3940                 strm.avail_out = sizeof(tmp);
3941                 ret = qz_inflate(&strm, Z_NO_FLUSH);
3942                 // it either returns Z_OK on progress, Z_STREAM_END on end
3943                 // or an error code
3944                 switch(ret)
3945                 {
3946                         case Z_STREAM_END:
3947                         case Z_OK:
3948                                 break;
3949                                 
3950                         case Z_STREAM_ERROR:
3951                                 Con_Print("FS_Inflate: stream error!\n");
3952                                 break;
3953                         case Z_DATA_ERROR:
3954                                 Con_Print("FS_Inflate: data error!\n");
3955                                 break;
3956                         case Z_MEM_ERROR:
3957                                 Con_Print("FS_Inflate: mem error!\n");
3958                                 break;
3959                         case Z_BUF_ERROR:
3960                                 Con_Print("FS_Inflate: buf error!\n");
3961                                 break;
3962                         default:
3963                                 Con_Print("FS_Inflate: unknown error!\n");
3964                                 break;
3965                                 
3966                 }
3967                 if(ret != Z_OK && ret != Z_STREAM_END)
3968                 {
3969                         Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3970                         Mem_Free(outbuf.data);
3971                         qz_inflateEnd(&strm);
3972                         return NULL;
3973                 }
3974                 have = sizeof(tmp) - strm.avail_out;
3975                 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3976                 SZ_Write(&outbuf, tmp, have);
3977         } while(ret != Z_STREAM_END);
3978
3979         qz_inflateEnd(&strm);
3980
3981         out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3982         if(!out)
3983         {
3984                 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3985                 Mem_Free(outbuf.data);
3986                 return NULL;
3987         }
3988
3989         memcpy(out, outbuf.data, outbuf.cursize);
3990         Mem_Free(outbuf.data);
3991
3992         if(inflated_size)
3993                 *inflated_size = (size_t)outbuf.cursize;
3994         
3995         return out;
3996 }