fs.c

   1 /*
   2         DarkPlaces file system
   3
   4         Copyright (C) 2003-2006 Mathieu Olivier
   5
   6         This program is free software; you can redistribute it and/or
   7         modify it under the terms of the GNU General Public License
   8         as published by the Free Software Foundation; either version 2
   9         of the License, or (at your option) any later version.
  10
  11         This program is distributed in the hope that it will be useful,
  12         but WITHOUT ANY WARRANTY; without even the implied warranty of
  13         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15         See the GNU General Public License for more details.
  16
  17         You should have received a copy of the GNU General Public License
  18         along with this program; if not, write to:
  19
  20                 Free Software Foundation, Inc.
  21                 59 Temple Place - Suite 330
  22                 Boston, MA  02111-1307, USA
  23 */
  24
  25 #include "quakedef.h"
  26
  27 #include <limits.h>
  28 #include <fcntl.h>
  29
  30 #ifdef WIN32
  31 # include <direct.h>
  32 # include <io.h>
  33 # include <shlobj.h>
  34 #else
  35 # include <pwd.h>
  36 # include <sys/stat.h>
  37 # include <unistd.h>
  38 #endif
  39
  40 #include "fs.h"
  41 #include "wad.h"
  42
  43 // Win32 requires us to add O_BINARY, but the other OSes don't have it
  44 #ifndef O_BINARY
  45 # define O_BINARY 0
  46 #endif
  47
  48 // In case the system doesn't support the O_NONBLOCK flag
  49 #ifndef O_NONBLOCK
  50 # define O_NONBLOCK 0
  51 #endif
  52
  53 // largefile support for Win32
  54 #ifdef WIN32
  55 # define lseek _lseeki64
  56 #endif
  57
  58 /*
  59
  60 All of Quake's data access is through a hierchal file system, but the contents
  61 of the file system can be transparently merged from several sources.
  62
  63 The "base directory" is the path to the directory holding the quake.exe and
  64 all game directories.  The sys_* files pass this to host_init in
  65 quakeparms_t->basedir.  This can be overridden with the "-basedir" command
  66 line parm to allow code debugging in a different directory.  The base
  67 directory is only used during filesystem initialization.
  68
  69 The "game directory" is the first tree on the search path and directory that
  70 all generated files (savegames, screenshots, demos, config files) will be
  71 saved to.  This can be overridden with the "-game" command line parameter.
  72 The game directory can never be changed while quake is executing.  This is a
  73 precaution against having a malicious server instruct clients to write files
  74 over areas they shouldn't.
  75
  76 */
  77
  78
  79 /*
  80 =============================================================================
  81
  82 CONSTANTS
  83
  84 =============================================================================
  85 */
  86
  87 // Magic numbers of a ZIP file (big-endian format)
  88 #define ZIP_DATA_HEADER 0x504B0304  // "PK\3\4"
  89 #define ZIP_CDIR_HEADER 0x504B0102  // "PK\1\2"
  90 #define ZIP_END_HEADER  0x504B0506  // "PK\5\6"
  91
  92 // Other constants for ZIP files
  93 #define ZIP_MAX_COMMENTS_SIZE           ((unsigned short)0xFFFF)
  94 #define ZIP_END_CDIR_SIZE                       22
  95 #define ZIP_CDIR_CHUNK_BASE_SIZE        46
  96 #define ZIP_LOCAL_CHUNK_BASE_SIZE       30
  97
  98 // Zlib constants (from zlib.h)
  99 #define Z_SYNC_FLUSH    2
 100 #define MAX_WBITS               15
 101 #define Z_OK                    0
 102 #define Z_STREAM_END    1
 103 #define ZLIB_VERSION    "1.2.3"
 104
 105 // Uncomment the following line if the zlib DLL you have still uses
 106 // the 1.1.x series calling convention on Win32 (WINAPI)
 107 //#define ZLIB_USES_WINAPI
 108
 109
 110 /*
 111 =============================================================================
 112
 113 TYPES
 114
 115 =============================================================================
 116 */
 117
 118 // Zlib stream (from zlib.h)
 119 // Warning: some pointers we don't use directly have
 120 // been cast to "void*" for a matter of simplicity
 121 typedef struct
 122 {
 123         unsigned char                   *next_in;       // next input byte
 124         unsigned int    avail_in;       // number of bytes available at next_in
 125         unsigned long   total_in;       // total nb of input bytes read so far
 126
 127         unsigned char                   *next_out;      // next output byte should be put there
 128         unsigned int    avail_out;      // remaining free space at next_out
 129         unsigned long   total_out;      // total nb of bytes output so far
 130
 131         char                    *msg;           // last error message, NULL if no error
 132         void                    *state;         // not visible by applications
 133
 134         void                    *zalloc;        // used to allocate the internal state
 135         void                    *zfree;         // used to free the internal state
 136         void                    *opaque;        // private data object passed to zalloc and zfree
 137
 138         int                             data_type;      // best guess about the data type: ascii or binary
 139         unsigned long   adler;          // adler32 value of the uncompressed data
 140         unsigned long   reserved;       // reserved for future use
 141 } z_stream;
 142
 143
 144 // inside a package (PAK or PK3)
 145 #define QFILE_FLAG_PACKED (1 << 0)
 146 // file is compressed using the deflate algorithm (PK3 only)
 147 #define QFILE_FLAG_DEFLATED (1 << 1)
 148
 149 #define FILE_BUFF_SIZE 2048
 150 typedef struct
 151 {
 152         z_stream        zstream;
 153         size_t          comp_length;                    // length of the compressed file
 154         size_t          in_ind, in_len;                 // input buffer current index and length
 155         size_t          in_position;                    // position in the compressed file
 156         unsigned char           input [FILE_BUFF_SIZE];
 157 } ztoolkit_t;
 158
 159 struct qfile_s
 160 {
 161         int                             flags;
 162         int                             handle;                                 // file descriptor
 163         fs_offset_t             real_length;                    // uncompressed file size (for files opened in "read" mode)
 164         fs_offset_t             position;                               // current position in the file
 165         fs_offset_t             offset;                                 // offset into the package (0 if external file)
 166         int                             ungetc;                                 // single stored character from ungetc, cleared to EOF when read
 167
 168         // Contents buffer
 169         fs_offset_t             buff_ind, buff_len;             // buffer current index and length
 170         unsigned char                   buff [FILE_BUFF_SIZE];
 171
 172         // For zipped files
 173         ztoolkit_t*             ztk;
 174 };
 175
 176
 177 // ------ PK3 files on disk ------ //
 178
 179 // You can get the complete ZIP format description from PKWARE website
 180
 181 typedef struct pk3_endOfCentralDir_s
 182 {
 183         unsigned int signature;
 184         unsigned short disknum;
 185         unsigned short cdir_disknum;    // number of the disk with the start of the central directory
 186         unsigned short localentries;    // number of entries in the central directory on this disk
 187         unsigned short nbentries;               // total number of entries in the central directory on this disk
 188         unsigned int cdir_size;                 // size of the central directory
 189         unsigned int cdir_offset;               // with respect to the starting disk number
 190         unsigned short comment_size;
 191 } pk3_endOfCentralDir_t;
 192
 193
 194 // ------ PAK files on disk ------ //
 195 typedef struct dpackfile_s
 196 {
 197         char name[56];
 198         int filepos, filelen;
 199 } dpackfile_t;
 200
 201 typedef struct dpackheader_s
 202 {
 203         char id[4];
 204         int dirofs;
 205         int dirlen;
 206 } dpackheader_t;
 207
 208
 209 // Packages in memory
 210 // the offset in packfile_t is the true contents offset
 211 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
 212 // file compressed using the deflate algorithm
 213 #define PACKFILE_FLAG_DEFLATED (1 << 1)
 214
 215 typedef struct packfile_s
 216 {
 217         char name [MAX_QPATH];
 218         int flags;
 219         fs_offset_t offset;
 220         fs_offset_t packsize;   // size in the package
 221         fs_offset_t realsize;   // real file size (uncompressed)
 222 } packfile_t;
 223
 224 typedef struct pack_s
 225 {
 226         char filename [MAX_OSPATH];
 227         int handle;
 228         int ignorecase;  // PK3 ignores case
 229         int numfiles;
 230         packfile_t *files;
 231 } pack_t;
 232
 233
 234 // Search paths for files (including packages)
 235 typedef struct searchpath_s
 236 {
 237         // only one of filename / pack will be used
 238         char filename[MAX_OSPATH];
 239         pack_t *pack;
 240         struct searchpath_s *next;
 241 } searchpath_t;
 242
 243
 244 /*
 245 =============================================================================
 246
 247 FUNCTION PROTOTYPES
 248
 249 =============================================================================
 250 */
 251
 252 void FS_Dir_f(void);
 253 void FS_Ls_f(void);
 254
 255 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet);
 256 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
 257                                                                         fs_offset_t offset, fs_offset_t packsize,
 258                                                                         fs_offset_t realsize, int flags);
 259
 260
 261 /*
 262 =============================================================================
 263
 264 VARIABLES
 265
 266 =============================================================================
 267 */
 268
 269 mempool_t *fs_mempool;
 270
 271 searchpath_t *fs_searchpaths = NULL;
 272
 273 #define MAX_FILES_IN_PACK       65536
 274
 275 char fs_gamedir[MAX_OSPATH];
 276 char fs_basedir[MAX_OSPATH];
 277
 278 // list of active game directories (empty if not running a mod)
 279 int fs_numgamedirs = 0;
 280 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
 281
 282 cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running)"};
 283 cvar_t fs_empty_files_in_pack_mark_deletions = {0, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
 284
 285
 286 /*
 287 =============================================================================
 288
 289 PRIVATE FUNCTIONS - PK3 HANDLING
 290
 291 =============================================================================
 292 */
 293
 294 // Functions exported from zlib
 295 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
 296 # define ZEXPORT WINAPI
 297 #else
 298 # define ZEXPORT
 299 #endif
 300
 301 static int (ZEXPORT *qz_inflate) (z_stream* strm, int flush);
 302 static int (ZEXPORT *qz_inflateEnd) (z_stream* strm);
 303 static int (ZEXPORT *qz_inflateInit2_) (z_stream* strm, int windowBits, const char *version, int stream_size);
 304 static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
 305
 306 #define qz_inflateInit2(strm, windowBits) \
 307         qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
 308
 309 static dllfunction_t zlibfuncs[] =
 310 {
 311         {"inflate",                     (void **) &qz_inflate},
 312         {"inflateEnd",          (void **) &qz_inflateEnd},
 313         {"inflateInit2_",       (void **) &qz_inflateInit2_},
 314         {"inflateReset",        (void **) &qz_inflateReset},
 315         {NULL, NULL}
 316 };
 317
 318 // Handle for Zlib DLL
 319 static dllhandle_t zlib_dll = NULL;
 320
 321
 322 /*
 323 ====================
 324 PK3_CloseLibrary
 325
 326 Unload the Zlib DLL
 327 ====================
 328 */
 329 void PK3_CloseLibrary (void)
 330 {
 331         Sys_UnloadLibrary (&zlib_dll);
 332 }
 333
 334
 335 /*
 336 ====================
 337 PK3_OpenLibrary
 338
 339 Try to load the Zlib DLL
 340 ====================
 341 */
 342 qboolean PK3_OpenLibrary (void)
 343 {
 344         const char* dllnames [] =
 345         {
 346 #if defined(WIN64)
 347                 "zlib64.dll",
 348 #elif defined(WIN32)
 349 # ifdef ZLIB_USES_WINAPI
 350                 "zlibwapi.dll",
 351                 "zlib.dll",
 352 # else
 353                 "zlib1.dll",
 354 # endif
 355 #elif defined(MACOSX)
 356                 "libz.dylib",
 357 #else
 358                 "libz.so.1",
 359                 "libz.so",
 360 #endif
 361                 NULL
 362         };
 363
 364         // Already loaded?
 365         if (zlib_dll)
 366                 return true;
 367
 368         // Load the DLL
 369         if (! Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs))
 370         {
 371                 Con_Printf ("Compressed files support disabled\n");
 372                 return false;
 373         }
 374
 375         Con_Printf ("Compressed files support enabled\n");
 376         return true;
 377 }
 378
 379
 380 /*
 381 ====================
 382 PK3_GetEndOfCentralDir
 383
 384 Extract the end of the central directory from a PK3 package
 385 ====================
 386 */
 387 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
 388 {
 389         fs_offset_t filesize, maxsize;
 390         unsigned char *buffer, *ptr;
 391         int ind;
 392
 393         // Get the package size
 394         filesize = lseek (packhandle, 0, SEEK_END);
 395         if (filesize < ZIP_END_CDIR_SIZE)
 396                 return false;
 397
 398         // Load the end of the file in memory
 399         if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
 400                 maxsize = filesize;
 401         else
 402                 maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
 403         buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
 404         lseek (packhandle, filesize - maxsize, SEEK_SET);
 405         if (read (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
 406         {
 407                 Mem_Free (buffer);
 408                 return false;
 409         }
 410
 411         // Look for the end of central dir signature around the end of the file
 412         maxsize -= ZIP_END_CDIR_SIZE;
 413         ptr = &buffer[maxsize];
 414         ind = 0;
 415         while (BuffBigLong (ptr) != ZIP_END_HEADER)
 416         {
 417                 if (ind == maxsize)
 418                 {
 419                         Mem_Free (buffer);
 420                         return false;
 421                 }
 422
 423                 ind++;
 424                 ptr--;
 425         }
 426
 427         memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
 428         eocd->signature = LittleLong (eocd->signature);
 429         eocd->disknum = LittleShort (eocd->disknum);
 430         eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
 431         eocd->localentries = LittleShort (eocd->localentries);
 432         eocd->nbentries = LittleShort (eocd->nbentries);
 433         eocd->cdir_size = LittleLong (eocd->cdir_size);
 434         eocd->cdir_offset = LittleLong (eocd->cdir_offset);
 435         eocd->comment_size = LittleShort (eocd->comment_size);
 436
 437         Mem_Free (buffer);
 438
 439         return true;
 440 }
 441
 442
 443 /*
 444 ====================
 445 PK3_BuildFileList
 446
 447 Extract the file list from a PK3 file
 448 ====================
 449 */
 450 int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
 451 {
 452         unsigned char *central_dir, *ptr;
 453         unsigned int ind;
 454         fs_offset_t remaining;
 455
 456         // Load the central directory in memory
 457         central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
 458         lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
 459         read (pack->handle, central_dir, eocd->cdir_size);
 460
 461         // Extract the files properties
 462         // The parsing is done "by hand" because some fields have variable sizes and
 463         // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
 464         remaining = eocd->cdir_size;
 465         pack->numfiles = 0;
 466         ptr = central_dir;
 467         for (ind = 0; ind < eocd->nbentries; ind++)
 468         {
 469                 fs_offset_t namesize, count;
 470
 471                 // Checking the remaining size
 472                 if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
 473                 {
 474                         Mem_Free (central_dir);
 475                         return -1;
 476                 }
 477                 remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
 478
 479                 // Check header
 480                 if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
 481                 {
 482                         Mem_Free (central_dir);
 483                         return -1;
 484                 }
 485
 486                 namesize = BuffLittleShort (&ptr[28]);  // filename length
 487
 488                 // Check encryption, compression, and attributes
 489                 // 1st uint8  : general purpose bit flag
 490                 //    Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
 491                 // 2nd uint8 : external file attributes
 492                 //    Check bits 3 (file is a directory) and 5 (file is a volume (?))
 493                 if ((ptr[8] & 0x29) == 0 && (ptr[38] & 0x18) == 0)
 494                 {
 495                         // Still enough bytes for the name?
 496                         if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
 497                         {
 498                                 Mem_Free (central_dir);
 499                                 return -1;
 500                         }
 501
 502                         // WinZip doesn't use the "directory" attribute, so we need to check the name directly
 503                         if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
 504                         {
 505                                 char filename [sizeof (pack->files[0].name)];
 506                                 fs_offset_t offset, packsize, realsize;
 507                                 int flags;
 508
 509                                 // Extract the name (strip it if necessary)
 510                                 namesize = min(namesize, (int)sizeof (filename) - 1);
 511                                 memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
 512                                 filename[namesize] = '\0';
 513
 514                                 if (BuffLittleShort (&ptr[10]))
 515                                         flags = PACKFILE_FLAG_DEFLATED;
 516                                 else
 517                                         flags = 0;
 518                                 offset = BuffLittleLong (&ptr[42]);
 519                                 packsize = BuffLittleLong (&ptr[20]);
 520                                 realsize = BuffLittleLong (&ptr[24]);
 521                                 FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
 522                         }
 523                 }
 524
 525                 // Skip the name, additionnal field, and comment
 526                 // 1er uint16 : extra field length
 527                 // 2eme uint16 : file comment length
 528                 count = namesize + BuffLittleShort (&ptr[30]) + BuffLittleShort (&ptr[32]);
 529                 ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
 530                 remaining -= count;
 531         }
 532
 533         // If the package is empty, central_dir is NULL here
 534         if (central_dir != NULL)
 535                 Mem_Free (central_dir);
 536         return pack->numfiles;
 537 }
 538
 539
 540 /*
 541 ====================
 542 FS_LoadPackPK3
 543
 544 Create a package entry associated with a PK3 file
 545 ====================
 546 */
 547 pack_t *FS_LoadPackPK3 (const char *packfile)
 548 {
 549         int packhandle;
 550         pk3_endOfCentralDir_t eocd;
 551         pack_t *pack;
 552         int real_nb_files;
 553
 554         packhandle = open (packfile, O_RDONLY | O_BINARY);
 555         if (packhandle < 0)
 556                 return NULL;
 557
 558         if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
 559         {
 560                 Con_Printf ("%s is not a PK3 file\n", packfile);
 561                 close(packhandle);
 562                 return NULL;
 563         }
 564
 565         // Multi-volume ZIP archives are NOT allowed
 566         if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
 567         {
 568                 Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
 569                 close(packhandle);
 570                 return NULL;
 571         }
 572
 573         // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
 574         // since eocd.nbentries is an unsigned 16 bits integer
 575 #if MAX_FILES_IN_PACK < 65535
 576         if (eocd.nbentries > MAX_FILES_IN_PACK)
 577         {
 578                 Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
 579                 close(packhandle);
 580                 return NULL;
 581         }
 582 #endif
 583
 584         // Create a package structure in memory
 585         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
 586         pack->ignorecase = true; // PK3 ignores case
 587         strlcpy (pack->filename, packfile, sizeof (pack->filename));
 588         pack->handle = packhandle;
 589         pack->numfiles = eocd.nbentries;
 590         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
 591
 592         real_nb_files = PK3_BuildFileList (pack, &eocd);
 593         if (real_nb_files < 0)
 594         {
 595                 Con_Printf ("%s is not a valid PK3 file\n", packfile);
 596                 close(pack->handle);
 597                 Mem_Free(pack);
 598                 return NULL;
 599         }
 600
 601         Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
 602         return pack;
 603 }
 604
 605
 606 /*
 607 ====================
 608 PK3_GetTrueFileOffset
 609
 610 Find where the true file data offset is
 611 ====================
 612 */
 613 qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
 614 {
 615         unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
 616         fs_offset_t count;
 617
 618         // Already found?
 619         if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
 620                 return true;
 621
 622         // Load the local file description
 623         lseek (pack->handle, pfile->offset, SEEK_SET);
 624         count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
 625         if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
 626         {
 627                 Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
 628                 return false;
 629         }
 630
 631         // Skip name and extra field
 632         pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
 633
 634         pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
 635         return true;
 636 }
 637
 638
 639 /*
 640 =============================================================================
 641
 642 OTHER PRIVATE FUNCTIONS
 643
 644 =============================================================================
 645 */
 646
 647
 648 /*
 649 ====================
 650 FS_AddFileToPack
 651
 652 Add a file to the list of files contained into a package
 653 ====================
 654 */
 655 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
 656                                                                          fs_offset_t offset, fs_offset_t packsize,
 657                                                                          fs_offset_t realsize, int flags)
 658 {
 659         int (*strcmp_funct) (const char* str1, const char* str2);
 660         int left, right, middle;
 661         packfile_t *pfile;
 662
 663         strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
 664
 665         // Look for the slot we should put that file into (binary search)
 666         left = 0;
 667         right = pack->numfiles - 1;
 668         while (left <= right)
 669         {
 670                 int diff;
 671
 672                 middle = (left + right) / 2;
 673                 diff = strcmp_funct (pack->files[middle].name, name);
 674
 675                 // If we found the file, there's a problem
 676                 if (!diff)
 677                         Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
 678
 679                 // If we're too far in the list
 680                 if (diff > 0)
 681                         right = middle - 1;
 682                 else
 683                         left = middle + 1;
 684         }
 685
 686         // We have to move the right of the list by one slot to free the one we need
 687         pfile = &pack->files[left];
 688         memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
 689         pack->numfiles++;
 690
 691         strlcpy (pfile->name, name, sizeof (pfile->name));
 692         pfile->offset = offset;
 693         pfile->packsize = packsize;
 694         pfile->realsize = realsize;
 695         pfile->flags = flags;
 696
 697         return pfile;
 698 }
 699
 700
 701 /*
 702 ============
 703 FS_CreatePath
 704
 705 Only used for FS_Open.
 706 ============
 707 */
 708 void FS_CreatePath (char *path)
 709 {
 710         char *ofs, save;
 711
 712         for (ofs = path+1 ; *ofs ; ofs++)
 713         {
 714                 if (*ofs == '/' || *ofs == '\\')
 715                 {
 716                         // create the directory
 717                         save = *ofs;
 718                         *ofs = 0;
 719                         FS_mkdir (path);
 720                         *ofs = save;
 721                 }
 722         }
 723 }
 724
 725
 726 /*
 727 ============
 728 FS_Path_f
 729
 730 ============
 731 */
 732 void FS_Path_f (void)
 733 {
 734         searchpath_t *s;
 735
 736         Con_Print("Current search path:\n");
 737         for (s=fs_searchpaths ; s ; s=s->next)
 738         {
 739                 if (s->pack)
 740                         Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
 741                 else
 742                         Con_Printf("%s\n", s->filename);
 743         }
 744 }
 745
 746
 747 /*
 748 =================
 749 FS_LoadPackPAK
 750
 751 Takes an explicit (not game tree related) path to a pak file.
 752
 753 Loads the header and directory, adding the files at the beginning
 754 of the list so they override previous pack files.
 755 =================
 756 */
 757 pack_t *FS_LoadPackPAK (const char *packfile)
 758 {
 759         dpackheader_t header;
 760         int i, numpackfiles;
 761         int packhandle;
 762         pack_t *pack;
 763         dpackfile_t *info;
 764
 765         packhandle = open (packfile, O_RDONLY | O_BINARY);
 766         if (packhandle < 0)
 767                 return NULL;
 768         read (packhandle, (void *)&header, sizeof(header));
 769         if (memcmp(header.id, "PACK", 4))
 770         {
 771                 Con_Printf ("%s is not a packfile\n", packfile);
 772                 close(packhandle);
 773                 return NULL;
 774         }
 775         header.dirofs = LittleLong (header.dirofs);
 776         header.dirlen = LittleLong (header.dirlen);
 777
 778         if (header.dirlen % sizeof(dpackfile_t))
 779         {
 780                 Con_Printf ("%s has an invalid directory size\n", packfile);
 781                 close(packhandle);
 782                 return NULL;
 783         }
 784
 785         numpackfiles = header.dirlen / sizeof(dpackfile_t);
 786
 787         if (numpackfiles > MAX_FILES_IN_PACK)
 788         {
 789                 Con_Printf ("%s has %i files\n", packfile, numpackfiles);
 790                 close(packhandle);
 791                 return NULL;
 792         }
 793
 794         info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
 795         lseek (packhandle, header.dirofs, SEEK_SET);
 796         if(header.dirlen != read (packhandle, (void *)info, header.dirlen))
 797         {
 798                 Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
 799                 Mem_Free(info);
 800                 close(packhandle);
 801                 return NULL;
 802         }
 803
 804         pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
 805         pack->ignorecase = false; // PAK is case sensitive
 806         strlcpy (pack->filename, packfile, sizeof (pack->filename));
 807         pack->handle = packhandle;
 808         pack->numfiles = 0;
 809         pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
 810
 811         // parse the directory
 812         for (i = 0;i < numpackfiles;i++)
 813         {
 814                 fs_offset_t offset = LittleLong (info[i].filepos);
 815                 fs_offset_t size = LittleLong (info[i].filelen);
 816
 817                 FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
 818         }
 819
 820         Mem_Free(info);
 821
 822         Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
 823         return pack;
 824 }
 825
 826 /*
 827 ================
 828 FS_AddPack_Fullpath
 829
 830 Adds the given pack to the search path.
 831 The pack type is autodetected by the file extension.
 832
 833 Returns true if the file was successfully added to the
 834 search path or if it was already included.
 835
 836 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
 837 plain directories.
 838 ================
 839 */
 840 static qboolean FS_AddPack_Fullpath(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
 841 {
 842         searchpath_t *search;
 843         pack_t *pak = NULL;
 844         const char *ext = FS_FileExtension(pakfile);
 845
 846         for(search = fs_searchpaths; search; search = search->next)
 847         {
 848                 if(search->pack && !strcasecmp(search->pack->filename, pakfile))
 849                 {
 850                         if(already_loaded)
 851                                 *already_loaded = true;
 852                         return true; // already loaded
 853                 }
 854         }
 855
 856         if(already_loaded)
 857                 *already_loaded = false;
 858
 859         if(!strcasecmp(ext, "pak"))
 860                 pak = FS_LoadPackPAK (pakfile);
 861         else if(!strcasecmp(ext, "pk3"))
 862                 pak = FS_LoadPackPK3 (pakfile);
 863         else
 864                 Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
 865
 866         if (pak)
 867         {
 868                 if(keep_plain_dirs)
 869                 {
 870                         // find the first item whose next one is a pack or NULL
 871                         searchpath_t *insertion_point = 0;
 872                         if(fs_searchpaths && !fs_searchpaths->pack)
 873                         {
 874                                 insertion_point = fs_searchpaths;
 875                                 for(;;)
 876                                 {
 877                                         if(!insertion_point->next)
 878                                                 break;
 879                                         if(insertion_point->next->pack)
 880                                                 break;
 881                                         insertion_point = insertion_point->next;
 882                                 }
 883                         }
 884                         // If insertion_point is NULL, this means that either there is no
 885                         // item in the list yet, or that the very first item is a pack. In
 886                         // that case, we want to insert at the beginning...
 887                         if(!insertion_point)
 888                         {
 889                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
 890                                 search->pack = pak;
 891                                 search->next = fs_searchpaths;
 892                                 fs_searchpaths = search;
 893                         }
 894                         else
 895                         // otherwise we want to append directly after insertion_point.
 896                         {
 897                                 search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
 898                                 search->pack = pak;
 899                                 search->next = insertion_point->next;
 900                                 insertion_point->next = search;
 901                         }
 902                 }
 903                 else
 904                 {
 905                         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
 906                         search->pack = pak;
 907                         search->next = fs_searchpaths;
 908                         fs_searchpaths = search;
 909                 }
 910                 return true;
 911         }
 912         else
 913         {
 914                 Con_Printf("unable to load pak \"%s\"\n", pakfile);
 915                 return false;
 916         }
 917 }
 918
 919
 920 /*
 921 ================
 922 FS_AddPack
 923
 924 Adds the given pack to the search path and searches for it in the game path.
 925 The pack type is autodetected by the file extension.
 926
 927 Returns true if the file was successfully added to the
 928 search path or if it was already included.
 929
 930 If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
 931 plain directories.
 932 ================
 933 */
 934 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
 935 {
 936         char fullpath[MAX_QPATH];
 937         int index;
 938         searchpath_t *search;
 939
 940         if(already_loaded)
 941                 *already_loaded = false;
 942
 943         // then find the real name...
 944         search = FS_FindFile(pakfile, &index, true);
 945         if(!search || search->pack)
 946         {
 947                 Con_Printf("could not find pak \"%s\"\n", pakfile);
 948                 return false;
 949         }
 950
 951         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
 952
 953         return FS_AddPack_Fullpath(fullpath, already_loaded, keep_plain_dirs);
 954 }
 955
 956
 957 /*
 958 ================
 959 FS_AddGameDirectory
 960
 961 Sets fs_gamedir, adds the directory to the head of the path,
 962 then loads and adds pak1.pak pak2.pak ...
 963 ================
 964 */
 965 void FS_AddGameDirectory (const char *dir)
 966 {
 967         int i;
 968         stringlist_t list;
 969         searchpath_t *search;
 970         char pakfile[MAX_OSPATH];
 971
 972         strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
 973
 974         stringlistinit(&list);
 975         listdirectory(&list, dir);
 976         stringlistsort(&list);
 977
 978         // add any PAK package in the directory
 979         for (i = 0;i < list.numstrings;i++)
 980         {
 981                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
 982                 {
 983                         dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
 984                         FS_AddPack_Fullpath(pakfile, NULL, false);
 985                 }
 986         }
 987
 988         // add any PK3 package in the directory
 989         for (i = 0;i < list.numstrings;i++)
 990         {
 991                 if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
 992                 {
 993                         dpsnprintf (pakfile, sizeof (pakfile), "%s%s", dir, list.strings[i]);
 994                         FS_AddPack_Fullpath(pakfile, NULL, false);
 995                 }
 996         }
 997
 998         stringlistfreecontents(&list);
 999
1000         // Add the directory to the search path
1001         // (unpacked files have the priority over packed files)
1002         search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
1003         strlcpy (search->filename, dir, sizeof (search->filename));
1004         search->next = fs_searchpaths;
1005         fs_searchpaths = search;
1006 }
1007
1008
1009 /*
1010 ================
1011 FS_AddGameHierarchy
1012 ================
1013 */
1014 void FS_AddGameHierarchy (const char *dir)
1015 {
1016         int i;
1017         char userdir[MAX_QPATH];
1018 #ifdef WIN32
1019         TCHAR appdata[MAX_PATH + 1];
1020 #else
1021         const char *homedir;
1022 #endif
1023
1024         // Add the common game directory
1025         FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
1026
1027         *userdir = 0;
1028
1029         // Add the personal game directory
1030 #ifdef WIN32
1031         if(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, appdata) == S_OK)
1032                 dpsnprintf(userdir, sizeof(userdir), "%s/%s/", appdata, gameuserdirname);
1033 #else
1034         homedir = getenv ("HOME");
1035         if(homedir)
1036                 dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
1037 #endif
1038
1039 #ifdef WIN32
1040         if(!COM_CheckParm("-appdata"))
1041         {
1042                 int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT | O_APPEND, 0666);
1043                 if(fd >= 0)
1044                 {
1045                         close(fd);
1046                         *userdir = 0; // we have write access to the game dir, so let's use it
1047                 }
1048         }
1049 #endif
1050
1051         if(COM_CheckParm("-nohome"))
1052                 *userdir = 0;
1053
1054         if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1055                 dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
1056
1057         if (*userdir)
1058                 FS_AddGameDirectory(va("%s%s/", userdir, dir));
1059 }
1060
1061
1062 /*
1063 ============
1064 FS_FileExtension
1065 ============
1066 */
1067 const char *FS_FileExtension (const char *in)
1068 {
1069         const char *separator, *backslash, *colon, *dot;
1070
1071         separator = strrchr(in, '/');
1072         backslash = strrchr(in, '\\');
1073         if (!separator || separator < backslash)
1074                 separator = backslash;
1075         colon = strrchr(in, ':');
1076         if (!separator || separator < colon)
1077                 separator = colon;
1078
1079         dot = strrchr(in, '.');
1080         if (dot == NULL || (separator && (dot < separator)))
1081                 return "";
1082
1083         return dot + 1;
1084 }
1085
1086
1087 /*
1088 ============
1089 FS_FileWithoutPath
1090 ============
1091 */
1092 const char *FS_FileWithoutPath (const char *in)
1093 {
1094         const char *separator, *backslash, *colon;
1095
1096         separator = strrchr(in, '/');
1097         backslash = strrchr(in, '\\');
1098         if (!separator || separator < backslash)
1099                 separator = backslash;
1100         colon = strrchr(in, ':');
1101         if (!separator || separator < colon)
1102                 separator = colon;
1103         return separator ? separator + 1 : in;
1104 }
1105
1106
1107 /*
1108 ================
1109 FS_ClearSearchPath
1110 ================
1111 */
1112 void FS_ClearSearchPath (void)
1113 {
1114         // unload all packs and directory information, close all pack files
1115         // (if a qfile is still reading a pack it won't be harmed because it used
1116         //  dup() to get its own handle already)
1117         while (fs_searchpaths)
1118         {
1119                 searchpath_t *search = fs_searchpaths;
1120                 fs_searchpaths = search->next;
1121                 if (search->pack)
1122                 {
1123                         // close the file
1124                         close(search->pack->handle);
1125                         // free any memory associated with it
1126                         if (search->pack->files)
1127                                 Mem_Free(search->pack->files);
1128                         Mem_Free(search->pack);
1129                 }
1130                 Mem_Free(search);
1131         }
1132 }
1133
1134
1135 /*
1136 ================
1137 FS_Rescan
1138 ================
1139 */
1140 void FS_Rescan (void)
1141 {
1142         int i;
1143         qboolean fs_modified = false;
1144
1145         FS_ClearSearchPath();
1146
1147         // add the game-specific paths
1148         // gamedirname1 (typically id1)
1149         FS_AddGameHierarchy (gamedirname1);
1150         // update the com_modname (used for server info)
1151         strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1152
1153         // add the game-specific path, if any
1154         // (only used for mission packs and the like, which should set fs_modified)
1155         if (gamedirname2)
1156         {
1157                 fs_modified = true;
1158                 FS_AddGameHierarchy (gamedirname2);
1159         }
1160
1161         // -game <gamedir>
1162         // Adds basedir/gamedir as an override game
1163         // LordHavoc: now supports multiple -game directories
1164         // set the com_modname (reported in server info)
1165         for (i = 0;i < fs_numgamedirs;i++)
1166         {
1167                 fs_modified = true;
1168                 FS_AddGameHierarchy (fs_gamedirs[i]);
1169                 // update the com_modname (used server info)
1170                 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1171         }
1172
1173         // set the default screenshot name to either the mod name or the
1174         // gamemode screenshot name
1175         if (strcmp(com_modname, gamedirname1))
1176                 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1177         else
1178                 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1179
1180         // If "-condebug" is in the command line, remove the previous log file
1181         if (COM_CheckParm ("-condebug") != 0)
1182                 unlink (va("%s/qconsole.log", fs_gamedir));
1183
1184         // look for the pop.lmp file and set registered to true if it is found
1185         if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1186         {
1187                 if (fs_modified)
1188                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1189                 else
1190                         Con_Print("Playing shareware version.\n");
1191         }
1192         else
1193         {
1194                 Cvar_Set ("registered", "1");
1195                 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1196                         Con_Print("Playing registered version.\n");
1197         }
1198
1199         // unload all wads so that future queries will return the new data
1200         W_UnloadAll();
1201 }
1202
1203 void FS_Rescan_f(void)
1204 {
1205         FS_Rescan();
1206 }
1207
1208 /*
1209 ================
1210 FS_ChangeGameDirs
1211 ================
1212 */
1213 extern void Host_SaveConfig (void);
1214 extern void Host_LoadConfig_f (void);
1215 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1216 {
1217         int i;
1218
1219         if (fs_numgamedirs == numgamedirs)
1220         {
1221                 for (i = 0;i < numgamedirs;i++)
1222                         if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1223                                 break;
1224                 if (i == numgamedirs)
1225                         return true; // already using this set of gamedirs, do nothing
1226         }
1227
1228         if (numgamedirs > MAX_GAMEDIRS)
1229         {
1230                 if (complain)
1231                         Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1232                 return false; // too many gamedirs
1233         }
1234
1235         for (i = 0;i < numgamedirs;i++)
1236         {
1237                 // if string is nasty, reject it
1238                 if(FS_CheckNastyPath(gamedirs[i], true))
1239                 {
1240                         if (complain)
1241                                 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1242                         return false; // nasty gamedirs
1243                 }
1244         }
1245
1246         for (i = 0;i < numgamedirs;i++)
1247         {
1248                 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1249                 {
1250                         if (complain)
1251                                 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1252                         return false; // missing gamedirs
1253                 }
1254         }
1255
1256         // halt demo playback to close the file
1257         CL_Disconnect();
1258
1259         Host_SaveConfig();
1260
1261         fs_numgamedirs = numgamedirs;
1262         for (i = 0;i < fs_numgamedirs;i++)
1263                 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1264
1265         // reinitialize filesystem to detect the new paks
1266         FS_Rescan();
1267
1268         // exec the new config
1269         Host_LoadConfig_f();
1270
1271         // unload all sounds so they will be reloaded from the new files as needed
1272         S_UnloadAllSounds_f();
1273
1274         // reinitialize renderer (this reloads hud/console background/etc)
1275         R_Modules_Restart();
1276
1277         return true;
1278 }
1279
1280 /*
1281 ================
1282 FS_GameDir_f
1283 ================
1284 */
1285 void FS_GameDir_f (void)
1286 {
1287         int i;
1288         int numgamedirs;
1289         char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1290
1291         if (Cmd_Argc() < 2)
1292         {
1293                 Con_Printf("gamedirs active:");
1294                 for (i = 0;i < fs_numgamedirs;i++)
1295                         Con_Printf(" %s", fs_gamedirs[i]);
1296                 Con_Printf("\n");
1297                 return;
1298         }
1299
1300         numgamedirs = Cmd_Argc() - 1;
1301         if (numgamedirs > MAX_GAMEDIRS)
1302         {
1303                 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1304                 return;
1305         }
1306
1307         for (i = 0;i < numgamedirs;i++)
1308                 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1309
1310         if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1311         {
1312                 // actually, changing during game would work fine, but would be stupid
1313                 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1314                 return;
1315         }
1316
1317         FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1318 }
1319
1320
1321 /*
1322 ================
1323 FS_CheckGameDir
1324 ================
1325 */
1326 qboolean FS_CheckGameDir(const char *gamedir)
1327 {
1328         qboolean success;
1329         stringlist_t list;
1330         stringlistinit(&list);
1331         listdirectory(&list, va("%s%s/", fs_basedir, gamedir));
1332         success = list.numstrings > 0;
1333         stringlistfreecontents(&list);
1334         return success;
1335 }
1336
1337
1338 /*
1339 ================
1340 FS_Init
1341 ================
1342 */
1343 void FS_Init (void)
1344 {
1345         int i;
1346
1347         fs_mempool = Mem_AllocPool("file management", 0, NULL);
1348
1349         strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1350
1351 // If the base directory is explicitly defined by the compilation process
1352 #ifdef DP_FS_BASEDIR
1353         strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1354 #else
1355         strlcpy(fs_basedir, "", sizeof(fs_basedir));
1356
1357 #ifdef MACOSX
1358         // FIXME: is there a better way to find the directory outside the .app?
1359         if (strstr(com_argv[0], ".app/"))
1360         {
1361                 char *split;
1362
1363                 split = strstr(com_argv[0], ".app/");
1364                 while (split > com_argv[0] && *split != '/')
1365                         split--;
1366                 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1367                 fs_basedir[split - com_argv[0]] = 0;
1368         }
1369 #endif
1370 #endif
1371
1372         PK3_OpenLibrary ();
1373
1374         // -basedir <path>
1375         // Overrides the system supplied base directory (under GAMENAME)
1376 // 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)
1377         i = COM_CheckParm ("-basedir");
1378         if (i && i < com_argc-1)
1379         {
1380                 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1381                 i = (int)strlen (fs_basedir);
1382                 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1383                         fs_basedir[i-1] = 0;
1384         }
1385
1386         // add a path separator to the end of the basedir if it lacks one
1387         if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1388                 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1389
1390         if (!FS_CheckGameDir(gamedirname1))
1391                 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1392
1393         if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1394                 Sys_Error("base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1395
1396         // -game <gamedir>
1397         // Adds basedir/gamedir as an override game
1398         // LordHavoc: now supports multiple -game directories
1399         for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1400         {
1401                 if (!com_argv[i])
1402                         continue;
1403                 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1404                 {
1405                         i++;
1406                         if (FS_CheckNastyPath(com_argv[i], true))
1407                                 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1408                         if (!FS_CheckGameDir(com_argv[i]))
1409                                 Sys_Error("-game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1410                         // add the gamedir to the list of active gamedirs
1411                         strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1412                         fs_numgamedirs++;
1413                 }
1414         }
1415
1416         // generate the searchpath
1417         FS_Rescan();
1418 }
1419
1420 void FS_Init_Commands(void)
1421 {
1422         Cvar_RegisterVariable (&scr_screenshot_name);
1423         Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1424
1425         Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1426         Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1427         Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1428         Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1429         Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1430 }
1431
1432 /*
1433 ================
1434 FS_Shutdown
1435 ================
1436 */
1437 void FS_Shutdown (void)
1438 {
1439         // close all pack files and such
1440         // (hopefully there aren't any other open files, but they'll be cleaned up
1441         //  by the OS anyway)
1442         FS_ClearSearchPath();
1443         Mem_FreePool (&fs_mempool);
1444 }
1445
1446 /*
1447 ====================
1448 FS_SysOpen
1449
1450 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1451 ====================
1452 */
1453 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1454 {
1455         qfile_t* file;
1456         int mod, opt;
1457         unsigned int ind;
1458
1459         // Parse the mode string
1460         switch (mode[0])
1461         {
1462                 case 'r':
1463                         mod = O_RDONLY;
1464                         opt = 0;
1465                         break;
1466                 case 'w':
1467                         mod = O_WRONLY;
1468                         opt = O_CREAT | O_TRUNC;
1469                         break;
1470                 case 'a':
1471                         mod = O_WRONLY;
1472                         opt = O_CREAT | O_APPEND;
1473                         break;
1474                 default:
1475                         Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1476                         return NULL;
1477         }
1478         for (ind = 1; mode[ind] != '\0'; ind++)
1479         {
1480                 switch (mode[ind])
1481                 {
1482                         case '+':
1483                                 mod = O_RDWR;
1484                                 break;
1485                         case 'b':
1486                                 opt |= O_BINARY;
1487                                 break;
1488                         default:
1489                                 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1490                                                         filepath, mode, mode[ind]);
1491                 }
1492         }
1493
1494         if (nonblocking)
1495                 opt |= O_NONBLOCK;
1496
1497         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1498         memset (file, 0, sizeof (*file));
1499         file->ungetc = EOF;
1500
1501         file->handle = open (filepath, mod | opt, 0666);
1502         if (file->handle < 0)
1503         {
1504                 Mem_Free (file);
1505                 return NULL;
1506         }
1507
1508         file->real_length = lseek (file->handle, 0, SEEK_END);
1509
1510         // For files opened in append mode, we start at the end of the file
1511         if (mod & O_APPEND)
1512                 file->position = file->real_length;
1513         else
1514                 lseek (file->handle, 0, SEEK_SET);
1515
1516         return file;
1517 }
1518
1519
1520 /*
1521 ===========
1522 FS_OpenPackedFile
1523
1524 Open a packed file using its package file descriptor
1525 ===========
1526 */
1527 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1528 {
1529         packfile_t *pfile;
1530         int dup_handle;
1531         qfile_t* file;
1532
1533         pfile = &pack->files[pack_ind];
1534
1535         // If we don't have the true offset, get it now
1536         if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1537                 if (!PK3_GetTrueFileOffset (pfile, pack))
1538                         return NULL;
1539
1540         // No Zlib DLL = no compressed files
1541         if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1542         {
1543                 Con_Printf("WARNING: can't open the compressed file %s\n"
1544                                         "You need the Zlib DLL to use compressed files\n",
1545                                         pfile->name);
1546                 return NULL;
1547         }
1548
1549         // LordHavoc: lseek affects all duplicates of a handle so we do it before
1550         // the dup() call to avoid having to close the dup_handle on error here
1551         if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1552         {
1553                 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1554                                         pfile->name, pack->filename, (int) pfile->offset);
1555                 return NULL;
1556         }
1557
1558         dup_handle = dup (pack->handle);
1559         if (dup_handle < 0)
1560         {
1561                 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1562                 return NULL;
1563         }
1564
1565         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1566         memset (file, 0, sizeof (*file));
1567         file->handle = dup_handle;
1568         file->flags = QFILE_FLAG_PACKED;
1569         file->real_length = pfile->realsize;
1570         file->offset = pfile->offset;
1571         file->position = 0;
1572         file->ungetc = EOF;
1573
1574         if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1575         {
1576                 ztoolkit_t *ztk;
1577
1578                 file->flags |= QFILE_FLAG_DEFLATED;
1579
1580                 // We need some more variables
1581                 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1582
1583                 ztk->comp_length = pfile->packsize;
1584
1585                 // Initialize zlib stream
1586                 ztk->zstream.next_in = ztk->input;
1587                 ztk->zstream.avail_in = 0;
1588
1589                 /* From Zlib's "unzip.c":
1590                  *
1591                  * windowBits is passed < 0 to tell that there is no zlib header.
1592                  * Note that in this case inflate *requires* an extra "dummy" byte
1593                  * after the compressed stream in order to complete decompression and
1594                  * return Z_STREAM_END.
1595                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1596                  * size of both compressed and uncompressed data
1597                  */
1598                 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1599                 {
1600                         Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1601                         close(dup_handle);
1602                         Mem_Free(file);
1603                         return NULL;
1604                 }
1605
1606                 ztk->zstream.next_out = file->buff;
1607                 ztk->zstream.avail_out = sizeof (file->buff);
1608
1609                 file->ztk = ztk;
1610         }
1611
1612         return file;
1613 }
1614
1615 /*
1616 ====================
1617 FS_CheckNastyPath
1618
1619 Return true if the path should be rejected due to one of the following:
1620 1: path elements that are non-portable
1621 2: path elements that would allow access to files outside the game directory,
1622    or are just not a good idea for a mod to be using.
1623 ====================
1624 */
1625 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1626 {
1627         // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1628         if (!path[0])
1629                 return 2;
1630
1631         // Windows: don't allow \ in filenames (windows-only), period.
1632         // (on Windows \ is a directory separator, but / is also supported)
1633         if (strstr(path, "\\"))
1634                 return 1; // non-portable
1635
1636         // Mac: don't allow Mac-only filenames - : is a directory separator
1637         // instead of /, but we rely on / working already, so there's no reason to
1638         // support a Mac-only path
1639         // Amiga and Windows: : tries to go to root of drive
1640         if (strstr(path, ":"))
1641                 return 1; // non-portable attempt to go to root of drive
1642
1643         // Amiga: // is parent directory
1644         if (strstr(path, "//"))
1645                 return 1; // non-portable attempt to go to parent directory
1646
1647         // all: don't allow going to parent directory (../ or /../)
1648         if (strstr(path, ".."))
1649                 return 2; // attempt to go outside the game directory
1650
1651         // Windows and UNIXes: don't allow absolute paths
1652         if (path[0] == '/')
1653                 return 2; // attempt to go outside the game directory
1654
1655         // all: don't allow . characters before the last slash (it should only be used in filenames, not path elements), this catches all imaginable cases of ./, ../, .../, etc
1656         if (strchr(path, '.'))
1657         {
1658                 if (isgamedir)
1659                 {
1660                         // gamedir is entirely path elements, so simply forbid . entirely
1661                         return 2;
1662                 }
1663                 if (strchr(path, '.') < strrchr(path, '/'))
1664                         return 2; // possible attempt to go outside the game directory
1665         }
1666
1667         // all: forbid trailing slash on gamedir
1668         if (isgamedir && path[strlen(path)-1] == '/')
1669                 return 2;
1670
1671         // all: forbid leading dot on any filename for any reason
1672         if (strstr(path, "/."))
1673                 return 2; // attempt to go outside the game directory
1674
1675         // after all these checks we're pretty sure it's a / separated filename
1676         // and won't do much if any harm
1677         return false;
1678 }
1679
1680
1681 /*
1682 ====================
1683 FS_FindFile
1684
1685 Look for a file in the packages and in the filesystem
1686
1687 Return the searchpath where the file was found (or NULL)
1688 and the file index in the package if relevant
1689 ====================
1690 */
1691 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1692 {
1693         searchpath_t *search;
1694         pack_t *pak;
1695
1696         // search through the path, one element at a time
1697         for (search = fs_searchpaths;search;search = search->next)
1698         {
1699                 // is the element a pak file?
1700                 if (search->pack)
1701                 {
1702                         int (*strcmp_funct) (const char* str1, const char* str2);
1703                         int left, right, middle;
1704
1705                         pak = search->pack;
1706                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1707
1708                         // Look for the file (binary search)
1709                         left = 0;
1710                         right = pak->numfiles - 1;
1711                         while (left <= right)
1712                         {
1713                                 int diff;
1714
1715                                 middle = (left + right) / 2;
1716                                 diff = strcmp_funct (pak->files[middle].name, name);
1717
1718                                 // Found it
1719                                 if (!diff)
1720                                 {
1721                                         if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1722                                         {
1723                                                 // yes, but the first one is empty so we treat it as not being there
1724                                                 if (!quiet && developer.integer >= 10)
1725                                                         Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1726
1727                                                 if (index != NULL)
1728                                                         *index = -1;
1729                                                 return NULL;
1730                                         }
1731
1732                                         if (!quiet && developer.integer >= 10)
1733                                                 Con_Printf("FS_FindFile: %s in %s\n",
1734                                                                         pak->files[middle].name, pak->filename);
1735
1736                                         if (index != NULL)
1737                                                 *index = middle;
1738                                         return search;
1739                                 }
1740
1741                                 // If we're too far in the list
1742                                 if (diff > 0)
1743                                         right = middle - 1;
1744                                 else
1745                                         left = middle + 1;
1746                         }
1747                 }
1748                 else
1749                 {
1750                         char netpath[MAX_OSPATH];
1751                         dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1752                         if (FS_SysFileExists (netpath))
1753                         {
1754                                 if (!quiet && developer.integer >= 10)
1755                                         Con_Printf("FS_FindFile: %s\n", netpath);
1756
1757                                 if (index != NULL)
1758                                         *index = -1;
1759                                 return search;
1760                         }
1761                 }
1762         }
1763
1764         if (!quiet && developer.integer >= 10)
1765                 Con_Printf("FS_FindFile: can't find %s\n", name);
1766
1767         if (index != NULL)
1768                 *index = -1;
1769         return NULL;
1770 }
1771
1772
1773 /*
1774 ===========
1775 FS_OpenReadFile
1776
1777 Look for a file in the search paths and open it in read-only mode
1778 ===========
1779 */
1780 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1781 {
1782         searchpath_t *search;
1783         int pack_ind;
1784
1785         search = FS_FindFile (filename, &pack_ind, quiet);
1786
1787         // Not found?
1788         if (search == NULL)
1789                 return NULL;
1790
1791         // Found in the filesystem?
1792         if (pack_ind < 0)
1793         {
1794                 char path [MAX_OSPATH];
1795                 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1796                 return FS_SysOpen (path, "rb", nonblocking);
1797         }
1798
1799         // So, we found it in a package...
1800         return FS_OpenPackedFile (search->pack, pack_ind);
1801 }
1802
1803
1804 /*
1805 =============================================================================
1806
1807 MAIN PUBLIC FUNCTIONS
1808
1809 =============================================================================
1810 */
1811
1812 /*
1813 ====================
1814 FS_Open
1815
1816 Open a file. The syntax is the same as fopen
1817 ====================
1818 */
1819 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1820 {
1821         if (FS_CheckNastyPath(filepath, false))
1822         {
1823                 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1824                 return NULL;
1825         }
1826
1827         // If the file is opened in "write", "append", or "read/write" mode
1828         if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1829         {
1830                 char real_path [MAX_OSPATH];
1831
1832                 // Open the file on disk directly
1833                 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1834
1835                 // Create directories up to the file
1836                 FS_CreatePath (real_path);
1837
1838                 return FS_SysOpen (real_path, mode, nonblocking);
1839         }
1840         // Else, we look at the various search paths and open the file in read-only mode
1841         else
1842                 return FS_OpenReadFile (filepath, quiet, nonblocking);
1843 }
1844
1845
1846 /*
1847 ====================
1848 FS_Close
1849
1850 Close a file
1851 ====================
1852 */
1853 int FS_Close (qfile_t* file)
1854 {
1855         if (close (file->handle))
1856                 return EOF;
1857
1858         if (file->ztk)
1859         {
1860                 qz_inflateEnd (&file->ztk->zstream);
1861                 Mem_Free (file->ztk);
1862         }
1863
1864         Mem_Free (file);
1865         return 0;
1866 }
1867
1868
1869 /*
1870 ====================
1871 FS_Write
1872
1873 Write "datasize" bytes into a file
1874 ====================
1875 */
1876 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1877 {
1878         fs_offset_t result;
1879
1880         // If necessary, seek to the exact file position we're supposed to be
1881         if (file->buff_ind != file->buff_len)
1882                 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1883
1884         // Purge cached data
1885         FS_Purge (file);
1886
1887         // Write the buffer and update the position
1888         result = write (file->handle, data, (fs_offset_t)datasize);
1889         file->position = lseek (file->handle, 0, SEEK_CUR);
1890         if (file->real_length < file->position)
1891                 file->real_length = file->position;
1892
1893         if (result < 0)
1894                 return 0;
1895
1896         return result;
1897 }
1898
1899
1900 /*
1901 ====================
1902 FS_Read
1903
1904 Read up to "buffersize" bytes from a file
1905 ====================
1906 */
1907 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1908 {
1909         fs_offset_t count, done;
1910
1911         if (buffersize == 0)
1912                 return 0;
1913
1914         // Get rid of the ungetc character
1915         if (file->ungetc != EOF)
1916         {
1917                 ((char*)buffer)[0] = file->ungetc;
1918                 buffersize--;
1919                 file->ungetc = EOF;
1920                 done = 1;
1921         }
1922         else
1923                 done = 0;
1924
1925         // First, we copy as many bytes as we can from "buff"
1926         if (file->buff_ind < file->buff_len)
1927         {
1928                 count = file->buff_len - file->buff_ind;
1929                 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1930                 done += count;
1931                 memcpy (buffer, &file->buff[file->buff_ind], count);
1932                 file->buff_ind += count;
1933
1934                 buffersize -= count;
1935                 if (buffersize == 0)
1936                         return done;
1937         }
1938
1939         // NOTE: at this point, the read buffer is always empty
1940
1941         // If the file isn't compressed
1942         if (! (file->flags & QFILE_FLAG_DEFLATED))
1943         {
1944                 fs_offset_t nb;
1945
1946                 // We must take care to not read after the end of the file
1947                 count = file->real_length - file->position;
1948
1949                 // If we have a lot of data to get, put them directly into "buffer"
1950                 if (buffersize > sizeof (file->buff) / 2)
1951                 {
1952                         if (count > (fs_offset_t)buffersize)
1953                                 count = (fs_offset_t)buffersize;
1954                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1955                         nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1956                         if (nb > 0)
1957                         {
1958                                 done += nb;
1959                                 file->position += nb;
1960
1961                                 // Purge cached data
1962                                 FS_Purge (file);
1963                         }
1964                 }
1965                 else
1966                 {
1967                         if (count > (fs_offset_t)sizeof (file->buff))
1968                                 count = (fs_offset_t)sizeof (file->buff);
1969                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1970                         nb = read (file->handle, file->buff, count);
1971                         if (nb > 0)
1972                         {
1973                                 file->buff_len = nb;
1974                                 file->position += nb;
1975
1976                                 // Copy the requested data in "buffer" (as much as we can)
1977                                 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1978                                 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1979                                 file->buff_ind = count;
1980                                 done += count;
1981                         }
1982                 }
1983
1984                 return done;
1985         }
1986
1987         // If the file is compressed, it's more complicated...
1988         // We cycle through a few operations until we have read enough data
1989         while (buffersize > 0)
1990         {
1991                 ztoolkit_t *ztk = file->ztk;
1992                 int error;
1993
1994                 // NOTE: at this point, the read buffer is always empty
1995
1996                 // If "input" is also empty, we need to refill it
1997                 if (ztk->in_ind == ztk->in_len)
1998                 {
1999                         // If we are at the end of the file
2000                         if (file->position == file->real_length)
2001                                 return done;
2002
2003                         count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2004                         if (count > (fs_offset_t)sizeof (ztk->input))
2005                                 count = (fs_offset_t)sizeof (ztk->input);
2006                         lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2007                         if (read (file->handle, ztk->input, count) != count)
2008                         {
2009                                 Con_Printf ("FS_Read: unexpected end of file\n");
2010                                 break;
2011                         }
2012
2013                         ztk->in_ind = 0;
2014                         ztk->in_len = count;
2015                         ztk->in_position += count;
2016                 }
2017
2018                 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2019                 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2020
2021                 // Now that we are sure we have compressed data available, we need to determine
2022                 // if it's better to inflate it in "file->buff" or directly in "buffer"
2023
2024                 // Inflate the data in "file->buff"
2025                 if (buffersize < sizeof (file->buff) / 2)
2026                 {
2027                         ztk->zstream.next_out = file->buff;
2028                         ztk->zstream.avail_out = sizeof (file->buff);
2029                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2030                         if (error != Z_OK && error != Z_STREAM_END)
2031                         {
2032                                 Con_Printf ("FS_Read: Can't inflate file\n");
2033                                 break;
2034                         }
2035                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2036
2037                         file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2038                         file->position += file->buff_len;
2039
2040                         // Copy the requested data in "buffer" (as much as we can)
2041                         count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2042                         memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2043                         file->buff_ind = count;
2044                 }
2045
2046                 // Else, we inflate directly in "buffer"
2047                 else
2048                 {
2049                         ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2050                         ztk->zstream.avail_out = (unsigned int)buffersize;
2051                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2052                         if (error != Z_OK && error != Z_STREAM_END)
2053                         {
2054                                 Con_Printf ("FS_Read: Can't inflate file\n");
2055                                 break;
2056                         }
2057                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2058
2059                         // How much data did it inflate?
2060                         count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2061                         file->position += count;
2062
2063                         // Purge cached data
2064                         FS_Purge (file);
2065                 }
2066
2067                 done += count;
2068                 buffersize -= count;
2069         }
2070
2071         return done;
2072 }
2073
2074
2075 /*
2076 ====================
2077 FS_Print
2078
2079 Print a string into a file
2080 ====================
2081 */
2082 int FS_Print (qfile_t* file, const char *msg)
2083 {
2084         return (int)FS_Write (file, msg, strlen (msg));
2085 }
2086
2087 /*
2088 ====================
2089 FS_Printf
2090
2091 Print a string into a file
2092 ====================
2093 */
2094 int FS_Printf(qfile_t* file, const char* format, ...)
2095 {
2096         int result;
2097         va_list args;
2098
2099         va_start (args, format);
2100         result = FS_VPrintf (file, format, args);
2101         va_end (args);
2102
2103         return result;
2104 }
2105
2106
2107 /*
2108 ====================
2109 FS_VPrintf
2110
2111 Print a string into a file
2112 ====================
2113 */
2114 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2115 {
2116         int len;
2117         fs_offset_t buff_size = MAX_INPUTLINE;
2118         char *tempbuff;
2119
2120         for (;;)
2121         {
2122                 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2123                 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2124                 if (len >= 0 && len < buff_size)
2125                         break;
2126                 Mem_Free (tempbuff);
2127                 buff_size *= 2;
2128         }
2129
2130         len = write (file->handle, tempbuff, len);
2131         Mem_Free (tempbuff);
2132
2133         return len;
2134 }
2135
2136
2137 /*
2138 ====================
2139 FS_Getc
2140
2141 Get the next character of a file
2142 ====================
2143 */
2144 int FS_Getc (qfile_t* file)
2145 {
2146         unsigned char c;
2147
2148         if (FS_Read (file, &c, 1) != 1)
2149                 return EOF;
2150
2151         return c;
2152 }
2153
2154
2155 /*
2156 ====================
2157 FS_UnGetc
2158
2159 Put a character back into the read buffer (only supports one character!)
2160 ====================
2161 */
2162 int FS_UnGetc (qfile_t* file, unsigned char c)
2163 {
2164         // If there's already a character waiting to be read
2165         if (file->ungetc != EOF)
2166                 return EOF;
2167
2168         file->ungetc = c;
2169         return c;
2170 }
2171
2172
2173 /*
2174 ====================
2175 FS_Seek
2176
2177 Move the position index in a file
2178 ====================
2179 */
2180 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2181 {
2182         ztoolkit_t *ztk;
2183         unsigned char* buffer;
2184         fs_offset_t buffersize;
2185
2186         // Compute the file offset
2187         switch (whence)
2188         {
2189                 case SEEK_CUR:
2190                         offset += file->position - file->buff_len + file->buff_ind;
2191                         break;
2192
2193                 case SEEK_SET:
2194                         break;
2195
2196                 case SEEK_END:
2197                         offset += file->real_length;
2198                         break;
2199
2200                 default:
2201                         return -1;
2202         }
2203         if (offset < 0 || offset > file->real_length)
2204                 return -1;
2205
2206         // If we have the data in our read buffer, we don't need to actually seek
2207         if (file->position - file->buff_len <= offset && offset <= file->position)
2208         {
2209                 file->buff_ind = offset + file->buff_len - file->position;
2210                 return 0;
2211         }
2212
2213         // Purge cached data
2214         FS_Purge (file);
2215
2216         // Unpacked or uncompressed files can seek directly
2217         if (! (file->flags & QFILE_FLAG_DEFLATED))
2218         {
2219                 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2220                         return -1;
2221                 file->position = offset;
2222                 return 0;
2223         }
2224
2225         // Seeking in compressed files is more a hack than anything else,
2226         // but we need to support it, so here we go.
2227         ztk = file->ztk;
2228
2229         // If we have to go back in the file, we need to restart from the beginning
2230         if (offset <= file->position)
2231         {
2232                 ztk->in_ind = 0;
2233                 ztk->in_len = 0;
2234                 ztk->in_position = 0;
2235                 file->position = 0;
2236                 lseek (file->handle, file->offset, SEEK_SET);
2237
2238                 // Reset the Zlib stream
2239                 ztk->zstream.next_in = ztk->input;
2240                 ztk->zstream.avail_in = 0;
2241                 qz_inflateReset (&ztk->zstream);
2242         }
2243
2244         // We need a big buffer to force inflating into it directly
2245         buffersize = 2 * sizeof (file->buff);
2246         buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2247
2248         // Skip all data until we reach the requested offset
2249         while (offset > file->position)
2250         {
2251                 fs_offset_t diff = offset - file->position;
2252                 fs_offset_t count, len;
2253
2254                 count = (diff > buffersize) ? buffersize : diff;
2255                 len = FS_Read (file, buffer, count);
2256                 if (len != count)
2257                 {
2258                         Mem_Free (buffer);
2259                         return -1;
2260                 }
2261         }
2262
2263         Mem_Free (buffer);
2264         return 0;
2265 }
2266
2267
2268 /*
2269 ====================
2270 FS_Tell
2271
2272 Give the current position in a file
2273 ====================
2274 */
2275 fs_offset_t FS_Tell (qfile_t* file)
2276 {
2277         return file->position - file->buff_len + file->buff_ind;
2278 }
2279
2280
2281 /*
2282 ====================
2283 FS_FileSize
2284
2285 Give the total size of a file
2286 ====================
2287 */
2288 fs_offset_t FS_FileSize (qfile_t* file)
2289 {
2290         return file->real_length;
2291 }
2292
2293
2294 /*
2295 ====================
2296 FS_Purge
2297
2298 Erases any buffered input or output data
2299 ====================
2300 */
2301 void FS_Purge (qfile_t* file)
2302 {
2303         file->buff_len = 0;
2304         file->buff_ind = 0;
2305         file->ungetc = EOF;
2306 }
2307
2308
2309 /*
2310 ============
2311 FS_LoadFile
2312
2313 Filename are relative to the quake directory.
2314 Always appends a 0 byte.
2315 ============
2316 */
2317 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2318 {
2319         qfile_t *file;
2320         unsigned char *buf = NULL;
2321         fs_offset_t filesize = 0;
2322
2323         file = FS_Open (path, "rb", quiet, false);
2324         if (file)
2325         {
2326                 filesize = file->real_length;
2327                 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2328                 buf[filesize] = '\0';
2329                 FS_Read (file, buf, filesize);
2330                 FS_Close (file);
2331         }
2332
2333         if (filesizepointer)
2334                 *filesizepointer = filesize;
2335         return buf;
2336 }
2337
2338
2339 /*
2340 ============
2341 FS_WriteFile
2342
2343 The filename will be prefixed by the current game directory
2344 ============
2345 */
2346 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2347 {
2348         qfile_t *file;
2349
2350         file = FS_Open (filename, "wb", false, false);
2351         if (!file)
2352         {
2353                 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2354                 return false;
2355         }
2356
2357         Con_DPrintf("FS_WriteFile: %s\n", filename);
2358         FS_Write (file, data, len);
2359         FS_Close (file);
2360         return true;
2361 }
2362
2363
2364 /*
2365 =============================================================================
2366
2367 OTHERS PUBLIC FUNCTIONS
2368
2369 =============================================================================
2370 */
2371
2372 /*
2373 ============
2374 FS_StripExtension
2375 ============
2376 */
2377 void FS_StripExtension (const char *in, char *out, size_t size_out)
2378 {
2379         char *last = NULL;
2380         char currentchar;
2381
2382         if (size_out == 0)
2383                 return;
2384
2385         while ((currentchar = *in) && size_out > 1)
2386         {
2387                 if (currentchar == '.')
2388                         last = out;
2389                 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2390                         last = NULL;
2391                 *out++ = currentchar;
2392                 in++;
2393                 size_out--;
2394         }
2395         if (last)
2396                 *last = 0;
2397         else
2398                 *out = 0;
2399 }
2400
2401
2402 /*
2403 ==================
2404 FS_DefaultExtension
2405 ==================
2406 */
2407 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2408 {
2409         const char *src;
2410
2411         // if path doesn't have a .EXT, append extension
2412         // (extension should include the .)
2413         src = path + strlen(path) - 1;
2414
2415         while (*src != '/' && src != path)
2416         {
2417                 if (*src == '.')
2418                         return;                 // it has an extension
2419                 src--;
2420         }
2421
2422         strlcat (path, extension, size_path);
2423 }
2424
2425
2426 /*
2427 ==================
2428 FS_FileExists
2429
2430 Look for a file in the packages and in the filesystem
2431 ==================
2432 */
2433 qboolean FS_FileExists (const char *filename)
2434 {
2435         return (FS_FindFile (filename, NULL, true) != NULL);
2436 }
2437
2438
2439 /*
2440 ==================
2441 FS_SysFileExists
2442
2443 Look for a file in the filesystem only
2444 ==================
2445 */
2446 qboolean FS_SysFileExists (const char *path)
2447 {
2448 #if WIN32
2449         int desc;
2450
2451         // TODO: use another function instead, to avoid opening the file
2452         desc = open (path, O_RDONLY | O_BINARY);
2453         if (desc < 0)
2454                 return false;
2455
2456         close (desc);
2457         return true;
2458 #else
2459         struct stat buf;
2460
2461         if (stat (path,&buf) == -1)
2462                 return false;
2463
2464         return true;
2465 #endif
2466 }
2467
2468 void FS_mkdir (const char *path)
2469 {
2470 #if WIN32
2471         _mkdir (path);
2472 #else
2473         mkdir (path, 0777);
2474 #endif
2475 }
2476
2477 /*
2478 ===========
2479 FS_Search
2480
2481 Allocate and fill a search structure with information on matching filenames.
2482 ===========
2483 */
2484 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2485 {
2486         fssearch_t *search;
2487         searchpath_t *searchpath;
2488         pack_t *pak;
2489         int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2490         stringlist_t resultlist;
2491         stringlist_t dirlist;
2492         const char *slash, *backslash, *colon, *separator;
2493         char *basepath;
2494         char netpath[MAX_OSPATH];
2495         char temp[MAX_OSPATH];
2496
2497         for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2498                 ;
2499
2500         if (i > 0)
2501         {
2502                 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2503                 return NULL;
2504         }
2505
2506         stringlistinit(&resultlist);
2507         stringlistinit(&dirlist);
2508         search = NULL;
2509         slash = strrchr(pattern, '/');
2510         backslash = strrchr(pattern, '\\');
2511         colon = strrchr(pattern, ':');
2512         separator = max(slash, backslash);
2513         separator = max(separator, colon);
2514         basepathlength = separator ? (separator + 1 - pattern) : 0;
2515         basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2516         if (basepathlength)
2517                 memcpy(basepath, pattern, basepathlength);
2518         basepath[basepathlength] = 0;
2519
2520         // search through the path, one element at a time
2521         for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2522         {
2523                 // is the element a pak file?
2524                 if (searchpath->pack)
2525                 {
2526                         // look through all the pak file elements
2527                         pak = searchpath->pack;
2528                         for (i = 0;i < pak->numfiles;i++)
2529                         {
2530                                 strlcpy(temp, pak->files[i].name, sizeof(temp));
2531                                 while (temp[0])
2532                                 {
2533                                         if (matchpattern(temp, (char *)pattern, true))
2534                                         {
2535                                                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2536                                                         if (!strcmp(resultlist.strings[resultlistindex], temp))
2537                                                                 break;
2538                                                 if (resultlistindex == resultlist.numstrings)
2539                                                 {
2540                                                         stringlistappend(&resultlist, temp);
2541                                                         if (!quiet)
2542                                                                 Con_DPrintf("SearchPackFile: %s : %s\n", pak->filename, temp);
2543                                                 }
2544                                         }
2545                                         // strip off one path element at a time until empty
2546                                         // this way directories are added to the listing if they match the pattern
2547                                         slash = strrchr(temp, '/');
2548                                         backslash = strrchr(temp, '\\');
2549                                         colon = strrchr(temp, ':');
2550                                         separator = temp;
2551                                         if (separator < slash)
2552                                                 separator = slash;
2553                                         if (separator < backslash)
2554                                                 separator = backslash;
2555                                         if (separator < colon)
2556                                                 separator = colon;
2557                                         *((char *)separator) = 0;
2558                                 }
2559                         }
2560                 }
2561                 else
2562                 {
2563                         // get a directory listing and look at each name
2564                         dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2565                         stringlistinit(&dirlist);
2566                         listdirectory(&dirlist, netpath);
2567                         for (dirlistindex = 0;dirlistindex < dirlist.numstrings;dirlistindex++)
2568                         {
2569                                 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirlist.strings[dirlistindex]);
2570                                 if (matchpattern(temp, (char *)pattern, true))
2571                                 {
2572                                         for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2573                                                 if (!strcmp(resultlist.strings[resultlistindex], temp))
2574                                                         break;
2575                                         if (resultlistindex == resultlist.numstrings)
2576                                         {
2577                                                 stringlistappend(&resultlist, temp);
2578                                                 if (!quiet)
2579                                                         Con_DPrintf("SearchDirFile: %s\n", temp);
2580                                         }
2581                                 }
2582                         }
2583                         stringlistfreecontents(&dirlist);
2584                 }
2585         }
2586
2587         if (resultlist.numstrings)
2588         {
2589                 stringlistsort(&resultlist);
2590                 numfiles = resultlist.numstrings;
2591                 numchars = 0;
2592                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2593                         numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2594                 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2595                 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2596                 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2597                 search->numfilenames = (int)numfiles;
2598                 numfiles = 0;
2599                 numchars = 0;
2600                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2601                 {
2602                         size_t textlen;
2603                         search->filenames[numfiles] = search->filenamesbuffer + numchars;
2604                         textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2605                         memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2606                         numfiles++;
2607                         numchars += (int)textlen;
2608                 }
2609         }
2610         stringlistfreecontents(&resultlist);
2611
2612         Mem_Free(basepath);
2613         return search;
2614 }
2615
2616 void FS_FreeSearch(fssearch_t *search)
2617 {
2618         Z_Free(search);
2619 }
2620
2621 extern int con_linewidth;
2622 int FS_ListDirectory(const char *pattern, int oneperline)
2623 {
2624         int numfiles;
2625         int numcolumns;
2626         int numlines;
2627         int columnwidth;
2628         int linebufpos;
2629         int i, j, k, l;
2630         const char *name;
2631         char linebuf[MAX_INPUTLINE];
2632         fssearch_t *search;
2633         search = FS_Search(pattern, true, true);
2634         if (!search)
2635                 return 0;
2636         numfiles = search->numfilenames;
2637         if (!oneperline)
2638         {
2639                 // FIXME: the names could be added to one column list and then
2640                 // gradually shifted into the next column if they fit, and then the
2641                 // next to make a compact variable width listing but it's a lot more
2642                 // complicated...
2643                 // find width for columns
2644                 columnwidth = 0;
2645                 for (i = 0;i < numfiles;i++)
2646                 {
2647                         l = (int)strlen(search->filenames[i]);
2648                         if (columnwidth < l)
2649                                 columnwidth = l;
2650                 }
2651                 // count the spacing character
2652                 columnwidth++;
2653                 // calculate number of columns
2654                 numcolumns = con_linewidth / columnwidth;
2655                 // don't bother with the column printing if it's only one column
2656                 if (numcolumns >= 2)
2657                 {
2658                         numlines = (numfiles + numcolumns - 1) / numcolumns;
2659                         for (i = 0;i < numlines;i++)
2660                         {
2661                                 linebufpos = 0;
2662                                 for (k = 0;k < numcolumns;k++)
2663                                 {
2664                                         l = i * numcolumns + k;
2665                                         if (l < numfiles)
2666                                         {
2667                                                 name = search->filenames[l];
2668                                                 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2669                                                         linebuf[linebufpos++] = name[j];
2670                                                 // space out name unless it's the last on the line
2671                                                 if (k + 1 < numcolumns && l + 1 < numfiles)
2672                                                         for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2673                                                                 linebuf[linebufpos++] = ' ';
2674                                         }
2675                                 }
2676                                 linebuf[linebufpos] = 0;
2677                                 Con_Printf("%s\n", linebuf);
2678                         }
2679                 }
2680                 else
2681                         oneperline = true;
2682         }
2683         if (oneperline)
2684                 for (i = 0;i < numfiles;i++)
2685                         Con_Printf("%s\n", search->filenames[i]);
2686         FS_FreeSearch(search);
2687         return (int)numfiles;
2688 }
2689
2690 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2691 {
2692         const char *pattern;
2693         if (Cmd_Argc() > 3)
2694         {
2695                 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2696                 return;
2697         }
2698         if (Cmd_Argc() == 2)
2699                 pattern = Cmd_Argv(1);
2700         else
2701                 pattern = "*";
2702         if (!FS_ListDirectory(pattern, oneperline))
2703                 Con_Print("No files found.\n");
2704 }
2705
2706 void FS_Dir_f(void)
2707 {
2708         FS_ListDirectoryCmd("dir", true);
2709 }
2710
2711 void FS_Ls_f(void)
2712 {
2713         FS_ListDirectoryCmd("ls", false);
2714 }
2715
2716 const char *FS_WhichPack(const char *filename)
2717 {
2718         int index;
2719         searchpath_t *sp = FS_FindFile(filename, &index, true);
2720         if(sp && sp->pack)
2721                 return sp->pack->filename;
2722         else
2723                 return 0;
2724 }
2725
2726 /*
2727 ====================
2728 FS_IsRegisteredQuakePack
2729
2730 Look for a proof of purchase file file in the requested package
2731
2732 If it is found, this file should NOT be downloaded.
2733 ====================
2734 */
2735 qboolean FS_IsRegisteredQuakePack(const char *name)
2736 {
2737         searchpath_t *search;
2738         pack_t *pak;
2739
2740         // search through the path, one element at a time
2741         for (search = fs_searchpaths;search;search = search->next)
2742         {
2743                 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2744                 {
2745                         int (*strcmp_funct) (const char* str1, const char* str2);
2746                         int left, right, middle;
2747
2748                         pak = search->pack;
2749                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2750
2751                         // Look for the file (binary search)
2752                         left = 0;
2753                         right = pak->numfiles - 1;
2754                         while (left <= right)
2755                         {
2756                                 int diff;
2757
2758                                 middle = (left + right) / 2;
2759                                 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2760
2761                                 // Found it
2762                                 if (!diff)
2763                                         return true;
2764
2765                                 // If we're too far in the list
2766                                 if (diff > 0)
2767                                         right = middle - 1;
2768                                 else
2769                                         left = middle + 1;
2770                         }
2771
2772                         // we found the requested pack but it is not registered quake
2773                         return false;
2774                 }
2775         }
2776
2777         return false;
2778 }
2779
2780 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2781 {
2782         int crc = -1;
2783         unsigned char *filedata;
2784         fs_offset_t filesize;
2785         if (filesizepointer)
2786                 *filesizepointer = 0;
2787         if (!filename || !*filename)
2788                 return crc;
2789         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2790         if (filedata)
2791         {
2792                 if (filesizepointer)
2793                         *filesizepointer = filesize;
2794                 crc = CRC_Block(filedata, filesize);
2795                 Mem_Free(filedata);
2796         }
2797         return crc;
2798 }
2799