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