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