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