fs.c

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