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