- Got rid of all the FILE* stuff in the FS code, relying on low-level

functions exclusively. It now manages its own per-file 2KB read buffers.
Writes are no longer buffered.
- Removed function "FS_Flush" and cvar "log_sync", since they're no
longer relevant
- Package's file descriptors are now duplicated when opening a new file
inside a package, to make package substitution at run time impossible on
non-Win32 systems. Added a couple of "lseek" when necessary (before
"read" calls in "FS_Read").
- Removed unused functions "FS_Eof", "Log_Print" and "S_ClearBuffer"
- Several other minor changes and fixes in the FS code
- Changed log open mode to "a" from "at" since 't' seems a Win32-only
extension

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@4946 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/cl_demo.c b/cl_demo.c
index c52e4ae264fd007d661170c837bbc07e806e02b0..af7015902170e583dca0688cc877d18f345d35fc 100644 (file)
--- a/cl_demo.c
+++ b/cl_demo.c
@@ -112,7 +112,6 @@ void CL_WriteDemoMessage (void)
                FS_Write (cls.demofile, &f, 4);
        }
        FS_Write (cls.demofile, net_message.data, net_message.cursize);
                FS_Write (cls.demofile, &f, 4);
        }
        FS_Write (cls.demofile, net_message.data, net_message.cursize);

-       FS_Flush (cls.demofile);

 }
 
 /*
 }
 
 /*

diff --git a/console.c b/console.c
index 92f399a14c96699de538af7f6e6e7ac1a489884e..9f967d1873e5e3fa1bfd81ef236f5f5d1ae35d41 100644 (file)
--- a/console.c
+++ b/console.c
@@ -72,7 +72,6 @@ LOGGING
 */
 
 cvar_t log_file = {0, "log_file",""};
 */
 
 cvar_t log_file = {0, "log_file",""};

-cvar_t log_sync = {0, "log_sync","0"};

 char crt_log_file [MAX_OSPATH] = "";
 qfile_t* logfile = NULL;
 
 char crt_log_file [MAX_OSPATH] = "";
 qfile_t* logfile = NULL;
 


@@ -121,15 +120,11 @@ void Log_Init (void)
        logq_ind = 0;
 
        Cvar_RegisterVariable (&log_file);
        logq_ind = 0;
 
        Cvar_RegisterVariable (&log_file);

-       Cvar_RegisterVariable (&log_sync);

 
        // support for the classic Quake option
 
        // support for the classic Quake option

-// COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log with sync on (so it keeps every message up to a crash), see also log_file and log_sync
+// COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file

        if (COM_CheckParm ("-condebug") != 0)
        if (COM_CheckParm ("-condebug") != 0)

-       {

                Cvar_SetQuick (&log_file, "qconsole.log");
                Cvar_SetQuick (&log_file, "qconsole.log");

-               Cvar_SetValueQuick (&log_sync, 1);
-       }

 }
 
 
 }
 
 


@@ -143,7 +138,7 @@ void Log_Open (void)
        if (logfile != NULL || log_file.string[0] == '\0')
                return;
 
        if (logfile != NULL || log_file.string[0] == '\0')
                return;
 

-       logfile = FS_Open (log_file.string, "at", false);
+       logfile = FS_Open (log_file.string, "a", false);

        if (logfile != NULL)
        {
                strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));
        if (logfile != NULL)
        {
                strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));


@@ -201,10 +196,12 @@ Log_ConPrint
 void Log_ConPrint (const char *msg)
 {
        static qboolean inprogress = false;
 void Log_ConPrint (const char *msg)
 {
        static qboolean inprogress = false;

+

        // don't allow feedback loops with memory error reports
        if (inprogress)
                return;
        inprogress = true;
        // don't allow feedback loops with memory error reports
        if (inprogress)
                return;
        inprogress = true;

+

        // Until the host is completely initialized, we maintain a log queue
        // to store the messages, since the log can't be started before
        if (logqueue != NULL)
        // Until the host is completely initialized, we maintain a log queue
        // to store the messages, since the log can't be started before
        if (logqueue != NULL)


@@ -241,31 +238,11 @@ void Log_ConPrint (const char *msg)
 
        // If a log file is available
        if (logfile != NULL)
 
        // If a log file is available
        if (logfile != NULL)

-       {

                FS_Print (logfile, msg);
                FS_Print (logfile, msg);

-               if (log_sync.integer)
-                       FS_Flush (logfile);
-       }

        inprogress = false;
 }
 
 
        inprogress = false;
 }
 
 

-/*
-================
-Log_Print
-================
-*/
-void Log_Print (const char *logfilename, const char *msg)
-{
-       qfile_t *file;
-       file = FS_Open(logfilename, "at", true);
-       if (file)
-       {
-               FS_Print(file, msg);
-               FS_Close(file);
-       }
-}
-

 /*
 ================
 Log_Printf
 /*
 ================
 Log_Printf


@@ -275,7 +252,7 @@ void Log_Printf (const char *logfilename, const char *fmt, ...)
 {
        qfile_t *file;
 
 {
        qfile_t *file;
 

-       file = FS_Open (logfilename, "at", true);
+       file = FS_Open (logfilename, "a", true);

        if (file != NULL)
        {
                va_list argptr;
        if (file != NULL)
        {
                va_list argptr;

diff --git a/console.h b/console.h
index a6267b9c375208b2e1716854b42e8462ed5ff0d4..abe35cf9c676f1f0c85bbdebf919601b65884610 100644 (file)
--- a/console.h
+++ b/console.h
@@ -58,7 +58,6 @@ void Log_Init (void);
 void Log_Close (void);
 void Log_Start (void);
 
 void Log_Close (void);
 void Log_Start (void);
 

-void Log_Print(const char *logfilename, const char *msg);

 void Log_Printf(const char *logfilename, const char *fmt, ...);
 
 #endif
 void Log_Printf(const char *logfilename, const char *fmt, ...);
 
 #endif

diff --git a/fs.c b/fs.c
index 233800ef19157efda9f411569d52a38eae91174b..0ffff63c1f2031b185a521448708c337e7662598 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -1,7 +1,7 @@
 /*
        DarkPlaces file system
 
 /*
        DarkPlaces file system
 

-       Copyright (C) 2003 Mathieu Olivier
+       Copyright (C) 2003-2005 Mathieu Olivier

        Copyright (C) 1999,2000  contributors of the QuakeForge project
 
        This program is free software; you can redistribute it and/or
        Copyright (C) 1999,2000  contributors of the QuakeForge project
 
        This program is free software; you can redistribute it and/or


@@ -37,20 +37,11 @@
 # include <unistd.h>
 #endif
 
 # include <unistd.h>
 #endif
 

-#ifndef PATH_MAX
-# define PATH_MAX 512
-#endif
-

 #include "fs.h"
 
 #include "fs.h"
 

-// use syscalls instead of f* functions
-#define FS_USESYSCALLS
-

 // Win32 requires us to add O_BINARY, but the other OSes don't have it
 // Win32 requires us to add O_BINARY, but the other OSes don't have it

-#ifdef FS_USESYSCALLS
-# ifndef O_BINARY
-#  define O_BINARY 0
-# endif
+#ifndef O_BINARY
+# define O_BINARY 0

 #endif
 
 
 #endif
 
 


@@ -69,7 +60,7 @@ The "game directory" is the first tree on the search path and directory that
 all generated files (savegames, screenshots, demos, config files) will be
 saved to.  This can be overridden with the "-game" command line parameter.
 The game directory can never be changed while quake is executing.  This is a
 all generated files (savegames, screenshots, demos, config files) will be
 saved to.  This can be overridden with the "-game" command line parameter.
 The game directory can never be changed while quake is executing.  This is a

-precacution against having a malicious server instruct clients to write files
+precaution against having a malicious server instruct clients to write files

 over areas they shouldn't.
 
 */
 over areas they shouldn't.
 
 */


@@ -136,39 +127,37 @@ typedef struct
 } z_stream;
 
 
 } z_stream;
 
 

-// Our own file structure on top of FILE

 typedef enum
 {
 typedef enum
 {

-       FS_FLAG_NONE            = 0,
-       FS_FLAG_PACKED          = (1 << 0),     // inside a package (PAK or PK3)
-       FS_FLAG_DEFLATED        = (1 << 1)      // file is compressed using the deflate algorithm (PK3 only)
-} fs_flags_t;
+       QFILE_FLAG_NONE         = 0,
+       QFILE_FLAG_PACKED       = (1 << 0),     // inside a package (PAK or PK3)
+       QFILE_FLAG_DEFLATED     = (1 << 1)      // file is compressed using the deflate algorithm (PK3 only)
+} qfile_flags_t;

 
 

