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