fs.c

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