-#define ZBUFF_SIZE 1024
+#define FILE_BUFF_SIZE 2048

 typedef struct
 {
        z_stream        zstream;
 typedef struct
 {
        z_stream        zstream;

-       size_t          real_length;                    // length of the uncompressed file
-       size_t          in_ind, in_max;                 // input buffer index and counter
+       size_t          comp_length;                    // length of the compressed file
+       size_t          in_ind, in_len;                 // input buffer current index and length

        size_t          in_position;                    // position in the compressed file
        size_t          in_position;                    // position in the compressed file

-       size_t          out_ind, out_max;               // output buffer index and counter
-       size_t          out_position;                   // how many bytes did we uncompress until now?
-       qbyte           input [ZBUFF_SIZE];
-       qbyte           output [ZBUFF_SIZE];
+       qbyte           input [FILE_BUFF_SIZE];

 } ztoolkit_t;
 
 struct qfile_s
 {
 } ztoolkit_t;
 
 struct qfile_s
 {

-       fs_flags_t      flags;
-#ifdef FS_USESYSCALLS
-       int                     stream;
-#else
-       FILE*           stream;
-#endif
-       size_t          length;         // file size on disk (PACKED only)
-       size_t          offset;         // offset into a package (PACKED only)
-       size_t          position;       // current position in the file (PACKED only)
-       ztoolkit_t*     z;                      // used for inflating (DEFLATED only)
+       qfile_flags_t   flags;
+       int                             handle;                                 // file descriptor
+       size_t                  real_length;                    // uncompressed file size (for files opened in "read" mode)
+       size_t                  position;                               // current position in the file
+       size_t                  offset;                                 // offset into the package (0 if external file)
+
+       // Contents buffer
+       size_t                  buff_ind, buff_len;             // buffer current index and length
+       qbyte                   buff [FILE_BUFF_SIZE];
+
+       // For zipped files
+       ztoolkit_t*             ztk;

 };
 
 
 };
 
 


@@ -207,15 +196,15 @@ typedef struct
 // Packages in memory
 typedef enum
 {
 // Packages in memory
 typedef enum
 {

-       FILE_FLAG_NONE          = 0,
-       FILE_FLAG_TRUEOFFS      = (1 << 0),     // the offset in packfile_t is the true contents offset
-       FILE_FLAG_DEFLATED      = (1 << 1)      // file compressed using the deflate algorithm
-} file_flags_t;
+       PACKFILE_FLAG_NONE              = 0,
+       PACKFILE_FLAG_TRUEOFFS  = (1 << 0),     // the offset in packfile_t is the true contents offset
+       PACKFILE_FLAG_DEFLATED  = (1 << 1)      // file compressed using the deflate algorithm
+} packfile_flags_t;

 
 typedef struct
 {
        char name [MAX_QPATH];
 
 typedef struct
 {
        char name [MAX_QPATH];

-       file_flags_t flags;
+       packfile_flags_t flags;

        size_t offset;
        size_t packsize;        // size in the package
        size_t realsize;        // real file size (uncompressed)
        size_t offset;
        size_t packsize;        // size in the package
        size_t realsize;        // real file size (uncompressed)


@@ -224,12 +213,8 @@ typedef struct
 typedef struct pack_s
 {
        char filename [MAX_OSPATH];
 typedef struct pack_s
 {
        char filename [MAX_OSPATH];

-#ifdef FS_USESYSCALLS

        int handle;
        int handle;

-#else
-       FILE *handle;
-#endif
-       int ignorecase; // PK3 ignores case
+       int ignorecase;  // PK3 ignores case

        int numfiles;
        packfile_t *files;
        mempool_t *mempool;
        int numfiles;
        packfile_t *files;
        mempool_t *mempool;


@@ -260,7 +245,7 @@ void FS_Ls_f(void);
 
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
                                                                         size_t offset, size_t packsize,
 
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
                                                                         size_t offset, size_t packsize,

-                                                                        size_t realsize, file_flags_t flags);
+                                                                        size_t realsize, packfile_flags_t flags);

 
 
 /*
 
 
 /*


@@ -382,23 +367,14 @@ PK3_GetEndOfCentralDir
 Extract the end of the central directory from a PK3 package
 ====================
 */
 Extract the end of the central directory from a PK3 package
 ====================
 */

-#ifdef FS_USESYSCALLS

 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)
 qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOfCentralDir_t *eocd)

-#else
-qboolean PK3_GetEndOfCentralDir (const char *packfile, FILE *packhandle, pk3_endOfCentralDir_t *eocd)
-#endif

 {
        long filesize, maxsize;
        qbyte *buffer, *ptr;
        int ind;
 
        // Get the package size
 {
        long filesize, maxsize;
        qbyte *buffer, *ptr;
        int ind;
 
        // Get the package size

-#ifdef FS_USESYSCALLS

        filesize = lseek (packhandle, 0, SEEK_END);
        filesize = lseek (packhandle, 0, SEEK_END);

-#else
-       fseek (packhandle, 0, SEEK_END);
-       filesize = ftell(packhandle);
-#endif

        if (filesize < ZIP_END_CDIR_SIZE)
                return false;
 
        if (filesize < ZIP_END_CDIR_SIZE)
                return false;
 


@@ -408,13 +384,8 @@ qboolean PK3_GetEndOfCentralDir (const char *packfile, FILE *packhandle, pk3_end
        else
                maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
        buffer = Mem_Alloc (tempmempool, maxsize);
        else
                maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
        buffer = Mem_Alloc (tempmempool, maxsize);

-#ifdef FS_USESYSCALLS

        lseek (packhandle, filesize - maxsize, SEEK_SET);
        if (read (packhandle, buffer, maxsize) != (ssize_t) maxsize)
        lseek (packhandle, filesize - maxsize, SEEK_SET);
        if (read (packhandle, buffer, maxsize) != (ssize_t) maxsize)

-#else
-       fseek (packhandle, filesize - maxsize, SEEK_SET);
-       if (fread (buffer, 1, maxsize, packhandle) != (size_t) maxsize)
-#endif

        {
                Mem_Free (buffer);
                return false;
        {
                Mem_Free (buffer);
                return false;


@@ -467,13 +438,8 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
 
        // Load the central directory in memory
        central_dir = Mem_Alloc (tempmempool, eocd->cdir_size);
 
        // Load the central directory in memory
        central_dir = Mem_Alloc (tempmempool, eocd->cdir_size);

-#ifdef FS_USESYSCALLS

        lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
        read (pack->handle, central_dir, eocd->cdir_size);
        lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
        read (pack->handle, central_dir, eocd->cdir_size);

-#else
-       fseek (pack->handle, eocd->cdir_offset, SEEK_SET);
-       fread (central_dir, 1, eocd->cdir_size, pack->handle);
-#endif

 
        // Extract the files properties
        // The parsing is done "by hand" because some fields have variable sizes and
 
        // Extract the files properties
        // The parsing is done "by hand" because some fields have variable sizes and


@@ -521,7 +487,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                        {
                                char filename [sizeof (pack->files[0].name)];
                                size_t offset, packsize, realsize;
                        {
                                char filename [sizeof (pack->files[0].name)];
                                size_t offset, packsize, realsize;

-                               file_flags_t flags;
+                               packfile_flags_t flags;

 
                                // Extract the name (strip it if necessary)
                                if (namesize >= sizeof (filename))
 
                                // Extract the name (strip it if necessary)
                                if (namesize >= sizeof (filename))


@@ -530,7 +496,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                                filename[namesize] = '\0';
 
                                if (BuffLittleShort (&ptr[10]))
                                filename[namesize] = '\0';
 
                                if (BuffLittleShort (&ptr[10]))

-                                       flags = FILE_FLAG_DEFLATED;
+                                       flags = PACKFILE_FLAG_DEFLATED;

                                else
                                        flags = 0;
                                offset = BuffLittleLong (&ptr[42]);
                                else
                                        flags = 0;
                                offset = BuffLittleLong (&ptr[42]);


@@ -564,24 +530,14 @@ Create a package entry associated with a PK3 file
 */
 pack_t *FS_LoadPackPK3 (const char *packfile)
 {
 */
 pack_t *FS_LoadPackPK3 (const char *packfile)
 {

-#ifdef FS_USESYSCALLS

        int packhandle;
        int packhandle;

-#else
-       FILE *packhandle;
-#endif

        pk3_endOfCentralDir_t eocd;
        pack_t *pack;
        int real_nb_files;
 
        pk3_endOfCentralDir_t eocd;
        pack_t *pack;
        int real_nb_files;
 

-#ifdef FS_USESYSCALLS

        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;
        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;

-#else
-       packhandle = fopen (packfile, "rb");
-       if (!packhandle)
-               return NULL;
-#endif

 
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
                Sys_Error ("%s is not a PK3 file", packfile);
 
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
                Sys_Error ("%s is not a PK3 file", packfile);


@@ -624,30 +580,25 @@ PK3_GetTrueFileOffset
 Find where the true file data offset is
 ====================
 */
 Find where the true file data offset is
 ====================
 */

-void PK3_GetTrueFileOffset (packfile_t *file, pack_t *pack)
+void PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)

 {
        qbyte buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
        size_t count;
 
        // Already found?
 {
        qbyte buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
        size_t count;
 
        // Already found?

-       if (file->flags & FILE_FLAG_TRUEOFFS)
+       if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)

                return;
 
        // Load the local file description
                return;
 
        // Load the local file description

-#ifdef FS_USESYSCALLS
-       lseek (pack->handle, file->offset, SEEK_SET);
+       lseek (pack->handle, pfile->offset, SEEK_SET);

        count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
        count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);

-#else
-       fseek (pack->handle, file->offset, SEEK_SET);
-       count = fread (buffer, 1, ZIP_LOCAL_CHUNK_BASE_SIZE, pack->handle);
-#endif

        if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
        if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)

-               Sys_Error ("Can't retrieve file %s in package %s", file->name, pack->filename);
+               Sys_Error ("Can't retrieve file %s in package %s", pfile->name, pack->filename);

 
        // Skip name and extra field
 
        // Skip name and extra field

-       file->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
+       pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;

 
 

-       file->flags |= FILE_FLAG_TRUEOFFS;
+       pfile->flags |= PACKFILE_FLAG_TRUEOFFS;

 }
 
 
 }
 
 


@@ -669,11 +620,11 @@ Add a file to the list of files contained into a package
 */
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
                                                                         size_t offset, size_t packsize,
 */
 static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
                                                                         size_t offset, size_t packsize,

-                                                                        size_t realsize, file_flags_t flags)
+                                                                        size_t realsize, packfile_flags_t flags)

 {
        int (*strcmp_funct) (const char* str1, const char* str2);
        int left, right, middle;
 {
        int (*strcmp_funct) (const char* str1, const char* str2);
        int left, right, middle;

-       packfile_t *file;
+       packfile_t *pfile;

 
        strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
 
 
        strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
 


@@ -700,17 +651,17 @@ static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
        }
 
        // We have to move the right of the list by one slot to free the one we need
        }
 
        // We have to move the right of the list by one slot to free the one we need

-       file = &pack->files[left];
-       memmove (file + 1, file, (pack->numfiles - left) * sizeof (*file));
+       pfile = &pack->files[left];
+       memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));

        pack->numfiles++;
 
        pack->numfiles++;
 

-       strlcpy (file->name, name, sizeof (file->name));
-       file->offset = offset;
-       file->packsize = packsize;
-       file->realsize = realsize;
-       file->flags = flags;
+       strlcpy (pfile->name, name, sizeof (pfile->name));
+       pfile->offset = offset;
+       pfile->packsize = packsize;
+       pfile->realsize = realsize;
+       pfile->flags = flags;

 
 

-       return file;
+       return pfile;

 }
 
 
 }
 
 


