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 #else
1027         homedir = getenv ("HOME");
1028         if(homedir)
1029                 dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
1030 #endif
1031
1032 #ifdef WIN32
1033         if(!COM_CheckParm("-mygames"))
1034         {
1035                 int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
1036                 if(fd >= 0)
1037                 {
1038                         close(fd);
1039                         *userdir = 0; // we have write access to the game dir, so let's use it
1040                 }
1041         }
1042 #endif
1043
1044         if(COM_CheckParm("-nohome"))
1045                 *userdir = 0;
1046
1047         if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
1048                 dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
1049
1050         if (*userdir)
1051                 FS_AddGameDirectory(va("%s%s/", userdir, dir));
1052 }
1053
1054
1055 /*
1056 ============
1057 FS_FileExtension
1058 ============
1059 */
1060 const char *FS_FileExtension (const char *in)
1061 {
1062         const char *separator, *backslash, *colon, *dot;
1063
1064         separator = strrchr(in, '/');
1065         backslash = strrchr(in, '\\');
1066         if (!separator || separator < backslash)
1067                 separator = backslash;
1068         colon = strrchr(in, ':');
1069         if (!separator || separator < colon)
1070                 separator = colon;
1071
1072         dot = strrchr(in, '.');
1073         if (dot == NULL || (separator && (dot < separator)))
1074                 return "";
1075
1076         return dot + 1;
1077 }
1078
1079
1080 /*
1081 ============
1082 FS_FileWithoutPath
1083 ============
1084 */
1085 const char *FS_FileWithoutPath (const char *in)
1086 {
1087         const char *separator, *backslash, *colon;
1088
1089         separator = strrchr(in, '/');
1090         backslash = strrchr(in, '\\');
1091         if (!separator || separator < backslash)
1092                 separator = backslash;
1093         colon = strrchr(in, ':');
1094         if (!separator || separator < colon)
1095                 separator = colon;
1096         return separator ? separator + 1 : in;
1097 }
1098
1099
1100 /*
1101 ================
1102 FS_ClearSearchPath
1103 ================
1104 */
1105 void FS_ClearSearchPath (void)
1106 {
1107         // unload all packs and directory information, close all pack files
1108         // (if a qfile is still reading a pack it won't be harmed because it used
1109         //  dup() to get its own handle already)
1110         while (fs_searchpaths)
1111         {
1112                 searchpath_t *search = fs_searchpaths;
1113                 fs_searchpaths = search->next;
1114                 if (search->pack)
1115                 {
1116                         // close the file
1117                         close(search->pack->handle);
1118                         // free any memory associated with it
1119                         if (search->pack->files)
1120                                 Mem_Free(search->pack->files);
1121                         Mem_Free(search->pack);
1122                 }
1123                 Mem_Free(search);
1124         }
1125 }
1126
1127
1128 /*
1129 ================
1130 FS_Rescan
1131 ================
1132 */
1133 void FS_Rescan (void)
1134 {
1135         int i;
1136         qboolean fs_modified = false;
1137
1138         FS_ClearSearchPath();
1139
1140         // add the game-specific paths
1141         // gamedirname1 (typically id1)
1142         FS_AddGameHierarchy (gamedirname1);
1143         // update the com_modname (used for server info)
1144         strlcpy(com_modname, gamedirname1, sizeof(com_modname));
1145
1146         // add the game-specific path, if any
1147         // (only used for mission packs and the like, which should set fs_modified)
1148         if (gamedirname2)
1149         {
1150                 fs_modified = true;
1151                 FS_AddGameHierarchy (gamedirname2);
1152         }
1153
1154         // -game <gamedir>
1155         // Adds basedir/gamedir as an override game
1156         // LordHavoc: now supports multiple -game directories
1157         // set the com_modname (reported in server info)
1158         for (i = 0;i < fs_numgamedirs;i++)
1159         {
1160                 fs_modified = true;
1161                 FS_AddGameHierarchy (fs_gamedirs[i]);
1162                 // update the com_modname (used server info)
1163                 strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
1164         }
1165
1166         // set the default screenshot name to either the mod name or the
1167         // gamemode screenshot name
1168         if (strcmp(com_modname, gamedirname1))
1169                 Cvar_SetQuick (&scr_screenshot_name, com_modname);
1170         else
1171                 Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
1172
1173         // If "-condebug" is in the command line, remove the previous log file
1174         if (COM_CheckParm ("-condebug") != 0)
1175                 unlink (va("%s/qconsole.log", fs_gamedir));
1176
1177         // look for the pop.lmp file and set registered to true if it is found
1178         if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
1179         {
1180                 if (fs_modified)
1181                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1182                 else
1183                         Con_Print("Playing shareware version.\n");
1184         }
1185         else
1186         {
1187                 Cvar_Set ("registered", "1");
1188                 if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1189                         Con_Print("Playing registered version.\n");
1190         }
1191
1192         // unload all wads so that future queries will return the new data
1193         W_UnloadAll();
1194 }
1195
1196 void FS_Rescan_f(void)
1197 {
1198         FS_Rescan();
1199 }
1200
1201 /*
1202 ================
1203 FS_ChangeGameDirs
1204 ================
1205 */
1206 extern void Host_SaveConfig (void);
1207 extern void Host_LoadConfig_f (void);
1208 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
1209 {
1210         int i;
1211
1212         if (fs_numgamedirs == numgamedirs)
1213         {
1214                 for (i = 0;i < numgamedirs;i++)
1215                         if (strcasecmp(fs_gamedirs[i], gamedirs[i]))
1216                                 break;
1217                 if (i == numgamedirs)
1218                         return true; // already using this set of gamedirs, do nothing
1219         }
1220
1221         if (numgamedirs > MAX_GAMEDIRS)
1222         {
1223                 if (complain)
1224                         Con_Printf("That is too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1225                 return false; // too many gamedirs
1226         }
1227
1228         for (i = 0;i < numgamedirs;i++)
1229         {
1230                 // if string is nasty, reject it
1231                 if(FS_CheckNastyPath(gamedirs[i], true))
1232                 {
1233                         if (complain)
1234                                 Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
1235                         return false; // nasty gamedirs
1236                 }
1237         }
1238
1239         for (i = 0;i < numgamedirs;i++)
1240         {
1241                 if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
1242                 {
1243                         if (complain)
1244                                 Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
1245                         return false; // missing gamedirs
1246                 }
1247         }
1248
1249         Host_SaveConfig();
1250
1251         fs_numgamedirs = numgamedirs;
1252         for (i = 0;i < fs_numgamedirs;i++)
1253                 strlcpy(fs_gamedirs[i], gamedirs[i], sizeof(fs_gamedirs[i]));
1254
1255         // reinitialize filesystem to detect the new paks
1256         FS_Rescan();
1257
1258         // exec the new config
1259         Host_LoadConfig_f();
1260
1261         // unload all sounds so they will be reloaded from the new files as needed
1262         S_UnloadAllSounds_f();
1263
1264         // reinitialize renderer (this reloads hud/console background/etc)
1265         R_Modules_Restart();
1266
1267         return true;
1268 }
1269
1270 /*
1271 ================
1272 FS_GameDir_f
1273 ================
1274 */
1275 void FS_GameDir_f (void)
1276 {
1277         int i;
1278         int numgamedirs;
1279         char gamedirs[MAX_GAMEDIRS][MAX_QPATH];
1280
1281         if (Cmd_Argc() < 2)
1282         {
1283                 Con_Printf("gamedirs active:");
1284                 for (i = 0;i < fs_numgamedirs;i++)
1285                         Con_Printf(" %s", fs_gamedirs[i]);
1286                 Con_Printf("\n");
1287                 return;
1288         }
1289
1290         numgamedirs = Cmd_Argc() - 1;
1291         if (numgamedirs > MAX_GAMEDIRS)
1292         {
1293                 Con_Printf("Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
1294                 return;
1295         }
1296
1297         for (i = 0;i < numgamedirs;i++)
1298                 strlcpy(gamedirs[i], Cmd_Argv(i+1), sizeof(gamedirs[i]));
1299
1300         if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
1301         {
1302                 // actually, changing during game would work fine, but would be stupid
1303                 Con_Printf("Can not change gamedir while client is connected or server is running!\n");
1304                 return;
1305         }
1306
1307         // halt demo playback to close the file
1308         CL_Disconnect();
1309
1310         FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
1311 }
1312
1313
1314 /*
1315 ================
1316 FS_CheckGameDir
1317 ================
1318 */
1319 qboolean FS_CheckGameDir(const char *gamedir)
1320 {
1321         qboolean success;
1322         stringlist_t list;
1323         stringlistinit(&list);
1324         listdirectory(&list, va("%s%s/", fs_basedir, gamedir));
1325         success = list.numstrings > 0;
1326         stringlistfreecontents(&list);
1327         return success;
1328 }
1329
1330
1331 /*
1332 ================
1333 FS_Init
1334 ================
1335 */
1336 void FS_Init (void)
1337 {
1338         int i;
1339
1340         fs_mempool = Mem_AllocPool("file management", 0, NULL);
1341
1342         strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
1343
1344 // If the base directory is explicitly defined by the compilation process
1345 #ifdef DP_FS_BASEDIR
1346         strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
1347 #else
1348         strlcpy(fs_basedir, "", sizeof(fs_basedir));
1349
1350 #ifdef MACOSX
1351         // FIXME: is there a better way to find the directory outside the .app?
1352         if (strstr(com_argv[0], ".app/"))
1353         {
1354                 char *split;
1355
1356                 split = strstr(com_argv[0], ".app/");
1357                 while (split > com_argv[0] && *split != '/')
1358                         split--;
1359                 strlcpy(fs_basedir, com_argv[0], sizeof(fs_basedir));
1360                 fs_basedir[split - com_argv[0]] = 0;
1361         }
1362 #endif
1363 #endif
1364
1365         PK3_OpenLibrary ();
1366
1367         // -basedir <path>
1368         // Overrides the system supplied base directory (under GAMENAME)
1369 // 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)
1370         i = COM_CheckParm ("-basedir");
1371         if (i && i < com_argc-1)
1372         {
1373                 strlcpy (fs_basedir, com_argv[i+1], sizeof (fs_basedir));
1374                 i = (int)strlen (fs_basedir);
1375                 if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
1376                         fs_basedir[i-1] = 0;
1377         }
1378
1379         // add a path separator to the end of the basedir if it lacks one
1380         if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
1381                 strlcat(fs_basedir, "/", sizeof(fs_basedir));
1382
1383         if (!FS_CheckGameDir(gamedirname1))
1384                 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
1385
1386         if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
1387                 Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
1388
1389         // -game <gamedir>
1390         // Adds basedir/gamedir as an override game
1391         // LordHavoc: now supports multiple -game directories
1392         for (i = 1;i < com_argc && fs_numgamedirs < MAX_GAMEDIRS;i++)
1393         {
1394                 if (!com_argv[i])
1395                         continue;
1396                 if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
1397                 {
1398                         i++;
1399                         if (FS_CheckNastyPath(com_argv[i], true))
1400                                 Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
1401                         if (!FS_CheckGameDir(com_argv[i]))
1402                                 Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
1403                         // add the gamedir to the list of active gamedirs
1404                         strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
1405                         fs_numgamedirs++;
1406                 }
1407         }
1408
1409         // generate the searchpath
1410         FS_Rescan();
1411 }
1412
1413 void FS_Init_Commands(void)
1414 {
1415         Cvar_RegisterVariable (&scr_screenshot_name);
1416         Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
1417
1418         Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
1419         Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
1420         Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
1421         Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
1422         Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
1423 }
1424
1425 /*
1426 ================
1427 FS_Shutdown
1428 ================
1429 */
1430 void FS_Shutdown (void)
1431 {
1432         // close all pack files and such
1433         // (hopefully there aren't any other open files, but they'll be cleaned up
1434         //  by the OS anyway)
1435         FS_ClearSearchPath();
1436         Mem_FreePool (&fs_mempool);
1437 }
1438
1439 /*
1440 ====================
1441 FS_SysOpen
1442
1443 Internal function used to create a qfile_t and open the relevant non-packed file on disk
1444 ====================
1445 */
1446 static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
1447 {
1448         qfile_t* file;
1449         int mod, opt;
1450         unsigned int ind;
1451
1452         // Parse the mode string
1453         switch (mode[0])
1454         {
1455                 case 'r':
1456                         mod = O_RDONLY;
1457                         opt = 0;
1458                         break;
1459                 case 'w':
1460                         mod = O_WRONLY;
1461                         opt = O_CREAT | O_TRUNC;
1462                         break;
1463                 case 'a':
1464                         mod = O_WRONLY;
1465                         opt = O_CREAT | O_APPEND;
1466                         break;
1467                 default:
1468                         Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
1469                         return NULL;
1470         }
1471         for (ind = 1; mode[ind] != '\0'; ind++)
1472         {
1473                 switch (mode[ind])
1474                 {
1475                         case '+':
1476                                 mod = O_RDWR;
1477                                 break;
1478                         case 'b':
1479                                 opt |= O_BINARY;
1480                                 break;
1481                         default:
1482                                 Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
1483                                                         filepath, mode, mode[ind]);
1484                 }
1485         }
1486
1487         if (nonblocking)
1488                 opt |= O_NONBLOCK;
1489
1490         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1491         memset (file, 0, sizeof (*file));
1492         file->ungetc = EOF;
1493
1494         file->handle = open (filepath, mod | opt, 0666);
1495         if (file->handle < 0)
1496         {
1497                 Mem_Free (file);
1498                 return NULL;
1499         }
1500
1501         file->real_length = lseek (file->handle, 0, SEEK_END);
1502
1503         // For files opened in append mode, we start at the end of the file
1504         if (mod & O_APPEND)
1505                 file->position = file->real_length;
1506         else
1507                 lseek (file->handle, 0, SEEK_SET);
1508
1509         return file;
1510 }
1511
1512
1513 /*
1514 ===========
1515 FS_OpenPackedFile
1516
1517 Open a packed file using its package file descriptor
1518 ===========
1519 */
1520 qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
1521 {
1522         packfile_t *pfile;
1523         int dup_handle;
1524         qfile_t* file;
1525
1526         pfile = &pack->files[pack_ind];
1527
1528         // If we don't have the true offset, get it now
1529         if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
1530                 if (!PK3_GetTrueFileOffset (pfile, pack))
1531                         return NULL;
1532
1533         // No Zlib DLL = no compressed files
1534         if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
1535         {
1536                 Con_Printf("WARNING: can't open the compressed file %s\n"
1537                                         "You need the Zlib DLL to use compressed files\n",
1538                                         pfile->name);
1539                 return NULL;
1540         }
1541
1542         // LordHavoc: lseek affects all duplicates of a handle so we do it before
1543         // the dup() call to avoid having to close the dup_handle on error here
1544         if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
1545         {
1546                 Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)\n",
1547                                         pfile->name, pack->filename, (int) pfile->offset);
1548                 return NULL;
1549         }
1550
1551         dup_handle = dup (pack->handle);
1552         if (dup_handle < 0)
1553         {
1554                 Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
1555                 return NULL;
1556         }
1557
1558         file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
1559         memset (file, 0, sizeof (*file));
1560         file->handle = dup_handle;
1561         file->flags = QFILE_FLAG_PACKED;
1562         file->real_length = pfile->realsize;
1563         file->offset = pfile->offset;
1564         file->position = 0;
1565         file->ungetc = EOF;
1566
1567         if (pfile->flags & PACKFILE_FLAG_DEFLATED)
1568         {
1569                 ztoolkit_t *ztk;
1570
1571                 file->flags |= QFILE_FLAG_DEFLATED;
1572
1573                 // We need some more variables
1574                 ztk = (ztoolkit_t *)Mem_Alloc (fs_mempool, sizeof (*ztk));
1575
1576                 ztk->comp_length = pfile->packsize;
1577
1578                 // Initialize zlib stream
1579                 ztk->zstream.next_in = ztk->input;
1580                 ztk->zstream.avail_in = 0;
1581
1582                 /* From Zlib's "unzip.c":
1583                  *
1584                  * windowBits is passed < 0 to tell that there is no zlib header.
1585                  * Note that in this case inflate *requires* an extra "dummy" byte
1586                  * after the compressed stream in order to complete decompression and
1587                  * return Z_STREAM_END.
1588                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1589                  * size of both compressed and uncompressed data
1590                  */
1591                 if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
1592                 {
1593                         Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
1594                         close(dup_handle);
1595                         Mem_Free(file);
1596                         return NULL;
1597                 }
1598
1599                 ztk->zstream.next_out = file->buff;
1600                 ztk->zstream.avail_out = sizeof (file->buff);
1601
1602                 file->ztk = ztk;
1603         }
1604
1605         return file;
1606 }
1607
1608 /*
1609 ====================
1610 FS_CheckNastyPath
1611
1612 Return true if the path should be rejected due to one of the following:
1613 1: path elements that are non-portable
1614 2: path elements that would allow access to files outside the game directory,
1615    or are just not a good idea for a mod to be using.
1616 ====================
1617 */
1618 int FS_CheckNastyPath (const char *path, qboolean isgamedir)
1619 {
1620         // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
1621         if (!path[0])
1622                 return 2;
1623
1624         // Windows: don't allow \ in filenames (windows-only), period.
1625         // (on Windows \ is a directory separator, but / is also supported)
1626         if (strstr(path, "\\"))
1627                 return 1; // non-portable
1628
1629         // Mac: don't allow Mac-only filenames - : is a directory separator
1630         // instead of /, but we rely on / working already, so there's no reason to
1631         // support a Mac-only path
1632         // Amiga and Windows: : tries to go to root of drive
1633         if (strstr(path, ":"))
1634                 return 1; // non-portable attempt to go to root of drive
1635
1636         // Amiga: // is parent directory
1637         if (strstr(path, "//"))
1638                 return 1; // non-portable attempt to go to parent directory
1639
1640         // all: don't allow going to parent directory (../ or /../)
1641         if (strstr(path, ".."))
1642                 return 2; // attempt to go outside the game directory
1643
1644         // Windows and UNIXes: don't allow absolute paths
1645         if (path[0] == '/')
1646                 return 2; // attempt to go outside the game directory
1647
1648         // 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
1649         if (strchr(path, '.'))
1650         {
1651                 if (isgamedir)
1652                 {
1653                         // gamedir is entirely path elements, so simply forbid . entirely
1654                         return 2;
1655                 }
1656                 if (strchr(path, '.') < strrchr(path, '/'))
1657                         return 2; // possible attempt to go outside the game directory
1658         }
1659
1660         // all: forbid trailing slash on gamedir
1661         if (isgamedir && path[strlen(path)-1] == '/')
1662                 return 2;
1663
1664         // all: forbid leading dot on any filename for any reason
1665         if (strstr(path, "/."))
1666                 return 2; // attempt to go outside the game directory
1667
1668         // after all these checks we're pretty sure it's a / separated filename
1669         // and won't do much if any harm
1670         return false;
1671 }
1672
1673
1674 /*
1675 ====================
1676 FS_FindFile
1677
1678 Look for a file in the packages and in the filesystem
1679
1680 Return the searchpath where the file was found (or NULL)
1681 and the file index in the package if relevant
1682 ====================
1683 */
1684 static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
1685 {
1686         searchpath_t *search;
1687         pack_t *pak;
1688
1689         // search through the path, one element at a time
1690         for (search = fs_searchpaths;search;search = search->next)
1691         {
1692                 // is the element a pak file?
1693                 if (search->pack)
1694                 {
1695                         int (*strcmp_funct) (const char* str1, const char* str2);
1696                         int left, right, middle;
1697
1698                         pak = search->pack;
1699                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
1700
1701                         // Look for the file (binary search)
1702                         left = 0;
1703                         right = pak->numfiles - 1;
1704                         while (left <= right)
1705                         {
1706                                 int diff;
1707
1708                                 middle = (left + right) / 2;
1709                                 diff = strcmp_funct (pak->files[middle].name, name);
1710
1711                                 // Found it
1712                                 if (!diff)
1713                                 {
1714                                         if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
1715                                         {
1716                                                 // yes, but the first one is empty so we treat it as not being there
1717                                                 if (!quiet && developer.integer >= 10)
1718                                                         Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
1719
1720                                                 if (index != NULL)
1721                                                         *index = -1;
1722                                                 return NULL;
1723                                         }
1724
1725                                         if (!quiet && developer.integer >= 10)
1726                                                 Con_Printf("FS_FindFile: %s in %s\n",
1727                                                                         pak->files[middle].name, pak->filename);
1728
1729                                         if (index != NULL)
1730                                                 *index = middle;
1731                                         return search;
1732                                 }
1733
1734                                 // If we're too far in the list
1735                                 if (diff > 0)
1736                                         right = middle - 1;
1737                                 else
1738                                         left = middle + 1;
1739                         }
1740                 }
1741                 else
1742                 {
1743                         char netpath[MAX_OSPATH];
1744                         dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
1745                         if (FS_SysFileExists (netpath))
1746                         {
1747                                 if (!quiet && developer.integer >= 10)
1748                                         Con_Printf("FS_FindFile: %s\n", netpath);
1749
1750                                 if (index != NULL)
1751                                         *index = -1;
1752                                 return search;
1753                         }
1754                 }
1755         }
1756
1757         if (!quiet && developer.integer >= 10)
1758                 Con_Printf("FS_FindFile: can't find %s\n", name);
1759
1760         if (index != NULL)
1761                 *index = -1;
1762         return NULL;
1763 }
1764
1765
1766 /*
1767 ===========
1768 FS_OpenReadFile
1769
1770 Look for a file in the search paths and open it in read-only mode
1771 ===========
1772 */
1773 qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonblocking)
1774 {
1775         searchpath_t *search;
1776         int pack_ind;
1777
1778         search = FS_FindFile (filename, &pack_ind, quiet);
1779
1780         // Not found?
1781         if (search == NULL)
1782                 return NULL;
1783
1784         // Found in the filesystem?
1785         if (pack_ind < 0)
1786         {
1787                 char path [MAX_OSPATH];
1788                 dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
1789                 return FS_SysOpen (path, "rb", nonblocking);
1790         }
1791
1792         // So, we found it in a package...
1793         return FS_OpenPackedFile (search->pack, pack_ind);
1794 }
1795
1796
1797 /*
1798 =============================================================================
1799
1800 MAIN PUBLIC FUNCTIONS
1801
1802 =============================================================================
1803 */
1804
1805 /*
1806 ====================
1807 FS_Open
1808
1809 Open a file. The syntax is the same as fopen
1810 ====================
1811 */
1812 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet, qboolean nonblocking)
1813 {
1814 #ifdef FS_FIX_PATHS
1815         char fixedFileName[MAX_QPATH];
1816         char *d;
1817         strlcpy( fixedFileName, filepath, MAX_QPATH );
1818         // try to fix common mistakes (\ instead of /)
1819         for( d = fixedFileName ; *d ; d++ )
1820                 if( *d == '\\' )
1821                         *d = '/';
1822         filepath = fixedFileName;
1823 #endif
1824
1825         if (FS_CheckNastyPath(filepath, false))
1826         {
1827                 Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
1828                 return NULL;
1829         }
1830
1831         // If the file is opened in "write", "append", or "read/write" mode
1832         if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
1833         {
1834                 char real_path [MAX_OSPATH];
1835
1836                 // Open the file on disk directly
1837                 dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
1838
1839                 // Create directories up to the file
1840                 FS_CreatePath (real_path);
1841
1842                 return FS_SysOpen (real_path, mode, nonblocking);
1843         }
1844         // Else, we look at the various search paths and open the file in read-only mode
1845         else
1846                 return FS_OpenReadFile (filepath, quiet, nonblocking);
1847 }
1848
1849
1850 /*
1851 ====================
1852 FS_Close
1853
1854 Close a file
1855 ====================
1856 */
1857 int FS_Close (qfile_t* file)
1858 {
1859         if (close (file->handle))
1860                 return EOF;
1861
1862         if (file->ztk)
1863         {
1864                 qz_inflateEnd (&file->ztk->zstream);
1865                 Mem_Free (file->ztk);
1866         }
1867
1868         Mem_Free (file);
1869         return 0;
1870 }
1871
1872
1873 /*
1874 ====================
1875 FS_Write
1876
1877 Write "datasize" bytes into a file
1878 ====================
1879 */
1880 fs_offset_t FS_Write (qfile_t* file, const void* data, size_t datasize)
1881 {
1882         fs_offset_t result;
1883
1884         // If necessary, seek to the exact file position we're supposed to be
1885         if (file->buff_ind != file->buff_len)
1886                 lseek (file->handle, file->buff_ind - file->buff_len, SEEK_CUR);
1887
1888         // Purge cached data
1889         FS_Purge (file);
1890
1891         // Write the buffer and update the position
1892         result = write (file->handle, data, (fs_offset_t)datasize);
1893         file->position = lseek (file->handle, 0, SEEK_CUR);
1894         if (file->real_length < file->position)
1895                 file->real_length = file->position;
1896
1897         if (result < 0)
1898                 return 0;
1899
1900         return result;
1901 }
1902
1903
1904 /*
1905 ====================
1906 FS_Read
1907
1908 Read up to "buffersize" bytes from a file
1909 ====================
1910 */
1911 fs_offset_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
1912 {
1913         fs_offset_t count, done;
1914
1915         if (buffersize == 0)
1916                 return 0;
1917
1918         // Get rid of the ungetc character
1919         if (file->ungetc != EOF)
1920         {
1921                 ((char*)buffer)[0] = file->ungetc;
1922                 buffersize--;
1923                 file->ungetc = EOF;
1924                 done = 1;
1925         }
1926         else
1927                 done = 0;
1928
1929         // First, we copy as many bytes as we can from "buff"
1930         if (file->buff_ind < file->buff_len)
1931         {
1932                 count = file->buff_len - file->buff_ind;
1933                 count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
1934                 done += count;
1935                 memcpy (buffer, &file->buff[file->buff_ind], count);
1936                 file->buff_ind += count;
1937
1938                 buffersize -= count;
1939                 if (buffersize == 0)
1940                         return done;
1941         }
1942
1943         // NOTE: at this point, the read buffer is always empty
1944
1945         // If the file isn't compressed
1946         if (! (file->flags & QFILE_FLAG_DEFLATED))
1947         {
1948                 fs_offset_t nb;
1949
1950                 // We must take care to not read after the end of the file
1951                 count = file->real_length - file->position;
1952
1953                 // If we have a lot of data to get, put them directly into "buffer"
1954                 if (buffersize > sizeof (file->buff) / 2)
1955                 {
1956                         if (count > (fs_offset_t)buffersize)
1957                                 count = (fs_offset_t)buffersize;
1958                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1959                         nb = read (file->handle, &((unsigned char*)buffer)[done], count);
1960                         if (nb > 0)
1961                         {
1962                                 done += nb;
1963                                 file->position += nb;
1964
1965                                 // Purge cached data
1966                                 FS_Purge (file);
1967                         }
1968                 }
1969                 else
1970                 {
1971                         if (count > (fs_offset_t)sizeof (file->buff))
1972                                 count = (fs_offset_t)sizeof (file->buff);
1973                         lseek (file->handle, file->offset + file->position, SEEK_SET);
1974                         nb = read (file->handle, file->buff, count);
1975                         if (nb > 0)
1976                         {
1977                                 file->buff_len = nb;
1978                                 file->position += nb;
1979
1980                                 // Copy the requested data in "buffer" (as much as we can)
1981                                 count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
1982                                 memcpy (&((unsigned char*)buffer)[done], file->buff, count);
1983                                 file->buff_ind = count;
1984                                 done += count;
1985                         }
1986                 }
1987
1988                 return done;
1989         }
1990
1991         // If the file is compressed, it's more complicated...
1992         // We cycle through a few operations until we have read enough data
1993         while (buffersize > 0)
1994         {
1995                 ztoolkit_t *ztk = file->ztk;
1996                 int error;
1997
1998                 // NOTE: at this point, the read buffer is always empty
1999
2000                 // If "input" is also empty, we need to refill it
2001                 if (ztk->in_ind == ztk->in_len)
2002                 {
2003                         // If we are at the end of the file
2004                         if (file->position == file->real_length)
2005                                 return done;
2006
2007                         count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
2008                         if (count > (fs_offset_t)sizeof (ztk->input))
2009                                 count = (fs_offset_t)sizeof (ztk->input);
2010                         lseek (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
2011                         if (read (file->handle, ztk->input, count) != count)
2012                         {
2013                                 Con_Printf ("FS_Read: unexpected end of file\n");
2014                                 break;
2015                         }
2016
2017                         ztk->in_ind = 0;
2018                         ztk->in_len = count;
2019                         ztk->in_position += count;
2020                 }
2021
2022                 ztk->zstream.next_in = &ztk->input[ztk->in_ind];
2023                 ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
2024
2025                 // Now that we are sure we have compressed data available, we need to determine
2026                 // if it's better to inflate it in "file->buff" or directly in "buffer"
2027
2028                 // Inflate the data in "file->buff"
2029                 if (buffersize < sizeof (file->buff) / 2)
2030                 {
2031                         ztk->zstream.next_out = file->buff;
2032                         ztk->zstream.avail_out = sizeof (file->buff);
2033                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2034                         if (error != Z_OK && error != Z_STREAM_END)
2035                         {
2036                                 Con_Printf ("FS_Read: Can't inflate file\n");
2037                                 break;
2038                         }
2039                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2040
2041                         file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
2042                         file->position += file->buff_len;
2043
2044                         // Copy the requested data in "buffer" (as much as we can)
2045                         count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
2046                         memcpy (&((unsigned char*)buffer)[done], file->buff, count);
2047                         file->buff_ind = count;
2048                 }
2049
2050                 // Else, we inflate directly in "buffer"
2051                 else
2052                 {
2053                         ztk->zstream.next_out = &((unsigned char*)buffer)[done];
2054                         ztk->zstream.avail_out = (unsigned int)buffersize;
2055                         error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
2056                         if (error != Z_OK && error != Z_STREAM_END)
2057                         {
2058                                 Con_Printf ("FS_Read: Can't inflate file\n");
2059                                 break;
2060                         }
2061                         ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
2062
2063                         // How much data did it inflate?
2064                         count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
2065                         file->position += count;
2066
2067                         // Purge cached data
2068                         FS_Purge (file);
2069                 }
2070
2071                 done += count;
2072                 buffersize -= count;
2073         }
2074
2075         return done;
2076 }
2077
2078
2079 /*
2080 ====================
2081 FS_Print
2082
2083 Print a string into a file
2084 ====================
2085 */
2086 int FS_Print (qfile_t* file, const char *msg)
2087 {
2088         return (int)FS_Write (file, msg, strlen (msg));
2089 }
2090
2091 /*
2092 ====================
2093 FS_Printf
2094
2095 Print a string into a file
2096 ====================
2097 */
2098 int FS_Printf(qfile_t* file, const char* format, ...)
2099 {
2100         int result;
2101         va_list args;
2102
2103         va_start (args, format);
2104         result = FS_VPrintf (file, format, args);
2105         va_end (args);
2106
2107         return result;
2108 }
2109
2110
2111 /*
2112 ====================
2113 FS_VPrintf
2114
2115 Print a string into a file
2116 ====================
2117 */
2118 int FS_VPrintf (qfile_t* file, const char* format, va_list ap)
2119 {
2120         int len;
2121         fs_offset_t buff_size = MAX_INPUTLINE;
2122         char *tempbuff;
2123
2124         for (;;)
2125         {
2126                 tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
2127                 len = dpvsnprintf (tempbuff, buff_size, format, ap);
2128                 if (len >= 0 && len < buff_size)
2129                         break;
2130                 Mem_Free (tempbuff);
2131                 buff_size *= 2;
2132         }
2133
2134         len = write (file->handle, tempbuff, len);
2135         Mem_Free (tempbuff);
2136
2137         return len;
2138 }
2139
2140
2141 /*
2142 ====================
2143 FS_Getc
2144
2145 Get the next character of a file
2146 ====================
2147 */
2148 int FS_Getc (qfile_t* file)
2149 {
2150         unsigned char c;
2151
2152         if (FS_Read (file, &c, 1) != 1)
2153                 return EOF;
2154
2155         return c;
2156 }
2157
2158
2159 /*
2160 ====================
2161 FS_UnGetc
2162
2163 Put a character back into the read buffer (only supports one character!)
2164 ====================
2165 */
2166 int FS_UnGetc (qfile_t* file, unsigned char c)
2167 {
2168         // If there's already a character waiting to be read
2169         if (file->ungetc != EOF)
2170                 return EOF;
2171
2172         file->ungetc = c;
2173         return c;
2174 }
2175
2176
2177 /*
2178 ====================
2179 FS_Seek
2180
2181 Move the position index in a file
2182 ====================
2183 */
2184 int FS_Seek (qfile_t* file, fs_offset_t offset, int whence)
2185 {
2186         ztoolkit_t *ztk;
2187         unsigned char* buffer;
2188         fs_offset_t buffersize;
2189
2190         // Compute the file offset
2191         switch (whence)
2192         {
2193                 case SEEK_CUR:
2194                         offset += file->position - file->buff_len + file->buff_ind;
2195                         break;
2196
2197                 case SEEK_SET:
2198                         break;
2199
2200                 case SEEK_END:
2201                         offset += file->real_length;
2202                         break;
2203
2204                 default:
2205                         return -1;
2206         }
2207         if (offset < 0 || offset > file->real_length)
2208                 return -1;
2209
2210         // If we have the data in our read buffer, we don't need to actually seek
2211         if (file->position - file->buff_len <= offset && offset <= file->position)
2212         {
2213                 file->buff_ind = offset + file->buff_len - file->position;
2214                 return 0;
2215         }
2216
2217         // Purge cached data
2218         FS_Purge (file);
2219
2220         // Unpacked or uncompressed files can seek directly
2221         if (! (file->flags & QFILE_FLAG_DEFLATED))
2222         {
2223                 if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
2224                         return -1;
2225                 file->position = offset;
2226                 return 0;
2227         }
2228
2229         // Seeking in compressed files is more a hack than anything else,
2230         // but we need to support it, so here we go.
2231         ztk = file->ztk;
2232
2233         // If we have to go back in the file, we need to restart from the beginning
2234         if (offset <= file->position)
2235         {
2236                 ztk->in_ind = 0;
2237                 ztk->in_len = 0;
2238                 ztk->in_position = 0;
2239                 file->position = 0;
2240                 lseek (file->handle, file->offset, SEEK_SET);
2241
2242                 // Reset the Zlib stream
2243                 ztk->zstream.next_in = ztk->input;
2244                 ztk->zstream.avail_in = 0;
2245                 qz_inflateReset (&ztk->zstream);
2246         }
2247
2248         // We need a big buffer to force inflating into it directly
2249         buffersize = 2 * sizeof (file->buff);
2250         buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
2251
2252         // Skip all data until we reach the requested offset
2253         while (offset > file->position)
2254         {
2255                 fs_offset_t diff = offset - file->position;
2256                 fs_offset_t count, len;
2257
2258                 count = (diff > buffersize) ? buffersize : diff;
2259                 len = FS_Read (file, buffer, count);
2260                 if (len != count)
2261                 {
2262                         Mem_Free (buffer);
2263                         return -1;
2264                 }
2265         }
2266
2267         Mem_Free (buffer);
2268         return 0;
2269 }
2270
2271
2272 /*
2273 ====================
2274 FS_Tell
2275
2276 Give the current position in a file
2277 ====================
2278 */
2279 fs_offset_t FS_Tell (qfile_t* file)
2280 {
2281         return file->position - file->buff_len + file->buff_ind;
2282 }
2283
2284
2285 /*
2286 ====================
2287 FS_FileSize
2288
2289 Give the total size of a file
2290 ====================
2291 */
2292 fs_offset_t FS_FileSize (qfile_t* file)
2293 {
2294         return file->real_length;
2295 }
2296
2297
2298 /*
2299 ====================
2300 FS_Purge
2301
2302 Erases any buffered input or output data
2303 ====================
2304 */
2305 void FS_Purge (qfile_t* file)
2306 {
2307         file->buff_len = 0;
2308         file->buff_ind = 0;
2309         file->ungetc = EOF;
2310 }
2311
2312
2313 /*
2314 ============
2315 FS_LoadFile
2316
2317 Filename are relative to the quake directory.
2318 Always appends a 0 byte.
2319 ============
2320 */
2321 unsigned char *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet, fs_offset_t *filesizepointer)
2322 {
2323         qfile_t *file;
2324         unsigned char *buf = NULL;
2325         fs_offset_t filesize = 0;
2326
2327         file = FS_Open (path, "rb", quiet, false);
2328         if (file)
2329         {
2330                 filesize = file->real_length;
2331                 buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
2332                 buf[filesize] = '\0';
2333                 FS_Read (file, buf, filesize);
2334                 FS_Close (file);
2335                 if (developer_loadfile.integer)
2336                         Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
2337         }
2338
2339         if (filesizepointer)
2340                 *filesizepointer = filesize;
2341         return buf;
2342 }
2343
2344
2345 /*
2346 ============
2347 FS_WriteFile
2348
2349 The filename will be prefixed by the current game directory
2350 ============
2351 */
2352 qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
2353 {
2354         qfile_t *file;
2355
2356         file = FS_Open (filename, "wb", false, false);
2357         if (!file)
2358         {
2359                 Con_Printf("FS_WriteFile: failed on %s\n", filename);
2360                 return false;
2361         }
2362
2363         Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
2364         FS_Write (file, data, len);
2365         FS_Close (file);
2366         return true;
2367 }
2368
2369
2370 /*
2371 =============================================================================
2372
2373 OTHERS PUBLIC FUNCTIONS
2374
2375 =============================================================================
2376 */
2377
2378 /*
2379 ============
2380 FS_StripExtension
2381 ============
2382 */
2383 void FS_StripExtension (const char *in, char *out, size_t size_out)
2384 {
2385         char *last = NULL;
2386         char currentchar;
2387
2388         if (size_out == 0)
2389                 return;
2390
2391         while ((currentchar = *in) && size_out > 1)
2392         {
2393                 if (currentchar == '.')
2394                         last = out;
2395                 else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
2396                         last = NULL;
2397                 *out++ = currentchar;
2398                 in++;
2399                 size_out--;
2400         }
2401         if (last)
2402                 *last = 0;
2403         else
2404                 *out = 0;
2405 }
2406
2407
2408 /*
2409 ==================
2410 FS_DefaultExtension
2411 ==================
2412 */
2413 void FS_DefaultExtension (char *path, const char *extension, size_t size_path)
2414 {
2415         const char *src;
2416
2417         // if path doesn't have a .EXT, append extension
2418         // (extension should include the .)
2419         src = path + strlen(path) - 1;
2420
2421         while (*src != '/' && src != path)
2422         {
2423                 if (*src == '.')
2424                         return;                 // it has an extension
2425                 src--;
2426         }
2427
2428         strlcat (path, extension, size_path);
2429 }
2430
2431
2432 /*
2433 ==================
2434 FS_FileType
2435
2436 Look for a file in the packages and in the filesystem
2437 ==================
2438 */
2439 int FS_FileType (const char *filename)
2440 {
2441         searchpath_t *search;
2442         char fullpath[MAX_QPATH];
2443
2444         search = FS_FindFile (filename, NULL, true);
2445         if(!search)
2446                 return FS_FILETYPE_NONE;
2447
2448         if(search->pack)
2449                 return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
2450
2451         dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
2452         return FS_SysFileType(fullpath);
2453 }
2454
2455
2456 /*
2457 ==================
2458 FS_FileExists
2459
2460 Look for a file in the packages and in the filesystem
2461 ==================
2462 */
2463 qboolean FS_FileExists (const char *filename)
2464 {
2465         return (FS_FindFile (filename, NULL, true) != NULL);
2466 }
2467
2468
2469 /*
2470 ==================
2471 FS_SysFileExists
2472
2473 Look for a file in the filesystem only
2474 ==================
2475 */
2476 int FS_SysFileType (const char *path)
2477 {
2478 #if WIN32
2479         DWORD result = GetFileAttributes(path);
2480
2481         if(result == INVALID_FILE_ATTRIBUTES)
2482                 return FS_FILETYPE_NONE;
2483
2484         if(result & FILE_ATTRIBUTE_DIRECTORY)
2485                 return FS_FILETYPE_DIRECTORY;
2486
2487         return FS_FILETYPE_FILE;
2488 #else
2489         struct stat buf;
2490
2491         if (stat (path,&buf) == -1)
2492                 return FS_FILETYPE_NONE;
2493
2494         if(S_ISDIR(buf.st_mode))
2495                 return FS_FILETYPE_DIRECTORY;
2496
2497         return FS_FILETYPE_FILE;
2498 #endif
2499 }
2500
2501 qboolean FS_SysFileExists (const char *path)
2502 {
2503         return FS_SysFileType (path) != FS_FILETYPE_NONE;
2504 }
2505
2506 void FS_mkdir (const char *path)
2507 {
2508 #if WIN32
2509         _mkdir (path);
2510 #else
2511         mkdir (path, 0777);
2512 #endif
2513 }
2514
2515 /*
2516 ===========
2517 FS_Search
2518
2519 Allocate and fill a search structure with information on matching filenames.
2520 ===========
2521 */
2522 fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
2523 {
2524         fssearch_t *search;
2525         searchpath_t *searchpath;
2526         pack_t *pak;
2527         int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
2528         stringlist_t resultlist;
2529         stringlist_t dirlist;
2530         const char *slash, *backslash, *colon, *separator;
2531         char *basepath;
2532         char netpath[MAX_OSPATH];
2533         char temp[MAX_OSPATH];
2534
2535         for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
2536                 ;
2537
2538         if (i > 0)
2539         {
2540                 Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
2541                 return NULL;
2542         }
2543
2544         stringlistinit(&resultlist);
2545         stringlistinit(&dirlist);
2546         search = NULL;
2547         slash = strrchr(pattern, '/');
2548         backslash = strrchr(pattern, '\\');
2549         colon = strrchr(pattern, ':');
2550         separator = max(slash, backslash);
2551         separator = max(separator, colon);
2552         basepathlength = separator ? (separator + 1 - pattern) : 0;
2553         basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
2554         if (basepathlength)
2555                 memcpy(basepath, pattern, basepathlength);
2556         basepath[basepathlength] = 0;
2557
2558         // search through the path, one element at a time
2559         for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
2560         {
2561                 // is the element a pak file?
2562                 if (searchpath->pack)
2563                 {
2564                         // look through all the pak file elements
2565                         pak = searchpath->pack;
2566                         for (i = 0;i < pak->numfiles;i++)
2567                         {
2568                                 strlcpy(temp, pak->files[i].name, sizeof(temp));
2569                                 while (temp[0])
2570                                 {
2571                                         if (matchpattern(temp, (char *)pattern, true))
2572                                         {
2573                                                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2574                                                         if (!strcmp(resultlist.strings[resultlistindex], temp))
2575                                                                 break;
2576                                                 if (resultlistindex == resultlist.numstrings)
2577                                                 {
2578                                                         stringlistappend(&resultlist, temp);
2579                                                         if (!quiet && developer_loading.integer)
2580                                                                 Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
2581                                                 }
2582                                         }
2583                                         // strip off one path element at a time until empty
2584                                         // this way directories are added to the listing if they match the pattern
2585                                         slash = strrchr(temp, '/');
2586                                         backslash = strrchr(temp, '\\');
2587                                         colon = strrchr(temp, ':');
2588                                         separator = temp;
2589                                         if (separator < slash)
2590                                                 separator = slash;
2591                                         if (separator < backslash)
2592                                                 separator = backslash;
2593                                         if (separator < colon)
2594                                                 separator = colon;
2595                                         *((char *)separator) = 0;
2596                                 }
2597                         }
2598                 }
2599                 else
2600                 {
2601                         // get a directory listing and look at each name
2602                         dpsnprintf(netpath, sizeof (netpath), "%s%s", searchpath->filename, basepath);
2603                         stringlistinit(&dirlist);
2604                         listdirectory(&dirlist, netpath);
2605                         for (dirlistindex = 0;dirlistindex < dirlist.numstrings;dirlistindex++)
2606                         {
2607                                 dpsnprintf(temp, sizeof(temp), "%s%s", basepath, dirlist.strings[dirlistindex]);
2608                                 if (matchpattern(temp, (char *)pattern, true))
2609                                 {
2610                                         for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2611                                                 if (!strcmp(resultlist.strings[resultlistindex], temp))
2612                                                         break;
2613                                         if (resultlistindex == resultlist.numstrings)
2614                                         {
2615                                                 stringlistappend(&resultlist, temp);
2616                                                 if (!quiet && developer_loading.integer)
2617                                                         Con_Printf("SearchDirFile: %s\n", temp);
2618                                         }
2619                                 }
2620                         }
2621                         stringlistfreecontents(&dirlist);
2622                 }
2623         }
2624
2625         if (resultlist.numstrings)
2626         {
2627                 stringlistsort(&resultlist);
2628                 numfiles = resultlist.numstrings;
2629                 numchars = 0;
2630                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2631                         numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
2632                 search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
2633                 search->filenames = (char **)((char *)search + sizeof(fssearch_t));
2634                 search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
2635                 search->numfilenames = (int)numfiles;
2636                 numfiles = 0;
2637                 numchars = 0;
2638                 for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
2639                 {
2640                         size_t textlen;
2641                         search->filenames[numfiles] = search->filenamesbuffer + numchars;
2642                         textlen = strlen(resultlist.strings[resultlistindex]) + 1;
2643                         memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
2644                         numfiles++;
2645                         numchars += (int)textlen;
2646                 }
2647         }
2648         stringlistfreecontents(&resultlist);
2649
2650         Mem_Free(basepath);
2651         return search;
2652 }
2653
2654 void FS_FreeSearch(fssearch_t *search)
2655 {
2656         Z_Free(search);
2657 }
2658
2659 extern int con_linewidth;
2660 int FS_ListDirectory(const char *pattern, int oneperline)
2661 {
2662         int numfiles;
2663         int numcolumns;
2664         int numlines;
2665         int columnwidth;
2666         int linebufpos;
2667         int i, j, k, l;
2668         const char *name;
2669         char linebuf[MAX_INPUTLINE];
2670         fssearch_t *search;
2671         search = FS_Search(pattern, true, true);
2672         if (!search)
2673                 return 0;
2674         numfiles = search->numfilenames;
2675         if (!oneperline)
2676         {
2677                 // FIXME: the names could be added to one column list and then
2678                 // gradually shifted into the next column if they fit, and then the
2679                 // next to make a compact variable width listing but it's a lot more
2680                 // complicated...
2681                 // find width for columns
2682                 columnwidth = 0;
2683                 for (i = 0;i < numfiles;i++)
2684                 {
2685                         l = (int)strlen(search->filenames[i]);
2686                         if (columnwidth < l)
2687                                 columnwidth = l;
2688                 }
2689                 // count the spacing character
2690                 columnwidth++;
2691                 // calculate number of columns
2692                 numcolumns = con_linewidth / columnwidth;
2693                 // don't bother with the column printing if it's only one column
2694                 if (numcolumns >= 2)
2695                 {
2696                         numlines = (numfiles + numcolumns - 1) / numcolumns;
2697                         for (i = 0;i < numlines;i++)
2698                         {
2699                                 linebufpos = 0;
2700                                 for (k = 0;k < numcolumns;k++)
2701                                 {
2702                                         l = i * numcolumns + k;
2703                                         if (l < numfiles)
2704                                         {
2705                                                 name = search->filenames[l];
2706                                                 for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
2707                                                         linebuf[linebufpos++] = name[j];
2708                                                 // space out name unless it's the last on the line
2709                                                 if (k + 1 < numcolumns && l + 1 < numfiles)
2710                                                         for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
2711                                                                 linebuf[linebufpos++] = ' ';
2712                                         }
2713                                 }
2714                                 linebuf[linebufpos] = 0;
2715                                 Con_Printf("%s\n", linebuf);
2716                         }
2717                 }
2718                 else
2719                         oneperline = true;
2720         }
2721         if (oneperline)
2722                 for (i = 0;i < numfiles;i++)
2723                         Con_Printf("%s\n", search->filenames[i]);
2724         FS_FreeSearch(search);
2725         return (int)numfiles;
2726 }
2727
2728 static void FS_ListDirectoryCmd (const char* cmdname, int oneperline)
2729 {
2730         const char *pattern;
2731         if (Cmd_Argc() > 3)
2732         {
2733                 Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
2734                 return;
2735         }
2736         if (Cmd_Argc() == 2)
2737                 pattern = Cmd_Argv(1);
2738         else
2739                 pattern = "*";
2740         if (!FS_ListDirectory(pattern, oneperline))
2741                 Con_Print("No files found.\n");
2742 }
2743
2744 void FS_Dir_f(void)
2745 {
2746         FS_ListDirectoryCmd("dir", true);
2747 }
2748
2749 void FS_Ls_f(void)
2750 {
2751         FS_ListDirectoryCmd("ls", false);
2752 }
2753
2754 const char *FS_WhichPack(const char *filename)
2755 {
2756         int index;
2757         searchpath_t *sp = FS_FindFile(filename, &index, true);
2758         if(sp && sp->pack)
2759                 return sp->pack->filename;
2760         else
2761                 return 0;
2762 }
2763
2764 /*
2765 ====================
2766 FS_IsRegisteredQuakePack
2767
2768 Look for a proof of purchase file file in the requested package
2769
2770 If it is found, this file should NOT be downloaded.
2771 ====================
2772 */
2773 qboolean FS_IsRegisteredQuakePack(const char *name)
2774 {
2775         searchpath_t *search;
2776         pack_t *pak;
2777
2778         // search through the path, one element at a time
2779         for (search = fs_searchpaths;search;search = search->next)
2780         {
2781                 if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
2782                 {
2783                         int (*strcmp_funct) (const char* str1, const char* str2);
2784                         int left, right, middle;
2785
2786                         pak = search->pack;
2787                         strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
2788
2789                         // Look for the file (binary search)
2790                         left = 0;
2791                         right = pak->numfiles - 1;
2792                         while (left <= right)
2793                         {
2794                                 int diff;
2795
2796                                 middle = (left + right) / 2;
2797                                 diff = !strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
2798
2799                                 // Found it
2800                                 if (!diff)
2801                                         return true;
2802
2803                                 // If we're too far in the list
2804                                 if (diff > 0)
2805                                         right = middle - 1;
2806                                 else
2807                                         left = middle + 1;
2808                         }
2809
2810                         // we found the requested pack but it is not registered quake
2811                         return false;
2812                 }
2813         }
2814
2815         return false;
2816 }
2817
2818 int FS_CRCFile(const char *filename, size_t *filesizepointer)
2819 {
2820         int crc = -1;
2821         unsigned char *filedata;
2822         fs_offset_t filesize;
2823         if (filesizepointer)
2824                 *filesizepointer = 0;
2825         if (!filename || !*filename)
2826                 return crc;
2827         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
2828         if (filedata)
2829         {
2830                 if (filesizepointer)
2831                         *filesizepointer = filesize;
2832                 crc = CRC_Block(filedata, filesize);
2833                 Mem_Free(filedata);
2834         }
2835         return crc;
2836 }
2837