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