@@ -776,25 +727,14 @@ pack_t *FS_LoadPackPAK (const char *packfile)
 {
        dpackheader_t header;
        int i, numpackfiles;
 {
        dpackheader_t header;
        int i, numpackfiles;

-#ifdef FS_USESYSCALLS

        int packhandle;
        int packhandle;

-#else
-       FILE *packhandle;
-#endif

        pack_t *pack;
        pack_t *pack;

-       dpackfile_t *info;      // temporary alloc, allowing huge pack directories
+       dpackfile_t *info;

 
 

-#ifdef FS_USESYSCALLS

        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;
        read (packhandle, (void *)&header, sizeof(header));
        packhandle = open (packfile, O_RDONLY | O_BINARY);
        if (packhandle < 0)
                return NULL;
        read (packhandle, (void *)&header, sizeof(header));

-#else
-       packhandle = fopen (packfile, "rb");
-       if (!packhandle)
-               return NULL;
-       fread ((void *)&header, 1, sizeof(header), packhandle);
-#endif

        if (memcmp(header.id, "PACK", 4))
                Sys_Error ("%s is not a packfile", packfile);
        header.dirofs = LittleLong (header.dirofs);
        if (memcmp(header.id, "PACK", 4))
                Sys_Error ("%s is not a packfile", packfile);
        header.dirofs = LittleLong (header.dirofs);


@@ -819,13 +759,8 @@ pack_t *FS_LoadPackPAK (const char *packfile)
        packlist = pack;
 
        info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
        packlist = pack;
 
        info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);

-#ifdef FS_USESYSCALLS

        lseek (packhandle, header.dirofs, SEEK_SET);
        read (packhandle, (void *)info, header.dirlen);
        lseek (packhandle, header.dirofs, SEEK_SET);
        read (packhandle, (void *)info, header.dirlen);

-#else
-       fseek (packhandle, header.dirofs, SEEK_SET);
-       fread ((void *)info, 1, header.dirlen, packhandle);
-#endif

 
        // parse the directory
        for (i = 0;i < numpackfiles;i++)
 
        // parse the directory
        for (i = 0;i < numpackfiles;i++)


@@ -833,7 +768,7 @@ pack_t *FS_LoadPackPAK (const char *packfile)
                size_t offset = LittleLong (info[i].filepos);
                size_t size = LittleLong (info[i].filelen);
 
                size_t offset = LittleLong (info[i].filepos);
                size_t size = LittleLong (info[i].filelen);
 

-               FS_AddFileToPack (info[i].name, pack, offset, size, size, FILE_FLAG_TRUEOFFS);
+               FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);

        }
 
        Mem_Free(info);
        }
 
        Mem_Free(info);


@@ -936,28 +871,23 @@ void FS_AddGameHierarchy (const char *dir)
 FS_FileExtension
 ============
 */
 FS_FileExtension
 ============
 */

-char *FS_FileExtension (const char *in)
+static const char *FS_FileExtension (const char *in)

 {
 {

-       static char exten[8];
-       const char *slash, *backslash, *colon, *dot, *separator;
-       int i;
+       const char *separator, *backslash, *colon, *dot;

 
 

-       slash = strrchr(in, '/');
+       separator = strrchr(in, '/');

        backslash = strrchr(in, '\\');
        backslash = strrchr(in, '\\');

-       colon = strrchr(in, ':');
-       dot = strrchr(in, '.');
-       separator = slash;

        if (separator < backslash)
                separator = backslash;
        if (separator < backslash)
                separator = backslash;

+       colon = strrchr(in, ':');

        if (separator < colon)
                separator = colon;
        if (separator < colon)
                separator = colon;

+
+       dot = strrchr(in, '.');

        if (dot == NULL || dot < separator)
                return "";
        if (dot == NULL || dot < separator)
                return "";

-       dot++;
-       for (i = 0;i < 7 && dot[i];i++)
-               exten[i] = dot[i];
-       exten[i] = 0;
-       return exten;
+
+       return dot + 1;

 }
 
 
 }
 
 


@@ -1077,38 +1007,66 @@ void FS_Shutdown (void)
 ====================
 FS_SysOpen
 
 ====================
 FS_SysOpen
 

