fs.c

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