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 = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
 640                                 packsize = (unsigned int)BuffLittleLong (&ptr[20]);
 641                                 realsize = (unsigned int)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 = (unsigned int)LittleLong (info[i].filepos);
 969                 fs_offset_t size = (unsigned int)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         qboolean reset = false;
1313         char gamedirbuf[MAX_INPUTLINE];
1314
1315         if (fs_searchpaths)
1316                 reset = true;
1317         FS_ClearSearchPath();
1318
1319         // automatically activate gamemode for the gamedirs specified
1320         if (reset)
1321                 COM_ChangeGameTypeForGameDirs();
1322
1323         // add the game-specific paths
1324         // gamedirname1 (typically id1)
1325         FS_AddGameHierarchy (gamedirname1);
1326         // update the com_modname (used for server info)
1327         strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1328
1329         // add the game-specific path, if any
1330         // (only used for mission packs and the like, which should set fs_modified)
1331         if (gamedirname2)
1332         {
1333                 fs_modified = true;
1334                 FS_AddGameHierarchy (gamedirname2);
1335         }
1336
1337         // -game <gamedir>
1338         // Adds basedir/gamedir as an override game
1339         // LordHavoc: now supports multiple -game directories
1340         // set the com_modname (reported in server info)
1341         *gamedirbuf = 0;
1342         for (i = 0;i < fs_numgamedirs;i++)
1343         {
1344                 fs_modified = true;
1345                 FS_AddGameHierarchy (fs_gamedirs[i]);
1346                 // update the com_modname (used server info)
1347                 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1348                 if(i)
1349                         strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
1350                 else
1351                         strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
1352         }
1353         Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
1354
1355         // add back the selfpack as new first item
1356         FS_AddSelfPack();
1357
1358         // set the default screenshot name to either the mod name or the
1359         // gamemode screenshot name
1360         if (strcmp(com_modname, gamedirname1))
1361                 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1362         else
1363                 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1364
1365         if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
1366                 strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
1367
1368         // If "-condebug" is in the command line, remove the previous log file
1369         if (COM_CheckParm ("-condebug") != 0)
1370                 unlink (va("%s/qconsole.log", fs_gamedir));
1371
1372         // look for the pop.lmp file and set registered to true if it is found
1373         if (FS_FileExists("gfx/pop.lmp"))
1374                 Cvar_Set ("registered", "1");
1375         switch(gamemode)
1376         {
1377         case GAME_NORMAL:
1378         case GAME_HIPNOTIC:
1379         case GAME_ROGUE:
1380                 if (!registered.integer)
1381                 {
1382                         if (fs_modified)
1383                                 Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1384                         else
1385                                 Con_Print("Playing shareware version.\n");
1386                 }
1387                 else
1388                         Con_Print("Playing registered version.\n");
1389                 break;
1390         case GAME_STEELSTORM:
1391                 if (registered.integer)
1392                         Con_Print("Playing registered version.\n");
1393                 else
1394                         Con_Print("Playing shareware version.\n");
1395                 break;
1396         default:
1397                 break;
1398         }
1399
1400         // unload all wads so that future queries will return the new data
1401         W_UnloadAll();
1402 }
1403
1404 void FS_Rescan_f(void)
1405 {
1406         FS_Rescan();
1407 }
1408
1409 /*
1410 ================
1411 FS_ChangeGameDirs
1412 ================
1413 */
1414 extern void Host_SaveConfig (void);
1415 extern void Host_LoadConfig_f (void);
1416 extern qboolean vid_opened;
1417 extern void VID_Stop(void);
1418 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1419 {
1420         int i;
1421         const char *p;
1422
1423         if (fs_numgamedirs == numgamedirs)
1424         {
1425                 for (i = 0;i < numgamedirs;i++)
1426                         if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1427                                 break;
1428                 if (i == numgamedirs)
1429                         return true; // already using this set of gamedirs, do nothing
1430         }
1431
1432         if (numgamedirs > MAX_GAMEDIRS)
1433         {
1434                 if (complain)
1435                         Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1436                 return false; // too many gamedirs
1437         }
1438
1439         for (i = 0;i < numgamedirs;i++)
1440         {
1441                 // if string is nasty, reject it
1442                 p = FS_CheckGameDir(gamedirs[i]);
1443                 if(!p)
1444                 {
1445                         if (complain)
1446                                 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1447                         return false; // nasty gamedirs
1448                 }
1449                 if(p == fs_checkgamedir_missing && failmissing)
1450                 {
1451                         if (complain)
1452                                 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1453                         return false; // missing gamedirs
1454                 }
1455         }
1456
1457         Host_SaveConfig();
1458
1459         fs_numgamedirs = numgamedirs;
1460         for (i = 0;i < fs_numgamedirs;i++)
1461                 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1462
1463         // reinitialize filesystem to detect the new paks
1464         FS_Rescan();
1465
1466         if (cls.demoplayback)
1467         {
1468                 CL_Disconnect_f();
1469                 cls.demonum = 0;
1470         }
1471
1472         // unload all sounds so they will be reloaded from the new files as needed
1473         S_UnloadAllSounds_f();
1474
1475         // close down the video subsystem, it will start up again when the config finishes...
1476         VID_Stop();
1477         vid_opened = false;
1478
1479         // restart the video subsystem after the config is executed
1480         Cbuf_InsertText("\nloadconfig\nvid_restart\n\n");
1481
1482         return true;
1483 }
1484
1485 /*
1486 ================
1487 FS_GameDir_f
1488 ================
1489 */
1490 void FS_GameDir_f (void)
1491 {
1492         int i;
1493         int numgamedirs;
1494         char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1495
1496         if (Cmd_Argc() < 2)
1497         {
1498                 Con_Printf("gamedirs active:");
1499                 for (i = 0;i < fs_numgamedirs;i++)
1500                         Con_Printf(" %s", fs_gamedirs[i]);
1501                 Con_Printf("\n");
1502                 return;
1503         }
1504
1505         numgamedirs = Cmd_Argc() - 1;
1506         if (numgamedirs > MAX_GAMEDIRS)
1507         {
1508                 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1509                 return;
1510         }
1511
1512         for (i = 0;i < numgamedirs;i++)
1513                 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1514
1515         if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1516         {
1517                 // actually, changing during game would work fine, but would be stupid
1518                 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1519                 return;
1520         }
1521
1522         // halt demo playback to close the file
1523         CL_Disconnect();
1524
1525         FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1526 }
1527
1528 static const char *FS_SysCheckGameDir(const char *gamedir)
1529 {
1530         static char buf[8192];
1531         qboolean success;
1532         qfile_t *f;
1533         stringlist_t list;
1534         fs_offset_t n;
1535
1536         stringlistinit(&list);
1537         listdirectory(&list, gamedir, "");
1538         success = list.numstrings > 0;
1539         stringlistfreecontents(&list);
1540
1541         if(success)
1542         {
1543                 f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
1544                 if(f)
1545                 {
1546                         n = FS_Read (f, buf, sizeof(buf) - 1);
1547                         if(n >= 0)
1548                                 buf[n] = 0;
1549                         else
1550                                 *buf = 0;
1551                         FS_Close(f);
1552                 }
1553                 else
1554                         *buf = 0;
1555                 return buf;
1556         }
1557
1558         return NULL;
1559 }
1560
1561 /*
1562 ================
1563 FS_CheckGameDir
1564 ================
1565 */
1566 const char *FS_CheckGameDir(const char *gamedir)
1567 {
1568         const char *ret;
1569
1570         if (FS_CheckNastyPath(gamedir, true))
1571                 return NULL;
1572
1573         ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
1574         if(ret)
1575         {
1576                 if(!*ret)
1577                 {
1578                         // get description from basedir
1579                         ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1580                         if(ret)
1581                                 return ret;
1582                         return "";
1583                 }
1584                 return ret;
1585         }
1586
1587         ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
1588         if(ret)
1589                 return ret;
1590
1591         return fs_checkgamedir_missing;
1592 }
1593
1594 static void FS_ListGameDirs(void)
1595 {
1596         stringlist_t list, list2;
1597         int i, j;
1598         const char *info;
1599
1600         fs_all_gamedirs_count = 0;
1601         if(fs_all_gamedirs)
1602                 Mem_Free(fs_all_gamedirs);
1603
1604         stringlistinit(&list);
1605         listdirectory(&list, va("%s/", fs_basedir), "");
1606         listdirectory(&list, va("%s/", fs_userdir), "");
1607         stringlistsort(&list);
1608
1609         stringlistinit(&list2);
1610         for(i = 0; i < list.numstrings; ++i)
1611         {
1612                 if(i)
1613                         if(!strcmp(list.strings[i-1], list.strings[i]))
1614                                 continue;
1615                 info = FS_CheckGameDir(list.strings[i]);
1616                 if(!info)
1617                         continue;
1618                 if(info == fs_checkgamedir_missing)
1619                         continue;
1620                 if(!*info)
1621                         continue;
1622                 stringlistappend(&list2, list.strings[i]);
1623         }
1624         stringlistfreecontents(&list);
1625
1626         fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
1627         for(i = 0; i < list2.numstrings; ++i)
1628         {
1629                 info = FS_CheckGameDir(list2.strings[i]);
1630                 // all this cannot happen any more, but better be safe than sorry
1631                 if(!info)
1632                         continue;
1633                 if(info == fs_checkgamedir_missing)
1634                         continue;
1635                 if(!*info)
1636                         continue;
1637                 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
1638                 strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
1639                 ++fs_all_gamedirs_count;
1640         }
1641 }
1642
1643 /*
1644 ================
1645 FS_Init_SelfPack
1646 ================
1647 */
1648 void FS_Init_SelfPack (void)
1649 {
1650         PK3_OpenLibrary ();
1651         fs_mempool = Mem_AllocPool("file management", 0, NULL);
1652         if(com_selffd >= 0)
1653         {
1654                 fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
1655                 if(fs_selfpack)
1656                 {
1657                         char *buf, *q;
1658                         const char *p;
1659                         FS_AddSelfPack();
1660                         buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
1661                         if(buf)
1662                         {
1663                                 const char **new_argv;
1664                                 int i = 0;
1665                                 int args_left = 256;
1666                                 new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
1667                                 if(com_argc == 0)
1668                                 {
1669                                         new_argv[0] = "dummy";
1670                                         com_argc = 1;
1671                                 }
1672                                 else
1673                                 {
1674                                         memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
1675                                 }
1676                                 p = buf;
1677                                 while(COM_ParseToken_Console(&p))
1678                                 {
1679                                         if(i >= args_left)
1680                                                 break;
1681                                         q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
1682                                         strlcpy(q, com_token, strlen(com_token) + 1);
1683                                         new_argv[com_argc + i] = q;
1684                                         ++i;
1685                                 }
1686                                 new_argv[i+com_argc] = NULL;
1687                                 com_argv = new_argv;
1688                                 com_argc = com_argc + i;
1689                         }
1690                         Mem_Free(buf);
1691                 }
1692         }
1693 }
1694
1695 /*
1696 ================
1697 FS_Init
1698 ================
1699 */
1700 void FS_Init (void)
1701 {
1702         const char *p;
1703         int i;
1704 #ifdef WIN32
1705         TCHAR mydocsdir[MAX_PATH + 1];
1706 #if _MSC_VER >= 1400
1707         size_t homedirlen;
1708 #endif
1709 #endif
1710 #ifndef __IPHONEOS__
1711         char *homedir;
1712 #endif
1713
1714 #ifdef WIN32
1715         const char* dllnames [] =
1716         {
1717                 "shfolder.dll",  // IE 4, or Win NT and higher
1718                 NULL
1719         };
1720         Sys_LoadLibrary(dllnames, &shfolder_dll, shfolderfuncs);
1721         // don't care for the result; if it fails, %USERPROFILE% will be used instead
1722 #endif
1723
1724         *fs_basedir = 0;
1725         *fs_userdir = 0;
1726         *fs_gamedir = 0;
1727
1728 #ifdef __IPHONEOS__
1729         // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
1730         // fs_userdir stores configurations to the Documents folder of the app
1731         strlcpy(fs_userdir, "../Documents/", sizeof(fs_userdir));
1732 #else
1733         // Add the personal game directory
1734         if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1735         {
1736                 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
1737         }
1738         else if(COM_CheckParm("-nohome"))
1739         {
1740                 *fs_userdir = 0;
1741         }
1742         else
1743         {
1744 #ifdef WIN32
1745                 if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
1746                 {
1747                         dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
1748                         Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
1749                 }
1750                 else
1751                 {
1752                         // use the environment
1753 #if _MSC_VER >= 1400
1754                         _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
1755 #else
1756                         homedir = getenv("USERPROFILE");
1757 #endif
1758
1759                         if(homedir)
1760                         {
1761                                 dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
1762 #if _MSC_VER >= 1400
1763                                 free(homedir);
1764 #endif
1765                                 Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
1766                         }
1767                 }
1768
1769                 if(!*fs_userdir)
1770                         Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
1771 #else
1772                 homedir = getenv ("HOME");
1773                 if(homedir)
1774                 {
1775 #ifdef __APPLE__
1776                         dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/Library/Application Support/%s/", homedir, gameuserdirname);
1777 #else
1778                         dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
1779 #endif
1780                 }
1781
1782                 if(!*fs_userdir)
1783                         Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
1784 #endif
1785
1786 #ifdef WIN32
1787                 if(!COM_CheckParm("-mygames"))
1788                 {
1789 #if _MSC_VER >= 1400
1790                         int fd;
1791                         _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!
1792 #else
1793                         int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1794 #endif
1795                         if(fd >= 0)
1796                         {
1797                                 close(fd);
1798                                 *fs_userdir = 0; // we have write access to the game dir, so let's use it
1799                         }
1800                 }
1801 #endif
1802         }
1803
1804         strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1805
1806 // If the base directory is explicitly defined by the compilation process
1807 #ifdef DP_FS_BASEDIR
1808         strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1809 #else
1810         *fs_basedir = 0;
1811
1812 #ifdef MACOSX
1813         // FIXME: is there a better way to find the directory outside the .app?
1814         if (strstr(com_argv[0], ".app/"))
1815         {
1816                 char *split;
1817
1818                 split = strstr(com_argv[0], ".app/");
1819                 while (split > com_argv[0] && *split != '/')
1820                         split--;
1821                 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1822                 fs_basedir[split - com_argv[0]] = 0;
1823         }
1824 #endif
1825 #endif
1826 #endif
1827
1828         // -basedir <path>
1829         // Overrides the system supplied base directory (under GAMENAME)
1830 // 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)
1831         i = COM_CheckParm ("-basedir");
1832         if (i && i < com_argc-1)
1833         {
1834                 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1835                 i = (int)strlen (fs_basedir);
1836                 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1837                         fs_basedir[i-1] = 0;
1838         }
1839
1840         // add a path separator to the end of the basedir if it lacks one
1841         if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1842                 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1843
1844         FS_ListGameDirs();
1845
1846         p = FS_CheckGameDir(gamedirname1);
1847         if(!p || p == fs_checkgamedir_missing)
1848                 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1849
1850         if(gamedirname2)
1851         {
1852                 p = FS_CheckGameDir(gamedirname2);
1853                 if(!p || p == fs_checkgamedir_missing)
1854                         Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1855         }
1856
1857         // -game <gamedir>
1858         // Adds basedir/gamedir as an override game
1859         // LordHavoc: now supports multiple -game directories
1860         for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1861         {
1862                 if (!com_argv[i])
1863                         continue;
1864                 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1865                 {
1866                         i++;
1867                         p = FS_CheckGameDir(com_argv[i]);
1868                         if(!p)
1869                                 Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
1870                         if(p == fs_checkgamedir_missing)
1871                                 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1872                         // add the gamedir to the list of active gamedirs
1873                         strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1874                         fs_numgamedirs++;
1875                 }
1876         }
1877
1878         // generate the searchpath
1879         FS_Rescan();
1880 }
1881
1882 void FS_Init_Commands(void)
1883 {
1884         Cvar_RegisterVariable (&scr_screenshot_name);
1885         Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1886         Cvar_RegisterVariable (&cvar_fs_gamedir);
1887
1888         Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1889         Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1890         Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1891         Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1892         Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1893         Cmd_AddCommand ("which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
1894 }
1895
1896 /*
1897 ================
1898 FS_Shutdown
1899 ================
1900 */
1901 void FS_Shutdown (void)
1902 {
1903         // close all pack files and such
1904         // (hopefully there aren't any other open files, but they'll be cleaned up
1905         //  by the OS anyway)
1906         FS_ClearSearchPath();
1907         Mem_FreePool (&fs_mempool);
1908
1909 #ifdef WIN32
1910         Sys_UnloadLibrary (&shfolder_dll);
1911 #endif
1912 }
1913
1914 int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
1915 {
1916         int handle;
1917         int mod, opt;
1918         unsigned int ind;
1919
1920         // Parse the mode string
1921         switch (mode[0])
1922         {
1923                 case 'r':
1924                         mod = O_RDONLY;
1925                         opt = 0;
1926                         break;
1927                 case 'w':
1928                         mod = O_WRONLY;
1929                         opt = O_CREAT | O_TRUNC;
1930                         break;
1931                 case 'a':
1932                         mod = O_WRONLY;
1933                         opt = O_CREAT | O_APPEND;
1934                         break;
1935                 default:
1936                         Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1937                         return -1;
1938         }
1939         for (ind = 1; mode[ind] != '\0'; ind++)
1940         {
1941                 switch (mode[ind])
1942                 {
1943                         case '+':
1944                                 mod = O_RDWR;
1945                                 break;
1946                         case 'b':
1947                                 opt |= O_BINARY;
1948                                 break;
1949                         default:
1950                                 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1951                                                         filepath, mode, mode[ind]);
1952                 }
1953         }
1954
1955         if (nonblocking)
1956                 opt |= O_NONBLOCK;
1957
1958 #if _MSC_VER >= 1400
1959         _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
1960 #else
1961         handle = open (filepath, mod | opt, 0666);
1962 #endif
1963         return handle;
1964 }
1965
1966 /*
1967 ====================
1968 FS_SysOpen
1969
1970 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1971 ====================
1972 */
1973 qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1974 {
1975         qfile_t* file;
1976
1977         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1978         file->ungetc = EOF;
1979         file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
1980         if (file->handle < 0)
1981         {
1982                 Mem_Free (file);
1983                 return NULL;
1984         }
1985
1986         file->filename = Mem_strdup(fs_mempool, filepath);
1987
1988         file->real_length = lseek (file->handle, 0, SEEK_END);
1989
1990         // For files opened in append mode, we start at the end of the file
1991         if (mode[0] == 'a')
1992                 file->position = file->real_length;
1993         else
1994                 lseek (file->handle, 0, SEEK_SET);
1995
1996         return file;
1997 }
1998
1999
2000 /*
2001 ===========
2002 FS_OpenPackedFile
2003
2004 Open a packed file using its package file descriptor
2005 ===========
2006 */
2007 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
2008 {
2009         packfile_t *pfile;
2010         int dup_handle;
2011         qfile_t* file;
2012
2013         pfile = &pack->files[pack_ind];
2014
2015         // If we don't have the true offset, get it now
2016         if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
2017                 if (!PK3_GetTrueFileOffset (pfile, pack))
2018                         return NULL;
2019
2020 #ifndef LINK_TO_ZLIB
2021         // No Zlib DLL = no compressed files
2022         if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
2023         {
2024                 Con_Printf("WARNING: can't open the compressed file %s\n"
2025                                         "You need the Zlib DLL to use compressed files\n",
2026                                         pfile->name);
2027                 return NULL;
2028         }
2029 #endif
2030
2031         // LordHavoc: lseek affects all duplicates of a handle so we do it before
2032         // the dup() call to avoid having to close the dup_handle on error here
2033         if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
2034         {
2035                 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
2036                                         pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
2037                 return NULL;
2038         }
2039
2040         dup_handle = dup (pack->handle);
2041         if (dup_handle < 0)
2042         {
2043                 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
2044                 return NULL;
2045         }
2046
2047         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2048         memset (file, 0, sizeof (*file));
2049         file->handle = dup_handle;
2050         file->flags = QFILE_FLAG_PACKED;
2051         file->real_length = pfile->realsize;
2052         file->offset = pfile->offset;
2053         file->position = 0;
2054         file->ungetc = EOF;
2055
2056         if (pfile->flags & PACKFILE_FLAG_DEFLATED)
2057         {
2058                 ztoolkit_t *ztk;
2059
2060                 file->flags |= QFILE_FLAG_DEFLATED;
2061
2062                 // We need some more variables
2063                 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
2064
2065                 ztk->comp_length = pfile->packsize;
2066
2067                 // Initialize zlib stream
2068                 ztk->zstream.next_in = ztk->input;
2069                 ztk->zstream.avail_in = 0;
2070
2071                 /* From Zlib's "unzip.c":
2072                  *
2073                  * windowBits is passed < 0 to tell that there is no zlib header.
2074                  * Note that in this case inflate *requires* an extra "dummy" byte
2075                  * after the compressed stream in order to complete decompression and
2076                  * return Z_STREAM_END.
2077                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2078                  * size of both compressed and uncompressed data
2079                  */
2080                 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
2081                 {
2082                         Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
2083                         close(dup_handle);
2084                         Mem_Free(file);
2085                         return NULL;
2086                 }
2087
2088                 ztk->zstream.next_out = file->buff;
2089                 ztk->zstream.avail_out = sizeof (file->buff);
2090
2091                 file->ztk = ztk;
2092         }
2093
2094         return file;
2095 }
2096
2097 /*
2098 ====================
2099 FS_CheckNastyPath
2100
2101 Return true if the path should be rejected due to one of the following:
2102 1: path elements that are non-portable
2103 2: path elements that would allow access to files outside the game directory,
2104    or are just not a good idea for a mod to be using.
2105 ====================
2106 */
2107 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
2108 {
2109         // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
2110         if (!path[0])
2111                 return 2;
2112
2113         // Windows: don't allow \ in filenames (windows-only), period.
2114         // (on Windows \ is a directory separator, but / is also supported)
2115         if (strstr(path, "\\"))
2116                 return 1; // non-portable
2117
2118         // Mac: don't allow Mac-only filenames - : is a directory separator
2119         // instead of /, but we rely on / working already, so there's no reason to
2120         // support a Mac-only path
2121         // Amiga and Windows: : tries to go to root of drive
2122         if (strstr(path, ":"))
2123                 return 1; // non-portable attempt to go to root of drive
2124
2125         // Amiga: // is parent directory
2126         if (strstr(path, "//"))
2127                 return 1; // non-portable attempt to go to parent directory
2128
2129         // all: don't allow going to parent directory (../ or /../)
2130         if (strstr(path, ".."))
2131                 return 2; // attempt to go outside the game directory
2132
2133         // Windows and UNIXes: don't allow absolute paths
2134         if (path[0] == '/')
2135                 return 2; // attempt to go outside the game directory
2136
2137         // 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
2138         if (strchr(path, '.'))
2139         {
2140                 if (isgamedir)
2141                 {
2142                         // gamedir is entirely path elements, so simply forbid . entirely
2143                         return 2;
2144                 }
2145                 if (strchr(path, '.') < strrchr(path, '/'))
2146                         return 2; // possible attempt to go outside the game directory
2147         }
2148
2149         // all: forbid trailing slash on gamedir
2150         if (isgamedir && path[strlen(path)-1] == '/')
2151                 return 2;
2152
2153         // all: forbid leading dot on any filename for any reason
2154         if (strstr(path, "/."))
2155                 return 2; // attempt to go outside the game directory
2156
2157         // after all these checks we're pretty sure it's a / separated filename
2158         // and won't do much if any harm
2159         return false;
2160 }
2161
2162
2163 /*
2164 ====================
2165 FS_FindFile
2166
2167 Look for a file in the packages and in the filesystem
2168
2169 Return the searchpath where the file was found (or NULL)
2170 and the file index in the package if relevant
2171 ====================
2172 */
2173 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
2174 {
2175         searchpath_t *search;
2176         pack_t *pak;
2177
2178         // search through the path, one element at a time
2179         for (search = fs_searchpaths;search;search = search->next)
2180         {
2181                 // is the element a pak file?
2182                 if (search->pack && !search->pack->vpack)
2183                 {
2184                         int (*strcmp_funct) (const char* str1, const char* str2);
2185                         int left, right, middle;
2186
2187                         pak = search->pack;
2188                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2189
2190                         // Look for the file (binary search)
2191                         left = 0;
2192                         right = pak->numfiles - 1;
2193                         while (left <= right)
2194                         {
2195                                 int diff;
2196
2197                                 middle = (left + right) / 2;
2198                                 diff = strcmp_funct (pak->files[middle].name, name);
2199
2200                                 // Found it
2201                                 if (!diff)
2202                                 {
2203                                         if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
2204                                         {
2205                                                 // yes, but the first one is empty so we treat it as not being there
2206                                                 if (!quiet && developer_extra.integer)
2207                                                         Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
2208
2209                                                 if (index != NULL)
2210                                                         *index = -1;
2211                                                 return NULL;
2212                                         }
2213
2214                                         if (!quiet && developer_extra.integer)
2215                                                 Con_DPrintf("FS_FindFile: %s in %s\n",
2216                                                                         pak->files[middle].name, pak->filename);
2217
2218                                         if (index != NULL)
2219                                                 *index = middle;
2220                                         return search;
2221                                 }
2222
2223                                 // If we're too far in the list
2224                                 if (diff > 0)
2225                                         right = middle - 1;
2226                                 else
2227                                         left = middle + 1;
2228                         }
2229                 }
2230                 else
2231                 {
2232                         char netpath[MAX_OSPATH];
2233                         dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
2234                         if (FS_SysFileExists (netpath))
2235                         {
2236                                 if (!quiet && developer_extra.integer)
2237                                         Con_DPrintf("FS_FindFile: %s\n", netpath);
2238
2239                                 if (index != NULL)
2240                                         *index = -1;
2241                                 return search;
2242                         }
2243                 }
2244         }
2245
2246         if (!quiet && developer_extra.integer)
2247                 Con_DPrintf("FS_FindFile: can't find %s\n", name);
2248
2249         if (index != NULL)
2250                 *index = -1;
2251         return NULL;
2252 }
2253
2254
2255 /*
2256 ===========
2257 FS_OpenReadFile
2258
2259 Look for a file in the search paths and open it in read-only mode
2260 ===========
2261 */
2262 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking, int symlinkLevels)
2263 {
2264         searchpath_t *search;
2265         int pack_ind;
2266
2267         search = FS_FindFile (filename, &pack_ind, quiet);
2268
2269         // Not found?
2270         if (search == NULL)
2271                 return NULL;
2272
2273         // Found in the filesystem?
2274         if (pack_ind < 0)
2275         {
2276                 // this works with vpacks, so we are fine
2277                 char path [MAX_OSPATH];
2278                 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
2279                 return FS_SysOpen (path, "rb", nonblocking);
2280         }
2281
2282         // So, we found it in a package...
2283
2284         // Is it a PK3 symlink?
2285         // TODO also handle directory symlinks by parsing the whole structure...
2286         // but heck, file symlinks are good enough for now
2287         if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
2288         {
2289                 if(symlinkLevels <= 0)
2290                 {
2291                         Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
2292                         return NULL;
2293                 }
2294                 else
2295                 {
2296                         char linkbuf[MAX_QPATH];
2297                         fs_offset_t count;
2298                         qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
2299                         const char *mergeslash;
2300                         char *mergestart;
2301
2302                         if(!linkfile)
2303                                 return NULL;
2304                         count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
2305                         FS_Close(linkfile);
2306                         if(count < 0)
2307                                 return NULL;
2308                         linkbuf[count] = 0;
2309
2310                         // Now combine the paths...
2311                         mergeslash = strrchr(filename, '/');
2312                         mergestart = linkbuf;
2313                         if(!mergeslash)
2314                                 mergeslash = filename;
2315                         while(!strncmp(mergestart, "../", 3))
2316                         {
2317                                 mergestart += 3;
2318                                 while(mergeslash > filename)
2319                                 {
2320                                         --mergeslash;
2321                                         if(*mergeslash == '/')
2322                                                 break;
2323                                 }
2324                         }
2325                         // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
2326                         if(mergeslash == filename)
2327                         {
2328                                 // Either mergeslash == filename, then we just replace the name (done below)
2329                         }
2330                         else
2331                         {
2332                                 // Or, we append the name after mergeslash;
2333                                 // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
2334                                 int spaceNeeded = mergeslash - filename + 1;
2335                                 int spaceRemoved = mergestart - linkbuf;
2336                                 if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
2337                                 {
2338                                         Con_DPrintf("symlink: too long path rejected\n");
2339                                         return NULL;
2340                                 }
2341                                 memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
2342                                 memcpy(linkbuf, filename, spaceNeeded);
2343                                 linkbuf[count - spaceRemoved + spaceNeeded] = 0;
2344                                 mergestart = linkbuf;
2345                         }
2346                         if (!quiet && developer_loading.integer)
2347                                 Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
2348                         if(FS_CheckNastyPath (mergestart, false))
2349                         {
2350                                 Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
2351                                 return NULL;
2352                         }
2353                         return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
2354                 }
2355         }
2356
2357         return FS_OpenPackedFile (search->pack, pack_ind);
2358 }
2359
2360
2361 /*
2362 =============================================================================
2363
2364 MAIN PUBLIC FUNCTIONS
2365
2366 =============================================================================
2367 */
2368
2369 /*
2370 ====================
2371 FS_OpenRealFile
2372
2373 Open a file in the userpath. The syntax is the same as fopen
2374 Used for savegame scanning in menu, and all file writing.
2375 ====================
2376 */
2377 qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet)
2378 {
2379         char real_path [MAX_OSPATH];
2380
2381         if (FS_CheckNastyPath(filepath, false))
2382         {
2383                 Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
2384                 return NULL;
2385         }
2386
2387         dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
2388
2389         // If the file is opened in "write", "append", or "read/write" mode,
2390         // create directories up to the file.
2391         if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
2392                 FS_CreatePath (real_path);
2393         return FS_SysOpen (real_path, mode, false);
2394 }
2395
2396
2397 /*
2398 ====================
2399 FS_OpenVirtualFile
2400
2401 Open a file. The syntax is the same as fopen
2402 ====================
2403 */
2404 qfile_t* FS_OpenVirtualFile (const char* filepath, qboolean quiet)
2405 {
2406         if (FS_CheckNastyPath(filepath, false))
2407         {
2408                 Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
2409                 return NULL;
2410         }
2411
2412         return FS_OpenReadFile (filepath, quiet, false, 16);
2413 }
2414
2415
2416 /*
2417 ====================
2418 FS_FileFromData
2419
2420 Open a file. The syntax is the same as fopen
2421 ====================
2422 */
2423 qfile_t* FS_FileFromData (const unsigned char *data, const size_t size, qboolean quiet)
2424 {
2425         qfile_t* file;
2426         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
2427         memset (file, 0, sizeof (*file));
2428         file->flags = QFILE_FLAG_DATA;
2429         file->ungetc = EOF;
2430         file->real_length = size;
2431         file->data = data;
2432         return file;
2433 }
2434
2435 /*
2436 ====================
2437 FS_Close
2438
2439 Close a file
2440 ====================
2441 */
2442 int FS_Close (qfile_t* file)
2443 {
2444         if(file->flags & QFILE_FLAG_DATA)
2445         {
2446                 Mem_Free(file);
2447                 return 0;
2448         }
2449
2450         if (close (file->handle))
2451                 return EOF;
2452
2453         if (file->filename)
2454         {
2455                 if (file->flags & QFILE_FLAG_REMOVE)
2456                         remove(file->filename);
2457
2458                 Mem_Free((void *) file->filename);
2459         }
2460
2461         if (file->ztk)
2462         {
2463                 qz_inflateEnd (&file->ztk->zstream);
2464                 Mem_Free (file->ztk);
2465         }
2466
2467         Mem_Free (file);
2468         return 0;
2469 }
2470
2471 void FS_RemoveOnClose(qfile_t* file)
2472 {
2473         file->flags |= QFILE_FLAG_REMOVE;
2474 }
2475
2476 /*
2477 ====================
2478 FS_Write
2479
2480 Write "datasize" bytes into a file
2481 ====================
2482 */
2483 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
2484 {
2485         fs_offset_t result;
2486
2487         // If necessary, seek to the exact file position we're supposed to be
2488         if (file->buff_ind != file->buff_len)
2489                 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
2490
2491         // Purge cached data
2492         FS_Purge (file);
2493
2494         // Write the buffer and update the position
2495         result = write (file->handle, data, (fs_offset_t)datasize);
2496         file->position = lseek (file->handle, 0, SEEK_CUR);
2497         if (file->real_length < file->position)
2498                 file->real_length = file->position;
2499
2500         if (result < 0)
2501                 return 0;
2502
2503         return result;
2504 }
2505
2506
2507 /*
2508 ====================
2509 FS_Read
2510
2511 Read up to "buffersize" bytes from a file
2512 ====================
2513 */
2514 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
2515 {
2516         fs_offset_t count, done;
2517
2518         if (buffersize == 0)
2519                 return 0;
2520
2521         // Get rid of the ungetc character
2522         if (file->ungetc != EOF)
2523         {
2524                 ((char*)buffer)[0] = file->ungetc;
2525                 buffersize--;
2526                 file->ungetc = EOF;
2527                 done = 1;
2528         }
2529         else
2530                 done = 0;
2531
2532         if(file->flags & QFILE_FLAG_DATA)
2533         {
2534                 size_t left = file->real_length - file->position;
2535                 if(buffersize > left)
2536                         buffersize = left;
2537                 memcpy(buffer, file->data + file->position, buffersize);
2538                 file->position += buffersize;
2539                 return buffersize;
2540         }
2541
2542         // First, we copy as many bytes as we can from "buff"
2543         if (file->buff_ind < file->buff_len)
2544         {
2545                 count = file->buff_len - file->buff_ind;
2546                 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
2547                 done += count;
2548                 memcpy (buffer, &file->buff[file->buff_ind], count);
2549                 file->buff_ind += count;
2550
2551                 buffersize -= count;
2552                 if (buffersize == 0)
2553                         return done;
2554         }
2555
2556         // NOTE: at this point, the read buffer is always empty
2557
2558         // If the file isn't compressed
2559         if (! (file->flags & QFILE_FLAG_DEFLATED))
2560         {
2561                 fs_offset_t nb;
2562
2563                 // We must take care to not read after the end of the file
2564                 count = file->real_length - file->position;
2565
2566                 // If we have a lot of data to get, put them directly into "buffer"
2567                 if (buffersize > sizeof (file->buff) / 2)
2568                 {
2569                         if (count > (fs_offset_t)buffersize)
2570                                 count = (fs_offset_t)buffersize;
2571                         lseek (file->handle, file->offset + file->position, SEEK_SET);
2572                         nb = read (file->handle, &((unsigned char*)buffer)[done], count);
2573                         if (nb > 0)
2574                         {
2575                                 done += nb;
2576                                 file->position += nb;
2577
2578                                 // Purge cached data
2579                                 FS_Purge (file);
2580                         }
2581                 }
2582                 else
2583                 {
2584                         if (count > (fs_offset_t)sizeof (file->buff))
2585                                 count = (fs_offset_t)sizeof (file->buff);
2586                         lseek (file->handle, file->offset + file->position, SEEK_SET);
2587                         nb = read (file->handle, file->buff, count);
2588                         if (nb > 0)
2589                         {
2590                                 file->buff_len = nb;
2591                                 file->position += nb;
2592
2593                                 // Copy the requested data in "buffer" (as much as we can)
2594                                 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2595                                 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2596                                 file->buff_ind = count;
2597                                 done += count;
2598                         }
2599                 }
2600
2601                 return done;
2602         }
2603
2604         // If the file is compressed, it's more complicated...
2605         // We cycle through a few operations until we have read enough data
2606         while (buffersize > 0)
2607         {
2608                 ztoolkit_t *ztk = file->ztk;
2609                 int error;
2610
2611                 // NOTE: at this point, the read buffer is always empty
2612
2613                 // If "input" is also empty, we need to refill it
2614                 if (ztk->in_ind == ztk->in_len)
2615                 {
2616                         // If we are at the end of the file
2617                         if (file->position == file->real_length)
2618                                 return done;
2619
2620                         count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2621                         if (count > (fs_offset_t)sizeof (ztk->input))
2622                                 count = (fs_offset_t)sizeof (ztk->input);
2623                         lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2624                         if (read (file->handle, ztk->input, count) != count)
2625                         {
2626                                 Con_Printf ("FS_Read: unexpected end of file\n");
2627                                 break;
2628                         }
2629
2630                         ztk->in_ind = 0;
2631                         ztk->in_len = count;
2632                         ztk->in_position += count;
2633                 }
2634
2635                 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2636                 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2637
2638                 // Now that we are sure we have compressed data available, we need to determine
2639                 // if it's better to inflate it in "file->buff" or directly in "buffer"
2640
2641                 // Inflate the data in "file->buff"
2642                 if (buffersize < sizeof (file->buff) / 2)
2643                 {
2644                         ztk->zstream.next_out = file->buff;
2645                         ztk->zstream.avail_out = sizeof (file->buff);
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                         file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2655                         file->position += file->buff_len;
2656
2657                         // Copy the requested data in "buffer" (as much as we can)
2658                         count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2659                         memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2660                         file->buff_ind = count;
2661                 }
2662
2663                 // Else, we inflate directly in "buffer"
2664                 else
2665                 {
2666                         ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2667                         ztk->zstream.avail_out = (unsigned int)buffersize;
2668                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2669                         if (error != Z_OK && error != Z_STREAM_END)
2670                         {
2671                                 Con_Printf ("FS_Read: Can't inflate file\n");
2672                                 break;
2673                         }
2674                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2675
2676                         // How much data did it inflate?
2677                         count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2678                         file->position += count;
2679
2680                         // Purge cached data
2681                         FS_Purge (file);
2682                 }
2683
2684                 done += count;
2685                 buffersize -= count;
2686         }
2687
2688         return done;
2689 }
2690
2691
2692 /*
2693 ====================
2694 FS_Print
2695
2696 Print a string into a file
2697 ====================
2698 */
2699 int FS_Print (qfile_t* file, const char *msg)
2700 {
2701         return (int)FS_Write (file, msg, strlen (msg));
2702 }
2703
2704 /*
2705 ====================
2706 FS_Printf
2707
2708 Print a string into a file
2709 ====================
2710 */
2711 int FS_Printf(qfile_t* file, const char* format, ...)
2712 {
2713         int result;
2714         va_list args;
2715
2716         va_start (args, format);
2717         result = FS_VPrintf (file, format, args);
2718         va_end (args);
2719
2720         return result;
2721 }
2722
2723
2724 /*
2725 ====================
2726 FS_VPrintf
2727
2728 Print a string into a file
2729 ====================
2730 */
2731 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2732 {
2733         int len;
2734         fs_offset_t buff_size = MAX_INPUTLINE;
2735         char *tempbuff;
2736
2737         for (;;)
2738         {
2739                 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2740                 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2741                 if (len >= 0 && len < buff_size)
2742                         break;
2743                 Mem_Free (tempbuff);
2744                 buff_size *= 2;
2745         }
2746
2747         len = write (file->handle, tempbuff, len);
2748         Mem_Free (tempbuff);
2749
2750         return len;
2751 }
2752
2753
2754 /*
2755 ====================
2756 FS_Getc
2757
2758 Get the next character of a file
2759 ====================
2760 */
2761 int FS_Getc (qfile_t* file)
2762 {
2763         unsigned char c;
2764
2765         if (FS_Read (file, &c, 1) != 1)
2766                 return EOF;
2767
2768         return c;
2769 }
2770
2771
2772 /*
2773 ====================
2774 FS_UnGetc
2775
2776 Put a character back into the read buffer (only supports one character!)
2777 ====================
2778 */
2779 int FS_UnGetc (qfile_t* file, unsigned char c)
2780 {
2781         // If there's already a character waiting to be read
2782         if (file->ungetc != EOF)
2783                 return EOF;
2784
2785         file->ungetc = c;
2786         return c;
2787 }
2788
2789
2790 /*
2791 ====================
2792 FS_Seek
2793
2794 Move the position index in a file
2795 ====================
2796 */
2797 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2798 {
2799         ztoolkit_t *ztk;
2800         unsigned char* buffer;
2801         fs_offset_t buffersize;
2802
2803         // Compute the file offset
2804         switch (whence)
2805         {
2806                 case SEEK_CUR:
2807                         offset += file->position - file->buff_len + file->buff_ind;
2808                         break;
2809
2810                 case SEEK_SET:
2811                         break;
2812
2813                 case SEEK_END:
2814                         offset += file->real_length;
2815                         break;
2816
2817                 default:
2818                         return -1;
2819         }
2820         if (offset < 0 || offset > file->real_length)
2821                 return -1;
2822
2823         if(file->flags & QFILE_FLAG_DATA)
2824         {
2825                 file->position = offset;
2826                 return 0;
2827         }
2828
2829         // If we have the data in our read buffer, we don't need to actually seek
2830         if (file->position - file->buff_len <= offset && offset <= file->position)
2831         {
2832                 file->buff_ind = offset + file->buff_len - file->position;
2833                 return 0;
2834         }
2835
2836         // Purge cached data
2837         FS_Purge (file);
2838
2839         // Unpacked or uncompressed files can seek directly
2840         if (! (file->flags & QFILE_FLAG_DEFLATED))
2841         {
2842                 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2843                         return -1;
2844                 file->position = offset;
2845                 return 0;
2846         }
2847
2848         // Seeking in compressed files is more a hack than anything else,
2849         // but we need to support it, so here we go.
2850         ztk = file->ztk;
2851
2852         // If we have to go back in the file, we need to restart from the beginning
2853         if (offset <= file->position)
2854         {
2855                 ztk->in_ind = 0;
2856                 ztk->in_len = 0;
2857                 ztk->in_position = 0;
2858                 file->position = 0;
2859                 lseek (file->handle, file->offset, SEEK_SET);
2860
2861                 // Reset the Zlib stream
2862                 ztk->zstream.next_in = ztk->input;
2863                 ztk->zstream.avail_in = 0;
2864                 qz_inflateReset (&ztk->zstream);
2865         }
2866
2867         // We need a big buffer to force inflating into it directly
2868         buffersize = 2 * sizeof (file->buff);
2869         buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2870
2871         // Skip all data until we reach the requested offset
2872         while (offset > file->position)
2873         {
2874                 fs_offset_t diff = offset - file->position;
2875                 fs_offset_t count, len;
2876
2877                 count = (diff > buffersize) ? buffersize : diff;
2878                 len = FS_Read (file, buffer, count);
2879                 if (len != count)
2880                 {
2881                         Mem_Free (buffer);
2882                         return -1;
2883                 }
2884         }
2885
2886         Mem_Free (buffer);
2887         return 0;
2888 }
2889
2890
2891 /*
2892 ====================
2893 FS_Tell
2894
2895 Give the current position in a file
2896 ====================
2897 */
2898 fs_offset_t FS_Tell (qfile_t* file)
2899 {
2900         return file->position - file->buff_len + file->buff_ind;
2901 }
2902
2903
2904 /*
2905 ====================
2906 FS_FileSize
2907
2908 Give the total size of a file
2909 ====================
2910 */
2911 fs_offset_t FS_FileSize (qfile_t* file)
2912 {
2913         return file->real_length;
2914 }
2915
2916
2917 /*
2918 ====================
2919 FS_Purge
2920
2921 Erases any buffered input or output data
2922 ====================
2923 */
2924 void FS_Purge (qfile_t* file)
2925 {
2926         file->buff_len = 0;
2927         file->buff_ind = 0;
2928         file->ungetc = EOF;
2929 }
2930
2931
2932 /*
2933 ============
2934 FS_LoadFile
2935
2936 Filename are relative to the quake directory.
2937 Always appends a 0 byte.
2938 ============
2939 */
2940 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2941 {
2942         qfile_t *file;
2943         unsigned char *buf = NULL;
2944         fs_offset_t filesize = 0;
2945
2946         file = FS_OpenVirtualFile(path, quiet);
2947         if (file)
2948         {
2949                 filesize = file->real_length;
2950                 if(filesize < 0)
2951                 {
2952                         Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
2953                         FS_Close(file);
2954                         return NULL;
2955                 }
2956
2957                 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2958                 buf[filesize] = '\0';
2959                 FS_Read (file, buf, filesize);
2960                 FS_Close (file);
2961                 if (developer_loadfile.integer)
2962                         Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2963         }
2964
2965         if (filesizepointer)
2966                 *filesizepointer = filesize;
2967         return buf;
2968 }
2969
2970
2971 /*
2972 ============
2973 FS_WriteFile
2974
2975 The filename will be prefixed by the current game directory
2976 ============
2977 */
2978 qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
2979 {
2980         qfile_t *file;
2981         size_t i;
2982         fs_offset_t lentotal;
2983
2984         file = FS_OpenRealFile(filename, "wb", false);
2985         if (!file)
2986         {
2987                 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2988                 return false;
2989         }
2990
2991         lentotal = 0;
2992         for(i = 0; i < count; ++i)
2993                 lentotal += len[i];
2994         Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
2995         for(i = 0; i < count; ++i)
2996                 FS_Write (file, data[i], len[i]);
2997         FS_Close (file);
2998         return true;
2999 }
3000
3001 qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
3002 {
3003         return FS_WriteFileInBlocks(filename, &data, &len, 1);
3004 }
3005
3006
3007 /*
3008 =============================================================================
3009
3010 OTHERS PUBLIC FUNCTIONS
3011
3012 =============================================================================
3013 */
3014
3015 /*
3016 ============
3017 FS_StripExtension
3018 ============
3019 */
3020 void FS_StripExtension (const char *in, char *out, size_t size_out)
3021 {
3022         char *last = NULL;
3023         char currentchar;
3024
3025         if (size_out == 0)
3026                 return;
3027
3028         while ((currentchar = *in) && size_out > 1)
3029         {
3030                 if (currentchar == '.')
3031                         last = out;
3032                 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
3033                         last = NULL;
3034                 *out++ = currentchar;
3035                 in++;
3036                 size_out--;
3037         }
3038         if (last)
3039                 *last = 0;
3040         else
3041                 *out = 0;
3042 }
3043
3044
3045 /*
3046 ==================
3047 FS_DefaultExtension
3048 ==================
3049 */
3050 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
3051 {
3052         const char *src;
3053
3054         // if path doesn't have a .EXT, append extension
3055         // (extension should include the .)
3056         src = path + strlen(path) - 1;
3057
3058         while (*src != '/' && src != path)
3059         {
3060                 if (*src == '.')
3061                         return;                 // it has an extension
3062                 src--;
3063         }
3064
3065         strlcat (path, extension, size_path);
3066 }
3067
3068
3069 /*
3070 ==================
3071 FS_FileType
3072
3073 Look for a file in the packages and in the filesystem
3074 ==================
3075 */
3076 int FS_FileType (const char *filename)
3077 {
3078         searchpath_t *search;
3079         char fullpath[MAX_OSPATH];
3080
3081         search = FS_FindFile (filename, NULL, true);
3082         if(!search)
3083                 return FS_FILETYPE_NONE;
3084
3085         if(search->pack && !search->pack->vpack)
3086                 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
3087
3088         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
3089         return FS_SysFileType(fullpath);
3090 }
3091
3092
3093 /*
3094 ==================
3095 FS_FileExists
3096
3097 Look for a file in the packages and in the filesystem
3098 ==================
3099 */
3100 qboolean FS_FileExists (const char *filename)
3101 {
3102         return (FS_FindFile (filename, NULL, true) != NULL);
3103 }
3104
3105
3106 /*
3107 ==================
3108 FS_SysFileExists
3109
3110 Look for a file in the filesystem only
3111 ==================
3112 */
3113 int FS_SysFileType (const char *path)
3114 {
3115 #if WIN32
3116 // Sajt - some older sdks are missing this define
3117 # ifndef INVALID_FILE_ATTRIBUTES
3118 #  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
3119 # endif
3120
3121         DWORD result = GetFileAttributes(path);
3122
3123         if(result == INVALID_FILE_ATTRIBUTES)
3124                 return FS_FILETYPE_NONE;
3125
3126         if(result & FILE_ATTRIBUTE_DIRECTORY)
3127                 return FS_FILETYPE_DIRECTORY;
3128
3129         return FS_FILETYPE_FILE;
3130 #else
3131         struct stat buf;
3132
3133         if (stat (path,&buf) == -1)
3134                 return FS_FILETYPE_NONE;
3135
3136 #ifndef S_ISDIR
3137 #define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
3138 #endif
3139         if(S_ISDIR(buf.st_mode))
3140                 return FS_FILETYPE_DIRECTORY;
3141
3142         return FS_FILETYPE_FILE;
3143 #endif
3144 }
3145
3146 qboolean FS_SysFileExists (const char *path)
3147 {
3148         return FS_SysFileType (path) != FS_FILETYPE_NONE;
3149 }
3150
3151 void FS_mkdir (const char *path)
3152 {
3153 #if WIN32
3154         _mkdir (path);
3155 #else
3156         mkdir (path, 0777);
3157 #endif
3158 }
3159
3160 /*
3161 ===========
3162 FS_Search
3163
3164 Allocate and fill a search structure with information on matching filenames.
3165 ===========
3166 */
3167 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
3168 {
3169         fssearch_t *search;
3170         searchpath_t *searchpath;
3171         pack_t *pak;
3172         int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
3173         stringlist_t resultlist;
3174         stringlist_t dirlist;
3175         const char *slash, *backslash, *colon, *separator;
3176         char *basepath;
3177         char temp[MAX_OSPATH];
3178
3179         for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
3180                 ;
3181
3182         if (i > 0)
3183         {
3184                 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
3185                 return NULL;
3186         }
3187
3188         stringlistinit(&resultlist);
3189         stringlistinit(&dirlist);
3190         search = NULL;
3191         slash = strrchr(pattern, '/');
3192         backslash = strrchr(pattern, '\\');
3193         colon = strrchr(pattern, ':');
3194         separator = max(slash, backslash);
3195         separator = max(separator, colon);
3196         basepathlength = separator ? (separator + 1 - pattern) : 0;
3197         basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
3198         if (basepathlength)
3199                 memcpy(basepath, pattern, basepathlength);
3200         basepath[basepathlength] = 0;
3201
3202         // search through the path, one element at a time
3203         for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
3204         {
3205                 // is the element a pak file?
3206                 if (searchpath->pack && !searchpath->pack->vpack)
3207                 {
3208                         // look through all the pak file elements
3209                         pak = searchpath->pack;
3210                         for (i = 0;i < pak->numfiles;i++)
3211                         {
3212                                 strlcpy(temp, pak->files[i].name, sizeof(temp));
3213                                 while (temp[0])
3214                                 {
3215                                         if (matchpattern(temp, (char *)pattern, true))
3216                                         {
3217                                                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3218                                                         if (!strcmp(resultlist.strings[resultlistindex], temp))
3219                                                                 break;
3220                                                 if (resultlistindex == resultlist.numstrings)
3221                                                 {
3222                                                         stringlistappend(&resultlist, temp);
3223                                                         if (!quiet && developer_loading.integer)
3224                                                                 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
3225                                                 }
3226                                         }
3227                                         // strip off one path element at a time until empty
3228                                         // this way directories are added to the listing if they match the pattern
3229                                         slash = strrchr(temp, '/');
3230                                         backslash = strrchr(temp, '\\');
3231                                         colon = strrchr(temp, ':');
3232                                         separator = temp;
3233                                         if (separator < slash)
3234                                                 separator = slash;
3235                                         if (separator < backslash)
3236                                                 separator = backslash;
3237                                         if (separator < colon)
3238                                                 separator = colon;
3239                                         *((char *)separator) = 0;
3240                                 }
3241                         }
3242                 }
3243                 else
3244                 {
3245                         stringlist_t matchedSet, foundSet;
3246                         const char *start = pattern;
3247
3248                         stringlistinit(&matchedSet);
3249                         stringlistinit(&foundSet);
3250                         // add a first entry to the set
3251                         stringlistappend(&matchedSet, "");
3252                         // iterate through pattern's path
3253                         while (*start)
3254                         {
3255                                 const char *asterisk, *wildcard, *nextseparator, *prevseparator;
3256                                 char subpath[MAX_OSPATH];
3257                                 char subpattern[MAX_OSPATH];
3258
3259                                 // find the next wildcard
3260                                 wildcard = strchr(start, '?');
3261                                 asterisk = strchr(start, '*');
3262                                 if (asterisk && (!wildcard || asterisk < wildcard))
3263                                 {
3264                                         wildcard = asterisk;
3265                                 }
3266
3267                                 if (wildcard)
3268                                 {
3269                                         nextseparator = strchr( wildcard, '/' );
3270                                 }
3271                                 else
3272                                 {
3273                                         nextseparator = NULL;
3274                                 }
3275
3276                                 if( !nextseparator ) {
3277                                         nextseparator = start + strlen( start );
3278                                 }
3279
3280                                 // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
3281                                 // copy everything up except nextseperator
3282                                 strlcpy(subpattern, pattern, min(sizeof(subpattern), (size_t) (nextseparator - pattern + 1)));
3283                                 // find the last '/' before the wildcard
3284                                 prevseparator = strrchr( subpattern, '/' );
3285                                 if (!prevseparator)
3286                                         prevseparator = subpattern;
3287                                 else
3288                                         prevseparator++;
3289                                 // copy everything from start to the previous including the '/' (before the wildcard)
3290                                 // everything up to start is already included in the path of matchedSet's entries
3291                                 strlcpy(subpath, start, min(sizeof(subpath), (size_t) ((prevseparator - subpattern) - (start - pattern) + 1)));
3292
3293                                 // for each entry in matchedSet try to open the subdirectories specified in subpath
3294                                 for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
3295                                         strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
3296                                         strlcat( temp, subpath, sizeof(temp) );
3297                                         listdirectory( &foundSet, searchpath->filename, temp );
3298                                 }
3299                                 if( dirlistindex == 0 ) {
3300                                         break;
3301                                 }
3302                                 // reset the current result set
3303                                 stringlistfreecontents( &matchedSet );
3304                                 // match against the pattern
3305                                 for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
3306                                         const char *direntry = foundSet.strings[ dirlistindex ];
3307                                         if (matchpattern(direntry, subpattern, true)) {
3308                                                 stringlistappend( &matchedSet, direntry );
3309                                         }
3310                                 }
3311                                 stringlistfreecontents( &foundSet );
3312
3313                                 start = nextseparator;
3314                         }
3315
3316                         for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
3317                         {
3318                                 const char *temp = matchedSet.strings[dirlistindex];
3319                                 if (matchpattern(temp, (char *)pattern, true))
3320                                 {
3321                                         for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3322                                                 if (!strcmp(resultlist.strings[resultlistindex], temp))
3323                                                         break;
3324                                         if (resultlistindex == resultlist.numstrings)
3325                                         {
3326                                                 stringlistappend(&resultlist, temp);
3327                                                 if (!quiet && developer_loading.integer)
3328                                                         Con_Printf("SearchDirFile: %s\n", temp);
3329                                         }
3330                                 }
3331                         }
3332                         stringlistfreecontents( &matchedSet );
3333                 }
3334         }
3335
3336         if (resultlist.numstrings)
3337         {
3338                 stringlistsort(&resultlist);
3339                 numfiles = resultlist.numstrings;
3340                 numchars = 0;
3341                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3342                         numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
3343                 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
3344                 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
3345                 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
3346                 search->numfilenames = (int)numfiles;
3347                 numfiles = 0;
3348                 numchars = 0;
3349                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
3350                 {
3351                         size_t textlen;
3352                         search->filenames[numfiles] = search->filenamesbuffer + numchars;
3353                         textlen = strlen(resultlist.strings[resultlistindex]) + 1;
3354                         memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
3355                         numfiles++;
3356                         numchars += (int)textlen;
3357                 }
3358         }
3359         stringlistfreecontents(&resultlist);
3360
3361         Mem_Free(basepath);
3362         return search;
3363 }
3364
3365 void FS_FreeSearch(fssearch_t *search)
3366 {
3367         Z_Free(search);
3368 }
3369
3370 extern int con_linewidth;
3371 int FS_ListDirectory(const char *pattern, int oneperline)
3372 {
3373         int numfiles;
3374         int numcolumns;
3375         int numlines;
3376         int columnwidth;
3377         int linebufpos;
3378         int i, j, k, l;
3379         const char *name;
3380         char linebuf[MAX_INPUTLINE];
3381         fssearch_t *search;
3382         search = FS_Search(pattern, true, true);
3383         if (!search)
3384                 return 0;
3385         numfiles = search->numfilenames;
3386         if (!oneperline)
3387         {
3388                 // FIXME: the names could be added to one column list and then
3389                 // gradually shifted into the next column if they fit, and then the
3390                 // next to make a compact variable width listing but it's a lot more
3391                 // complicated...
3392                 // find width for columns
3393                 columnwidth = 0;
3394                 for (i = 0;i < numfiles;i++)
3395                 {
3396                         l = (int)strlen(search->filenames[i]);
3397                         if (columnwidth < l)
3398                                 columnwidth = l;
3399                 }
3400                 // count the spacing character
3401                 columnwidth++;
3402                 // calculate number of columns
3403                 numcolumns = con_linewidth / columnwidth;
3404                 // don't bother with the column printing if it's only one column
3405                 if (numcolumns >= 2)
3406                 {
3407                         numlines = (numfiles + numcolumns - 1) / numcolumns;
3408                         for (i = 0;i < numlines;i++)
3409                         {
3410                                 linebufpos = 0;
3411                                 for (k = 0;k < numcolumns;k++)
3412                                 {
3413                                         l = i * numcolumns + k;
3414                                         if (l < numfiles)
3415                                         {
3416                                                 name = search->filenames[l];
3417                                                 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
3418                                                         linebuf[linebufpos++] = name[j];
3419                                                 // space out name unless it's the last on the line
3420                                                 if (k + 1 < numcolumns && l + 1 < numfiles)
3421                                                         for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
3422                                                                 linebuf[linebufpos++] = ' ';
3423                                         }
3424                                 }
3425                                 linebuf[linebufpos] = 0;
3426                                 Con_Printf("%s\n", linebuf);
3427                         }
3428                 }
3429                 else
3430                         oneperline = true;
3431         }
3432         if (oneperline)
3433                 for (i = 0;i < numfiles;i++)
3434                         Con_Printf("%s\n", search->filenames[i]);
3435         FS_FreeSearch(search);
3436         return (int)numfiles;
3437 }
3438
3439 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
3440 {
3441         const char *pattern;
3442         if (Cmd_Argc() > 3)
3443         {
3444                 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
3445                 return;
3446         }
3447         if (Cmd_Argc() == 2)
3448                 pattern = Cmd_Argv(1);
3449         else
3450                 pattern = "*";
3451         if (!FS_ListDirectory(pattern, oneperline))
3452                 Con_Print("No files found.\n");
3453 }
3454
3455 void FS_Dir_f(void)
3456 {
3457         FS_ListDirectoryCmd("dir", true);
3458 }
3459
3460 void FS_Ls_f(void)
3461 {
3462         FS_ListDirectoryCmd("ls", false);
3463 }
3464
3465 void FS_Which_f(void)
3466 {
3467         const char *filename;
3468         int index;
3469         searchpath_t *sp;
3470         if (Cmd_Argc() != 2)
3471         {
3472                 Con_Printf("usage:\n%s <file>\n", Cmd_Argv(0));
3473                 return;
3474         }
3475         filename = Cmd_Argv(1);
3476         sp = FS_FindFile(filename, &index, true);
3477         if (!sp) {
3478                 Con_Printf("%s isn't anywhere\n", filename);
3479                 return;
3480         }
3481         if (sp->pack)
3482         {
3483                 if(sp->pack->vpack)
3484                         Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
3485                 else
3486                         Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
3487         }
3488         else
3489                 Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
3490 }
3491
3492
3493 const char *FS_WhichPack(const char *filename)
3494 {
3495         int index;
3496         searchpath_t *sp = FS_FindFile(filename, &index, true);
3497         if(sp && sp->pack)
3498                 return sp->pack->shortname;
3499         else
3500                 return 0;
3501 }
3502
3503 /*
3504 ====================
3505 FS_IsRegisteredQuakePack
3506
3507 Look for a proof of purchase file file in the requested package
3508
3509 If it is found, this file should NOT be downloaded.
3510 ====================
3511 */
3512 qboolean FS_IsRegisteredQuakePack(const char *name)
3513 {
3514         searchpath_t *search;
3515         pack_t *pak;
3516
3517         // search through the path, one element at a time
3518         for (search = fs_searchpaths;search;search = search->next)
3519         {
3520                 if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
3521                         // TODO do we want to support vpacks in here too?
3522                 {
3523                         int (*strcmp_funct) (const char* str1, const char* str2);
3524                         int left, right, middle;
3525
3526                         pak = search->pack;
3527                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
3528
3529                         // Look for the file (binary search)
3530                         left = 0;
3531                         right = pak->numfiles - 1;
3532                         while (left <= right)
3533                         {
3534                                 int diff;
3535
3536                                 middle = (left + right) / 2;
3537                                 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
3538
3539                                 // Found it
3540                                 if (!diff)
3541                                         return true;
3542
3543                                 // If we're too far in the list
3544                                 if (diff > 0)
3545                                         right = middle - 1;
3546                                 else
3547                                         left = middle + 1;
3548                         }
3549
3550                         // we found the requested pack but it is not registered quake
3551                         return false;
3552                 }
3553         }
3554
3555         return false;
3556 }
3557
3558 int FS_CRCFile(const char *filename, size_t *filesizepointer)
3559 {
3560         int crc = -1;
3561         unsigned char *filedata;
3562         fs_offset_t filesize;
3563         if (filesizepointer)
3564                 *filesizepointer = 0;
3565         if (!filename || !*filename)
3566                 return crc;
3567         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
3568         if (filedata)
3569         {
3570                 if (filesizepointer)
3571                         *filesizepointer = filesize;
3572                 crc = CRC_Block(filedata, filesize);
3573                 Mem_Free(filedata);
3574         }
3575         return crc;
3576 }
3577
3578 unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
3579 {
3580         z_stream strm;
3581         unsigned char *out = NULL;
3582         unsigned char *tmp;
3583
3584         *deflated_size = 0;
3585 #ifndef LINK_TO_ZLIB
3586         if(!zlib_dll)
3587                 return NULL;
3588 #endif
3589
3590         memset(&strm, 0, sizeof(strm));
3591         strm.zalloc = Z_NULL;
3592         strm.zfree = Z_NULL;
3593         strm.opaque = Z_NULL;
3594
3595         if(level < 0)
3596                 level = Z_DEFAULT_COMPRESSION;
3597
3598         if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
3599         {
3600                 Con_Printf("FS_Deflate: deflate init error!\n");
3601                 return NULL;
3602         }
3603
3604         strm.next_in = (unsigned char*)data;
3605         strm.avail_in = size;
3606
3607         tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
3608         if(!tmp)
3609         {
3610                 Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
3611                 qz_deflateEnd(&strm);
3612                 return NULL;
3613         }
3614
3615         strm.next_out = tmp;
3616         strm.avail_out = size;
3617
3618         if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
3619         {
3620                 Con_Printf("FS_Deflate: deflate failed!\n");
3621                 qz_deflateEnd(&strm);
3622                 Mem_Free(tmp);
3623                 return NULL;
3624         }
3625
3626         if(qz_deflateEnd(&strm) != Z_OK)
3627         {
3628                 Con_Printf("FS_Deflate: deflateEnd failed\n");
3629                 Mem_Free(tmp);
3630                 return NULL;
3631         }
3632
3633         if(strm.total_out >= size)
3634         {
3635                 Con_Printf("FS_Deflate: deflate is useless on this data!\n");
3636                 Mem_Free(tmp);
3637                 return NULL;
3638         }
3639
3640         out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
3641         if(!out)
3642         {
3643                 Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
3644                 Mem_Free(tmp);
3645                 return NULL;
3646         }
3647
3648         if(deflated_size)
3649                 *deflated_size = (size_t)strm.total_out;
3650
3651         memcpy(out, tmp, strm.total_out);
3652         Mem_Free(tmp);
3653
3654         return out;
3655 }
3656
3657 static void AssertBufsize(sizebuf_t *buf, int length)
3658 {
3659         if(buf->cursize + length > buf->maxsize)
3660         {
3661                 int oldsize = buf->maxsize;
3662                 unsigned char *olddata;
3663                 olddata = buf->data;
3664                 buf->maxsize += length;
3665                 buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
3666                 if(olddata)
3667                 {
3668                         memcpy(buf->data, olddata, oldsize);
3669                         Mem_Free(olddata);
3670                 }
3671         }
3672 }
3673
3674 unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
3675 {
3676         int ret;
3677         z_stream strm;
3678         unsigned char *out = NULL;
3679         unsigned char tmp[2048];
3680         unsigned int have;
3681         sizebuf_t outbuf;
3682
3683         *inflated_size = 0;
3684 #ifndef LINK_TO_ZLIB
3685         if(!zlib_dll)
3686                 return NULL;
3687 #endif
3688
3689         memset(&outbuf, 0, sizeof(outbuf));
3690         outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
3691         outbuf.maxsize = sizeof(tmp);
3692
3693         memset(&strm, 0, sizeof(strm));
3694         strm.zalloc = Z_NULL;
3695         strm.zfree = Z_NULL;
3696         strm.opaque = Z_NULL;
3697
3698         if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
3699         {
3700                 Con_Printf("FS_Inflate: inflate init error!\n");
3701                 Mem_Free(outbuf.data);
3702                 return NULL;
3703         }
3704
3705         strm.next_in = (unsigned char*)data;
3706         strm.avail_in = size;
3707
3708         do
3709         {
3710                 strm.next_out = tmp;
3711                 strm.avail_out = sizeof(tmp);
3712                 ret = qz_inflate(&strm, Z_NO_FLUSH);
3713                 // it either returns Z_OK on progress, Z_STREAM_END on end
3714                 // or an error code
3715                 switch(ret)
3716                 {
3717                         case Z_STREAM_END:
3718                         case Z_OK:
3719                                 break;
3720
3721                         case Z_STREAM_ERROR:
3722                                 Con_Print("FS_Inflate: stream error!\n");
3723                                 break;
3724                         case Z_DATA_ERROR:
3725                                 Con_Print("FS_Inflate: data error!\n");
3726                                 break;
3727                         case Z_MEM_ERROR:
3728                                 Con_Print("FS_Inflate: mem error!\n");
3729                                 break;
3730                         case Z_BUF_ERROR:
3731                                 Con_Print("FS_Inflate: buf error!\n");
3732                                 break;
3733                         default:
3734                                 Con_Print("FS_Inflate: unknown error!\n");
3735                                 break;
3736
3737                 }
3738                 if(ret != Z_OK && ret != Z_STREAM_END)
3739                 {
3740                         Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
3741                         Mem_Free(outbuf.data);
3742                         qz_inflateEnd(&strm);
3743                         return NULL;
3744                 }
3745                 have = sizeof(tmp) - strm.avail_out;
3746                 AssertBufsize(&outbuf, max(have, sizeof(tmp)));
3747                 SZ_Write(&outbuf, tmp, have);
3748         } while(ret != Z_STREAM_END);
3749
3750         qz_inflateEnd(&strm);
3751
3752         out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
3753         if(!out)
3754         {
3755                 Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
3756                 Mem_Free(outbuf.data);
3757                 return NULL;
3758         }
3759
3760         memcpy(out, outbuf.data, outbuf.cursize);
3761         Mem_Free(outbuf.data);
3762
3763         if(inflated_size)
3764                 *inflated_size = (size_t)outbuf.cursize;
3765
3766         return out;
3767 }