-Internal function used to create a qfile_t and open the relevant file on disk
+Internal function used to create a qfile_t and open the relevant non-packed file on disk

 ====================
 */
 static qfile_t* FS_SysOpen (const char* filepath, const char* mode)
 {
        qfile_t* file;
 ====================
 */
 static qfile_t* FS_SysOpen (const char* filepath, const char* mode)
 {
        qfile_t* file;

+       int mod, opt;
+       unsigned int ind;
+
+       // Parse the mode string
+       switch (mode[0])
+       {
+               case 'r':
+                       mod = O_RDONLY;
+                       opt = 0;
+                       break;
+               case 'w':
+                       mod = O_WRONLY;
+                       opt = O_CREAT | O_TRUNC;
+                       break;
+               case 'a':
+                       mod = O_WRONLY;
+                       opt = O_CREAT | O_APPEND;
+                       break;
+               default:
+                       Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
+                       return NULL;
+       }
+       for (ind = 1; mode[ind] != '\0'; ind++)
+       {
+               switch (mode[ind])
+               {
+                       case '+':
+                               mod = O_RDWR;
+                               break;
+                       case 'b':
+                               opt |= O_BINARY;
+                               break;
+                       default:
+                               Con_Printf ("FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
+                                                       filepath, mode, mode[ind]);
+               }
+       }

 
        file = Mem_Alloc (fs_mempool, sizeof (*file));
        memset (file, 0, sizeof (*file));
 
 
        file = Mem_Alloc (fs_mempool, sizeof (*file));
        memset (file, 0, sizeof (*file));
 

-#ifdef FS_USESYSCALLS
-       if (strchr(mode, 'r'))
-               file->stream = open (filepath, O_RDONLY | O_BINARY);
-       else if (strchr(mode, 'w'))
-               file->stream = open (filepath, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, 0666);
-       else if (strchr(mode, 'a'))
-               file->stream = open (filepath, O_RDWR | O_BINARY | O_CREAT | O_APPEND, 0666);
-       else
-               file->stream = -1;
-       if (file->stream < 0)
+       file->handle = open (filepath, mod | opt, 0666);
+       if (file->handle < 0)

        {
                Mem_Free (file);
                return NULL;
        }
        {
                Mem_Free (file);
                return NULL;
        }

-#else
-       file->stream = fopen (filepath, mode);
-       if (!file->stream)
+
+       // For files opened in read mode, we now need to get the length
+       if (mod == O_RDONLY)

        {
        {

-               Mem_Free (file);
-               return NULL;
+               file->real_length = lseek (file->handle, 0, SEEK_END);
+               lseek (file->handle, 0, SEEK_SET);

        }
        }

-#endif

 
        return file;
 }
 
        return file;
 }


@@ -1116,48 +1074,84 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode)
 
 /*
 ===========
 
 /*
 ===========

-FS_OpenRead
+FS_OpenPackedFile
+
+Open a packed file using its package file descriptor

 ===========
 */
 ===========
 */

-qfile_t *FS_OpenRead (const char *path, int offs, int len)
+qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)

 {
 {

+       packfile_t *pfile;
+       int dup_handle;

        qfile_t* file;
 
        qfile_t* file;
 

-       file = FS_SysOpen (path, "rb");
-       if (!file)
+       pfile = &pack->files[pack_ind];
+
+       // If we don't have the true offset, get it now
+       if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
+               PK3_GetTrueFileOffset (pfile, pack);
+
+       // No Zlib DLL = no compressed files
+       if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))

        {
        {

-               Sys_Error ("Couldn't open %s", path);
+               Con_Printf("WARNING: can't open the compressed file %s\n"
+                                       "You need the Zlib DLL to use compressed files\n",
+                                       pfile->name);
+               fs_filesize = -1;

                return NULL;
        }
 
                return NULL;
        }
 

-       // Normal file
-       if (offs < 0 || len < 0)
-       {
-               // We set fs_filesize here for normal files
-#ifdef FS_USESYSCALLS
-               fs_filesize = lseek (file->stream, 0, SEEK_END);
-               lseek (file->stream, 0, SEEK_SET);
-#else
-               fseek (file->stream, 0, SEEK_END);
-               fs_filesize = ftell (file->stream);
-               fseek (file->stream, 0, SEEK_SET);
-#endif
-       }
-       // Packed file
-       else
+       dup_handle = dup (pack->handle);
+       if (dup_handle < 0)
+               Sys_Error ("FS_OpenPackedFile: can't dup package's handle (pack: %s)", pack->filename);
+
+       file = Mem_Alloc (fs_mempool, sizeof (*file));
+       memset (file, 0, sizeof (*file));
+       file->handle = dup_handle;
+       file->flags = QFILE_FLAG_PACKED;
+       file->real_length = pfile->realsize;
+       file->offset = pfile->offset;
+       file->position = 0;
+
+       if (lseek (file->handle, file->offset, SEEK_SET) == -1)
+               Sys_Error ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)",
+                                       pfile->name, pack->filename, file->offset);
+
+       if (pfile->flags & PACKFILE_FLAG_DEFLATED)

        {
        {

-#ifdef FS_USESYSCALLS
-               lseek (file->stream, offs, SEEK_SET);
-#else
-               fseek (file->stream, offs, SEEK_SET);
-#endif
+               ztoolkit_t *ztk;

 
 

-               file->flags |= FS_FLAG_PACKED;
-               file->length = len;
-               file->offset = offs;
-               file->position = 0;
+               file->flags |= QFILE_FLAG_DEFLATED;
+
+               // We need some more variables
+               ztk = Mem_Alloc (fs_mempool, sizeof (*ztk));
+
+               ztk->comp_length = pfile->packsize;
+
+               // Initialize zlib stream
+               ztk->zstream.next_in = ztk->input;
+               ztk->zstream.avail_in = 0;
+
+               /* From Zlib's "unzip.c":
+                *
+                * windowBits is passed < 0 to tell that there is no zlib header.
+                * Note that in this case inflate *requires* an extra "dummy" byte
+                * after the compressed stream in order to complete decompression and
+                * return Z_STREAM_END.
+                * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+                * size of both compressed and uncompressed data
+                */
+               if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
+                       Sys_Error ("FS_OpenPackedFile: inflate init error (file: %s)", pfile->name);
+
+               ztk->zstream.next_out = file->buff;
+               ztk->zstream.avail_out = sizeof (file->buff);
+
+               file->ztk = ztk;

        }
 
        }
 

+       fs_filesize = pfile->realsize;
+

        return file;
 }
 
        return file;
 }
 


@@ -1177,21 +1171,26 @@ int FS_CheckNastyPath (const char *path)
        // (on Windows \ is a directory separator, but / is also supported)
        if (strstr(path, "\\"))
                return 1; // non-portable
        // (on Windows \ is a directory separator, but / is also supported)
        if (strstr(path, "\\"))
                return 1; // non-portable

+

        // Mac: don't allow Mac-only filenames - : is a directory separator
        // instead of /, but we rely on / working already, so there's no reason to
        // support a Mac-only path
        // Amiga and Windows: : tries to go to root of drive
        if (strstr(path, ":"))
                return 1; // non-portable attempt to go to root of drive
        // Mac: don't allow Mac-only filenames - : is a directory separator
        // instead of /, but we rely on / working already, so there's no reason to
        // support a Mac-only path
        // Amiga and Windows: : tries to go to root of drive
        if (strstr(path, ":"))
                return 1; // non-portable attempt to go to root of drive

+

        // Amiga: // is parent directory
        if (strstr(path, "//"))
                return 1; // non-portable attempt to go to parent directory
        // Amiga: // is parent directory
        if (strstr(path, "//"))
                return 1; // non-portable attempt to go to parent directory

+

        // all: don't allow going to current directory (./) or parent directory (../ or /../)
        if (strstr(path, "./"))
                return 2; // attempt to go outside the game directory
        // all: don't allow going to current directory (./) or parent directory (../ or /../)
        if (strstr(path, "./"))
                return 2; // attempt to go outside the game directory

+

        // Windows and UNIXes: don't allow absolute paths
        if (path[0] == '/')
                return 2; // attempt to go outside the game directory
        // Windows and UNIXes: don't allow absolute paths
        if (path[0] == '/')
                return 2; // attempt to go outside the game directory

+

        // after all these checks we're pretty sure it's a / separated filename
        // and won't do much if any harm
        return false;
        // after all these checks we're pretty sure it's a / separated filename
        // and won't do much if any harm
        return false;


@@ -1281,22 +1280,19 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
 
 /*
 ===========
 
 /*
 ===========

-FS_FOpenFile
+FS_OpenReadFile

 
 

-If the requested file is inside a packfile, a new qfile_t* will be opened
-into the file.
+Look for a file in the search paths and open it in read-only mode

 
 Sets fs_filesize
 ===========
 */
 
 Sets fs_filesize
 ===========
 */

-qfile_t *FS_FOpenFile (const char *filename, qboolean quiet)
+qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet)

 {
        searchpath_t *search;
 {
        searchpath_t *search;

-       packfile_t *packfile;
-       int i;
-       qfile_t *file;
+       int pack_ind;

 
 

-       search = FS_FindFile (filename, &i, quiet);
+       search = FS_FindFile (filename, &pack_ind, quiet);

 
        // Not found?
        if (search == NULL)
 
        // Not found?
        if (search == NULL)


@@ -1306,68 +1302,15 @@ qfile_t *FS_FOpenFile (const char *filename, qboolean quiet)
        }
 
        // Found in the filesystem?
        }
 
        // Found in the filesystem?

-       if (i < 0)
+       if (pack_ind < 0)

        {
        {

-               char netpath[MAX_OSPATH];
-               snprintf(netpath, sizeof(netpath), "%s/%s", search->filename, filename);
-               return FS_OpenRead(netpath, -1, -1);
+               char path [MAX_OSPATH];
+               snprintf (path, sizeof (path), "%s/%s", search->filename, filename);
+               return FS_SysOpen (path, "rb");

        }
 
        // So, we found it in a package...
        }
 
        // So, we found it in a package...

-       packfile = &search->pack->files[i];
-
-       // If we don't have the true offset, get it now
-       if (! (packfile->flags & FILE_FLAG_TRUEOFFS))
-               PK3_GetTrueFileOffset (packfile, search->pack);
-
-       // No Zlib DLL = no compressed files
-       if (!zlib_dll && (packfile->flags & FILE_FLAG_DEFLATED))
-       {
-               Con_Printf("WARNING: can't open the compressed file %s\n"
-                                       "You need the Zlib DLL to use compressed files\n",
-                                       filename);
-               fs_filesize = -1;
-               return NULL;
-       }
-
-       // open a new file in the pakfile
-       file = FS_OpenRead (search->pack->filename, packfile->offset, packfile->packsize);
-       fs_filesize = packfile->realsize;
-
-       if (packfile->flags & FILE_FLAG_DEFLATED)
-       {
-               ztoolkit_t *ztk;
-
-               file->flags |= FS_FLAG_DEFLATED;
-
-               // We need some more variables
-               ztk = Mem_Alloc (fs_mempool, sizeof (*file->z));
-
-               ztk->real_length = packfile->realsize;
-
-               // Initialize zlib stream
-               ztk->zstream.next_in = ztk->input;
-               ztk->zstream.avail_in = 0;
-
-               /* From Zlib's "unzip.c":
-                *
-                * windowBits is passed < 0 to tell that there is no zlib header.
-                * Note that in this case inflate *requires* an extra "dummy" byte
-                * after the compressed stream in order to complete decompression and
-                * return Z_STREAM_END.
-                * In unzip, i don't wait absolutely Z_STREAM_END because I known the
-                * size of both compressed and uncompressed data
-                */
-               if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
-                       Sys_Error ("inflate init error (file: %s)", filename);
-
-               ztk->zstream.next_out = ztk->output;
-               ztk->zstream.avail_out = sizeof (ztk->output);
-
-               file->z = ztk;
-       }
-
-       return file;
+       return FS_OpenPackedFile (search->pack, pack_ind);

 }
 
 
 }
 
 


@@ -1388,14 +1331,16 @@ Open a file. The syntax is the same as fopen
 */
 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet)
 {
 */
 qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet)
 {

+       qfile_t* file;
+

        if (FS_CheckNastyPath(filepath))
        {
                Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
                return NULL;
        }
 
        if (FS_CheckNastyPath(filepath))
        {
                Con_Printf("FS_Open(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
                return NULL;
        }
 

-       // If the file is opened in "write" or "append" mode
-       if (strchr (mode, 'w') || strchr (mode, 'a'))
+       // If the file is opened in "write", "append", or "read/write" mode
+       if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))

        {
                char real_path [MAX_OSPATH];
 
        {
                char real_path [MAX_OSPATH];
 


@@ -1408,8 +1353,12 @@ qfile_t* FS_Open (const char* filepath, const char* mode, qboolean quiet)
                return FS_SysOpen (real_path, mode);
        }
 
                return FS_SysOpen (real_path, mode);
        }
 

-       // Else, we look at the various search paths
-       return FS_FOpenFile (filepath, quiet);
+       // Else, we look at the various search paths and open the file in read-only mode
+       file = FS_OpenReadFile (filepath, quiet);
+       if (file != NULL)
+               fs_filesize = file->real_length;
+
+       return file;

 }
 
 
 }
 
 


@@ -1422,17 +1371,13 @@ Close a file
 */
 int FS_Close (qfile_t* file)
 {
 */
 int FS_Close (qfile_t* file)
 {

-#ifdef FS_USESYSCALLS
-       if (close (file->stream))
-#else
-       if (fclose (file->stream))
-#endif
+       if (close (file->handle))

                return EOF;
 
                return EOF;
 

-       if (file->z)
+       if (file->ztk)

        {
        {

-               qz_inflateEnd (&file->z->zstream);
-               Mem_Free (file->z);
+               qz_inflateEnd (&file->ztk->zstream);
+               Mem_Free (file->ztk);

        }
 
        Mem_Free (file);
        }
 
        Mem_Free (file);


@@ -1449,11 +1394,11 @@ Write "datasize" bytes into a file
 */
 size_t FS_Write (qfile_t* file, const void* data, size_t datasize)
 {
 */
 size_t FS_Write (qfile_t* file, const void* data, size_t datasize)
 {

-#ifdef FS_USESYSCALLS
-       return write (file->stream, data, datasize);
-#else
-       return fwrite (data, 1, datasize, file->stream);
-#endif
+       ssize_t result = write (file->handle, data, datasize);
+       if (result < 0)
+               return 0;
+
+       return result;

 }
 
 
 }
 
 


@@ -1466,151 +1411,150 @@ Read up to "buffersize" bytes from a file
 */
 size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
 {
 */
 size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
 {

-       size_t count, nb;
-       ztoolkit_t *ztk;
+       size_t count, done;

 
 

-       // Quick path for unpacked files
-       if (! (file->flags & FS_FLAG_PACKED))
-#ifdef FS_USESYSCALLS
-               return read (file->stream, buffer, buffersize);
-#else
-               return fread (buffer, 1, buffersize, file->stream);
-#endif
-
-       // If the file isn't compressed
-       if (! (file->flags & FS_FLAG_DEFLATED))
+       // First, we copy as many bytes as we can from "buff"
+       if (file->buff_ind < file->buff_len)

        {
        {

-               // We must take care to not read after the end of the file
-               count = file->length - file->position;
-               if (buffersize > count)
-                       buffersize = count;
+               count = file->buff_len - file->buff_ind;

 
 

-#ifdef FS_USESYSCALLS
-               nb = read (file->stream, buffer, buffersize);
-#else
-               nb = fread (buffer, 1, buffersize, file->stream);
-#endif
+               done = (buffersize > count) ? count : buffersize;
+               memcpy (buffer, &file->buff[file->buff_ind], done);
+               file->buff_ind += done;

 
 

-               file->position += nb;
-               return nb;
+               buffersize -= done;
+               if (buffersize == 0)
+                       return done;

        }
        }

+       else
+               done = 0;

 
 

-       // If the file is compressed, it's more complicated...
-       ztk = file->z;
+       // NOTE: at this point, the read buffer is always empty

 
 

-       // First, we copy as many bytes as we can from "output"
-       if (ztk->out_ind < ztk->out_max)
+       // If the file isn't compressed
+       if (! (file->flags & QFILE_FLAG_DEFLATED))

        {
        {

-               count = ztk->out_max - ztk->out_ind;
+               int nb;
+
+               // We must take care to not read after the end of the file
+               count = file->real_length - file->position;
+
+               // If we have a lot of data to get, put them directly into "buffer"
+               if (buffersize > sizeof (file->buff) / 2)
+               {
+                       if (count > buffersize)
+                               count = buffersize;
+                       lseek (file->handle, file->offset + file->position, SEEK_SET);
+                       nb = read (file->handle, &((qbyte*)buffer)[done], count);
+                       if (nb > 0)
+                       {
+                               done += nb;
+                               file->position += nb;
+
+                               // Invalidate the output data (for FS_Seek)
+                               file->buff_len = 0;
+                               file->buff_ind = 0;
+                       }
+               }
+               else
+               {
+                       if (count > sizeof (file->buff))
+                               count = sizeof (file->buff);
+                       lseek (file->handle, file->offset + file->position, SEEK_SET);
+                       nb = read (file->handle, file->buff, count);
+                       if (nb > 0)
+                       {
+                               file->buff_len = nb;
+                               file->position += nb;
+
+                               // Copy the requested data in "buffer" (as much as we can)
+                               count = (buffersize > file->buff_len) ? file->buff_len : buffersize;
+                               memcpy (&((qbyte*)buffer)[done], file->buff, count);
+                               file->buff_ind = count;
+                               done += count;
+                       }
+               }

 
 

-               nb = (buffersize > count) ? count : buffersize;
-               memcpy (buffer, &ztk->output[ztk->out_ind], nb);
-               ztk->out_ind += nb;
-               file->position += nb;
+               return done;

        }
        }

-       else
-               nb = 0;

 
 

-       // We cycle through a few operations until we have inflated enough data
-       while (nb < buffersize)
+       // If the file is compressed, it's more complicated...
+       // We cycle through a few operations until we have read enough data
+       while (buffersize > 0)

        {
        {

-               // NOTE: at this point, "output" should always be empty
+               ztoolkit_t *ztk = file->ztk;
+               int error;

 
 

-               // If "input" is also empty, we need to fill it
-               if (ztk->in_ind == ztk->in_max)
-               {
-                       size_t remain;
+               // NOTE: at this point, the read buffer is always empty

 
 

+               // If "input" is also empty, we need to refill it
+               if (ztk->in_ind == ztk->in_len)
+               {

                        // If we are at the end of the file
                        // If we are at the end of the file

-                       if (ztk->out_position == ztk->real_length)
-                               return nb;
+                       if (file->position == file->real_length)
+                               return done;

 
 

-                       remain = file->length - ztk->in_position;
-                       count = (remain > sizeof (ztk->input)) ? sizeof (ztk->input) : remain;
-#ifdef FS_USESYSCALLS
-                       read (file->stream, ztk->input, count);
-#else
-                       fread (ztk->input, 1, count, file->stream);
-#endif
+                       count = ztk->comp_length - ztk->in_position;
+                       if (count > sizeof (ztk->input))
+                               count = sizeof (ztk->input);
+                       lseek (file->handle, file->offset + ztk->in_position, SEEK_SET);
+                       if (read (file->handle, ztk->input, count) != (ssize_t)count)
+                               Sys_Error ("FS_Read: unexpected end of file");

 
 

-                       // Update indexes and counters

                        ztk->in_ind = 0;
                        ztk->in_ind = 0;

-                       ztk->in_max = count;
+                       ztk->in_len = count;

                        ztk->in_position += count;
                }
 
                        ztk->in_position += count;
                }
 

-               // Now that we are sure we have compressed data available, we need to determine
-               // if it's better to inflate it in "output" or directly in "buffer" (we are in this
-               // case if we still need more bytes than "output" can contain)
-

                ztk->zstream.next_in = &ztk->input[ztk->in_ind];
                ztk->zstream.next_in = &ztk->input[ztk->in_ind];

-               ztk->zstream.avail_in = ztk->in_max - ztk->in_ind;
+               ztk->zstream.avail_in = ztk->in_len - ztk->in_ind;

 
 

-               // If output will be able to contain at least 1 more byte than the data we need
-               if (buffersize - nb < sizeof (ztk->output))
-               {
-                       int error;
+               // Now that we are sure we have compressed data available, we need to determine
+               // if it's better to inflate it in "file->buff" or directly in "buffer"

 
 

-                       // Inflate the data in "output"
-                       ztk->zstream.next_out = ztk->output;
-                       ztk->zstream.avail_out = sizeof (ztk->output);
+               // Inflate the data in "file->buff"
+               if (buffersize < sizeof (file->buff) / 2)
+               {
+                       ztk->zstream.next_out = file->buff;
+                       ztk->zstream.avail_out = sizeof (file->buff);

                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
                                Sys_Error ("Can't inflate file");
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
                                Sys_Error ("Can't inflate file");

-                       ztk->in_ind = ztk->in_max - ztk->zstream.avail_in;
-                       ztk->out_max = sizeof (ztk->output) - ztk->zstream.avail_out;
-                       ztk->out_position += ztk->out_max;
+                       ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
+
+                       file->buff_len = sizeof (file->buff) - ztk->zstream.avail_out;
+                       file->position += file->buff_len;

 
                        // Copy the requested data in "buffer" (as much as we can)
 
                        // Copy the requested data in "buffer" (as much as we can)

-                       count = (buffersize - nb > ztk->out_max) ? ztk->out_max : buffersize - nb;
-                       memcpy (&((qbyte*)buffer)[nb], ztk->output, count);
-                       ztk->out_ind = count;
+                       count = (buffersize > file->buff_len) ? file->buff_len : buffersize;
+                       memcpy (&((qbyte*)buffer)[done], file->buff, count);
+                       file->buff_ind = count;

                }
 
                // Else, we inflate directly in "buffer"
                else
                {
                }
 
                // Else, we inflate directly in "buffer"
                else
                {

-                       int error;
-
-                       // Inflate the data in "buffer"
-                       ztk->zstream.next_out = &((qbyte*)buffer)[nb];
-                       ztk->zstream.avail_out = buffersize - nb;
+                       ztk->zstream.next_out = &((qbyte*)buffer)[done];
+                       ztk->zstream.avail_out = buffersize;

                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
                                Sys_Error ("Can't inflate file");
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
                                Sys_Error ("Can't inflate file");

-                       ztk->in_ind = ztk->in_max - ztk->zstream.avail_in;
-
-                       // Invalidate the output data (for FS_Seek)
-                       ztk->out_max = 0;
-                       ztk->out_ind = 0;
+                       ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;

 
                        // How much data did it inflate?
 
                        // How much data did it inflate?

-                       count = buffersize - nb - ztk->zstream.avail_out;
-                       ztk->out_position += count;
+                       count = buffersize - ztk->zstream.avail_out;
+                       file->position += count;
+
+                       // Invalidate the output data (for FS_Seek)
+                       file->buff_len = 0;
+                       file->buff_ind = 0;

                }
 
                }
 

-               nb += count;
-               file->position += count;
+               done += count;
+               buffersize -= count;

        }
 
        }
 

-       return nb;
-}
-
-
-/*
-====================
-FS_Flush
-
-Flush the file output stream
-====================
-*/
-int FS_Flush (qfile_t* file)
-{
-#ifdef FS_USESYSCALLS
-       return 0;
-#else
-       return fflush (file->stream);
-#endif
+       return done;

 }
 
 
 }
 
 


@@ -1621,9 +1565,9 @@ FS_Print
 Print a string into a file
 ====================
 */
 Print a string into a file
 ====================
 */

-int FS_Print(qfile_t* file, const char *msg)
+int FS_Print (qfile_t* file, const char *msg)

 {
 {

-       return FS_Write(file, msg, strlen(msg));
+       return FS_Write (file, msg, strlen (msg));

 }
 
 /*
 }
 
 /*


@@ -1639,7 +1583,7 @@ int FS_Printf(qfile_t* file, const char* format, ...)
        va_list args;
 
        va_start (args, format);
        va_list args;
 
        va_start (args, format);

-       result = FS_VPrintf(file, format, args);
+       result = FS_VPrintf (file, format, args);

        va_end (args);
 
        return result;
        va_end (args);
 
        return result;


@@ -1653,28 +1597,22 @@ FS_VPrintf
 Print a string into a file
 ====================
 */
 Print a string into a file
 ====================
 */

-int FS_VPrintf(qfile_t* file, const char* format, va_list ap)
-{
-#ifdef FS_USESYSCALLS
+int FS_VPrintf (qfile_t* file, const char* format, va_list ap)

 {
        int len;
 {
        int len;

-       char tempstring[1024];
+       char tempstring [1024];
+

        len = vsnprintf (tempstring, sizeof(tempstring), format, ap);
        len = vsnprintf (tempstring, sizeof(tempstring), format, ap);

-       if (len >= sizeof(tempstring))
+       if (len >= sizeof (tempstring))

        {
        {

-               int result;
-               char *temp = Mem_Alloc(tempmempool, len + 1);
+               char *temp = Mem_Alloc (tempmempool, len + 1);

                len = vsnprintf (temp, len + 1, format, ap);
                len = vsnprintf (temp, len + 1, format, ap);

-               result = write (file->stream, temp, len);
-               Mem_Free(temp);
-               return result;
+               len = write (file->handle, temp, len);
+               Mem_Free (temp);
+               return len;

        }
        }

-       else
-               return write (file->stream, tempstring, len);
-}
-#else
-       return vfprintf (file->stream, format, ap);
-#endif
+
+       return write (file->handle, tempstring, len);

 }
 
 
 }
 
 


@@ -1705,119 +1643,90 @@ Move the position index in a file
 */
 int FS_Seek (qfile_t* file, long offset, int whence)
 {
 */
 int FS_Seek (qfile_t* file, long offset, int whence)
 {

-       // Quick path for unpacked files
-       if (! (file->flags & FS_FLAG_PACKED))
-#ifdef FS_USESYSCALLS
-       {
-               if (lseek (file->stream, offset, whence) == -1)
-                       return -1;
-               return 0;
-       }
-#else
-               return fseek (file->stream, offset, whence);
-#endif
+       ztoolkit_t *ztk;
+       qbyte* buffer;
+       size_t buffersize;

 
 

-       // Seeking in compressed files is more a hack than anything else,
-       // but we need to support it, so here it is.
-       if (file->flags & FS_FLAG_DEFLATED)
+       // Compute the file offset
+       switch (whence)

        {
        {

-               ztoolkit_t *ztk = file->z;
-               qbyte buffer [sizeof (ztk->output)];  // it's big to force inflating into buffer directly
-
-               switch (whence)
-               {
-                       case SEEK_CUR:
-                               offset += file->position;
-                               break;
+               case SEEK_CUR:
+                       offset += file->position - file->buff_len + file->buff_ind;
+                       break;

 
 

-                       case SEEK_SET:
-                               break;
+               case SEEK_SET:
+                       break;

 
 

-                       case SEEK_END:
-                               offset += ztk->real_length;
-                               break;
+               case SEEK_END:
+                       offset += file->real_length;
+                       break;

 
 

-                       default:
-                               return -1;
-               }
-               if (offset < 0 || offset > (long) ztk->real_length)
+               default:

                        return -1;
                        return -1;

+       }
+       if (offset < 0 || offset > (long) file->real_length)
+               return -1;

 
 

-               // If we need to go back in the file
-               if (offset <= (long) file->position)
-               {
-                       // If we still have the data we need in the output buffer
-                       if (file->position - offset <= ztk->out_ind)
-                       {
-                               ztk->out_ind -= file->position - offset;
-                               file->position = offset;
-                               return 0;
-                       }
-
-                       // Else, we restart from the beginning of the file
-                       ztk->in_ind = 0;
-                       ztk->in_max = 0;
-                       ztk->in_position = 0;
-                       ztk->out_ind = 0;
-                       ztk->out_max = 0;
-                       ztk->out_position = 0;
-                       file->position = 0;
-#ifdef FS_USESYSCALLS
-                       lseek (file->stream, file->offset, SEEK_SET);
-#else
-                       fseek (file->stream, file->offset, SEEK_SET);
-#endif
-
-                       // Reset the Zlib stream
-                       ztk->zstream.next_in = ztk->input;
-                       ztk->zstream.avail_in = 0;
-                       qz_inflateReset (&ztk->zstream);
-               }
-
-               // Skip all data until we reach the requested offset
-               while ((long) file->position < offset)
-               {
-                       size_t diff = offset - file->position;
-                       size_t count, len;
+       // If we have the data in our read buffer, we don't need to actually seek
+       if (file->position - file->buff_len <= (size_t)offset &&
+               (size_t)offset <= file->position)
+       {
+               file->buff_ind = offset + file->buff_len - file->position;
+               return 0;
+       }

 
 

-                       count = (diff > sizeof (buffer)) ? sizeof (buffer) : diff;
-                       len = FS_Read (file, buffer, count);
-                       if (len != count)
-                               return -1;
-               }
+       // Invalidate the read buffer contents
+       file->buff_ind = 0;
+       file->buff_len = 0;

 
 

+       // Unpacked or uncompressed files can seek directly
+       if (! (file->flags & QFILE_FLAG_DEFLATED))
+       {
+               if (lseek (file->handle, file->offset + offset, SEEK_SET) == -1)
+                       return -1;
+               file->position = offset;

                return 0;
        }
 
                return 0;
        }
 

-       // Packed files receive a special treatment too, because
-       // we need to make sure it doesn't go outside of the file
-       switch (whence)
+       // Seeking in compressed files is more a hack than anything else,
+       // but we need to support it, so here we go.
+       ztk = file->ztk;
+
+       // If we have to go back in the file, we need to restart from the beginning
+       if ((size_t)offset <= file->position)

        {
        {

-               case SEEK_CUR:
-                       offset += file->position;
-                       break;
+               ztk->in_ind = 0;
+               ztk->in_len = 0;
+               ztk->in_position = 0;
+               file->position = 0;
+               lseek (file->handle, file->offset, SEEK_SET);

 
 

-               case SEEK_SET:
-                       break;
+               // Reset the Zlib stream
+               ztk->zstream.next_in = ztk->input;
+               ztk->zstream.avail_in = 0;
+               qz_inflateReset (&ztk->zstream);
+       }

 
 

-               case SEEK_END:
-                       offset += file->length;
-                       break;
+       // We need a big buffer to force inflating into it directly
+       buffersize = 2 * sizeof (file->buff);
+       buffer = Mem_Alloc (tempmempool, buffersize);

 
 

-               default:
+       // Skip all data until we reach the requested offset
+       while ((size_t)offset > file->position)
+       {
+               size_t diff = offset - file->position;
+               size_t count, len;
+
+               count = (diff > buffersize) ? buffersize : diff;
+               len = FS_Read (file, buffer, count);
+               if (len != count)
+               {
+                       Mem_Free (buffer);

                        return -1;
                        return -1;

+               }

        }
        }

-       if (offset < 0 || offset > (long) file->length)
-               return -1;

 
 

-#ifdef FS_USESYSCALLS
-       if (lseek (file->stream, file->offset + offset, SEEK_SET) == -1)
-               return -1;
-#else
-       if (fseek (file->stream, file->offset + offset, SEEK_SET) == -1)
-               return -1;
-#endif
-       file->position = offset;
+       Mem_Free (buffer);

        return 0;
 }
 
        return 0;
 }
 


@@ -1831,14 +1740,7 @@ Give the current position in a file
 */
 long FS_Tell (qfile_t* file)
 {
 */
 long FS_Tell (qfile_t* file)
 {

-       if (file->flags & FS_FLAG_PACKED)
-               return file->position;
-
-#ifdef FS_USESYSCALLS
-       return lseek (file->stream, 0, SEEK_CUR);
-#else
-       return ftell (file->stream);
-#endif
+       return file->position - file->buff_len + file->buff_ind;

 }
 
 
 }
 
 


@@ -1849,23 +1751,17 @@ FS_Gets
 Extract a line from a file
 ====================
 */
 Extract a line from a file
 ====================
 */

-char* FS_Gets (qfile_t* file, char* buffer, int buffersize)
+char* FS_Gets (qfile_t* file, char* buffer, size_t buffersize)

 {
        size_t ind;
 
 {
        size_t ind;
 

-       // Quick path for unpacked files
-#ifndef FS_USESYSCALLS
-       if (! (file->flags & FS_FLAG_PACKED))
-               return fgets (buffer, buffersize, file->stream);
-#endif
-

        for (ind = 0; ind < (size_t) buffersize - 1; ind++)
        {
                int c = FS_Getc (file);
                switch (c)
                {
                        // End of file
        for (ind = 0; ind < (size_t) buffersize - 1; ind++)
        {
                int c = FS_Getc (file);
                switch (c)
                {
                        // End of file

-                       case -1:
+                       case EOF:

                                if (!ind)
                                        return NULL;
 
                                if (!ind)
                                        return NULL;
 


@@ -1928,33 +1824,6 @@ char *FS_Getline (qfile_t *file)
 }
 
 
 }
 
 

-/*
-====================
-FS_Eof
-
-Extract a line from a file
-====================
-*/
-// FIXME: remove this function?
-int FS_Eof (qfile_t* file)
-{
-       if (file->flags & FS_FLAG_PACKED)
-       {
-               if (file->flags & FS_FLAG_DEFLATED)
-                       return (file->position == file->z->real_length);
-
-               return (file->position == file->length);
-       }
-
-#ifdef FS_USESYSCALLS
-       Sys_Error("FS_Eof: not implemented using syscalls\n");
-       return false;
-#else
-       return feof (file->stream);
-#endif
-}
-
-

 /*
 ============
 FS_LoadFile
 /*
 ============
 FS_LoadFile


@@ -1965,22 +1834,18 @@ Always appends a 0 byte.
 */
 qbyte *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet)
 {
 */
 qbyte *FS_LoadFile (const char *path, mempool_t *pool, qboolean quiet)
 {

-       qfile_t *h;
+       qfile_t *file;

        qbyte *buf;
 
        qbyte *buf;
 

-       // look for it in the filesystem or pack files
-       h = FS_Open (path, "rb", quiet);
-       if (!h)
+       file = FS_Open (path, "rb", quiet);
+       if (!file)

                return NULL;
 
                return NULL;
 

-       buf = Mem_Alloc(pool, fs_filesize+1);
-       if (!buf)
-               Sys_Error ("FS_LoadFile: not enough available memory for %s (size %i)", path, fs_filesize);
-
-       ((qbyte *)buf)[fs_filesize] = 0;
+       buf = Mem_Alloc (pool, fs_filesize + 1);
+       buf[fs_filesize] = '\0';

 
 

-       FS_Read (h, buf, fs_filesize);
-       FS_Close (h);
+       FS_Read (file, buf, fs_filesize);
+       FS_Close (file);

 
        return buf;
 }
 
        return buf;
 }


@@ -1995,18 +1860,18 @@ The filename will be prefixed by the current game directory
 */
 qboolean FS_WriteFile (const char *filename, void *data, int len)
 {
 */
 qboolean FS_WriteFile (const char *filename, void *data, int len)
 {

-       qfile_t *handle;
+       qfile_t *file;

 
 

-       handle = FS_Open (filename, "wb", false);
-       if (!handle)
+       file = FS_Open (filename, "wb", false);
+       if (!file)

        {
                Con_Printf("FS_WriteFile: failed on %s\n", filename);
                return false;
        }
 
        Con_DPrintf("FS_WriteFile: %s\n", filename);
        {
                Con_Printf("FS_WriteFile: failed on %s\n", filename);
                return false;
        }
 
        Con_DPrintf("FS_WriteFile: %s\n", filename);

-       FS_Write (handle, data, len);
-       FS_Close (handle);
+       FS_Write (file, data, len);
+       FS_Close (file);

        return true;
 }
 
        return true;
 }
 


@@ -2094,16 +1959,15 @@ Look for a file in the filesystem only
 qboolean FS_SysFileExists (const char *path)
 {
 #if WIN32
 qboolean FS_SysFileExists (const char *path)
 {
 #if WIN32

-       FILE *f;
+       int desc;

 
 

-       f = fopen (path, "rb");
-       if (f)
-       {
-               fclose (f);
-               return true;
-       }
+       // TODO: use another function instead, to avoid opening the file
+       desc = open (path, O_RDONLY | O_BINARY);
+       if (desc < 0)
+               return false;

 
 

-       return false;
+       close (desc);
+       return true;

 #else
        struct stat buf;
 
 #else
        struct stat buf;
 

diff --git a/fs.h b/fs.h
index 79115351e86c9a2c666e8b5fd3ce3566a8e0d579..7af7b039e425aa08bd5407a50712277819a60419 100644 (file)
--- a/fs.h
+++ b/fs.h
@@ -1,7 +1,7 @@
 /*
        DarkPlaces file system
 
 /*
        DarkPlaces file system
 

-       Copyright (C) 2003 Mathieu Olivier
+       Copyright (C) 2003-2005 Mathieu Olivier

 
        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
 
        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License


@@ -48,16 +48,14 @@ qfile_t *FS_Open (const char* filepath, const char* mode, qboolean quiet);
 int FS_Close (qfile_t* file);
 size_t FS_Write (qfile_t* file, const void* data, size_t datasize);
 size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize);
 int FS_Close (qfile_t* file);
 size_t FS_Write (qfile_t* file, const void* data, size_t datasize);
 size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize);

-int FS_Flush (qfile_t* file);

 int FS_Print(qfile_t* file, const char *msg);
 int FS_Printf(qfile_t* file, const char* format, ...);
 int FS_VPrintf(qfile_t* file, const char* format, va_list ap);
 int FS_Getc (qfile_t* file);
 int FS_Seek (qfile_t* file, long offset, int whence);
 long FS_Tell (qfile_t* file);
 int FS_Print(qfile_t* file, const char *msg);
 int FS_Printf(qfile_t* file, const char* format, ...);
 int FS_VPrintf(qfile_t* file, const char* format, va_list ap);
 int FS_Getc (qfile_t* file);
 int FS_Seek (qfile_t* file, long offset, int whence);
 long FS_Tell (qfile_t* file);

-char *FS_Gets (qfile_t* file, char* buffer, int buffersize);
+char *FS_Gets (qfile_t* file, char* buffer, size_t buffersize);

 char *FS_Getline (qfile_t *file);  // DO NOT FREE the returned buffer
 char *FS_Getline (qfile_t *file);  // DO NOT FREE the returned buffer

-int FS_Eof (qfile_t* file);

 
 typedef struct fssearch_s
 {
 
 typedef struct fssearch_s
 {

diff --git a/host_cmd.c b/host_cmd.c
index 0ab60c24e8490e0beeefe64a1e9926a26e948c01..88dc8b38d94a331ba87e0e3b3f3dc5a452d6135d 100644 (file)
--- a/host_cmd.c
+++ b/host_cmd.c
@@ -65,8 +65,8 @@ void Host_Status_f (void)
        for (players = 0, j = 0;j < svs.maxclients;j++)
                if (svs.clients[j].active)
                        players++;
        for (players = 0, j = 0;j < svs.maxclients;j++)
                if (svs.clients[j].active)
                        players++;

-       print ("host:    %s\n", Cvar_VariableString ("hostname"));
-       print ("version: %s build %s\n", gamename, buildstring);
+       print ("host:     %s\n", Cvar_VariableString ("hostname"));
+       print ("version:  %s build %s\n", gamename, buildstring);

        switch(sv.protocol)
        {
                case PROTOCOL_QUAKE: protocolname = sv.netquakecompatible ? "QUAKE" : "QUAKEDP";break;
        switch(sv.protocol)
        {
                case PROTOCOL_QUAKE: protocolname = sv.netquakecompatible ? "QUAKE" : "QUAKEDP";break;


@@ -79,8 +79,8 @@ void Host_Status_f (void)
                default: protocolname = "PROTOCOL_UNKNOWN";break;
        }
        print ("protocol: %i (%s)\n", sv.protocol, protocolname);
                default: protocolname = "PROTOCOL_UNKNOWN";break;
        }
        print ("protocol: %i (%s)\n", sv.protocol, protocolname);

-       print ("map:     %s\n", sv.name);
-       print ("players: %i active (%i max)\n\n", players, svs.maxclients);
+       print ("map:      %s\n", sv.name);
+       print ("players:  %i active (%i max)\n\n", players, svs.maxclients);

        for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
        {
                if (!client->active)
        for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
        {
                if (!client->active)


@@ -516,8 +516,7 @@ void Host_Savegame_f (void)
        FS_Printf(f, "%s\n", sv.name);
        FS_Printf(f, "%f\n",sv.time);
 
        FS_Printf(f, "%s\n", sv.name);
        FS_Printf(f, "%f\n",sv.time);
 

-// write the light styles
-
+       // write the light styles

        for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
        {
                if (sv.lightstyles[i])
        for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
        {
                if (sv.lightstyles[i])


@@ -526,13 +525,9 @@ void Host_Savegame_f (void)
                        FS_Print(f,"m\n");
        }
 
                        FS_Print(f,"m\n");
        }
 

-

        ED_WriteGlobals (f);
        for (i=0 ; i<sv.num_edicts ; i++)
        ED_WriteGlobals (f);
        for (i=0 ; i<sv.num_edicts ; i++)

-       {

                ED_Write (f, EDICT_NUM(i));
                ED_Write (f, EDICT_NUM(i));

-               FS_Flush (f);
-       }

        FS_Close (f);
        Con_Print("done.\n");
 }
        FS_Close (f);
        Con_Print("done.\n");
 }

diff --git a/snd_null.c b/snd_null.c
index 5a8c94a1fc33b6cfb25288930bd57e4fdd7f076c..21e3f09f2d10b6d81bb2e2750ccf632ffb79d910 100755 (executable)
--- a/snd_null.c
+++ b/snd_null.c
@@ -78,10 +78,6 @@ void S_PauseGameSounds (qboolean toggle)
 {
 }
 
 {
 }
 

-void S_ClearBuffer (void)
-{
-}
-

 void S_SetChannelVolume (unsigned int ch_ind, float fvol)
 {
 }
 void S_SetChannelVolume (unsigned int ch_ind, float fvol)
 {
 }

diff --git a/sound.h b/sound.h
index f5ab1b7583df9b404211dea36da20aaccefd7d55..af734196cc8fcddfab8aee88a4aa82198a34c3fc 100644 (file)
--- a/sound.h
+++ b/sound.h
@@ -75,7 +75,6 @@ void S_StaticSound (sfx_t *sfx, vec3_t origin, float fvol, float attenuation);
 void S_StopSound (int entnum, int entchannel);
 void S_StopAllSounds (void);
 void S_PauseGameSounds (qboolean toggle);
 void S_StopSound (int entnum, int entchannel);
 void S_StopAllSounds (void);
 void S_PauseGameSounds (qboolean toggle);

-void S_ClearBuffer (void);

 
 void S_StopChannel (unsigned int channel_ind);
 qboolean S_SetChannelFlag (unsigned int ch_ind, unsigned int flag, qboolean value);
 
 void S_StopChannel (unsigned int channel_ind);
 qboolean S_SetChannelFlag (unsigned int ch_ind, unsigned int flag, qboolean value);