fs.c File Reference

#include <limits.h>
#include <fcntl.h>
#include <pwd.h>
#include <sys/stat.h>
#include <unistd.h>
#include "quakedef.h"
#include "thread.h"
#include "fs.h"
#include "wad.h"
#include "utf8lib.h"

Include dependency graph for fs.c:

Go to the source code of this file.

Data Structures
struct	dpackfile_t
struct	dpackheader_t
struct	pack_t
struct	packfile_t
struct	pk3_endOfCentralDir_t
struct	qfile_t
struct	searchpath_t
	Search paths for files (including packages) More...
struct	z_stream
struct	ztoolkit_t

Macros
#define	FILE_BUFF_SIZE   2048
#define	FILEDESC_CLOSE   close
#define	FILEDESC_INVALID   -1
#define	FILEDESC_ISVALID(fd)
#define	FILEDESC_READ   read
#define	FILEDESC_READ   ReadAll
#define	FILEDESC_SEEK   lseek
#define	FILEDESC_WRITE   write
#define	FILEDESC_WRITE   WriteAll
#define	MAX_WBITS   15
#define	O_BINARY   0
#define	O_NONBLOCK   0
#define	QFILE_FLAG_DATA   (1 << 2)
	file is actually already loaded data
#define	QFILE_FLAG_DEFLATED   (1 << 1)
	file is compressed using the deflate algorithm (PK3 only)
#define	QFILE_FLAG_PACKED   (1 << 0)
	inside a package (PAK or PK3)
#define	QFILE_FLAG_REMOVE   (1 << 3)
	real file will be removed on close
#define	S_ISDIR(a)
#define	WPATHDEF(var)
#define	Z_BINARY   0
#define	Z_BUF_ERROR   (-5)
#define	Z_DATA_ERROR   (-3)
#define	Z_DEFAULT_COMPRESSION   (-1)
#define	Z_DEFLATED   8
#define	Z_FINISH   4
#define	Z_FULL_FLUSH   3
#define	Z_MEM_ERROR   (-4)
#define	Z_MEMLEVEL_DEFAULT   8
#define	Z_NO_FLUSH   0
#define	Z_NULL   0
#define	Z_OK   0
#define	Z_STREAM_END   1
#define	Z_STREAM_ERROR   (-2)
#define	Z_SYNC_FLUSH   2
#define	Z_SYNC_FLUSH   2
#define	ZIP_CDIR_CHUNK_BASE_SIZE   46
#define	ZIP_CDIR_HEADER   0x504B0102
#define	ZIP_DATA_HEADER   0x504B0304
#define	ZIP_END_CDIR_SIZE   22
#define	ZIP_END_HEADER   0x504B0506
#define	ZIP_LOCAL_CHUNK_BASE_SIZE   30
#define	ZIP_MAX_COMMENTS_SIZE   ((unsigned short)0xFFFF)
#define	ZLIB_VERSION   "1.2.3"

Typedefs
typedef int	filedesc_t

Functions
static filedesc_t	FILEDESC_DUP (const char *filename, filedesc_t fd)
static fs_offset_t	ReadAll (const filedesc_t fd, void *const buf, const size_t length)
static fs_offset_t	WriteAll (const filedesc_t fd, const void *const buf, const size_t length)

Packages in memory
static void	AssertBufsize (sizebuf_t *buf, int length)
static void	COM_InsertFlags (const char *buf)
int	con_linewidth
cvar_t	cvar_fs_gamedir = {CF_CLIENT | CF_SERVER | CF_READONLY | CF_PERSISTENT, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"}
static int	flush
static packfile_t *	FS_AddFileToPack (const char *name, pack_t *pack, fs_offset_t offset, fs_offset_t packsize, fs_offset_t realsize, int flags)
static void	FS_AddGameDirectory (const char *dir)
static void	FS_AddGameHierarchy (const char *dir)
qbool	FS_AddPack (const char *pakfile, qbool *already_loaded, qbool keep_plain_dirs, qbool dlcache)
static qbool	FS_AddPack_Fullpath (const char *pakfile, const char *shortname, qbool *already_loaded, qbool keep_plain_dirs, qbool dlcache)
static void	FS_AddSelfPack (void)
gamedir_t *	fs_all_gamedirs = NULL
int	fs_all_gamedirs_count = 0
char	fs_basedir [MAX_OSPATH]
qbool	FS_ChangeGameDirs (int numgamedirs, const char *gamedirs[], qbool failmissing)
const char *	FS_CheckGameDir (const char *gamedir)
const char *const	fs_checkgamedir_missing = "missing"
int	FS_CheckNastyPath (const char *path, qbool isgamedir)
static int	FS_ChooseUserDir (userdirmode_t userdirmode, char *userdir, size_t userdirsize)
static void	FS_ClearSearchPath (void)
int	FS_Close (qfile_t *file)
int	FS_CRCFile (const char *filename, size_t *filesizepointer)
void	FS_CreatePath (char *path)
void	FS_DefaultExtension (char *path, const char *extension, size_t size_path)
unsigned char *	FS_Deflate (const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool)
void	FS_Dir_f (cmd_state_t *cmd)
cvar_t	fs_empty_files_in_pack_mark_deletions = {CF_CLIENT | CF_SERVER, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"}
const char *	FS_FileExists (const char *filename)
	Look for a file in the packages and in the filesystem Returns its canonical name (same case as used in the pack) if found, else NULL.
const char *	FS_FileExtension (const char *in)
qfile_t *	FS_FileFromData (const unsigned char *data, const size_t size, qbool quiet)
fs_offset_t	FS_FileSize (qfile_t *file)
int	FS_FileType (const char *filename)
	Look for a file in the packages and in the filesystem.
const char *	FS_FileWithoutPath (const char *in)
static searchpath_t *	FS_FindFile (const char *name, int *index, const char **canonicalname, qbool quiet)
void	FS_FreeSearch (fssearch_t *search)
char	fs_gamedir [MAX_OSPATH]
static void	FS_GameDir_f (cmd_state_t *cmd)
char	fs_gamedirs [MAX_GAMEDIRS][MAX_QPATH]
int	FS_Getc (qfile_t *file)
qbool	FS_HasZlib (void)
unsigned char *	FS_Inflate (const unsigned char *data, size_t size, size_t *inflated_size, mempool_t *mempool)
void	FS_Init (void)
void	FS_Init_Commands (void)
static void	FS_Init_Dir (void)
void	FS_Init_SelfPack (void)
qbool	FS_IsRegisteredQuakePack (const char *name)
static int	FS_ListDirectory (const char *pattern, int oneperline)
static void	FS_ListDirectoryCmd (cmd_state_t *cmd, const char *cmdname, int oneperline)
static void	FS_ListGameDirs (void)
static unsigned char *	FS_LoadAndCloseQFile (qfile_t *file, const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
unsigned char *	FS_LoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
static pack_t *	FS_LoadPackPAK (const char *packfile)
static pack_t *	FS_LoadPackPK3 (const char *packfile)
static pack_t *	FS_LoadPackPK3FromFD (const char *packfile, filedesc_t packhandle, qbool silent)
static pack_t *	FS_LoadPackVirtual (const char *dirname)
void	FS_Ls_f (cmd_state_t *cmd)
mempool_t *	fs_mempool
static void	FS_mkdir (const char *path)
void *	fs_mutex = NULL
int	fs_numgamedirs = 0
static qfile_t *	FS_OpenPackedFile (pack_t *pack, int pack_ind)
static qfile_t *	FS_OpenReadFile (const char *filename, qbool quiet, qbool nonblocking, int symlinkLevels)
qfile_t *	FS_OpenRealFile (const char *filepath, const char *mode, qbool quiet)
qfile_t *	FS_OpenVirtualFile (const char *filepath, qbool quiet)
static void	FS_Path_f (cmd_state_t *cmd)
int	FS_Print (qfile_t *file, const char *msg)
int	FS_Printf (qfile_t *file, const char *format,...)
void	FS_Purge (qfile_t *file)
fs_offset_t	FS_Read (qfile_t *file, void *buffer, size_t buffersize)
void	FS_RemoveOnClose (qfile_t *file)
void	FS_Rescan (void)
static void	FS_Rescan_f (cmd_state_t *cmd)
void	FS_SanitizePath (char *path)
fssearch_t *	FS_Search (const char *pattern, int caseinsensitive, int quiet, const char *packfile)
searchpath_t *	fs_searchpaths = NULL
int	FS_Seek (qfile_t *file, fs_offset_t offset, int whence)
static pack_t *	fs_selfpack = NULL
addgamedirs_t	FS_SetGameDirs (int numgamedirs, const char *gamedirs[], qbool failmissing, qbool abortonfail)
void	FS_Shutdown (void)
void	FS_StripExtension (const char *in, char *out, size_t size_out)
static const char *	FS_SysCheckGameDir (const char *gamedir, char *buf, size_t buflength)
qbool	FS_SysFileExists (const char *path)
	Look for a file in the filesystem only.
int	FS_SysFileType (const char *path)
	Look for a file in the filesystem only.
unsigned char *	FS_SysLoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
qfile_t *	FS_SysOpen (const char *filepath, const char *mode, qbool nonblocking)
int	FS_SysOpenFD (const char *filepath, const char *mode, qbool nonblocking)
static filedesc_t	FS_SysOpenFiledesc (const char *filepath, const char *mode, qbool nonblocking)
fs_offset_t	FS_Tell (qfile_t *file)
int	FS_UnGetc (qfile_t *file, unsigned char c)
cvar_t	fs_unload_dlcache = {CF_CLIENT, "fs_unload_dlcache", "1", "if enabled, unload dlcache's loaded pak/pk3 files when changing server and/or map WARNING: disabling unloading can cause servers to override assets of other servers, \"memory leaking\" by dlcache assets never unloading and many more issues"}
void	FS_UnloadPacks_dlcache (void)
char	fs_userdir [MAX_OSPATH]
int	FS_VPrintf (qfile_t *file, const char *format, va_list ap)
void	FS_Which_f (cmd_state_t *cmd)
const char *	FS_WhichPack (const char *filename)
fs_offset_t	FS_Write (qfile_t *file, const void *data, size_t datasize)
qbool	FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
qbool	FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
static	int (ZEXPORT *qz_inflate)(z_stream *strm
static int	level
#define	MAX_FILES_IN_PACK   65536
static int int int int	memLevel
static int int	method
#define	PACKFILE_FLAG_DEFLATED   (1 << 1)
	file compressed using the deflate algorithm
#define	PACKFILE_FLAG_SYMLINK   (1 << 2)
	file is a symbolic link
#define	PACKFILE_FLAG_TRUEOFFS   (1 << 0)
	the offset in packfile_t is the true contents offset
static int	PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
static void	PK3_CloseLibrary (void)
static qbool	PK3_GetEndOfCentralDir (const char *packfile, filedesc_t packhandle, pk3_endOfCentralDir_t *eocd)
static qbool	PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
static qbool	PK3_OpenLibrary (void)
#define	qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy)
#define	qz_inflateInit2(strm, windowBits)
cvar_t	scr_screenshot_name = {CF_CLIENT | CF_PERSISTENT, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"}
static int int int int int	strategy
static int const char int	stream_size
static int const char *	version
static int	windowBits
#define	ZEXPORT
static dllhandle_t	zlib_dll = NULL
	Handle for Zlib DLL.
static dllfunction_t	zlibfuncs []

Macro Definition Documentation

FILE_BUFF_SIZE

#define FILE_BUFF_SIZE   2048

Definition at line 302 of file fs.c.

FILEDESC_CLOSE

#define FILEDESC_CLOSE   close

Definition at line 111 of file fs.c.

Referenced by FS_ChooseUserDir(), FS_ClearSearchPath(), FS_Close(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_OpenPackedFile(), FS_SysOpenFiledesc(), and FS_UnloadPacks_dlcache().

FILEDESC_INVALID

#define FILEDESC_INVALID   -1

Definition at line 107 of file fs.c.

Referenced by FS_LoadPackVirtual(), and FS_SysOpenFiledesc().

FILEDESC_ISVALID

#define FILEDESC_ISVALID

(

fd

)

Value:

((fd) != -1)

Definition at line 108 of file fs.c.

Referenced by FS_LoadPackPAK(), FS_LoadPackPK3(), FS_OpenPackedFile(), and FS_SysOpen().

FILEDESC_READ [1/2]

#define FILEDESC_READ   read

Definition at line 109 of file fs.c.

Referenced by FS_LoadPackPAK(), FS_Read(), PK3_BuildFileList(), PK3_GetEndOfCentralDir(), PK3_GetTrueFileOffset(), and ReadAll().

FILEDESC_READ [2/2]

#define FILEDESC_READ   ReadAll

Definition at line 109 of file fs.c.

FILEDESC_SEEK

#define FILEDESC_SEEK   lseek

Definition at line 112 of file fs.c.

Referenced by FS_LoadPackPAK(), FS_OpenPackedFile(), FS_Read(), FS_Seek(), FS_SysOpen(), FS_Write(), PK3_BuildFileList(), PK3_GetEndOfCentralDir(), and PK3_GetTrueFileOffset().

FILEDESC_WRITE [1/2]

#define FILEDESC_WRITE   write

Definition at line 110 of file fs.c.

Referenced by FS_VPrintf(), FS_Write(), and WriteAll().

FILEDESC_WRITE [2/2]

#define FILEDESC_WRITE   WriteAll

Definition at line 110 of file fs.c.

MAX_FILES_IN_PACK

#define MAX_FILES_IN_PACK   65536

Definition at line 440 of file fs.c.

Referenced by FS_LoadPackPAK(), and FS_LoadPackPK3FromFD().

MAX_WBITS

#define MAX_WBITS   15

Definition at line 232 of file fs.c.

Referenced by FS_Deflate(), FS_Inflate(), and FS_OpenPackedFile().

O_BINARY

#define O_BINARY   0

Definition at line 56 of file fs.c.

Referenced by FS_SysOpenFiledesc().

O_NONBLOCK

#define O_NONBLOCK   0

Definition at line 61 of file fs.c.

Referenced by FS_SysOpenFiledesc(), Sys_Error(), Sys_HandleCrash(), Sys_Main(), and Sys_Print().

PACKFILE_FLAG_DEFLATED

#define PACKFILE_FLAG_DEFLATED   (1 << 1)

file compressed using the deflate algorithm

Definition at line 372 of file fs.c.

Referenced by FS_OpenPackedFile(), and PK3_BuildFileList().

PACKFILE_FLAG_SYMLINK

#define PACKFILE_FLAG_SYMLINK   (1 << 2)

file is a symbolic link

Definition at line 374 of file fs.c.

Referenced by FS_OpenReadFile(), and PK3_BuildFileList().

PACKFILE_FLAG_TRUEOFFS

#define PACKFILE_FLAG_TRUEOFFS   (1 << 0)

the offset in packfile_t is the true contents offset

Definition at line 370 of file fs.c.

Referenced by FS_LoadPackPAK(), FS_OpenPackedFile(), and PK3_GetTrueFileOffset().

QFILE_FLAG_DATA

#define QFILE_FLAG_DATA   (1 << 2)

file is actually already loaded data

Definition at line 298 of file fs.c.

Referenced by FS_Close(), FS_FileFromData(), FS_Read(), and FS_Seek().

QFILE_FLAG_DEFLATED

#define QFILE_FLAG_DEFLATED   (1 << 1)

file is compressed using the deflate algorithm (PK3 only)

Definition at line 296 of file fs.c.

Referenced by FS_OpenPackedFile(), FS_Read(), and FS_Seek().

QFILE_FLAG_PACKED

#define QFILE_FLAG_PACKED   (1 << 0)

inside a package (PAK or PK3)

Definition at line 294 of file fs.c.

Referenced by FS_OpenPackedFile().

QFILE_FLAG_REMOVE

#define QFILE_FLAG_REMOVE   (1 << 3)

real file will be removed on close

Definition at line 300 of file fs.c.

Referenced by FS_Close(), and FS_RemoveOnClose().

qz_deflateInit2

#define qz_deflateInit2	(		strm,
			level,
			method,
			windowBits,
			memLevel,
			strategy )

Value:

        qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))

Definition at line 488 of file fs.c.

#define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
        qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))

Referenced by FS_Deflate().

qz_inflateInit2

#define qz_inflateInit2	(		strm,
			windowBits )

Value:

        qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))

Definition at line 486 of file fs.c.

#define qz_inflateInit2(strm, windowBits) \
        qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))

Referenced by FS_Inflate(), and FS_OpenPackedFile().

S_ISDIR

#define S_ISDIR

(

a

)

Value:

(((a) & S_IFMT) == S_IFDIR)

Referenced by FS_SysFileType().

WPATHDEF

#define WPATHDEF

(

var

)

Value:

;

Definition at line 84 of file fs.c.

Referenced by FS_Init_Dir(), FS_mkdir(), FS_SysFileType(), and FS_SysOpenFiledesc().

Z_BINARY

#define Z_BINARY   0

Definition at line 241 of file fs.c.

Referenced by FS_Deflate().

Z_BUF_ERROR

#define Z_BUF_ERROR   (-5)

Definition at line 238 of file fs.c.

Referenced by FS_Inflate().

Z_DATA_ERROR

#define Z_DATA_ERROR   (-3)

Definition at line 236 of file fs.c.

Referenced by FS_Inflate().

Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   (-1)

Definition at line 246 of file fs.c.

Referenced by FS_Deflate().

Z_DEFLATED

#define Z_DEFLATED   8

Definition at line 242 of file fs.c.

Referenced by FS_Deflate().

Z_FINISH

#define Z_FINISH   4

Definition at line 250 of file fs.c.

Referenced by FS_Deflate().

Z_FULL_FLUSH

#define Z_FULL_FLUSH   3

Definition at line 249 of file fs.c.

Z_MEM_ERROR

#define Z_MEM_ERROR   (-4)

Definition at line 237 of file fs.c.

Referenced by FS_Inflate().

Z_MEMLEVEL_DEFAULT

#define Z_MEMLEVEL_DEFAULT   8

Definition at line 243 of file fs.c.

Referenced by FS_Deflate().

Z_NO_FLUSH

#define Z_NO_FLUSH   0

Definition at line 247 of file fs.c.

Referenced by FS_Inflate().

Z_NULL

#define Z_NULL   0

Definition at line 245 of file fs.c.

Referenced by FS_Deflate(), and FS_Inflate().

Z_OK

#define Z_OK   0

Definition at line 233 of file fs.c.

Referenced by FS_Deflate(), FS_Inflate(), FS_OpenPackedFile(), and FS_Read().

Z_STREAM_END

#define Z_STREAM_END   1

Definition at line 234 of file fs.c.

Referenced by FS_Deflate(), FS_Inflate(), and FS_Read().

Z_STREAM_ERROR

#define Z_STREAM_ERROR   (-2)

Definition at line 235 of file fs.c.

Referenced by FS_Inflate().

Z_SYNC_FLUSH [1/2]

#define Z_SYNC_FLUSH   2

Definition at line 231 of file fs.c.

Referenced by FS_Read().

Z_SYNC_FLUSH [2/2]

#define Z_SYNC_FLUSH   2

Definition at line 231 of file fs.c.

ZEXPORT

#define ZEXPORT

Definition at line 474 of file fs.c.

ZIP_CDIR_CHUNK_BASE_SIZE

#define ZIP_CDIR_CHUNK_BASE_SIZE   46

Definition at line 214 of file fs.c.

Referenced by PK3_BuildFileList().

ZIP_CDIR_HEADER

#define ZIP_CDIR_HEADER   0x504B0102

Definition at line 208 of file fs.c.

Referenced by PK3_BuildFileList().

ZIP_DATA_HEADER

#define ZIP_DATA_HEADER   0x504B0304

Definition at line 207 of file fs.c.

Referenced by PK3_GetTrueFileOffset().

ZIP_END_CDIR_SIZE

#define ZIP_END_CDIR_SIZE   22

Definition at line 213 of file fs.c.

Referenced by PK3_GetEndOfCentralDir().

ZIP_END_HEADER

#define ZIP_END_HEADER   0x504B0506

Definition at line 209 of file fs.c.

Referenced by PK3_GetEndOfCentralDir().

ZIP_LOCAL_CHUNK_BASE_SIZE

#define ZIP_LOCAL_CHUNK_BASE_SIZE   30

Definition at line 215 of file fs.c.

Referenced by PK3_GetTrueFileOffset().

ZIP_MAX_COMMENTS_SIZE

#define ZIP_MAX_COMMENTS_SIZE   ((unsigned short)0xFFFF)

Definition at line 212 of file fs.c.

Referenced by PK3_GetEndOfCentralDir().

ZLIB_VERSION

#define ZLIB_VERSION   "1.2.3"

Definition at line 239 of file fs.c.

Typedef Documentation

filedesc_t

typedef int filedesc_t

Definition at line 106 of file fs.c.

Function Documentation

AssertBufsize()

static void AssertBufsize ( sizebuf_t * buf, int length )

static

Definition at line 4256 of file fs.c.

{
    if(buf->cursize + length > buf->maxsize)
    {
        int oldsize = buf->maxsize;
        unsigned char *olddata;
        olddata = buf->data;
        buf->maxsize += length;
        buf->data = (unsigned char *) Mem_Alloc(tempmempool, buf->maxsize);
        if(olddata)
        {
            memcpy(buf->data, olddata, oldsize);
            Mem_Free(olddata);
        }
    }
}

References buf, length, Mem_Alloc, Mem_Free, olddata, and tempmempool.

Referenced by FS_Inflate().

COM_InsertFlags()

static void COM_InsertFlags ( const char * buf )

static

Definition at line 1911 of file fs.c.

                                             {
    const char *p;
    char *q;
    const char **new_argv;
    int i = 0;
    int args_left = 256;
    new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*sys.argv) * (sys.argc + args_left + 2));
    if(sys.argc == 0)
        new_argv[0] = "dummy";  // Can't really happen.
    else
        new_argv[0] = sys.argv[0];
    ++i;
    p = buf;
    while(COM_ParseToken_Console(&p))
    {
        size_t sz = strlen(com_token) + 1; // shut up clang
        if(i > args_left)
            break;
        q = (char *)Mem_Alloc(fs_mempool, sz);
        dp_strlcpy(q, com_token, sz);
        new_argv[i] = q;
        ++i;
    }
    // Now: i <= args_left + 1.
    if (sys.argc >= 1)
    {
        memcpy((char *)(&new_argv[i]), &sys.argv[1], sizeof(*sys.argv) * (sys.argc - 1));
        i += sys.argc - 1;
    }
    // Now: i <= args_left + (sys.argc || 1).
    new_argv[i] = NULL;
    sys.argv = new_argv;
    sys.argc = i;
}

References sys_t::argc, sys_t::argv, buf, COM_ParseToken_Console(), com_token, dp_strlcpy, fs_mempool, i, Mem_Alloc, NULL, strlen(), and sys.

Referenced by FS_Init_SelfPack().

FILEDESC_DUP()

static filedesc_t FILEDESC_DUP ( const char * filename, filedesc_t fd )

static

Definition at line 113 of file fs.c.

                                                                    {
    return dup(fd);
}

Referenced by FS_OpenPackedFile().

FS_AddFileToPack()

static packfile_t * FS_AddFileToPack ( const char * name, pack_t * pack, fs_offset_t offset, fs_offset_t packsize, fs_offset_t realsize, int flags )

static

Definition at line 954 of file fs.c.

{
    int (*strcmp_funct) (const char* str1, const char* str2);
    int left, right, middle;
    packfile_t *pfile;
 
    strcmp_funct = pack->ignorecase ? strcasecmp : strcmp;
 
    // Look for the slot we should put that file into (binary search)
    left = 0;
    right = pack->numfiles - 1;
    while (left <= right)
    {
        int diff;
 
        middle = (left + right) / 2;
        diff = strcmp_funct (pack->files[middle].name, name);
 
        // If we found the file, there's a problem
        if (!diff)
            Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
 
        // If we're too far in the list
        if (diff > 0)
            right = middle - 1;
        else
            left = middle + 1;
    }
 
    // We have to move the right of the list by one slot to free the one we need
    pfile = &pack->files[left];
    memmove (pfile + 1, pfile, (pack->numfiles - left) * sizeof (*pfile));
    pack->numfiles++;
 
    dp_strlcpy (pfile->name, name, sizeof (pfile->name));
    pfile->offset = offset;
    pfile->packsize = packsize;
    pfile->realsize = realsize;
    pfile->flags = flags;
 
    return pfile;
}

References Con_Printf(), dp_strlcpy, pack_t::filename, pack_t::files, flags, packfile_t::flags, pack_t::ignorecase, int(), name, packfile_t::name, pack_t::numfiles, offset, packfile_t::offset, packfile_t::packsize, packfile_t::realsize, and right.

Referenced by FS_LoadPackPAK(), and PK3_BuildFileList().

FS_AddGameDirectory()

static void FS_AddGameDirectory ( const char * dir )

static

Definition at line 1340 of file fs.c.

{
    int i;
    stringlist_t list;
    searchpath_t *search;
 
    dp_strlcpy (fs_gamedir, dir, sizeof (fs_gamedir));
 
    stringlistinit(&list);
    listdirectory(&list, "", dir);
    stringlistsort(&list, false);
 
    // add any PAK package in the directory
    for (i = 0;i < list.numstrings;i++)
    {
        if (!strcasecmp(FS_FileExtension(list.strings[i]), "pak"))
        {
            FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false, false);
        }
    }
 
    // add any PK3 package in the directory
    for (i = 0;i < list.numstrings;i++)
    {
        if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "obb") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir")
            || !strcasecmp(FS_FileExtension(list.strings[i]), "dpk") || !strcasecmp(FS_FileExtension(list.strings[i]), "dpkdir"))
        {
            FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false, false);
        }
    }
 
    stringlistfreecontents(&list);
 
    // Add the directory to the search path
    // (unpacked files have the priority over packed files)
    search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
    dp_strlcpy (search->filename, dir, sizeof (search->filename));
    search->next = fs_searchpaths;
    fs_searchpaths = search;
}

References dir, dp_strlcpy, searchpath_t::filename, FS_AddPack_Fullpath(), FS_FileExtension(), fs_gamedir, fs_mempool, fs_searchpaths, i, listdirectory(), Mem_Alloc, searchpath_t::next, NULL, stringlist_t::numstrings, stringlistfreecontents(), stringlistinit(), stringlistsort(), stringlist_t::strings, and strlen().

Referenced by FS_AddGameHierarchy().

FS_AddGameHierarchy()

static void FS_AddGameHierarchy ( const char * dir )

static

Definition at line 1387 of file fs.c.

{
    char vabuf[1024];
    // Add the common game directory
    FS_AddGameDirectory (va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, dir));
 
    if (*fs_userdir)
        FS_AddGameDirectory(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, dir));
}

References dir, FS_AddGameDirectory(), fs_basedir, fs_userdir, and va().

Referenced by FS_Rescan().

FS_AddPack()

qbool FS_AddPack	(	const char *	pakfile,
		qbool *	already_loaded,
		qbool	keep_plain_dirs,
		qbool	dlcache )

Adds the given pack to the search path and searches for it in the game path. The pack type is autodetected by the file extension.

Returns true if the file was successfully added to the search path or if it was already included.

If keep_plain_dirs is set, the pack will be added AFTER the first sequence of plain directories.

Definition at line 1309 of file fs.c.

{
    char fullpath[MAX_OSPATH];
    int index;
    searchpath_t *search;
 
    if(already_loaded)
        *already_loaded = false;
 
    // then find the real name...
    search = FS_FindFile(pakfile, &index, NULL, true);
    if(!search || search->pack)
    {
        Con_Printf("could not find pak \"%s\"\n", pakfile);
        return false;
    }
 
    dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, pakfile);
 
    return FS_AddPack_Fullpath(fullpath, pakfile, already_loaded, keep_plain_dirs, dlcache);
}

References Con_Printf(), dpsnprintf(), searchpath_t::filename, FS_AddPack_Fullpath(), FS_FindFile(), index, MAX_OSPATH, NULL, and searchpath_t::pack.

Referenced by Curl_Begin(), and Curl_EndDownload().

FS_AddPack_Fullpath()

static qbool FS_AddPack_Fullpath ( const char * pakfile, const char * shortname, qbool * already_loaded, qbool keep_plain_dirs, qbool dlcache )

static

Adds the given pack to the search path. The pack type is autodetected by the file extension.

Returns true if the file was successfully added to the search path or if it was already included.

If keep_plain_dirs is set, the pack will be added AFTER the first sequence of plain directories.

Definition at line 1194 of file fs.c.

{
    searchpath_t *search;
    pack_t *pak = NULL;
    const char *ext = FS_FileExtension(pakfile);
    size_t l;
 
    for(search = fs_searchpaths; search; search = search->next)
    {
        if(search->pack && !strcasecmp(search->pack->filename, pakfile))
        {
            if(already_loaded)
                *already_loaded = true;
            return true; // already loaded
        }
    }
 
    if(already_loaded)
        *already_loaded = false;
 
    if(!strcasecmp(ext, "pk3dir") || !strcasecmp(ext, "dpkdir"))
        pak = FS_LoadPackVirtual (pakfile);
    else if(!strcasecmp(ext, "pak"))
        pak = FS_LoadPackPAK (pakfile);
    else if(!strcasecmp(ext, "pk3") || !strcasecmp(ext, "dpk"))
        pak = FS_LoadPackPK3 (pakfile);
    else if(!strcasecmp(ext, "obb")) // android apk expansion
        pak = FS_LoadPackPK3 (pakfile);
    else
        Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
 
    if(pak)
    {
        dp_strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
 
        //Con_DPrintf("  Registered pack with short name %s\n", shortname);
        if(keep_plain_dirs)
        {
            // find the first item whose next one is a pack or NULL
            searchpath_t *insertion_point = 0;
            if(fs_searchpaths && !fs_searchpaths->pack)
            {
                insertion_point = fs_searchpaths;
                for(;;)
                {
                    if(!insertion_point->next)
                        break;
                    if(insertion_point->next->pack)
                        break;
                    insertion_point = insertion_point->next;
                }
            }
            // If insertion_point is NULL, this means that either there is no
            // item in the list yet, or that the very first item is a pack. In
            // that case, we want to insert at the beginning...
            if(!insertion_point)
            {
                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
                search->next = fs_searchpaths;
                fs_searchpaths = search;
            }
            else
            // otherwise we want to append directly after insertion_point.
            {
                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
                search->next = insertion_point->next;
                insertion_point->next = search;
            }
        }
        else
        {
            search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
            search->next = fs_searchpaths;
            fs_searchpaths = search;
        }
        search->pack = pak;
        search->pack->dlcache = dlcache;
        if(pak->vpack)
        {
            dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
            // if shortname ends with "pk3dir" or "dpkdir", strip that suffix to make it just "pk3" or "dpk"
            // same goes for the name inside the pack structure
            l = strlen(pak->shortname);
            if(l >= 7)
                if(!strcasecmp(pak->shortname + l - 7, ".pk3dir") || !strcasecmp(pak->shortname + l - 7, ".dpkdir"))
                    pak->shortname[l - 3] = 0;
            l = strlen(pak->filename);
            if(l >= 7)
                if(!strcasecmp(pak->filename + l - 7, ".pk3dir") || !strcasecmp(pak->filename + l - 7, ".dpkdir"))
                    pak->filename[l - 3] = 0;
        }
        return true;
    }
    else
    {
        Con_Printf(CON_ERROR "unable to load pak \"%s\"\n", pakfile);
        return false;
    }
}

References CON_ERROR, Con_Printf(), pack_t::dlcache, dp_strlcpy, dpsnprintf(), pack_t::filename, searchpath_t::filename, FS_FileExtension(), FS_LoadPackPAK(), FS_LoadPackPK3(), FS_LoadPackVirtual(), fs_mempool, fs_searchpaths, Mem_Alloc, searchpath_t::next, NULL, searchpath_t::pack, pack_t::shortname, strlen(), and pack_t::vpack.

Referenced by FS_AddGameDirectory(), and FS_AddPack().

FS_AddSelfPack()

static void FS_AddSelfPack ( void )

static

Definition at line 1519 of file fs.c.

{
    if(fs_selfpack)
    {
        searchpath_t *search;
        search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
        search->next = fs_searchpaths;
        search->pack = fs_selfpack;
        fs_searchpaths = search;
    }
}

References fs_mempool, fs_searchpaths, fs_selfpack, Mem_Alloc, searchpath_t::next, and searchpath_t::pack.

Referenced by FS_Init_SelfPack(), and FS_Rescan().

FS_ChangeGameDirs()

qbool FS_ChangeGameDirs	(	int	numgamedirs,
		const char *	gamedirs[],
		qbool	failmissing )

Definition at line 1719 of file fs.c.

{
    addgamedirs_t addresult = COM_ChangeGameTypeForGameDirs(numgamedirs, gamedirs, failmissing, false);
 
    if (addresult == GAMEDIRS_ALLGOOD)
        return true; // already using this set of gamedirs, do nothing
    else if (addresult == GAMEDIRS_FAILURE)
        return false;
 
    Host_SaveConfig(CONFIGFILENAME);
 
    if (cls.demoplayback)
        CL_Disconnect();
    cls.demonum = 0; // make sure startdemos will work if the mod uses it
 
    // unload all sounds so they will be reloaded from the new files as needed
    S_UnloadAllSounds_f(cmd_local);
 
    // reinitialize filesystem to detect the new paks
    FS_Rescan();
 
    // reload assets after the config is executed
    Cbuf_InsertText(cmd_local, "\nloadconfig\nr_restart\n");
 
    return true;
}

References Cbuf_InsertText(), CL_Disconnect(), cls, cmd_local, COM_ChangeGameTypeForGameDirs(), CONFIGFILENAME, client_static_t::demonum, client_static_t::demoplayback, FS_Rescan(), GAMEDIRS_ALLGOOD, GAMEDIRS_FAILURE, Host_SaveConfig(), and S_UnloadAllSounds_f().

Referenced by CL_ParseServerInfo(), FS_GameDir_f(), and ModList_Enable().

FS_CheckGameDir()

const char * FS_CheckGameDir

(

const char *

gamedir

)

Definition at line 1824 of file fs.c.

{
    const char *ret;
    static char buf[8192];
    char vabuf[1024];
 
    if (FS_CheckNastyPath(gamedir, true))
        return NULL;
 
    ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_userdir, gamedir), buf, sizeof(buf));
    if(ret)
    {
        if(!*ret)
        {
            // get description from basedir
            ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
            if(ret)
                return ret;
            return "";
        }
        return ret;
    }
 
    ret = FS_SysCheckGameDir(va(vabuf, sizeof(vabuf), "%s%s/", fs_basedir, gamedir), buf, sizeof(buf));
    if(ret)
        return ret;
 
    return fs_checkgamedir_missing;
}

References buf, fs_basedir, fs_checkgamedir_missing, FS_CheckNastyPath(), FS_SysCheckGameDir(), fs_userdir, NULL, ret, and va().

Referenced by FS_ListGameDirs(), FS_SetGameDirs(), and ModList_RebuildList().

FS_CheckNastyPath()

int FS_CheckNastyPath	(	const char *	path,
		qbool	isgamedir )

Definition at line 2618 of file fs.c.

{
    // all: never allow an empty path, as for gamedir it would access the parent directory and a non-gamedir path it is just useless
    if (!path[0])
        return 2;
 
    // Windows: don't allow \ in filenames (windows-only), period.
    // (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
 
    // Amiga: // is parent directory
    if (strstr(path, "//"))
        return 1; // non-portable attempt to go to parent directory
 
    // all: don't allow going to 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
 
    // all: don't allow . character immediately before a slash, this catches all imaginable cases of ./, ../, .../, etc
    if (strstr(path, "./"))
        return 2; // possible attempt to go outside the game directory
 
    // all: forbid trailing slash on gamedir
    if (isgamedir && path[strlen(path)-1] == '/')
        return 2;
 
    // all: forbid leading dot on any filename for any reason
    if (strstr(path, "/."))
        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;
}

References strlen().

Referenced by CL_DownloadBegin_f(), FS_CheckGameDir(), FS_OpenReadFile(), FS_OpenRealFile(), FS_OpenVirtualFile(), SV_Download_f(), and VM_loadfromfile().

FS_ChooseUserDir()

static int FS_ChooseUserDir ( userdirmode_t userdirmode, char * userdir, size_t userdirsize )

static

Definition at line 1946 of file fs.c.

{
#if defined(__IPHONEOS__)
    if (userdirmode == USERDIRMODE_HOME)
    {
        // fs_basedir is "" by default, to utilize this you can simply add your gamedir to the Resources in xcode
        // fs_userdir stores configurations to the Documents folder of the app
        dp_strlcpy(userdir, "../Documents/", MAX_OSPATH);
        return 1;
    }
    return -1;
 
#elif defined(WIN32)
    char homedir[MAX_OSWPATH];
    wchar *homedirw;
#if _MSC_VER >= 1400
    size_t homedirwlen;
#endif
    char mydocsdir[MAX_OSWPATH];
    wchar mydocsdirw[MAX_OSWPATH];
    char savedgamesdir[MAX_OSWPATH];
    wchar *savedgamesdirw;
    int fd;
    char vabuf[1024];
 
    userdir[0] = 0;
    switch(userdirmode)
    {
    default:
        return -1;
    case USERDIRMODE_NOHOME:
        dp_strlcpy(userdir, fs_basedir, userdirsize);
        break;
    case USERDIRMODE_MYGAMES:
        if (!shfolder_dll)
            Sys_LoadDependency(shfolderdllnames, &shfolder_dll, shfolderfuncs);
        mydocsdir[0] = 0;
        if (qSHGetFolderPath && qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdirw) == S_OK)
        {
            NARROW(mydocsdirw, mydocsdir);
            dpsnprintf(userdir, userdirsize, "%s/My Games/%s/", mydocsdir, gameuserdirname);
            break;
        }
#if _MSC_VER >= 1400
        _wdupenv_s(&homedirw, &homedirwlen, L"USERPROFILE");
        NARROW(homedirw, homedir);
        if(homedir[0])
        {
            dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
            free(homedirw);
            break;
        }
#else
        homedirw = _wgetenv(L"USERPROFILE");
        NARROW(homedirw, homedir);
        if(homedir[0])
        {
            dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
            break;
        }
#endif
        return -1;
    case USERDIRMODE_SAVEDGAMES:
        if (!shell32_dll)
            Sys_LoadDependency(shell32dllnames, &shell32_dll, shell32funcs);
        if (!ole32_dll)
            Sys_LoadDependency(ole32dllnames, &ole32_dll, ole32funcs);
        if (qSHGetKnownFolderPath && qCoInitializeEx && qCoTaskMemFree && qCoUninitialize)
        {
            savedgamesdir[0] = 0;
            qCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
/*
#ifdef __cplusplus
            if (SHGetKnownFolderPath(FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
#else
            if (SHGetKnownFolderPath(&FOLDERID_SavedGames, KF_FLAG_CREATE | KF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
#endif
*/
            if (qSHGetKnownFolderPath(&qFOLDERID_SavedGames, qKF_FLAG_CREATE | qKF_FLAG_NO_ALIAS, NULL, &savedgamesdirw) == S_OK)
            {
                NARROW(savedgamesdirw, savedgamesdir);
                qCoTaskMemFree(savedgamesdirw);
            }
            qCoUninitialize();
            if (savedgamesdir[0])
            {
                dpsnprintf(userdir, userdirsize, "%s/%s/", savedgamesdir, gameuserdirname);
                break;
            }
        }
        return -1;
    }
#else
    int fd;
    char *homedir;
    char vabuf[1024];
    userdir[0] = 0;
    switch(userdirmode)
    {
    default:
        return -1;
    case USERDIRMODE_NOHOME:
        dp_strlcpy(userdir, fs_basedir, userdirsize);
        break;
    case USERDIRMODE_HOME:
        homedir = getenv("HOME");
        if(homedir)
        {
            dpsnprintf(userdir, userdirsize, "%s/.%s/", homedir, gameuserdirname);
            break;
        }
        return -1;
    case USERDIRMODE_SAVEDGAMES:
        homedir = getenv("HOME");
        if(homedir)
        {
#ifdef MACOSX
            dpsnprintf(userdir, userdirsize, "%s/Library/Application Support/%s/", homedir, gameuserdirname);
#else
            // the XDG say some files would need to go in:
            // XDG_CONFIG_HOME (or ~/.config/%s/)
            // XDG_DATA_HOME (or ~/.local/share/%s/)
            // XDG_CACHE_HOME (or ~/.cache/%s/)
            // and also search the following global locations if defined:
            // XDG_CONFIG_DIRS (normally /etc/xdg/%s/)
            // XDG_DATA_DIRS (normally /usr/share/%s/)
            // this would be too complicated...
            return -1;
#endif
            break;
        }
        return -1;
    }
#endif
 
 
#if !defined(__IPHONEOS__)
 
#ifdef WIN32
    // historical behavior...
    if (userdirmode == USERDIRMODE_NOHOME && strcmp(gamedirname1, "id1"))
        return 0; // don't bother checking if the basedir folder is writable, it's annoying...  unless it is Quake on Windows where NOHOME is the default preferred and we have to check for an error case
#endif
 
    // see if we can write to this path (note: won't create path)
#ifdef WIN32
    // no access() here, we must try to open the file for appending
    fd = FS_SysOpenFiledesc(va(vabuf, sizeof(vabuf), "%s%s/config.cfg", userdir, gamedirname1), "a", false);
    if(fd >= 0)
        FILEDESC_CLOSE(fd);
#else
    // on Unix, we don't need to ACTUALLY attempt to open the file
    if(access(va(vabuf, sizeof(vabuf), "%s%s/", userdir, gamedirname1), W_OK | X_OK) >= 0)
        fd = 1;
    else
        fd = -1;
#endif
    if(fd >= 0)
    {
        return 1; // good choice - the path exists and is writable
    }
    else
    {
        if (userdirmode == USERDIRMODE_NOHOME)
            return -1; // path usually already exists, we lack permissions
        else
            return 0; // probably good - failed to write but maybe we need to create path
    }
#endif
}

References dp_strlcpy, dpsnprintf(), FILEDESC_CLOSE, fs_basedir, FS_SysOpenFiledesc(), gamedirname1, gameuserdirname, MAX_OSPATH, NARROW, NULL, Sys_LoadDependency(), USERDIRMODE_HOME, USERDIRMODE_MYGAMES, USERDIRMODE_NOHOME, USERDIRMODE_SAVEDGAMES, and va().

Referenced by FS_Init_Dir().

FS_ClearSearchPath()

static void FS_ClearSearchPath ( void )

static

Definition at line 1451 of file fs.c.

{
    // unload all packs and directory information, close all pack files
    // (if a qfile is still reading a pack it won't be harmed because it used
    //  dup() to get its own handle already)
    while (fs_searchpaths)
    {
        searchpath_t *search = fs_searchpaths;
        fs_searchpaths = search->next;
        if (search->pack && search->pack != fs_selfpack)
        {
            if(!search->pack->vpack)
            {
                // close the file
                FILEDESC_CLOSE(search->pack->handle);
                // free any memory associated with it
                if (search->pack->files)
                    Mem_Free(search->pack->files);
            }
            Mem_Free(search->pack);
        }
        Mem_Free(search);
    }
}

References FILEDESC_CLOSE, pack_t::files, fs_searchpaths, fs_selfpack, pack_t::handle, Mem_Free, searchpath_t::next, searchpath_t::pack, and pack_t::vpack.

Referenced by FS_Rescan(), and FS_Shutdown().

FS_Close()

int FS_Close

(

qfile_t *

file

)

Definition at line 2970 of file fs.c.

{
    if(file->flags & QFILE_FLAG_DATA)
    {
        Mem_Free(file);
        return 0;
    }
 
    if (FILEDESC_CLOSE (file->handle))
        return EOF;
 
    if (file->filename)
    {
        if (file->flags & QFILE_FLAG_REMOVE)
        {
            if (remove(file->filename) == -1)
            {
                // No need to report this. If removing a just
                // written file failed, this most likely means
                // someone else deleted it first - which we
                // like.
            }
        }
 
        Mem_Free((void *) file->filename);
    }
 
    if (file->ztk)
    {
        qz_inflateEnd (&file->ztk->zstream);
        Mem_Free (file->ztk);
    }
 
    Mem_Free (file);
    return 0;
}

References FILEDESC_CLOSE, Mem_Free, QFILE_FLAG_DATA, QFILE_FLAG_REMOVE, and remove().

Referenced by CL_CutDemo(), CL_Locs_Save_f(), CL_Stop_f(), CL_StopPlayback(), Con_ConDump_f(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_LoadFile(), Crypto_SavePubKeyTextFile(), Curl_Begin(), Curl_EndDownload(), FS_LoadAndCloseQFile(), FS_OpenReadFile(), FS_SysCheckGameDir(), FS_WriteFileInBlocks(), GetMapList(), Host_SaveConfig(), Host_UnlockSession(), hz_bitstream_read_close(), jam_close(), JPEG_SaveImage_preflipped(), Key_History_Init(), Key_History_Shutdown(), libavw_close(), Log_Close(), Log_Printf(), M_ScanSaves(), PNG_SaveImage_preflipped(), PRVM_Prog_Load(), QW_CL_CheckOrDownloadFile(), R_GLSL_DumpShader_f(), SCR_CaptureVideo_Avi_EndVideo(), SCR_CaptureVideo_Ogg_EndVideo(), SV_Download_f(), SV_DropClient(), SV_ReadClientMessage(), SV_Savegame_to(), SV_StopDemoRecording(), VM_buf_loadfile(), VM_fclose(), VM_Files_CloseAll(), W_LoadTextureWadFile(), and W_UnloadAll().

FS_CRCFile()

int FS_CRCFile	(	const char *	filename,
		size_t *	filesizepointer )

Definition at line 4158 of file fs.c.

{
    int crc = -1;
    unsigned char *filedata;
    fs_offset_t filesize;
    if (filesizepointer)
        *filesizepointer = 0;
    if (!filename || !*filename)
        return crc;
    filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
    if (filedata)
    {
        if (filesizepointer)
            *filesizepointer = filesize;
        crc = CRC_Block(filedata, filesize);
        Mem_Free(filedata);
    }
    return crc;
}

References CRC_Block(), FS_LoadFile(), Mem_Free, and tempmempool.

Referenced by CL_BeginDownloads(), CL_StopDownload(), and QW_CL_RequestNextDownload().

FS_CreatePath()

void FS_CreatePath

(

char *

path

)

Definition at line 1028 of file fs.c.

{
    char *ofs, save;
 
    for (ofs = path+1 ; *ofs ; ofs++)
    {
        if (*ofs == '/' || *ofs == '\\')
        {
            // create the directory
            save = *ofs;
            *ofs = 0;
            FS_mkdir (path);
            *ofs = save;
        }
    }
}

References FS_mkdir(), and ofs.

Referenced by Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), FS_OpenRealFile(), and Host_LockSession().

FS_DefaultExtension()

void FS_DefaultExtension	(	char *	path,
		const char *	extension,
		size_t	size_path )

Definition at line 3641 of file fs.c.

{
    const char *src;
 
    // if path doesn't have a .EXT, append extension
    // (extension should include the .)
    src = path + strlen(path);
 
    while (*src != '/' && src != path)
    {
        if (*src == '.')
            return;                 // it has an extension
        src--;
    }
 
    dp_strlcat (path, extension, size_path);
}

References dp_strlcat, src, and strlen().

Referenced by CL_PlayDemo(), CL_Record_f(), R_LoadTextureDDSFile(), SV_Loadgame_f(), SV_Savegame_f(), and SV_StartDemoRecording().

FS_Deflate()

unsigned char * FS_Deflate	(	const unsigned char *	data,
		size_t	size,
		size_t *	deflated_size,
		int	level,
		mempool_t *	mempool )

Definition at line 4178 of file fs.c.

{
    z_stream strm;
    unsigned char *out = NULL;
    unsigned char *tmp;
 
    *deflated_size = 0;
#ifndef LINK_TO_ZLIB
    if(!zlib_dll)
        return NULL;
#endif
 
    memset(&strm, 0, sizeof(strm));
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
 
    if(level < 0)
        level = Z_DEFAULT_COMPRESSION;
 
    if(qz_deflateInit2(&strm, level, Z_DEFLATED, -MAX_WBITS, Z_MEMLEVEL_DEFAULT, Z_BINARY) != Z_OK)
    {
        Con_Printf("FS_Deflate: deflate init error!\n");
        return NULL;
    }
 
    strm.next_in = (unsigned char*)data;
    strm.avail_in = (unsigned int)size;
 
    tmp = (unsigned char *) Mem_Alloc(tempmempool, size);
    if(!tmp)
    {
        Con_Printf("FS_Deflate: not enough memory in tempmempool!\n");
        qz_deflateEnd(&strm);
        return NULL;
    }
 
    strm.next_out = tmp;
    strm.avail_out = (unsigned int)size;
 
    if(qz_deflate(&strm, Z_FINISH) != Z_STREAM_END)
    {
        Con_Printf("FS_Deflate: deflate failed!\n");
        qz_deflateEnd(&strm);
        Mem_Free(tmp);
        return NULL;
    }
 
    if(qz_deflateEnd(&strm) != Z_OK)
    {
        Con_Printf("FS_Deflate: deflateEnd failed\n");
        Mem_Free(tmp);
        return NULL;
    }
 
    if(strm.total_out >= size)
    {
        Con_Printf("FS_Deflate: deflate is useless on this data!\n");
        Mem_Free(tmp);
        return NULL;
    }
 
    out = (unsigned char *) Mem_Alloc(mempool, strm.total_out);
    if(!out)
    {
        Con_Printf("FS_Deflate: not enough memory in target mempool!\n");
        Mem_Free(tmp);
        return NULL;
    }
 
    *deflated_size = (size_t)strm.total_out;
 
    memcpy(out, tmp, strm.total_out);
    Mem_Free(tmp);
 
    return out;
}

References z_stream::avail_in, z_stream::avail_out, Con_Printf(), data, int(), level, MAX_WBITS, Mem_Alloc, Mem_Free, z_stream::next_in, z_stream::next_out, NULL, z_stream::opaque, qz_deflateInit2, size, tempmempool, z_stream::total_out, Z_BINARY, Z_DEFAULT_COMPRESSION, Z_DEFLATED, Z_FINISH, Z_MEMLEVEL_DEFAULT, Z_NULL, Z_OK, Z_STREAM_END, z_stream::zalloc, z_stream::zfree, and zlib_dll.

Referenced by SV_Prepare_CSQC().

FS_Dir_f()

void FS_Dir_f

(

cmd_state_t *

cmd

)

Definition at line 4053 of file fs.c.

{
    FS_ListDirectoryCmd(cmd, "dir", true);
}

References cmd(), and FS_ListDirectoryCmd().

Referenced by FS_Init_Commands().

FS_FileExists()

const char * FS_FileExists

(

const char *

filename

)

Look for a file in the packages and in the filesystem Returns its canonical name (same case as used in the pack) if found, else NULL.

If the file is found outside a pak, this will be the same pointer as passed in.

Definition at line 3693 of file fs.c.

{
    const char *canonicalname;
 
    return FS_FindFile(filename, NULL, &canonicalname, true) ? canonicalname : NULL;
}

References FS_FindFile(), and NULL.

Referenced by CDAudio_Play_byName(), CL_BeginDownloads(), CL_SetupWorldModel(), CL_StopDownload(), Curl_Begin(), Curl_Curl_f(), Font_LoadFont(), FS_Rescan(), Host_AddConfigText(), loadimagepixelsbgra(), M_Menu_Main_f(), MR_SetRouting(), SV_Download_f(), and SV_SpawnServer().

FS_FileExtension()

const char * FS_FileExtension

(

const char *

in

)

Definition at line 1403 of file fs.c.

{
    const char *separator, *backslash, *colon, *dot;
 
    dot = strrchr(in, '.');
    if (dot == NULL)
        return "";
 
    separator = strrchr(in, '/');
    backslash = strrchr(in, '\\');
    if (!separator || separator < backslash)
        separator = backslash;
    colon = strrchr(in, ':');
    if (!separator || separator < colon)
        separator = colon;
 
    if (separator && (dot < separator))
        return "";
 
    return dot + 1;
}

References NULL.

Referenced by CL_PlayVideo_f(), CL_StopDownload(), FS_AddGameDirectory(), FS_AddPack_Fullpath(), Image_StripImageExtension(), Mod_LoadModel(), SCR_ScreenShot_f(), and SV_Download_f().

FS_FileFromData()

qfile_t * FS_FileFromData	(	const unsigned char *	data,
		const size_t	size,
		qbool	quiet )

Definition at line 2951 of file fs.c.

{
    qfile_t* file;
    file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
    memset (file, 0, sizeof (*file));
    file->flags = QFILE_FLAG_DATA;
    file->ungetc = EOF;
    file->real_length = size;
    file->data = data;
    return file;
}

References data, fs_mempool, Mem_Alloc, QFILE_FLAG_DATA, and size.

Referenced by SV_Download_f().

FS_FileSize()

fs_offset_t FS_FileSize

(

qfile_t *

file

)

Definition at line 3474 of file fs.c.

{
    return file->real_length;
}

Referenced by LibAvW_FS_SeekSize(), SV_Download_f(), and SV_ReadClientMessage().

FS_FileType()

int FS_FileType

(

const char *

filename

)

Look for a file in the packages and in the filesystem.

Definition at line 3667 of file fs.c.

{
    searchpath_t *search;
    char fullpath[MAX_OSPATH];
 
    search = FS_FindFile (filename, NULL, NULL, true);
    if(!search)
        return FS_FILETYPE_NONE;
 
    if(search->pack && !search->pack->vpack)
        return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
 
    dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
    return FS_SysFileType(fullpath);
}

References dpsnprintf(), searchpath_t::filename, FS_FILETYPE_FILE, FS_FILETYPE_NONE, FS_FindFile(), FS_SysFileType(), MAX_OSPATH, NULL, searchpath_t::pack, and pack_t::vpack.

Referenced by Con_CompleteCommandLine().

FS_FileWithoutPath()

const char * FS_FileWithoutPath

(

const char *

in

)

Definition at line 1431 of file fs.c.

{
    const char *separator, *backslash, *colon;
 
    separator = strrchr(in, '/');
    backslash = strrchr(in, '\\');
    if (!separator || separator < backslash)
        separator = backslash;
    colon = strrchr(in, ':');
    if (!separator || separator < colon)
        separator = colon;
    return separator ? separator + 1 : in;
}

Referenced by COM_InitGameType(), and FS_IsRegisteredQuakePack().

FS_FindFile()

static searchpath_t * FS_FindFile ( const char * name, int * index, const char ** canonicalname, qbool quiet )

static

Definition at line 2690 of file fs.c.

{
    searchpath_t *search;
    pack_t *pak;
 
    // search through the path, one element at a time
    for (search = fs_searchpaths;search;search = search->next)
    {
        // is the element a pak file?
        if (search->pack && !search->pack->vpack)
        {
            int (*strcmp_funct) (const char* str1, const char* str2);
            int left, right, middle;
 
            pak = search->pack;
            strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
 
            // Look for the file (binary search)
            left = 0;
            right = pak->numfiles - 1;
            while (left <= right)
            {
                int diff;
 
                middle = (left + right) / 2;
                diff = strcmp_funct (pak->files[middle].name, name);
 
                // Found it
                if (!diff)
                {
                    if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
                    {
                        // yes, but the first one is empty so we treat it as not being there
                        if (!quiet && developer_extra.integer)
                            Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
 
                        if (index != NULL)
                            *index = -1;
                        if (canonicalname)
                            *canonicalname = NULL;
                        return NULL;
                    }
 
                    if (!quiet && developer_extra.integer)
                        Con_DPrintf("FS_FindFile: %s in %s\n", pak->files[middle].name, pak->filename);
 
                    if (index != NULL)
                        *index = middle;
                    if (canonicalname)
                        *canonicalname = pak->files[middle].name;
                    return search;
                }
 
                // If we're too far in the list
                if (diff > 0)
                    right = middle - 1;
                else
                    left = middle + 1;
            }
        }
        else
        {
            char netpath[MAX_OSPATH];
            dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
            if (FS_SysFileExists (netpath))
            {
                if (!quiet && developer_extra.integer)
                    Con_DPrintf("FS_FindFile: %s\n", netpath);
 
                if (index != NULL)
                    *index = -1;
                if (canonicalname)
                    *canonicalname = name;
                return search;
            }
        }
    }
 
    if (!quiet && developer_extra.integer)
        Con_DPrintf("FS_FindFile: can't find %s\n", name);
 
    if (index != NULL)
        *index = -1;
    if (canonicalname)
        *canonicalname = NULL;
    return NULL;
}

References Con_DPrintf(), developer_extra, dpsnprintf(), pack_t::filename, searchpath_t::filename, pack_t::files, fs_empty_files_in_pack_mark_deletions, fs_searchpaths, FS_SysFileExists(), pack_t::ignorecase, index, int(), cvar_t::integer, MAX_OSPATH, name, packfile_t::name, searchpath_t::next, NULL, pack_t::numfiles, searchpath_t::pack, packfile_t::realsize, right, and pack_t::vpack.

Referenced by FS_AddPack(), FS_FileExists(), FS_FileType(), FS_OpenReadFile(), FS_Which_f(), and FS_WhichPack().

FS_FreeSearch()

void FS_FreeSearch

(

fssearch_t *

search

)

Definition at line 3963 of file fs.c.

{
    Z_Free(search);
}

References Z_Free.

Referenced by Cmd_Exec_f(), Con_CompleteCommandLine(), FS_ListDirectory(), GetMapList(), Image_FixTransparentPixels_f(), Mod_LoadQ3Shaders(), VM_search_end(), and VM_Search_Reset().

FS_GameDir_f()

static void FS_GameDir_f ( cmd_state_t * cmd )

static

Definition at line 1751 of file fs.c.

{
    int i;
    int numgamedirs;
    const char *gamedirs[MAX_GAMEDIRS];
 
    if (Cmd_Argc(cmd) < 2)
    {
        Con_Printf("gamedirs active:");
        for (i = 0;i < fs_numgamedirs;i++)
            Con_Printf(" %s%s", (strcasecmp(fs_gamedirs[i], gamedirname1) && (!gamedirname2 || strcasecmp(fs_gamedirs[i], gamedirname2))) ? "^7" : "^9", fs_gamedirs[i]);
        Con_Printf("\n");
        return;
    }
 
    numgamedirs = Cmd_Argc(cmd) - 1;
    if (numgamedirs > MAX_GAMEDIRS)
    {
        Con_Printf(CON_ERROR "Too many gamedirs (%i > %i)\n", numgamedirs, MAX_GAMEDIRS);
        return;
    }
 
    for (i = 0;i < numgamedirs;i++)
        gamedirs[i] = Cmd_Argv(cmd, i+1);
 
    if ((cls.state == ca_connected && !cls.demoplayback) || sv.active)
    {
        // actually, changing during game would work fine, but would be stupid
        Con_Printf(CON_ERROR "Can not change gamedir while client is connected or server is running!\n");
        return;
    }
 
    FS_ChangeGameDirs(numgamedirs, gamedirs, true);
}

References server_t::active, ca_connected, cls, cmd(), Cmd_Argc(), Cmd_Argv(), CON_ERROR, Con_Printf(), client_static_t::demoplayback, FS_ChangeGameDirs(), fs_gamedirs, fs_numgamedirs, gamedirname1, gamedirname2, i, MAX_GAMEDIRS, client_static_t::state, and sv.

Referenced by FS_Init_Commands().

FS_Getc()

int FS_Getc

(

qfile_t *

file

)

Definition at line 3323 of file fs.c.

{
    unsigned char c;
 
    if (FS_Read (file, &c, 1) != 1)
        return EOF;
 
    return c;
}

References FS_Read().

Referenced by CL_PlayDemo(), Key_History_Init(), VM_buf_loadfile(), and VM_fgets().

FS_HasZlib()

qbool FS_HasZlib

(

void

)

Definition at line 620 of file fs.c.

{
#ifdef LINK_TO_ZLIB
    return true;
#else
    PK3_OpenLibrary(); // to be safe
    return (zlib_dll != 0);
#endif
}

References PK3_OpenLibrary(), and zlib_dll.

Referenced by CL_BeginDownloads().

FS_Inflate()

unsigned char * FS_Inflate	(	const unsigned char *	data,
		size_t	size,
		size_t *	inflated_size,
		mempool_t *	mempool )

Definition at line 4273 of file fs.c.

{
    int ret;
    z_stream strm;
    unsigned char *out = NULL;
    unsigned char tmp[2048];
    unsigned int have;
    sizebuf_t outbuf;
 
    *inflated_size = 0;
#ifndef LINK_TO_ZLIB
    if(!zlib_dll)
        return NULL;
#endif
 
    memset(&outbuf, 0, sizeof(outbuf));
    outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
    outbuf.maxsize = sizeof(tmp);
 
    memset(&strm, 0, sizeof(strm));
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
 
    if(qz_inflateInit2(&strm, -MAX_WBITS) != Z_OK)
    {
        Con_Printf("FS_Inflate: inflate init error!\n");
        Mem_Free(outbuf.data);
        return NULL;
    }
 
    strm.next_in = (unsigned char*)data;
    strm.avail_in = (unsigned int)size;
 
    do
    {
        strm.next_out = tmp;
        strm.avail_out = sizeof(tmp);
        ret = qz_inflate(&strm, Z_NO_FLUSH);
        // it either returns Z_OK on progress, Z_STREAM_END on end
        // or an error code
        switch(ret)
        {
            case Z_STREAM_END:
            case Z_OK:
                break;
 
            case Z_STREAM_ERROR:
                Con_Print("FS_Inflate: stream error!\n");
                break;
            case Z_DATA_ERROR:
                Con_Print("FS_Inflate: data error!\n");
                break;
            case Z_MEM_ERROR:
                Con_Print("FS_Inflate: mem error!\n");
                break;
            case Z_BUF_ERROR:
                Con_Print("FS_Inflate: buf error!\n");
                break;
            default:
                Con_Print("FS_Inflate: unknown error!\n");
                break;
 
        }
        if(ret != Z_OK && ret != Z_STREAM_END)
        {
            Con_Printf("Error after inflating %u bytes\n", (unsigned)strm.total_in);
            Mem_Free(outbuf.data);
            qz_inflateEnd(&strm);
            return NULL;
        }
        have = sizeof(tmp) - strm.avail_out;
        AssertBufsize(&outbuf, max(have, sizeof(tmp)));
        SZ_Write(&outbuf, tmp, have);
    } while(ret != Z_STREAM_END);
 
    qz_inflateEnd(&strm);
 
    out = (unsigned char *) Mem_Alloc(mempool, outbuf.cursize);
    if(!out)
    {
        Con_Printf("FS_Inflate: not enough memory in target mempool!\n");
        Mem_Free(outbuf.data);
        return NULL;
    }
 
    memcpy(out, outbuf.data, outbuf.cursize);
    Mem_Free(outbuf.data);
 
    *inflated_size = (size_t)outbuf.cursize;
 
    return out;
}

References AssertBufsize(), z_stream::avail_in, z_stream::avail_out, Con_Print(), Con_Printf(), sizebuf_t::cursize, data, sizebuf_t::data, int(), max, MAX_WBITS, sizebuf_t::maxsize, Mem_Alloc, Mem_Free, z_stream::next_in, z_stream::next_out, NULL, z_stream::opaque, qz_inflateInit2, ret, size, SZ_Write(), tempmempool, z_stream::total_in, Z_BUF_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_NO_FLUSH, Z_NULL, Z_OK, Z_STREAM_END, Z_STREAM_ERROR, z_stream::zalloc, z_stream::zfree, and zlib_dll.

Referenced by CL_StopDownload().

FS_Init()

void FS_Init

(

void

)

Definition at line 2342 of file fs.c.

{
    fs_mempool = Mem_AllocPool("file management", 0, NULL);
 
    PK3_OpenLibrary ();
 
    // initialize the self-pack (must be before COM_InitGameType as it may add command line options)
    FS_Init_SelfPack();
 
    // detect gamemode from commandline options or executable name
    COM_InitGameType();
 
    FS_Init_Commands(); // assumes com_startupgamegroup is set
 
    FS_Init_Dir();
}

References COM_InitGameType(), FS_Init_Commands(), FS_Init_Dir(), FS_Init_SelfPack(), fs_mempool, Mem_AllocPool, NULL, and PK3_OpenLibrary().

Referenced by Host_Init().

FS_Init_Commands()

void FS_Init_Commands

(

void

)

Definition at line 2117 of file fs.c.

{
    Cvar_RegisterVariable (&scr_screenshot_name);
    Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
    Cvar_RegisterVariable (&fs_unload_dlcache);
    Cvar_RegisterVariable (&cvar_fs_gamedir);
 
    Cmd_AddCommand(CF_SHARED, "gamedir", FS_GameDir_f, "changes active gamedir list, can take multiple arguments which shouldn't include the base directory, the last gamedir is the \"primary\" and files will be saved there (example usage: gamedir ctf id1)");
    Cmd_AddCommand(CF_SHARED, "fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
    Cmd_AddCommand(CF_SHARED, "path", FS_Path_f, "print searchpath (game directories and archives)");
    Cmd_AddCommand(CF_SHARED, "dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
    Cmd_AddCommand(CF_SHARED, "ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
    Cmd_AddCommand(CF_SHARED, "which", FS_Which_f, "accepts a file name as argument and reports where the file is taken from");
 
#ifdef __EMSCRIPTEN__
    Sys_EM_Register_Commands();
#endif
 
    if (com_startupgamegroup == GAME_NORMAL)
        Cmd_AddCommand(CF_SHARED, "game", FS_GameDir_f, "alias of gamedir, for compatibility with some Quake mod READMEs");
}

References CF_SHARED, Cmd_AddCommand(), com_startupgamegroup, cvar_fs_gamedir, Cvar_RegisterVariable(), FS_Dir_f(), fs_empty_files_in_pack_mark_deletions, FS_GameDir_f(), FS_Ls_f(), FS_Path_f(), FS_Rescan_f(), fs_unload_dlcache, FS_Which_f(), GAME_NORMAL, scr_screenshot_name, and Sys_EM_Register_Commands().

Referenced by FS_Init().

FS_Init_Dir()

static void FS_Init_Dir ( void )

static

Definition at line 2139 of file fs.c.

{
    int i;
    int numgamedirs;
    const char *cmdline_gamedirs[MAX_GAMEDIRS];
    WPATHDEF(fs_basedirw);
 
    *fs_basedir = 0;
    *fs_userdir = 0;
    *fs_gamedir = 0;
 
    // -basedir <path>
    // Overrides the system supplied base directory (under GAMENAME)
// 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)
    i = Sys_CheckParm ("-basedir");
    if (i && i < sys.argc-1)
    {
        dp_strlcpy (fs_basedir, sys.argv[i+1], sizeof (fs_basedir));
        i = (int)strlen (fs_basedir);
        if (i > 0 && (fs_basedir[i-1] == '\\' || fs_basedir[i-1] == '/'))
            fs_basedir[i-1] = 0;
    }
    else
    {
// If the base directory is explicitly defined by the compilation process
#ifdef DP_FS_BASEDIR
        dp_strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
#elif defined(__ANDROID__)
        dpsnprintf(fs_basedir, sizeof(fs_basedir), "/sdcard/%s/", gameuserdirname);
#elif defined(MACOSX)
        // FIXME: is there a better way to find the directory outside the .app, without using Objective-C?
        if (strstr(sys.argv[0], ".app/"))
        {
            char *split;
            dp_strlcpy(fs_basedir, sys.argv[0], sizeof(fs_basedir));
            split = strstr(fs_basedir, ".app/");
            if (split)
            {
                struct stat statresult;
                char vabuf[1024];
                // truncate to just after the .app/
                split[5] = 0;
                // see if gamedir exists in Resources
                if (stat(va(vabuf, sizeof(vabuf), "%s/Contents/Resources/%s", fs_basedir, gamedirname1), &statresult) == 0)
                {
                    // found gamedir inside Resources, use it
                    dp_strlcat(fs_basedir, "Contents/Resources/", sizeof(fs_basedir));
                }
                else
                {
                    // no gamedir found in Resources, gamedir is probably
                    // outside the .app, remove .app part of path
                    while (split > fs_basedir && *split != '/')
                        split--;
                    *split = 0;
                }
            }
        }
#else
    // use the working directory
    #ifdef WIN32
        GetCurrentDirectoryW(sizeof(fs_basedirw) / sizeof(*fs_basedirw), fs_basedirw);
        NARROW(fs_basedirw, fs_basedir);
    #else
        getcwd(fs_basedir, sizeof(fs_basedir));
    #endif
#endif
    }
 
    // make sure the appending of a path separator won't create an unterminated string
    memset(fs_basedir + sizeof(fs_basedir) - 2, 0, 2);
    // add a path separator to the end of the basedir if it lacks one
    if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
        dp_strlcat(fs_basedir, "/", sizeof(fs_basedir));
 
    // Add the personal game directory
    if((i = Sys_CheckParm("-userdir")) && i < sys.argc - 1)
        dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", sys.argv[i+1]);
    else if (Sys_CheckParm("-nohome"))
        *fs_userdir = 0; // user wants roaming installation, no userdir
    else
    {
#ifdef DP_FS_USERDIR
        dp_strlcpy(fs_userdir, DP_FS_USERDIR, sizeof(fs_userdir));
#else
        int dirmode;
        int highestuserdirmode = USERDIRMODE_COUNT - 1;
        int preferreduserdirmode = USERDIRMODE_COUNT - 1;
        int userdirstatus[USERDIRMODE_COUNT];
# ifdef WIN32
        // historical behavior...
        if (!strcmp(gamedirname1, "id1"))
            preferreduserdirmode = USERDIRMODE_NOHOME;
# endif
        // check what limitations the user wants to impose
        if (Sys_CheckParm("-home")) preferreduserdirmode = USERDIRMODE_HOME;
        if (Sys_CheckParm("-mygames")) preferreduserdirmode = USERDIRMODE_MYGAMES;
        if (Sys_CheckParm("-savedgames")) preferreduserdirmode = USERDIRMODE_SAVEDGAMES;
        // gather the status of the possible userdirs
        for (dirmode = 0;dirmode < USERDIRMODE_COUNT;dirmode++)
        {
            userdirstatus[dirmode] = FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
            if (userdirstatus[dirmode] == 1)
                Con_DPrintf("userdir %i = %s (writable)\n", dirmode, fs_userdir);
            else if (userdirstatus[dirmode] == 0)
                Con_DPrintf("userdir %i = %s (not writable or does not exist)\n", dirmode, fs_userdir);
            else
                Con_DPrintf("userdir %i (not applicable)\n", dirmode);
        }
        // some games may prefer writing to basedir, but if write fails we
        // have to search for a real userdir...
        if (preferreduserdirmode == 0 && userdirstatus[0] < 1)
            preferreduserdirmode = highestuserdirmode;
        // check for an existing userdir and continue using it if possible...
        for (dirmode = USERDIRMODE_COUNT - 1;dirmode > 0;dirmode--)
            if (userdirstatus[dirmode] == 1)
                break;
        // if no existing userdir found, make a new one...
        if (dirmode == 0 && preferreduserdirmode > 0)
            for (dirmode = preferreduserdirmode;dirmode > 0;dirmode--)
                if (userdirstatus[dirmode] >= 0)
                    break;
        // and finally, we picked one...
        FS_ChooseUserDir((userdirmode_t)dirmode, fs_userdir, sizeof(fs_userdir));
        Con_DPrintf("userdir %i is the winner\n", dirmode);
#endif
    }
 
    // if userdir equal to basedir, clear it to avoid confusion later
    if (!strcmp(fs_basedir, fs_userdir))
        fs_userdir[0] = 0;
 
    // -game <gamedir>
    // Adds basedir/gamedir as an override game
    // LadyHavoc: now supports multiple -game directories
    // the last one is the primary (where files are saved) and is used to identify mods
    for (i = 1, numgamedirs = 0; i < sys.argc && numgamedirs < MAX_GAMEDIRS; i++)
    {
        if (!sys.argv[i])
            continue;
        if (!strcmp (sys.argv[i], "-game") && i < sys.argc-1)
        {
            i++;
            cmdline_gamedirs[numgamedirs++] = sys.argv[i];
        }
    }
    COM_ChangeGameTypeForGameDirs(numgamedirs, cmdline_gamedirs, true, true);
 
    // generate the searchpath
    FS_Rescan();
 
    if (Thread_HasThreads())
        fs_mutex = Thread_CreateMutex();
}

References sys_t::argc, sys_t::argv, COM_ChangeGameTypeForGameDirs(), Con_DPrintf(), dp_strlcat, dp_strlcpy, dpsnprintf(), fs_basedir, FS_ChooseUserDir(), fs_gamedir, fs_mutex, FS_Rescan(), fs_userdir, gamedirname1, gameuserdirname, i, int(), MAX_GAMEDIRS, NARROW, strlen(), sys, Sys_CheckParm(), Thread_CreateMutex, Thread_HasThreads(), USERDIRMODE_COUNT, USERDIRMODE_HOME, USERDIRMODE_MYGAMES, USERDIRMODE_NOHOME, USERDIRMODE_SAVEDGAMES, va(), and WPATHDEF.

Referenced by FS_Init().

FS_Init_SelfPack()

void FS_Init_SelfPack

(

void

)

Definition at line 2299 of file fs.c.

{
    char *buf;
 
    // Load darkplaces.opt from the FS.
    if (!Sys_CheckParm("-noopt"))
    {
        buf = (char *) FS_SysLoadFile("darkplaces.opt", tempmempool, true, NULL);
        if(buf)
        {
            COM_InsertFlags(buf);
            Mem_Free(buf);
        }
    }
 
#ifndef USE_RWOPS
    // Provide the SelfPack.
    if (!Sys_CheckParm("-noselfpack") && sys.selffd >= 0)
    {
        fs_selfpack = FS_LoadPackPK3FromFD(sys.argv[0], sys.selffd, true);
        if(fs_selfpack)
        {
            FS_AddSelfPack();
            if (!Sys_CheckParm("-noopt"))
            {
                buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
                if(buf)
                {
                    COM_InsertFlags(buf);
                    Mem_Free(buf);
                }
            }
        }
    }
#endif
}

References sys_t::argv, buf, COM_InsertFlags(), FS_AddSelfPack(), FS_LoadFile(), FS_LoadPackPK3FromFD(), fs_selfpack, FS_SysLoadFile(), Mem_Free, NULL, sys_t::selffd, sys, Sys_CheckParm(), and tempmempool.

Referenced by FS_Init().

FS_IsRegisteredQuakePack()

qbool FS_IsRegisteredQuakePack

(

const char *

name

)

Definition at line 4112 of file fs.c.

{
    searchpath_t *search;
    pack_t *pak;
 
    // search through the path, one element at a time
    for (search = fs_searchpaths;search;search = search->next)
    {
        if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
            // TODO do we want to support vpacks in here too?
        {
            int (*strcmp_funct) (const char* str1, const char* str2);
            int left, right, middle;
 
            pak = search->pack;
            strcmp_funct = pak->ignorecase ? strcasecmp : strcmp;
 
            // Look for the file (binary search)
            left = 0;
            right = pak->numfiles - 1;
            while (left <= right)
            {
                int diff;
 
                middle = (left + right) / 2;
                diff = strcmp_funct (pak->files[middle].name, "gfx/pop.lmp");
 
                // Found it
                if (!diff)
                    return true;
 
                // If we're too far in the list
                if (diff > 0)
                    right = middle - 1;
                else
                    left = middle + 1;
            }
 
            // we found the requested pack but it is not registered quake
            return false;
        }
    }
 
    return false;
}

References searchpath_t::filename, pack_t::files, FS_FileWithoutPath(), fs_searchpaths, pack_t::ignorecase, int(), name, packfile_t::name, searchpath_t::next, pack_t::numfiles, searchpath_t::pack, right, and pack_t::vpack.

Referenced by SV_Download_f().

FS_ListDirectory()

static int FS_ListDirectory ( const char * pattern, int oneperline )

static

Definition at line 3969 of file fs.c.

{
    int numfiles;
    int numcolumns;
    int numlines;
    int columnwidth;
    int linebufpos;
    int i, j, k, l;
    const char *name;
    char linebuf[MAX_INPUTLINE];
    fssearch_t *search;
    search = FS_Search(pattern, true, true, NULL);
    if (!search)
        return 0;
    numfiles = search->numfilenames;
    if (!oneperline)
    {
        // FIXME: the names could be added to one column list and then
        // gradually shifted into the next column if they fit, and then the
        // next to make a compact variable width listing but it's a lot more
        // complicated...
        // find width for columns
        columnwidth = 0;
        for (i = 0;i < numfiles;i++)
        {
            l = (int)strlen(search->filenames[i]);
            if (columnwidth < l)
                columnwidth = l;
        }
        // count the spacing character
        columnwidth++;
        // calculate number of columns
        numcolumns = con_linewidth / columnwidth;
        // don't bother with the column printing if it's only one column
        if (numcolumns >= 2)
        {
            numlines = (numfiles + numcolumns - 1) / numcolumns;
            for (i = 0;i < numlines;i++)
            {
                linebufpos = 0;
                for (k = 0;k < numcolumns;k++)
                {
                    l = i * numcolumns + k;
                    if (l < numfiles)
                    {
                        name = search->filenames[l];
                        for (j = 0;name[j] && linebufpos + 1 < (int)sizeof(linebuf);j++)
                            linebuf[linebufpos++] = name[j];
                        // space out name unless it's the last on the line
                        if (k + 1 < numcolumns && l + 1 < numfiles)
                            for (;j < columnwidth && linebufpos + 1 < (int)sizeof(linebuf);j++)
                                linebuf[linebufpos++] = ' ';
                    }
                }
                linebuf[linebufpos] = 0;
                Con_Printf("%s\n", linebuf);
            }
        }
        else
            oneperline = true;
    }
    if (oneperline)
        for (i = 0;i < numfiles;i++)
            Con_Printf("%s\n", search->filenames[i]);
    FS_FreeSearch(search);
    return (int)numfiles;
}

References con_linewidth, Con_Printf(), fssearch_t::filenames, FS_FreeSearch(), FS_Search(), i, int(), MAX_INPUTLINE, name, NULL, fssearch_t::numfilenames, and strlen().

Referenced by FS_ListDirectoryCmd().

FS_ListDirectoryCmd()

static void FS_ListDirectoryCmd ( cmd_state_t * cmd, const char * cmdname, int oneperline )

static

Definition at line 4037 of file fs.c.

{
    const char *pattern;
    if (Cmd_Argc(cmd) >= 3)
    {
        Con_Printf("usage:\n%s [path/pattern]\n", cmdname);
        return;
    }
    if (Cmd_Argc(cmd) == 2)
        pattern = Cmd_Argv(cmd, 1);
    else
        pattern = "*";
    if (!FS_ListDirectory(pattern, oneperline))
        Con_Print("No files found.\n");
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), and FS_ListDirectory().

Referenced by FS_Dir_f(), and FS_Ls_f().

FS_ListGameDirs()

static void FS_ListGameDirs ( void )

static

Definition at line 1854 of file fs.c.

{
    stringlist_t list, list2;
    int i;
    const char *info;
    char vabuf[1024];
 
    fs_all_gamedirs_count = 0;
    if(fs_all_gamedirs)
        Mem_Free(fs_all_gamedirs);
 
    stringlistinit(&list);
    listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_basedir), "");
    listdirectory(&list, va(vabuf, sizeof(vabuf), "%s/", fs_userdir), "");
    stringlistsort(&list, false);
 
    stringlistinit(&list2);
    for(i = 0; i < list.numstrings; ++i)
    {
        if(i)
            if(!strcmp(list.strings[i-1], list.strings[i]))
                continue;
        info = FS_CheckGameDir(list.strings[i]);
        if(!info)
            continue;
        if(info == fs_checkgamedir_missing)
            continue;
        if(!*info)
            continue;
        stringlistappend(&list2, list.strings[i]);
    }
    stringlistfreecontents(&list);
 
    fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
    for(i = 0; i < list2.numstrings; ++i)
    {
        info = FS_CheckGameDir(list2.strings[i]);
        // all this cannot happen any more, but better be safe than sorry
        if(!info)
            continue;
        if(info == fs_checkgamedir_missing)
            continue;
        if(!*info)
            continue;
        dp_strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[fs_all_gamedirs_count].name));
        dp_strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[fs_all_gamedirs_count].description));
        ++fs_all_gamedirs_count;
    }
}

References dp_strlcpy, fs_all_gamedirs, fs_all_gamedirs_count, fs_basedir, FS_CheckGameDir(), fs_checkgamedir_missing, fs_mempool, fs_userdir, i, listdirectory(), Mem_Alloc, Mem_Free, gamedir_t::name, name, stringlist_t::numstrings, stringlistappend(), stringlistfreecontents(), stringlistinit(), stringlistsort(), stringlist_t::strings, and va().

Referenced by FS_Rescan().

FS_LoadAndCloseQFile()

static unsigned char * FS_LoadAndCloseQFile ( qfile_t * file, const char * path, mempool_t * pool, qbool quiet, fs_offset_t * filesizepointer )

static

Definition at line 3503 of file fs.c.

{
    unsigned char *buf = NULL;
    fs_offset_t filesize = 0;
 
    if (file)
    {
        filesize = file->real_length;
        if(filesize < 0)
        {
            Con_Printf("FS_LoadFile(\"%s\", pool, %s, filesizepointer): trying to open a non-regular file\n", path, quiet ? "true" : "false");
            FS_Close(file);
            return NULL;
        }
 
        buf = (unsigned char *)Mem_Alloc (pool, filesize + 1);
        buf[filesize] = '\0';
        FS_Read (file, buf, filesize);
        FS_Close (file);
        if (developer_loadfile.integer)
            Con_Printf("loaded file \"%s\" (%u bytes)\n", path, (unsigned int)filesize);
    }
 
    if (filesizepointer)
        *filesizepointer = filesize;
    return buf;
}

References buf, Con_Printf(), developer_loadfile, FS_Close(), FS_Read(), cvar_t::integer, Mem_Alloc, and NULL.

Referenced by FS_LoadFile(), and FS_SysLoadFile().

FS_LoadFile()

unsigned char * FS_LoadFile	(	const char *	path,
		mempool_t *	pool,
		qbool	quiet,
		fs_offset_t *	filesizepointer )

Definition at line 3540 of file fs.c.

{
    qfile_t *file = FS_OpenVirtualFile(path, quiet);
    return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
}

References FS_LoadAndCloseQFile(), and FS_OpenVirtualFile().

Referenced by CL_CutDemo(), CL_IPLog_Load(), CL_Locs_Reload_f(), CL_Particles_LoadEffectInfo(), CL_ReadPointFile_f(), CL_VM_Init(), Cmd_Exec(), Curl_FindPackURL(), decode_image(), fontfilecache_LoadFile(), FS_CRCFile(), FS_Init_SelfPack(), GetMapList(), gl_main_newmap(), Image_GetStockPicSize(), LoadFont(), loadimagepixelsbgra(), LoadSubtitles(), M_Setup_Draw(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q2BSP_LoadTexinfo(), OGG_LoadVorbisFile(), Palette_Load(), Palette_LoadQ2Colormap(), Palette_SetupSpecialPalettes(), PRVM_LoadLNO(), PRVM_PO_Load(), PRVM_Prog_Load(), R_InitParticleTexture(), R_LoadQWSkin(), R_LoadTextureDDSFile(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), S_LoadWavFile(), ShaderModeInfo_GetShaderText(), SV_Loadgame_f(), SV_ParticleEffectIndex(), SV_Prepare_CSQC(), SV_SpawnServer(), VM_loadfromfile(), W_GetLumpName(), and XMP_LoadModFile().

FS_LoadPackPAK()

static pack_t * FS_LoadPackPAK ( const char * packfile )

static

Takes an explicit (not game tree related) path to a pak file. Loads the header and directory, adding the files at the beginning of the list so they override previous pack files.

Definition at line 1081 of file fs.c.

{
    dpackheader_t header;
    int i, numpackfiles;
    filedesc_t packhandle;
    pack_t *pack;
    dpackfile_t *info;
 
    packhandle = FS_SysOpenFiledesc(packfile, "rb", false);
    if (!FILEDESC_ISVALID(packhandle))
        return NULL;
    if(FILEDESC_READ (packhandle, (void *)&header, sizeof(header)) != sizeof(header))
    {
        Con_Printf ("%s is not a packfile\n", packfile);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
    if (memcmp(header.id, "PACK", 4))
    {
        Con_Printf ("%s is not a packfile\n", packfile);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
    header.dirofs = LittleLong (header.dirofs);
    header.dirlen = LittleLong (header.dirlen);
 
    if (header.dirlen % sizeof(dpackfile_t))
    {
        Con_Printf ("%s has an invalid directory size\n", packfile);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
 
    numpackfiles = header.dirlen / sizeof(dpackfile_t);
 
    if (numpackfiles < 0 || numpackfiles > MAX_FILES_IN_PACK)
    {
        Con_Printf ("%s has %i files\n", packfile, numpackfiles);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
 
    info = (dpackfile_t *)Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
    FILEDESC_SEEK (packhandle, header.dirofs, SEEK_SET);
    if(header.dirlen != FILEDESC_READ (packhandle, (void *)info, header.dirlen))
    {
        Con_Printf("%s is an incomplete PAK, not loading\n", packfile);
        Mem_Free(info);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
 
    pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
    pack->ignorecase = true; // PAK is sensitive in Quake1 but insensitive in Quake2
    dp_strlcpy (pack->filename, packfile, sizeof (pack->filename));
    pack->handle = packhandle;
    pack->numfiles = 0;
    pack->files = (packfile_t *)Mem_Alloc(fs_mempool, numpackfiles * sizeof(packfile_t));
 
    // parse the directory
    for (i = 0;i < numpackfiles;i++)
    {
        fs_offset_t offset = (unsigned int)LittleLong (info[i].filepos);
        fs_offset_t size = (unsigned int)LittleLong (info[i].filelen);
 
        // Ensure a zero terminated file name (required by format).
        info[i].name[sizeof(info[i].name) - 1] = 0;
 
        FS_AddFileToPack (info[i].name, pack, offset, size, size, PACKFILE_FLAG_TRUEOFFS);
    }
 
    Mem_Free(info);
 
    Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
    return pack;
}

References Con_DPrintf(), Con_Printf(), dpackheader_t::dirlen, dpackheader_t::dirofs, dp_strlcpy, FILEDESC_CLOSE, FILEDESC_ISVALID, FILEDESC_READ, FILEDESC_SEEK, pack_t::filename, pack_t::files, FS_AddFileToPack(), fs_mempool, FS_SysOpenFiledesc(), pack_t::handle, i, dpackheader_t::id, pack_t::ignorecase, int(), LittleLong, MAX_FILES_IN_PACK, Mem_Alloc, Mem_Free, dpackfile_t::name, name, NULL, pack_t::numfiles, offset, PACKFILE_FLAG_TRUEOFFS, size, and tempmempool.

Referenced by FS_AddPack_Fullpath().

FS_LoadPackPK3()

static pack_t * FS_LoadPackPK3 ( const char * packfile )

static

Definition at line 891 of file fs.c.

{
    filedesc_t packhandle;
    packhandle = FS_SysOpenFiledesc (packfile, "rb", false);
    if (!FILEDESC_ISVALID(packhandle))
        return NULL;
    return FS_LoadPackPK3FromFD(packfile, packhandle, false);
}

References FILEDESC_ISVALID, FS_LoadPackPK3FromFD(), FS_SysOpenFiledesc(), and NULL.

Referenced by FS_AddPack_Fullpath().

FS_LoadPackPK3FromFD()

static pack_t * FS_LoadPackPK3FromFD ( const char * packfile, filedesc_t packhandle, qbool silent )

static

Definition at line 836 of file fs.c.

{
    pk3_endOfCentralDir_t eocd;
    pack_t *pack;
    int real_nb_files;
 
    if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
    {
        if(!silent)
            Con_Printf ("%s is not a PK3 file\n", packfile);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
 
    // Multi-volume ZIP archives are NOT allowed
    if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
    {
        Con_Printf ("%s is a multi-volume ZIP archive\n", packfile);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
 
    // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
    // since eocd.nbentries is an unsigned 16 bits integer
#if MAX_FILES_IN_PACK < 65535
    if (eocd.nbentries > MAX_FILES_IN_PACK)
    {
        Con_Printf ("%s contains too many files (%hu)\n", packfile, eocd.nbentries);
        FILEDESC_CLOSE(packhandle);
        return NULL;
    }
#endif
 
    // Create a package structure in memory
    pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
    pack->ignorecase = true; // PK3 ignores case
    dp_strlcpy (pack->filename, packfile, sizeof (pack->filename));
    pack->handle = packhandle;
    pack->numfiles = eocd.nbentries;
    pack->files = (packfile_t *)Mem_Alloc(fs_mempool, eocd.nbentries * sizeof(packfile_t));
 
    real_nb_files = PK3_BuildFileList (pack, &eocd);
    if (real_nb_files < 0)
    {
        Con_Printf ("%s is not a valid PK3 file\n", packfile);
        FILEDESC_CLOSE(pack->handle);
        Mem_Free(pack);
        return NULL;
    }
 
    Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
    return pack;
}

References pk3_endOfCentralDir_t::cdir_disknum, Con_DPrintf(), Con_Printf(), pk3_endOfCentralDir_t::disknum, dp_strlcpy, FILEDESC_CLOSE, pack_t::filename, pack_t::files, fs_mempool, pack_t::handle, pack_t::ignorecase, MAX_FILES_IN_PACK, Mem_Alloc, Mem_Free, pk3_endOfCentralDir_t::nbentries, NULL, pack_t::numfiles, PK3_BuildFileList(), and PK3_GetEndOfCentralDir().

Referenced by FS_Init_SelfPack(), and FS_LoadPackPK3().

FS_LoadPackVirtual()

static pack_t * FS_LoadPackVirtual ( const char * dirname )

static

Definition at line 1165 of file fs.c.

{
    pack_t *pack;
    pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
    pack->vpack = true;
    pack->ignorecase = false;
    dp_strlcpy (pack->filename, dirname, sizeof(pack->filename));
    pack->handle = FILEDESC_INVALID;
    pack->numfiles = -1;
    pack->files = NULL;
    Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
    return pack;
}

References Con_DPrintf(), dp_strlcpy, FILEDESC_INVALID, pack_t::filename, pack_t::files, fs_mempool, pack_t::handle, pack_t::ignorecase, Mem_Alloc, NULL, pack_t::numfiles, and pack_t::vpack.

Referenced by FS_AddPack_Fullpath().

FS_Ls_f()

void FS_Ls_f

(

cmd_state_t *

cmd

)

Definition at line 4058 of file fs.c.

{
    FS_ListDirectoryCmd(cmd, "ls", false);
}

References cmd(), and FS_ListDirectoryCmd().

Referenced by FS_Init_Commands().

FS_mkdir()

static void FS_mkdir ( const char * path )

static

Definition at line 999 of file fs.c.

{
    WPATHDEF(pathw);
 
    if(Sys_CheckParm("-readonly"))
        return;
 
    WIDE(path, pathw);
 
#ifdef WIN32
    if (_wmkdir(pathw) == -1)
#else
    if (mkdir(path, 0777) == -1)
#endif
    {
        // No logging for this. The only caller is FS_CreatePath (which
        // calls it in ways that will intentionally produce EEXIST),
        // and its own callers always use the directory afterwards and
        // thus will detect failure that way.
    }
}

References Sys_CheckParm(), WIDE, and WPATHDEF.

Referenced by FS_CreatePath().

FS_OpenPackedFile()

static qfile_t * FS_OpenPackedFile ( pack_t * pack, int pack_ind )

static

Definition at line 2518 of file fs.c.

{
    packfile_t *pfile;
    filedesc_t dup_handle;
    qfile_t* file;
 
    pfile = &pack->files[pack_ind];
 
    // If we don't have the true offset, get it now
    if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
        if (!PK3_GetTrueFileOffset (pfile, pack))
            return NULL;
 
#ifndef LINK_TO_ZLIB
    // No Zlib DLL = no compressed files
    if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
    {
        Con_Printf(CON_WARN "WARNING: can't open the compressed file %s\n"
                    "You need the Zlib DLL to use compressed files\n",
                    pfile->name);
        return NULL;
    }
#endif
 
    // LadyHavoc: FILEDESC_SEEK affects all duplicates of a handle so we do it before
    // the dup() call to avoid having to close the dup_handle on error here
    if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
    {
        Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %08x%08x)\n",
                    pfile->name, pack->filename, (unsigned int)(pfile->offset >> 32), (unsigned int)(pfile->offset));
        return NULL;
    }
 
    dup_handle = FILEDESC_DUP (pack->filename, pack->handle);
    if (!FILEDESC_ISVALID(dup_handle))
    {
        Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)\n", pack->filename);
        return NULL;
    }
 
    file = (qfile_t *)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;
    file->ungetc = EOF;
 
    if (pfile->flags & PACKFILE_FLAG_DEFLATED)
    {
        ztoolkit_t *ztk;
 
        file->flags |= QFILE_FLAG_DEFLATED;
 
        // We need some more variables
        ztk = (ztoolkit_t *)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)
        {
            Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)\n", pfile->name);
            FILEDESC_CLOSE(dup_handle);
            Mem_Free(file);
            return NULL;
        }
 
        ztk->zstream.next_out = file->buff;
        ztk->zstream.avail_out = sizeof (file->buff);
 
        file->ztk = ztk;
    }
 
    return file;
}

References z_stream::avail_in, z_stream::avail_out, ztoolkit_t::comp_length, Con_Printf(), CON_WARN, FILEDESC_CLOSE, FILEDESC_DUP(), FILEDESC_ISVALID, FILEDESC_SEEK, pack_t::filename, pack_t::files, packfile_t::flags, fs_mempool, pack_t::handle, ztoolkit_t::input, MAX_WBITS, Mem_Alloc, Mem_Free, packfile_t::name, z_stream::next_in, z_stream::next_out, NULL, packfile_t::offset, PACKFILE_FLAG_DEFLATED, PACKFILE_FLAG_TRUEOFFS, packfile_t::packsize, PK3_GetTrueFileOffset(), QFILE_FLAG_DEFLATED, QFILE_FLAG_PACKED, qz_inflateInit2, packfile_t::realsize, Z_OK, zlib_dll, and ztoolkit_t::zstream.

Referenced by FS_OpenReadFile().

FS_OpenReadFile()

static qfile_t * FS_OpenReadFile ( const char * filename, qbool quiet, qbool nonblocking, int symlinkLevels )

static

Definition at line 2786 of file fs.c.

{
    searchpath_t *search;
    int pack_ind;
 
    search = FS_FindFile (filename, &pack_ind, NULL, quiet);
 
    // Not found?
    if (search == NULL)
        return NULL;
 
    // Found in the filesystem?
    if (pack_ind < 0)
    {
        // this works with vpacks, so we are fine
        char path [MAX_OSPATH];
        dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
        return FS_SysOpen (path, "rb", nonblocking);
    }
 
    // So, we found it in a package...
 
    // Is it a PK3 symlink?
    // TODO also handle directory symlinks by parsing the whole structure...
    // but heck, file symlinks are good enough for now
    if(search->pack->files[pack_ind].flags & PACKFILE_FLAG_SYMLINK)
    {
        if(symlinkLevels <= 0)
        {
            Con_Printf("symlink: %s: too many levels of symbolic links\n", filename);
            return NULL;
        }
        else
        {
            char linkbuf[MAX_QPATH];
            fs_offset_t count;
            qfile_t *linkfile = FS_OpenPackedFile (search->pack, pack_ind);
            const char *mergeslash;
            char *mergestart;
 
            if(!linkfile)
                return NULL;
            count = FS_Read(linkfile, linkbuf, sizeof(linkbuf) - 1);
            FS_Close(linkfile);
            if(count < 0)
                return NULL;
            linkbuf[count] = 0;
 
            // Now combine the paths...
            mergeslash = strrchr(filename, '/');
            mergestart = linkbuf;
            if(!mergeslash)
                mergeslash = filename;
            while(!strncmp(mergestart, "../", 3))
            {
                mergestart += 3;
                while(mergeslash > filename)
                {
                    --mergeslash;
                    if(*mergeslash == '/')
                        break;
                }
            }
            // Now, mergestart will point to the path to be appended, and mergeslash points to where it should be appended
            if(mergeslash == filename)
            {
                // Either mergeslash == filename, then we just replace the name (done below)
            }
            else
            {
                // Or, we append the name after mergeslash;
                // or rather, we can also shift the linkbuf so we can put everything up to and including mergeslash first
                int spaceNeeded = mergeslash - filename + 1;
                int spaceRemoved = mergestart - linkbuf;
                if(count - spaceRemoved + spaceNeeded >= MAX_QPATH)
                {
                    Con_DPrintf("symlink: too long path rejected\n");
                    return NULL;
                }
                memmove(linkbuf + spaceNeeded, linkbuf + spaceRemoved, count - spaceRemoved);
                memcpy(linkbuf, filename, spaceNeeded);
                linkbuf[count - spaceRemoved + spaceNeeded] = 0;
                mergestart = linkbuf;
            }
            if (!quiet && developer_loading.integer)
                Con_DPrintf("symlink: %s -> %s\n", filename, mergestart);
            if(FS_CheckNastyPath (mergestart, false))
            {
                Con_DPrintf("symlink: nasty path %s rejected\n", mergestart);
                return NULL;
            }
            return FS_OpenReadFile(mergestart, quiet, nonblocking, symlinkLevels - 1);
        }
    }
 
    return FS_OpenPackedFile (search->pack, pack_ind);
}

References Con_DPrintf(), Con_Printf(), count, developer_loading, dpsnprintf(), searchpath_t::filename, pack_t::files, packfile_t::flags, FS_CheckNastyPath(), FS_Close(), FS_FindFile(), FS_OpenPackedFile(), FS_OpenReadFile(), FS_Read(), FS_SysOpen(), cvar_t::integer, MAX_OSPATH, MAX_QPATH, NULL, searchpath_t::pack, and PACKFILE_FLAG_SYMLINK.

Referenced by FS_OpenReadFile(), and FS_OpenVirtualFile().

FS_OpenRealFile()

qfile_t * FS_OpenRealFile	(	const char *	filepath,
		const char *	mode,
		qbool	quiet )

Definition at line 2901 of file fs.c.

{
    char real_path [MAX_OSPATH];
 
    if (FS_CheckNastyPath(filepath, false))
    {
        Con_Printf("FS_OpenRealFile(\"%s\", \"%s\", %s): nasty filename rejected\n", filepath, mode, quiet ? "true" : "false");
        return NULL;
    }
 
    dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
 
    // If the file is opened in "write", "append", or "read/write" mode,
    // create directories up to the file.
    if (mode[0] == 'w' || mode[0] == 'a' || strchr (mode, '+'))
        FS_CreatePath (real_path);
    return FS_SysOpen (real_path, mode, false);
}

References Con_Printf(), dpsnprintf(), FS_CheckNastyPath(), FS_CreatePath(), fs_gamedir, FS_SysOpen(), MAX_OSPATH, mode, and NULL.

Referenced by CheckPendingDownloads(), CL_CutDemo(), CL_Locs_Save_f(), CL_ParseServerInfo(), CL_Record_f(), Con_ConDump_f(), Curl_Begin(), Curl_EndDownload(), FS_WriteFileInBlocks(), Host_SaveConfig(), JPEG_SaveImage_preflipped(), Key_History_Init(), Key_History_Shutdown(), Log_Open(), Log_Printf(), M_ScanSaves(), PNG_SaveImage_preflipped(), PRVM_Prog_Load(), R_GLSL_DumpShader_f(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SV_Savegame_to(), SV_StartDemoRecording(), and VM_fopen().

FS_OpenVirtualFile()

qfile_t * FS_OpenVirtualFile	(	const char *	filepath,
		qbool	quiet )

Definition at line 2928 of file fs.c.

{
    qfile_t *result = NULL;
    if (FS_CheckNastyPath(filepath, false))
    {
        Con_Printf("FS_OpenVirtualFile(\"%s\", %s): nasty filename rejected\n", filepath, quiet ? "true" : "false");
        return NULL;
    }
 
    if (fs_mutex) Thread_LockMutex(fs_mutex);
    result = FS_OpenReadFile (filepath, quiet, false, 16);
    if (fs_mutex) Thread_UnlockMutex(fs_mutex);
    return result;
}

References Con_Printf(), FS_CheckNastyPath(), fs_mutex, FS_OpenReadFile(), NULL, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by CL_PlayDemo(), FS_LoadFile(), GetMapList(), hz_bitstream_read_open(), jam_open(), LibAvW_OpenVideo(), QW_CL_CheckOrDownloadFile(), SV_Download_f(), VM_buf_loadfile(), VM_fopen(), and W_LoadTextureWadFile().

FS_Path_f()

static void FS_Path_f ( cmd_state_t * cmd )

static

Definition at line 1052 of file fs.c.

{
    searchpath_t *s;
 
    Con_Print("Current search path:\n");
    for (s=fs_searchpaths ; s ; s=s->next)
    {
        if (s->pack)
        {
            if(s->pack->vpack)
                Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
            else
                Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
        }
        else
            Con_Printf("%s\n", s->filename);
    }
}

References Con_Print(), Con_Printf(), pack_t::filename, searchpath_t::filename, fs_searchpaths, searchpath_t::next, pack_t::numfiles, searchpath_t::pack, and pack_t::vpack.

Referenced by FS_Init_Commands().

FS_Print()

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

Definition at line 3261 of file fs.c.

{
    return (int)FS_Write (file, msg, strlen (msg));
}

References FS_Write(), and strlen().

Referenced by Log_Close(), Log_ConPrint(), Log_Open(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), R_GLSL_DumpShader_f(), and SV_Savegame_to().

FS_Printf()

int FS_Printf	(	qfile_t *	file,
		const char *	format,
			... )

Definition at line 3273 of file fs.c.

{
    int result;
    va_list args;
 
    va_start (args, format);
    result = FS_VPrintf (file, format, args);
    va_end (args);
 
    return result;
}

References format, and FS_VPrintf().

Referenced by CL_CutDemo(), CL_Locs_Save_f(), CL_ParseServerInfo(), CL_Record_f(), Crypto_SavePubKeyTextFile(), Cvar_WriteVariables(), Key_History_Shutdown(), Key_WriteBindings(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_Prog_Load(), SV_Savegame_to(), and SV_StartDemoRecording().

FS_Purge()

void FS_Purge

(

qfile_t *

file

)

Definition at line 3487 of file fs.c.

{
    file->buff_len = 0;
    file->buff_ind = 0;
    file->ungetc = EOF;
}

Referenced by FS_Read(), FS_Seek(), and FS_Write().

FS_Read()

fs_offset_t FS_Read	(	qfile_t *	file,
		void *	buffer,
		size_t	buffersize )

Definition at line 3066 of file fs.c.

{
    fs_offset_t count, done;
 
    if (buffersize == 0 || !buffer)
        return 0;
 
    // Get rid of the ungetc character
    if (file->ungetc != EOF)
    {
        ((char*)buffer)[0] = file->ungetc;
        buffersize--;
        file->ungetc = EOF;
        done = 1;
    }
    else
        done = 0;
 
    if(file->flags & QFILE_FLAG_DATA)
    {
        size_t left = file->real_length - file->position;
        if(buffersize > left)
            buffersize = left;
        memcpy(buffer, file->data + file->position, buffersize);
        file->position += buffersize;
        return buffersize;
    }
 
    // First, we copy as many bytes as we can from "buff"
    if (file->buff_ind < file->buff_len)
    {
        count = file->buff_len - file->buff_ind;
        count = ((fs_offset_t)buffersize > count) ? count : (fs_offset_t)buffersize;
        done += count;
        memcpy (buffer, &file->buff[file->buff_ind], count);
        file->buff_ind += count;
 
        buffersize -= count;
        if (buffersize == 0)
            return done;
    }
 
    // NOTE: at this point, the read buffer is always empty
 
    // If the file isn't compressed
    if (! (file->flags & QFILE_FLAG_DEFLATED))
    {
        fs_offset_t 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 > (fs_offset_t)buffersize)
                count = (fs_offset_t)buffersize;
            if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
            {
                // Seek failed. When reading from a pipe, and
                // the caller never called FS_Seek, this still
                // works fine.  So no reporting this error.
            }
            nb = FILEDESC_READ (file->handle, &((unsigned char*)buffer)[done], count);
            if (nb > 0)
            {
                done += nb;
                file->position += nb;
 
                // Purge cached data
                FS_Purge (file);
            }
        }
        else
        {
            if (count > (fs_offset_t)sizeof (file->buff))
                count = (fs_offset_t)sizeof (file->buff);
            if (FILEDESC_SEEK (file->handle, file->offset + file->position, SEEK_SET) == -1)
            {
                // Seek failed. When reading from a pipe, and
                // the caller never called FS_Seek, this still
                // works fine.  So no reporting this error.
            }
            nb = FILEDESC_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 = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
                memcpy (&((unsigned char*)buffer)[done], file->buff, count);
                file->buff_ind = count;
                done += count;
            }
        }
 
        return done;
    }
 
    // If the file is compressed, it's more complicated...
    // We cycle through a few operations until we have read enough data
    while (buffersize > 0)
    {
        ztoolkit_t *ztk = file->ztk;
        int error;
 
        // 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 (file->position == file->real_length)
                return done;
 
            count = (fs_offset_t)(ztk->comp_length - ztk->in_position);
            if (count > (fs_offset_t)sizeof (ztk->input))
                count = (fs_offset_t)sizeof (ztk->input);
            FILEDESC_SEEK (file->handle, file->offset + (fs_offset_t)ztk->in_position, SEEK_SET);
            if (FILEDESC_READ (file->handle, ztk->input, count) != count)
            {
                Con_Printf ("FS_Read: unexpected end of file\n");
                break;
            }
 
            ztk->in_ind = 0;
            ztk->in_len = count;
            ztk->in_position += count;
        }
 
        ztk->zstream.next_in = &ztk->input[ztk->in_ind];
        ztk->zstream.avail_in = (unsigned int)(ztk->in_len - ztk->in_ind);
 
        // 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 "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)
            {
                Con_Printf ("FS_Read: Can't inflate file\n");
                break;
            }
            ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
 
            file->buff_len = (fs_offset_t)sizeof (file->buff) - ztk->zstream.avail_out;
            file->position += file->buff_len;
 
            // Copy the requested data in "buffer" (as much as we can)
            count = (fs_offset_t)buffersize > file->buff_len ? file->buff_len : (fs_offset_t)buffersize;
            memcpy (&((unsigned char*)buffer)[done], file->buff, count);
            file->buff_ind = count;
        }
 
        // Else, we inflate directly in "buffer"
        else
        {
            ztk->zstream.next_out = &((unsigned char*)buffer)[done];
            ztk->zstream.avail_out = (unsigned int)buffersize;
            error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
            if (error != Z_OK && error != Z_STREAM_END)
            {
                Con_Printf ("FS_Read: Can't inflate file\n");
                break;
            }
            ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
 
            // How much data did it inflate?
            count = (fs_offset_t)(buffersize - ztk->zstream.avail_out);
            file->position += count;
 
            // Purge cached data
            FS_Purge (file);
        }
 
        done += count;
        buffersize -= count;
    }
 
    return done;
}

References z_stream::avail_in, z_stream::avail_out, buffer, ztoolkit_t::comp_length, Con_Printf(), count, error(), FILEDESC_READ, FILEDESC_SEEK, FS_Purge(), ztoolkit_t::in_ind, ztoolkit_t::in_len, ztoolkit_t::in_position, ztoolkit_t::input, int(), z_stream::next_in, z_stream::next_out, QFILE_FLAG_DATA, QFILE_FLAG_DEFLATED, Z_OK, Z_STREAM_END, Z_SYNC_FLUSH, and ztoolkit_t::zstream.

Referenced by CL_ReadDemoMessage(), Crypto_LoadFile(), Curl_Begin(), FS_Getc(), FS_LoadAndCloseQFile(), FS_OpenReadFile(), FS_Seek(), FS_SysCheckGameDir(), GetMapList(), hz_bitstream_read_blocks_read(), jam_open(), jam_video(), LibAvW_FS_Read(), M_ScanSaves(), SV_ReadClientMessage(), SV_SendClientDatagram(), W_GetTextureBGRA(), and W_LoadTextureWadFile().

FS_RemoveOnClose()

void FS_RemoveOnClose

(

qfile_t *

file

)

Definition at line 3007 of file fs.c.

{
    file->flags |= QFILE_FLAG_REMOVE;
}

References QFILE_FLAG_REMOVE.

Referenced by CL_Stop_f(), and SV_StopDemoRecording().

FS_Rescan()

void FS_Rescan

(

void

)

Definition at line 1538 of file fs.c.

{
    int i;
    char gamedirbuf[MAX_INPUTLINE];
    char vabuf[1024];
 
    FS_ListGameDirs();
 
    FS_ClearSearchPath();
 
    // update the com_modname (used for server info)
    if (gamedirname2 && gamedirname2[0])
        dp_strlcpy(com_modname, gamedirname2, sizeof(com_modname));
    else
        dp_strlcpy(com_modname, gamedirname1, sizeof(com_modname));
 
    // -game <gamedir>
    // Adds basedir/gamedir as an override game
    // LadyHavoc: now supports multiple -game directories
    // set the com_modname (reported in server info)
    *gamedirbuf = 0;
    for (i = 0;i < fs_numgamedirs;i++)
    {
        FS_AddGameHierarchy (fs_gamedirs[i]);
        // update the com_modname (used server info)
        dp_strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
        if(i)
            dp_strlcat(gamedirbuf, va(vabuf, sizeof(vabuf), " %s", fs_gamedirs[i]), sizeof(gamedirbuf));
        else
            dp_strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
    }
    Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
 
    // add back the selfpack as new first item
    FS_AddSelfPack();
 
    if (cls.state != ca_dedicated)
    {
        // set the default screenshot name to either the mod name or the
        // gamemode screenshot name
        if (strcmp(com_modname, gamedirname1))
            Cvar_SetQuick (&scr_screenshot_name, com_modname);
        else
            Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
    }
 
    if((i = Sys_CheckParm("-modname")) && i < sys.argc - 1)
        dp_strlcpy(com_modname, sys.argv[i+1], sizeof(com_modname));
 
    // If "-condebug" is in the command line, remove the previous log file
    if (Sys_CheckParm ("-condebug") != 0)
        unlink (va(vabuf, sizeof(vabuf), "%s/qconsole.log", fs_gamedir));
 
    // look for the pop.lmp file and set registered to true if it is found
    if (FS_FileExists("gfx/pop.lmp"))
        Cvar_SetValueQuick(&registered, 1);
    switch(gamemode)
    {
    case GAME_NORMAL:
    case GAME_HIPNOTIC:
    case GAME_ROGUE:
        if (!registered.integer)
        {
            if (fs_numgamedirs > 1)
                Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
            else
                Con_Print("Playing shareware version.\n");
        }
        else
            Con_Print("Playing registered version.\n");
        break;
    case GAME_STEELSTORM:
        if (registered.integer)
            Con_Print("Playing registered version.\n");
        else
            Con_Print("Playing shareware version.\n");
        break;
    default:
        break;
    }
 
    // unload all wads so that future queries will return the new data
    W_UnloadAll();
}

References sys_t::argc, sys_t::argv, ca_dedicated, cls, com_modname, Con_Print(), cvar_fs_gamedir, Cvar_SetQuick(), Cvar_SetValueQuick(), dp_strlcat, dp_strlcpy, FS_AddGameHierarchy(), FS_AddSelfPack(), FS_ClearSearchPath(), FS_FileExists(), fs_gamedir, fs_gamedirs, FS_ListGameDirs(), fs_numgamedirs, GAME_HIPNOTIC, GAME_NORMAL, GAME_ROGUE, GAME_STEELSTORM, gamedirname1, gamedirname2, gamemode, gamescreenshotname, i, cvar_t::integer, MAX_INPUTLINE, registered, scr_screenshot_name, client_static_t::state, sys, Sys_CheckParm(), va(), and W_UnloadAll().

Referenced by CL_StopDownload(), FS_ChangeGameDirs(), FS_Init_Dir(), and FS_Rescan_f().

FS_Rescan_f()

static void FS_Rescan_f ( cmd_state_t * cmd )

static

Definition at line 1623 of file fs.c.

{
    FS_Rescan();
}

References FS_Rescan().

Referenced by FS_Init_Commands().

FS_SanitizePath()

void FS_SanitizePath

(

char *

path

)

Definition at line 2673 of file fs.c.

{
    for (; *path; path++)
        if (*path == '\\')
            *path = '/';
}

Referenced by loadimagepixelsbgra().

FS_Search()

fssearch_t * FS_Search	(	const char *	pattern,
		int	caseinsensitive,
		int	quiet,
		const char *	packfile )

Definition at line 3756 of file fs.c.

{
    fssearch_t *search;
    searchpath_t *searchpath;
    pack_t *pak;
    int i, basepathlength, numfiles, numchars, resultlistindex, dirlistindex;
    stringlist_t resultlist;
    stringlist_t dirlist;
    stringlist_t matchedSet, foundSet;
    const char *start, *slash, *backslash, *colon, *separator;
    char *basepath;
 
    for (i = 0;pattern[i] == '.' || pattern[i] == ':' || pattern[i] == '/' || pattern[i] == '\\';i++)
        ;
 
    if (i > 0)
    {
        Con_Printf("Don't use punctuation at the beginning of a search pattern!\n");
        return NULL;
    }
 
    stringlistinit(&resultlist);
    stringlistinit(&dirlist);
    search = NULL;
    slash = strrchr(pattern, '/');
    backslash = strrchr(pattern, '\\');
    colon = strrchr(pattern, ':');
    separator = max(slash, backslash);
    separator = max(separator, colon);
    basepathlength = separator ? (separator + 1 - pattern) : 0;
    basepath = (char *)Mem_Alloc (tempmempool, basepathlength + 1);
    if (basepathlength)
        memcpy(basepath, pattern, basepathlength);
    basepath[basepathlength] = 0;
 
    // search through the path, one element at a time
    for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
    {
        // is the element a pak file?
        if (searchpath->pack && !searchpath->pack->vpack)
        {
            // look through all the pak file elements
            pak = searchpath->pack;
            if(packfile)
            {
                if(strcmp(packfile, pak->shortname))
                    continue;
            }
            for (i = 0;i < pak->numfiles;i++)
            {
                char temp[MAX_OSPATH];
                dp_strlcpy(temp, pak->files[i].name, sizeof(temp));
                while (temp[0])
                {
                    if (matchpattern(temp, (char *)pattern, true))
                    {
                        for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
                            if (!strcmp(resultlist.strings[resultlistindex], temp))
                                break;
                        if (resultlistindex == resultlist.numstrings)
                        {
                            stringlistappend(&resultlist, temp);
                            if (!quiet && developer_loading.integer)
                                Con_Printf("SearchPackFile: %s : %s\n", pak->filename, temp);
                        }
                    }
                    // strip off one path element at a time until empty
                    // this way directories are added to the listing if they match the pattern
                    slash = strrchr(temp, '/');
                    backslash = strrchr(temp, '\\');
                    colon = strrchr(temp, ':');
                    separator = temp;
                    if (separator < slash)
                        separator = slash;
                    if (separator < backslash)
                        separator = backslash;
                    if (separator < colon)
                        separator = colon;
                    *((char *)separator) = 0;
                }
            }
        }
        else
        {
            if(packfile)
                continue;
 
            start = pattern;
 
            stringlistinit(&matchedSet);
            stringlistinit(&foundSet);
            // add a first entry to the set
            stringlistappend(&matchedSet, "");
            // iterate through pattern's path
            while (*start)
            {
                const char *asterisk, *wildcard, *nextseparator, *prevseparator;
                char subpath[MAX_OSPATH];
                char subpattern[MAX_OSPATH];
 
                // find the next wildcard
                wildcard = strchr(start, '?');
                asterisk = strchr(start, '*');
                if (asterisk && (!wildcard || asterisk < wildcard))
                {
                    wildcard = asterisk;
                }
 
                if (wildcard)
                {
                    nextseparator = strchr( wildcard, '/' );
                }
                else
                {
                    nextseparator = NULL;
                }
 
                if( !nextseparator ) {
                    nextseparator = start + strlen( start );
                }
 
                // prevseparator points past the '/' right before the wildcard and nextseparator at the one following it (or at the end of the string)
                // copy everything up except nextseperator
                dp_ustr2stp(subpattern, sizeof(subpattern), pattern, nextseparator - pattern);
                // find the last '/' before the wildcard
                prevseparator = strrchr( subpattern, '/' );
                if (!prevseparator)
                    prevseparator = subpattern;
                else
                    prevseparator++;
                // copy everything from start to the previous including the '/' (before the wildcard)
                // everything up to start is already included in the path of matchedSet's entries
                dp_ustr2stp(subpath, sizeof(subpath), start, (prevseparator - subpattern) - (start - pattern));
 
                // for each entry in matchedSet try to open the subdirectories specified in subpath
                for( dirlistindex = 0 ; dirlistindex < matchedSet.numstrings ; dirlistindex++ ) {
                    char temp[MAX_OSPATH];
                    dp_strlcpy( temp, matchedSet.strings[ dirlistindex ], sizeof(temp) );
                    dp_strlcat( temp, subpath, sizeof(temp) );
                    listdirectory( &foundSet, searchpath->filename, temp );
                }
                if( dirlistindex == 0 ) {
                    break;
                }
                // reset the current result set
                stringlistfreecontents( &matchedSet );
                // match against the pattern
                for( dirlistindex = 0 ; dirlistindex < foundSet.numstrings ; dirlistindex++ ) {
                    const char *direntry = foundSet.strings[ dirlistindex ];
                    if (matchpattern(direntry, subpattern, true)) {
                        stringlistappend( &matchedSet, direntry );
                    }
                }
                stringlistfreecontents( &foundSet );
 
                start = nextseparator;
            }
 
            for (dirlistindex = 0;dirlistindex < matchedSet.numstrings;dirlistindex++)
            {
                const char *matchtemp = matchedSet.strings[dirlistindex];
                if (matchpattern(matchtemp, (char *)pattern, true))
                {
                    for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
                        if (!strcmp(resultlist.strings[resultlistindex], matchtemp))
                            break;
                    if (resultlistindex == resultlist.numstrings)
                    {
                        stringlistappend(&resultlist, matchtemp);
                        if (!quiet && developer_loading.integer)
                            Con_Printf("SearchDirFile: %s\n", matchtemp);
                    }
                }
            }
            stringlistfreecontents( &matchedSet );
        }
    }
 
    if (resultlist.numstrings)
    {
        stringlistsort(&resultlist, true);
        numfiles = resultlist.numstrings;
        numchars = 0;
        for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
            numchars += (int)strlen(resultlist.strings[resultlistindex]) + 1;
        search = (fssearch_t *)Z_Malloc(sizeof(fssearch_t) + numchars + numfiles * sizeof(char *));
        search->filenames = (char **)((char *)search + sizeof(fssearch_t));
        search->filenamesbuffer = (char *)((char *)search + sizeof(fssearch_t) + numfiles * sizeof(char *));
        search->numfilenames = (int)numfiles;
        numfiles = 0;
        numchars = 0;
        for (resultlistindex = 0;resultlistindex < resultlist.numstrings;resultlistindex++)
        {
            size_t textlen;
            search->filenames[numfiles] = search->filenamesbuffer + numchars;
            textlen = strlen(resultlist.strings[resultlistindex]) + 1;
            memcpy(search->filenames[numfiles], resultlist.strings[resultlistindex], textlen);
            numfiles++;
            numchars += (int)textlen;
        }
    }
    stringlistfreecontents(&resultlist);
 
    Mem_Free(basepath);
    return search;
}

References Con_Printf(), developer_loading, dp_strlcat, dp_strlcpy, dp_ustr2stp(), pack_t::filename, searchpath_t::filename, fssearch_t::filenames, fssearch_t::filenamesbuffer, pack_t::files, fs_searchpaths, i, int(), cvar_t::integer, listdirectory(), matchpattern(), max, MAX_OSPATH, Mem_Alloc, Mem_Free, packfile_t::name, searchpath_t::next, NULL, fssearch_t::numfilenames, pack_t::numfiles, stringlist_t::numstrings, searchpath_t::pack, pack_t::shortname, stringlistappend(), stringlistfreecontents(), stringlistinit(), stringlistsort(), stringlist_t::strings, strlen(), tempmempool, pack_t::vpack, and Z_Malloc.

Referenced by Cmd_Exec_f(), Con_CompleteCommandLine(), FS_ListDirectory(), GetMapList(), Image_FixTransparentPixels_f(), Mod_LoadQ3Shaders(), and VM_search_begin().

FS_Seek()

int FS_Seek	(	qfile_t *	file,
		fs_offset_t	offset,
		int	whence )

Definition at line 3359 of file fs.c.

{
    ztoolkit_t *ztk;
    unsigned char* buffer;
    fs_offset_t buffersize;
 
    // Compute the file offset
    switch (whence)
    {
        case SEEK_CUR:
            offset += file->position - file->buff_len + file->buff_ind;
            break;
 
        case SEEK_SET:
            break;
 
        case SEEK_END:
            offset += file->real_length;
            break;
 
        default:
            return -1;
    }
    if (offset < 0 || offset > file->real_length)
        return -1;
 
    if(file->flags & QFILE_FLAG_DATA)
    {
        file->position = offset;
        return 0;
    }
 
    // If we have the data in our read buffer, we don't need to actually seek
    if (file->position - file->buff_len <= offset && offset <= file->position)
    {
        file->buff_ind = offset + file->buff_len - file->position;
        return 0;
    }
 
    // Purge cached data
    FS_Purge (file);
 
    // Unpacked or uncompressed files can seek directly
    if (! (file->flags & QFILE_FLAG_DEFLATED))
    {
        if (FILEDESC_SEEK (file->handle, file->offset + offset, SEEK_SET) == -1)
            return -1;
        file->position = offset;
        return 0;
    }
 
    // 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 (offset <= file->position)
    {
        ztk->in_ind = 0;
        ztk->in_len = 0;
        ztk->in_position = 0;
        file->position = 0;
        if (FILEDESC_SEEK (file->handle, file->offset, SEEK_SET) == -1)
            Con_Printf("IMPOSSIBLE: couldn't seek in already opened pk3 file.\n");
 
        // Reset the Zlib stream
        ztk->zstream.next_in = ztk->input;
        ztk->zstream.avail_in = 0;
        qz_inflateReset (&ztk->zstream);
    }
 
    // We need a big buffer to force inflating into it directly
    buffersize = 2 * sizeof (file->buff);
    buffer = (unsigned char *)Mem_Alloc (tempmempool, buffersize);
 
    // Skip all data until we reach the requested offset
    while (offset > (file->position - file->buff_len + file->buff_ind))
    {
        fs_offset_t diff = offset - (file->position - file->buff_len + file->buff_ind);
        fs_offset_t count, len;
 
        count = (diff > buffersize) ? buffersize : diff;
        len = FS_Read (file, buffer, count);
        if (len != count)
        {
            Mem_Free (buffer);
            return -1;
        }
    }
 
    Mem_Free (buffer);
    return 0;
}

References z_stream::avail_in, buffer, Con_Printf(), count, FILEDESC_SEEK, FS_Purge(), FS_Read(), ztoolkit_t::in_ind, ztoolkit_t::in_len, ztoolkit_t::in_position, ztoolkit_t::input, Mem_Alloc, Mem_Free, z_stream::next_in, offset, position, QFILE_FLAG_DATA, QFILE_FLAG_DEFLATED, tempmempool, and ztoolkit_t::zstream.

Referenced by CheckPendingDownloads(), CL_ReadDemoMessage(), GetMapList(), LibAvW_FS_Seek(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Avi_EndVideo(), SCR_CaptureVideo_RIFF_Finish(), SCR_CaptureVideo_RIFF_MakeIxChunk(), SCR_CaptureVideo_RIFF_Pop(), SV_ReadClientMessage(), W_GetTextureBGRA(), and W_LoadTextureWadFile().

FS_SetGameDirs()

addgamedirs_t FS_SetGameDirs	(	int	numgamedirs,
		const char *	gamedirs[],
		qbool	failmissing,
		qbool	abortonfail )

Definition at line 1633 of file fs.c.

{
    int i, j, k;
    const char *p;
    const char *gamedirs_ok[MAX_GAMEDIRS + 2];
    int numgamedirs_ok;
 
    // prepend the game-specific gamedirs (the primary and search order can be overriden)
    gamedirs_ok[0] = gamedirname1;
    numgamedirs_ok = 1;
    if (gamedirname2 && gamedirname2[0])
    {
        gamedirs_ok[1] = gamedirname2;
        ++numgamedirs_ok;
    }
 
    // check the game-specific gamedirs
    for (i = 0; i < numgamedirs_ok; ++i)
    {
        p = FS_CheckGameDir(gamedirs_ok[i]);
        if(!p)
            Sys_Error("BUG: nasty gamedir name \"%s\" in gamemode_info", gamedirs_ok[i]);
        if(p == fs_checkgamedir_missing && failmissing)
        {
            Con_Printf(abortonfail ? CON_ERROR : CON_WARN "Base gamedir \"%s\" empty or not found!\n", gamedirs_ok[i]);
            if (abortonfail)
                return GAMEDIRS_FAILURE; // missing gamedirs
        }
    }
 
    // copy and check the user-specified gamedirs
    for (i = 0; i < numgamedirs && (size_t)numgamedirs_ok < sizeof(gamedirs_ok) / sizeof(gamedirs_ok[0]); ++i)
    {
        // remove any previously-added duplicate (last one wins)
        for (j = 0; j < numgamedirs_ok; ++j)
            if (!strcasecmp(gamedirs_ok[j], gamedirs[i]))
            {
                --numgamedirs_ok;
                for (k = j; k < numgamedirs_ok; ++k)
                    gamedirs_ok[k] = gamedirs_ok[k + 1];
            }
 
        // if string is nasty, reject it
        p = FS_CheckGameDir(gamedirs[i]);
        if(!p)
        {
            Con_Printf(abortonfail ? CON_ERROR : CON_WARN "Nasty gamedir name \"%s\" rejected\n", gamedirs[i]);
            if (abortonfail)
                return GAMEDIRS_FAILURE; // nasty gamedirs
            else
                continue;
        }
        if(p == fs_checkgamedir_missing && failmissing)
        {
            Con_Printf(abortonfail ? CON_ERROR : CON_WARN "Gamedir \"%s\" empty or not found!\n", gamedirs[i]);
            if (abortonfail)
                return GAMEDIRS_FAILURE; // missing gamedirs
            else
                continue;
        }
 
        gamedirs_ok[numgamedirs_ok++] = gamedirs[i];
    }
 
    if (fs_numgamedirs == numgamedirs_ok)
    {
        for (i = 0;i < numgamedirs_ok;i++)
            if (strcasecmp(fs_gamedirs[i], gamedirs_ok[i]))
                break;
        if (i == numgamedirs_ok)
            return GAMEDIRS_ALLGOOD; // already using this set of gamedirs, do nothing
    }
 
    if (numgamedirs_ok > MAX_GAMEDIRS)
    {
        Con_Printf(abortonfail ? CON_ERROR : CON_WARN "That is too many gamedirs (%i > %i)\n", numgamedirs_ok, MAX_GAMEDIRS);
        if (abortonfail)
            return GAMEDIRS_FAILURE; // too many gamedirs
    }
 
    for (i = 0, fs_numgamedirs = 0; i < numgamedirs_ok && fs_numgamedirs < MAX_GAMEDIRS; ++i)
        dp_strlcpy(fs_gamedirs[fs_numgamedirs++], gamedirs_ok[i], sizeof(fs_gamedirs[0]));
 
    return GAMEDIRS_SUCCESS;
}

References CON_ERROR, Con_Printf(), CON_WARN, dp_strlcpy, FS_CheckGameDir(), fs_checkgamedir_missing, fs_gamedirs, fs_numgamedirs, gamedirname1, gamedirname2, GAMEDIRS_ALLGOOD, GAMEDIRS_FAILURE, GAMEDIRS_SUCCESS, i, MAX_GAMEDIRS, and Sys_Error().

Referenced by COM_ChangeGameTypeForGameDirs().

FS_Shutdown()

void FS_Shutdown

(

void

)

Definition at line 2364 of file fs.c.

{
    // close all pack files and such
    // (hopefully there aren't any other open files, but they'll be cleaned up
    //  by the OS anyway)
    FS_ClearSearchPath();
    Mem_FreePool (&fs_mempool);
    PK3_CloseLibrary ();
 
#ifdef WIN32
    Sys_FreeLibrary (&shfolder_dll);
    Sys_FreeLibrary (&shell32_dll);
    Sys_FreeLibrary (&ole32_dll);
#endif
 
    if (fs_mutex)
        Thread_DestroyMutex(fs_mutex);
}

References FS_ClearSearchPath(), fs_mempool, fs_mutex, Mem_FreePool, PK3_CloseLibrary(), Sys_FreeLibrary(), and Thread_DestroyMutex.

FS_StripExtension()

void FS_StripExtension	(	const char *	in,
		char *	out,
		size_t	size_out )

Definition at line 3611 of file fs.c.

{
    char *last = NULL;
    char currentchar;
 
    if (size_out == 0)
        return;
 
    while ((currentchar = *in) && size_out > 1)
    {
        if (currentchar == '.')
            last = out;
        else if (currentchar == '/' || currentchar == '\\' || currentchar == ':')
            last = NULL;
        *out++ = currentchar;
        in++;
        size_out--;
    }
    if (last)
        *last = 0;
    else
        *out = 0;
}

References NULL.

Referenced by CL_ParseServerInfo(), CL_SetupWorldModel(), COM_InitGameType(), dpvsimpledecode_open(), Image_StripImageExtension(), jam_open(), LibAvW_OpenVideo(), Mod_Decompile_f(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadTextures(), Mod_Q3BSP_LoadLightmaps(), PRVM_LoadLNO(), R_LoadTextureDDSFile(), and SV_SpawnServer().

FS_SysCheckGameDir()

static const char * FS_SysCheckGameDir ( const char * gamedir, char * buf, size_t buflength )

static

Definition at line 1786 of file fs.c.

{
    qbool success;
    qfile_t *f;
    stringlist_t list;
    fs_offset_t n;
    char vabuf[1024];
 
    stringlistinit(&list);
    listdirectory(&list, gamedir, "");
    success = list.numstrings > 0;
    stringlistfreecontents(&list);
 
    if(success)
    {
        f = FS_SysOpen(va(vabuf, sizeof(vabuf), "%smodinfo.txt", gamedir), "r", false);
        if(f)
        {
            n = FS_Read (f, buf, buflength - 1);
            if(n >= 0)
                buf[n] = 0;
            else
                *buf = 0;
            FS_Close(f);
        }
        else
            *buf = 0;
        return buf;
    }
 
    return NULL;
}

References buf, f, FS_Close(), FS_Read(), FS_SysOpen(), listdirectory(), n, NULL, stringlist_t::numstrings, stringlistfreecontents(), stringlistinit(), and va().

Referenced by FS_CheckGameDir().

FS_SysFileExists()

qbool FS_SysFileExists

(

const char *

path

)

Look for a file in the filesystem only.

Definition at line 3744 of file fs.c.

{
    return FS_SysFileType (path) != FS_FILETYPE_NONE;
}

References FS_FILETYPE_NONE, and FS_SysFileType().

Referenced by FS_FindFile(), SCR_ScreenShot_f(), and Sys_FindInPATH().

FS_SysFileType()

int FS_SysFileType

(

const char *

path

)

Look for a file in the filesystem only.

Definition at line 3708 of file fs.c.

{
#ifdef WIN32
    // Sajt - some older sdks are missing this define
# ifndef INVALID_FILE_ATTRIBUTES
#  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
# endif
    WPATHDEF(pathw);
    DWORD result;
 
    WIDE(path, pathw);
    result = GetFileAttributesW(pathw);
 
    if(result == INVALID_FILE_ATTRIBUTES)
        return FS_FILETYPE_NONE;
 
    if(result & FILE_ATTRIBUTE_DIRECTORY)
        return FS_FILETYPE_DIRECTORY;
 
    return FS_FILETYPE_FILE;
#else
    struct stat buf;
 
    if (stat (path,&buf) == -1)
        return FS_FILETYPE_NONE;
 
#ifndef S_ISDIR
#define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
#endif
    if(S_ISDIR(buf.st_mode))
        return FS_FILETYPE_DIRECTORY;
 
    return FS_FILETYPE_FILE;
#endif
}

References buf, FS_FILETYPE_DIRECTORY, FS_FILETYPE_FILE, FS_FILETYPE_NONE, S_ISDIR, WIDE, and WPATHDEF.

Referenced by FS_FileType(), and FS_SysFileExists().

FS_SysLoadFile()

unsigned char * FS_SysLoadFile	(	const char *	path,
		mempool_t *	pool,
		qbool	quiet,
		fs_offset_t *	filesizepointer )

Definition at line 3555 of file fs.c.

{
    qfile_t *file = FS_SysOpen(path, "rb", false);
    return FS_LoadAndCloseQFile(file, path, pool, quiet, filesizepointer);
}

References FS_LoadAndCloseQFile(), and FS_SysOpen().

Referenced by FS_Init_SelfPack(), and listdirectory().

FS_SysOpen()

qfile_t * FS_SysOpen	(	const char *	filepath,
		const char *	mode,
		qbool	nonblocking )

Definition at line 2484 of file fs.c.

{
    qfile_t* file;
 
    file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
    file->ungetc = EOF;
    file->handle = FS_SysOpenFiledesc(filepath, mode, nonblocking);
    if (!FILEDESC_ISVALID(file->handle))
    {
        Mem_Free (file);
        return NULL;
    }
 
    file->filename = Mem_strdup(fs_mempool, filepath);
 
    file->real_length = FILEDESC_SEEK (file->handle, 0, SEEK_END);
 
    // For files opened in append mode, we start at the end of the file
    if (mode[0] == 'a')
        file->position = file->real_length;
    else
        FILEDESC_SEEK (file->handle, 0, SEEK_SET);
 
    return file;
}

References FILEDESC_ISVALID, FILEDESC_SEEK, fs_mempool, FS_SysOpenFiledesc(), Mem_Alloc, Mem_Free, Mem_strdup, mode, and NULL.

Referenced by Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_LoadFile(), Crypto_SavePubKeyTextFile(), FS_OpenReadFile(), FS_OpenRealFile(), FS_SysCheckGameDir(), FS_SysLoadFile(), and Host_LockSession().

FS_SysOpenFD()

int FS_SysOpenFD	(	const char *	filepath,
		const char *	mode,
		qbool	nonblocking )

Definition at line 2468 of file fs.c.

{
#ifdef USE_RWOPS
    return -1;
#else
    return FS_SysOpenFiledesc(filepath, mode, nonblocking);
#endif
}

References FS_SysOpenFiledesc(), and mode.

Referenced by Sys_ProvideSelfFD().

FS_SysOpenFiledesc()

static filedesc_t FS_SysOpenFiledesc ( const char * filepath, const char * mode, qbool nonblocking )

static

Definition at line 2383 of file fs.c.

{
    filedesc_t handle = FILEDESC_INVALID;
    int mod, opt;
    unsigned int ind;
    qbool dolock = false;
    WPATHDEF(filepathw);
 
    // 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(CON_ERROR "FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
            return FILEDESC_INVALID;
    }
    for (ind = 1; mode[ind] != '\0'; ind++)
    {
        switch (mode[ind])
        {
            case '+':
                mod = O_RDWR;
                break;
            case 'b':
                opt |= O_BINARY;
                break;
            case 'l':
                dolock = true;
                break;
            default:
                Con_Printf(CON_ERROR "FS_SysOpen(%s, %s): unknown character in mode (%c)\n",
                            filepath, mode, mode[ind]);
        }
    }
 
    if (nonblocking)
        opt |= O_NONBLOCK;
 
    if(Sys_CheckParm("-readonly") && mod != O_RDONLY)
        return FILEDESC_INVALID;
 
#if USE_RWOPS
    if (dolock)
        return FILEDESC_INVALID;
    handle = SDL_RWFromFile(filepath, mode);
#else
# ifdef WIN32
    WIDE(filepath, filepathw);
#  if _MSC_VER >= 1400
    _wsopen_s(&handle, filepathw, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
#  else
    handle = _wsopen(filepathw, mod | opt, (dolock ? ((mod == O_RDONLY) ? _SH_DENYRD : _SH_DENYRW) : _SH_DENYNO), _S_IREAD | _S_IWRITE);
#  endif
# else
    handle = open(filepath, mod | opt, 0666);
    if(handle >= 0 && dolock)
    {
        struct flock l;
        l.l_type = ((mod == O_RDONLY) ? F_RDLCK : F_WRLCK);
        l.l_whence = SEEK_SET;
        l.l_start = 0;
        l.l_len = 0;
        if(fcntl(handle, F_SETLK, &l) == -1)
        {
            FILEDESC_CLOSE(handle);
            handle = -1;
        }
    }
# endif
#endif
 
    return handle;
}

References CON_ERROR, Con_Printf(), FILEDESC_CLOSE, FILEDESC_INVALID, mod(), mode, O_BINARY, O_NONBLOCK, Sys_CheckParm(), WIDE, and WPATHDEF.

Referenced by FS_ChooseUserDir(), FS_LoadPackPAK(), FS_LoadPackPK3(), FS_SysOpen(), and FS_SysOpenFD().

FS_Tell()

fs_offset_t FS_Tell

(

qfile_t *

file

)

Definition at line 3461 of file fs.c.

{
    return file->position - file->buff_len + file->buff_ind;
}

Referenced by CheckPendingDownloads(), SCR_CaptureVideo_RIFF_IndexEntry(), and SV_SendClientDatagram().

FS_UnGetc()

int FS_UnGetc	(	qfile_t *	file,
		unsigned char	c )

Definition at line 3341 of file fs.c.

{
    // If there's already a character waiting to be read
    if (file->ungetc != EOF)
        return EOF;
 
    file->ungetc = c;
    return c;
}

Referenced by VM_buf_loadfile(), and VM_fgets().

FS_UnloadPacks_dlcache()

void FS_UnloadPacks_dlcache

(

void

)

Definition at line 1485 of file fs.c.

{
    searchpath_t *search = fs_searchpaths, *searchprev = fs_searchpaths, *searchnext;
 
    if (!fs_unload_dlcache.integer)
        return;
 
    while (search)
    {
        searchnext = search->next;
        if (search->pack && search->pack->dlcache)
        {
            Con_DPrintf("Unloading pack: %s\n", search->pack->shortname);
 
            // remove it from the search path list
            if (search == fs_searchpaths)
                fs_searchpaths = search->next;
            else
                searchprev->next = search->next;
 
            // close the file
            FILEDESC_CLOSE(search->pack->handle);
            // free any memory associated with it
            if (search->pack->files)
                Mem_Free(search->pack->files);
            Mem_Free(search->pack);
            Mem_Free(search);
        }
        else
            searchprev = search;
        search = searchnext;
    }
}

References Con_DPrintf(), pack_t::dlcache, FILEDESC_CLOSE, pack_t::files, fs_searchpaths, fs_unload_dlcache, pack_t::handle, cvar_t::integer, Mem_Free, searchpath_t::next, searchpath_t::pack, and pack_t::shortname.

Referenced by CL_DisconnectEx(), and CL_ParseServerInfo().

FS_VPrintf()

int FS_VPrintf	(	qfile_t *	file,
		const char *	format,
		va_list	ap )

Definition at line 3293 of file fs.c.

{
    int len;
    fs_offset_t buff_size = MAX_INPUTLINE;
    char *tempbuff;
 
    for (;;)
    {
        tempbuff = (char *)Mem_Alloc (tempmempool, buff_size);
        len = dpvsnprintf (tempbuff, buff_size, format, ap);
        if (len >= 0 && len < buff_size)
            break;
        Mem_Free (tempbuff);
        buff_size *= 2;
    }
 
    len = FILEDESC_WRITE (file->handle, tempbuff, len);
    Mem_Free (tempbuff);
 
    return len;
}

References dpvsnprintf(), FILEDESC_WRITE, format, MAX_INPUTLINE, Mem_Alloc, Mem_Free, and tempmempool.

Referenced by FS_Printf(), and Log_Printf().

FS_Which_f()

void FS_Which_f

(

cmd_state_t *

cmd

)

Definition at line 4063 of file fs.c.

{
    const char *filename;
    int index;
    searchpath_t *sp;
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Printf("usage:\n%s <file>\n", Cmd_Argv(cmd, 0));
        return;
    }
    filename = Cmd_Argv(cmd, 1);
    sp = FS_FindFile(filename, &index, NULL, true);
    if (!sp) {
        Con_Printf("%s isn't anywhere\n", filename);
        return;
    }
    if (sp->pack)
    {
        if(sp->pack->vpack)
            Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
        else
            Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
    }
    else
        Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), searchpath_t::filename, FS_FindFile(), index, NULL, searchpath_t::pack, pack_t::shortname, and pack_t::vpack.

Referenced by FS_Init_Commands().

FS_WhichPack()

const char * FS_WhichPack

(

const char *

filename

)

Definition at line 4091 of file fs.c.

{
    int index;
    searchpath_t *sp = FS_FindFile(filename, &index, NULL, true);
    if(sp && sp->pack)
        return sp->pack->shortname;
    else if(sp)
        return "";
    else
        return 0;
}

References FS_FindFile(), index, NULL, searchpath_t::pack, and pack_t::shortname.

Referenced by Curl_SendRequirement(), SV_Download_f(), and VM_whichpack().

FS_Write()

fs_offset_t FS_Write	(	qfile_t *	file,
		const void *	data,
		size_t	datasize )

Definition at line 3019 of file fs.c.

{
    fs_offset_t written = 0;
 
    // If necessary, seek to the exact file position we're supposed to be
    if (file->buff_ind != file->buff_len)
    {
        if (FILEDESC_SEEK (file->handle, file->buff_ind - file->buff_len, SEEK_CUR) == -1)
        {
            Con_Printf(CON_WARN "WARNING: could not seek in %s.\n", file->filename);
        }
    }
 
    // Purge cached data
    FS_Purge (file);
 
    // Write the buffer and update the position
    // LadyHavoc: to hush a warning about passing size_t to an unsigned int parameter on Win64 we do this as multiple writes if the size would be too big for an integer (we never write that big in one go, but it's a theory)
    while (written < (fs_offset_t)datasize)
    {
        // figure out how much to write in one chunk
        fs_offset_t maxchunk = 1<<30; // 1 GiB
        int chunk = (int)min((fs_offset_t)datasize - written, maxchunk);
        int result = (int)FILEDESC_WRITE (file->handle, (const unsigned char *)data + written, chunk);
        // if at least some was written, add it to our accumulator
        if (result > 0)
            written += result;
        // if the result is not what we expected, consider the write to be incomplete
        if (result != chunk)
            break;
    }
    file->position = FILEDESC_SEEK (file->handle, 0, SEEK_CUR);
    if (file->real_length < file->position)
        file->real_length = file->position;
 
    // note that this will never be less than 0 even if the write failed
    return written;
}

References Con_Printf(), CON_WARN, data, FILEDESC_SEEK, FILEDESC_WRITE, FS_Purge(), int(), and min.

Referenced by CL_PasteDemo(), CL_WriteDemoMessage(), Con_ConDump_f(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), CURL_fwrite(), FS_Print(), FS_WriteFileInBlocks(), JPEG_EmptyOutputBuffer(), JPEG_TermDestination(), Log_Start(), PNG_fWriteData(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_Ogg_EndVideo(), SCR_CaptureVideo_Ogg_FlushInterleaving(), SCR_CaptureVideo_Ogg_Interleave(), SCR_CaptureVideo_RIFF_Flush(), SCR_CaptureVideo_RIFF_FlushNoIncrease(), SCR_CaptureVideo_RIFF_Pop(), SCR_CaptureVideo_RIFF_WriteBytes(), SV_WriteDemoMessage(), VM_buf_writefile(), and VM_fputs().

FS_WriteFile()

qbool FS_WriteFile	(	const char *	filename,
		const void *	data,
		fs_offset_t	len )

Definition at line 3592 of file fs.c.

{
    return FS_WriteFileInBlocks(filename, &data, &len, 1);
}

References data, and FS_WriteFileInBlocks().

Referenced by CL_StopDownload(), Image_WriteTGABGRA(), Mod_Decompile_f(), Mod_Decompile_OBJ(), Mod_Decompile_SMD(), QW_CL_ParseDownload(), R_SaveTextureDDSFile(), R_Shadow_SaveWorldLights(), and SV_SaveEntFile_f().

FS_WriteFileInBlocks()

qbool FS_WriteFileInBlocks	(	const char *	filename,
		const void *const *	data,
		const fs_offset_t *	len,
		size_t	count )

Definition at line 3569 of file fs.c.

{
    qfile_t *file;
    size_t i;
    fs_offset_t lentotal;
 
    file = FS_OpenRealFile(filename, "wb", false);
    if (!file)
    {
        Con_Printf("FS_WriteFile: failed on %s\n", filename);
        return false;
    }
 
    lentotal = 0;
    for(i = 0; i < count; ++i)
        lentotal += len[i];
    Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
    for(i = 0; i < count; ++i)
        FS_Write (file, data[i], len[i]);
    FS_Close (file);
    return true;
}

References Con_DPrintf(), Con_Printf(), count, data, FS_Close(), FS_OpenRealFile(), FS_Write(), and i.

Referenced by FS_WriteFile(), and Image_WriteTGABGR_preflipped().

int()

static int ( ZEXPORT * qz_inflate )

static

Referenced by animatemodel(), Buffer_Callback(), BufStr_Flush(), BuildGammaTable16(), BuildGammaTable8(), CDAudio_Play_byName(), CDAudio_StartPlaylist(), CL_Beam_AddPolygons(), CL_Beams_SetupBuiltinTexture(), CL_DrawVideo_DisplaySubtitleLine(), CL_Frame(), CL_GenericHitSuperContentsMask(), CL_GetTagMatrix(), CL_Locs_AddNode(), CL_Locs_Reload_f(), CL_Locs_Save_f(), CL_movestep(), CL_NewParticle(), CL_NewParticlesFromEffectinfo(), CL_Packet_f(), CL_ParseDownload(), CL_ParseServerMessage(), CL_ParticleCube(), CL_ParticleRain(), CL_Particles_ParseEffectInfo(), CL_PQRcon_f(), CL_Rcon_f(), CL_RelinkEffects(), CL_RelinkLightFlashes(), CL_RelinkWorld(), CL_Screen_Init(), CL_SpawnDecalParticleForSurface(), CL_StopDownload(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), CL_Video_Frame(), Cmd_TokenizeString(), Collision_Cache_Lookup(), COM_InitGameType(), COM_ReadAndTokenizeLine(), Con_CheckResize(), Con_CompleteCommandLine(), Con_DisplayLineFunc(), Con_DisplayList(), Con_DrawConsole(), Con_DrawInput(), Con_DrawNotifyRect(), CSQC_AddRenderEdict(), Cvar_Get(), Cvar_RegisterVariable(), Cvar_SetQuick_Internal(), detect_match_rule(), DrawQ_SetClipArea(), DrawQ_String_Scale(), DrawQ_TextWidth_UntilWidth_TrackColors_Scale(), EntityFrame5_ExpandEdicts(), EntityFrameQuake_ReadEntity(), EntityFrameQuake_WriteFrame(), EntityState5_ReadUpdate(), FindFraction(), Font_Postprocess(), Font_SetSize(), Font_UnloadFont(), Font_VirtualToRealSize(), FS_AddFileToPack(), FS_Deflate(), FS_FindFile(), FS_Inflate(), FS_Init_Dir(), FS_IsRegisteredQuakePack(), FS_ListDirectory(), FS_LoadPackPAK(), FS_Read(), FS_Search(), FS_Write(), getdrawfont(), GetMapList(), gl_backend_devicelost(), GL_Mesh_ListVBOs(), GL_Setup(), GL_TextureMode_f(), Image_HeightmapToNormalmap_BGRA(), Image_Resample32Lerp(), Image_Resample32LerpLine(), InfoString_SetValue(), JPEG_SaveImage_to_Buffer(), Key_AddChar(), Key_History_Down(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Up(), Key_Parse_CommonKeys(), Key_PrintBindList(), Key_StringToKeynum(), Key_Unbindall_f(), Key_WriteBindings(), LHNETADDRESS_FromString(), loadimagepixelsbgra(), M_Draw(), M_GameOptions_Key(), M_LanConfig_Key(), M_Main_Draw(), M_Menu_GameOptions_f(), M_ModList_Draw(), M_MultiPlayer_Draw(), M_Options_ColorControl_Draw(), M_Options_Draw(), M_Options_Effects_Draw(), M_Options_Graphics_Draw(), M_Setup_Key(), M_SinglePlayer_Draw(), M_UnbindCommand(), main(), MakeDownloadPacket(), Mod_BSP_FinalizePortals(), Mod_BSP_LightPoint_RecursiveBSPNode(), Mod_ClearUsed(), Mod_DARKPLACESMODEL_Load(), Mod_FindName(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_IDS2_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_Mesh_IndexForVertex(), mod_newmap(), Mod_OBJ_Load(), Mod_Print_f(), Mod_PSKMODEL_Load(), Mod_PurgeUnused(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LightPoint(), Mod_Q3BSP_LoadLightGrid(), Mod_Q3BSP_LoadLightmaps(), Mod_Reload(), Mod_ShadowMesh_AddVertex(), mod_shutdown(), Mod_Skeletal_AnimateVertices_Generic(), Mod_Sprite_SharedSetup(), mod_start(), Mod_VBSP_LoadFaces(), Mod_ZYMOTICMODEL_Load(), MR_Init(), NetConn_BuildStatusResponse(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerParsePacket(), Nicks_CutMatchesAlphaNumeric(), Nicks_CutMatchesNormal(), Nicks_CutMatchesNoSpaces(), noise4f(), OGG_DecodeTags(), particletextureblotch(), PHYS_UnstickEntityReturnOffset(), PK3_BuildFileList(), PNG_fReadData(), PNG_LoadImage_BGRA(), PRVM_ConsoleCommand(), PRVM_ED_ParseEpair(), PRVM_LeakTest(), PRVM_PrintStatement(), PRVM_Prog_Load(), PRVM_UglyValueString(), R_Bloom_StartFrame(), R_BufferData_Store(), R_BuildFogTexture(), R_BuildLightMap(), R_CompleteLightPoint(), R_DrawParticles(), R_DrawTextureSurfaceList_ShowSurfaces(), R_GetCurrentTexture(), R_GLSL_Restart_f(), R_HDR_UpdateIrisAdaptation(), R_InitParticleTexture(), R_LoadTextureDDSFile(), R_Mesh_Draw(), R_Mesh_UpdateMeshBuffer(), R_RenderTarget_FreeUnused(), R_RenderTarget_Get(), R_RTLight_Compile(), R_ScissorForBBox(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), R_Shadow_BounceGrid_Slice(), R_Shadow_BounceGrid_UpdateSpacing(), R_Shadow_DrawCoronas(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_Shadow_GetRTLightInfo(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_Shadow_MakeTextures_MakeCorona(), R_StainNode(), R_tcMod_ApplyToMatrix(), r_textures_devicelost(), r_textures_devicerestored(), R_TimeReport(), R_TimeReport_EndFrame(), R_Water_StartFrame(), RSurf_FogPoint(), RSurf_FogVertex(), S_ConvertPaintBuffer(), S_MixToBuffer(), S_PaintAndSubmit(), S_PlaySfxOnChannel(), S_SoundList_f(), S_StartSound_StartPosition_Flags(), S_UnloadAllSounds_f(), Sbar_DeathmatchOverlay(), Sbar_Draw(), Sbar_DrawInventory(), Sbar_IntermissionOverlay(), Sbar_MiniDeathmatchOverlay(), Sbar_PrintScoreboardItem(), Sbar_Score(), Sbar_SoloScoreboard(), SCR_CaptureVideo_Avi_SoundFrame(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_RIFF_Pop(), SCR_Centerprint_f(), SCR_DrawCenterString(), SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawQWDownload(), SCR_DrawScreen(), should_use_incmap(), snap_to_pixel_x(), snap_to_pixel_y(), SND_PickChannel(), SV_CleanupEnts(), SV_CreateBaseline(), SV_DisableCheats_c(), SV_Ent_Remove_f(), SV_FixCheckBottom(), SV_FlyMove(), SV_GenericHitSuperContentsMask(), SV_GetModelFromEdict(), SV_GetTagIndex(), SV_GetTagMatrix(), SV_Give_f(), SV_God_f(), SV_Kick_f(), SV_LinkEdict(), SV_Loadgame_f(), SV_movestep(), SV_Notarget_f(), SV_Physics_Step(), SV_Physics_Toss(), SV_Pings_f(), SV_PlayerPhysics(), SV_PointSuperContents(), SV_Prepare_CSQC(), SV_PrepareEntityForSending(), SV_PushEntity(), SV_PushMove(), SV_ReadClientMessage(), SV_Savegame_to(), SV_SaveSpawnparms(), SV_SendClientDatagram(), SV_SpawnServer(), SV_StartPointSound(), SV_StartSound(), SV_Status_f(), SV_Tell_f(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), SV_UpdateToReliableMessages(), SV_Viewframe_f(), SV_Viewmodel_f(), SV_Viewnext_f(), SV_Viewprev_f(), SV_WalkMove(), SV_WaterJump(), SV_WriteClientdataToMessage(), SVBSP_InsertOccluderPolygonNodes(), Sys_Con_NearestColor(), u8_strpad(), u8_strpad_colorcodes(), V_CalcRefdefUsing(), VID_ApplyJoyState(), VM_altstr_get(), VM_altstr_ins(), VM_altstr_set(), VM_argv(), VM_argv_end_index(), VM_argv_start_index(), VM_buf_copy(), VM_buf_create(), VM_buf_sort(), VM_buf_writefile(), VM_bufstr_add(), VM_bufstr_find(), VM_bufstr_free(), VM_bufstr_get(), VM_bufstr_set(), VM_cin_getstate(), VM_CL_boxparticles(), VM_CL_droptofloor(), VM_CL_frameduration(), VM_CL_frameforname(), VM_CL_getinputstate(), VM_CL_getplayerkey(), VM_CL_getstatf(), VM_CL_getstati(), VM_CL_getstats(), VM_CL_gettaginfo(), VM_CL_lightstyle(), VM_CL_makestatic(), VM_CL_particle(), VM_CL_ParticleTheme(), VM_CL_ParticleThemeFree(), VM_CL_ParticleThemeFromGlobals(), VM_CL_ParticleThemeSave(), VM_CL_pointparticles(), VM_CL_R_AddDynamicLight(), VM_CL_R_AddEntities(), VM_CL_R_PolygonBegin(), VM_CL_R_SetView(), VM_CL_runplayerphysics(), VM_CL_setattachment(), VM_CL_setmodelindex(), VM_CL_skel_build(), VM_CL_skel_copybones(), VM_CL_skel_create(), VM_CL_skel_delete(), VM_CL_skel_find_bone(), VM_CL_skel_get_boneabs(), VM_CL_skel_get_bonename(), VM_CL_skel_get_boneparent(), VM_CL_skel_get_bonerel(), VM_CL_skel_get_numbones(), VM_CL_skel_mul_bone(), VM_CL_skel_mul_bones(), VM_CL_skel_set_bone(), VM_CL_sound(), VM_CL_SpawnParticle(), VM_CL_SpawnParticleDelayed(), VM_CL_te_explosion2(), VM_CL_tracebox(), VM_CL_traceline(), VM_CL_trailparticles(), VM_CL_V_CalcRefdef(), VM_drawcharacter(), VM_drawcolorcodedstring(), VM_drawfill(), VM_drawline(), VM_drawpic(), VM_drawrotpic(), VM_drawstring(), VM_drawsubpic(), VM_entityfieldname(), VM_entityfieldtype(), VM_fclose(), VM_fgets(), VM_fopen(), VM_fputs(), VM_FrameBlendFromFrameGroupBlend(), VM_GenerateFrameGroupBlend(), VM_getentityfieldstring(), VM_getsoundtime(), VM_getsurfacepoint(), VM_getsurfacepointattribute(), VM_getsurfacetriangle(), VM_gettime(), VM_M_getgamedirinfo(), VM_M_getresolution(), VM_M_getserverlistnumber(), VM_M_getserverliststat(), VM_M_getserverliststring(), VM_M_setserverlistmasknumber(), VM_M_setserverlistmaskstring(), VM_M_setserverlistsort(), VM_M_WriteDest(), VM_matchpattern(), VM_netaddress_resolve(), VM_putentityfieldstring(), VM_registercvar(), VM_search_begin(), VM_search_end(), VM_search_getfilename(), VM_search_getsize(), VM_sprint(), VM_sprintf(), VM_str2chr(), VM_strconv(), VM_stringwidth(), VM_strireplace(), VM_strlennocol(), VM_strpad(), VM_strreplace(), VM_strstrofs(), VM_substring(), VM_SV_AddStat(), VM_SV_droptofloor(), VM_SV_frameduration(), VM_SV_frameforname(), VM_SV_gettaginfo(), VM_SV_lightstyle(), VM_SV_modelnameforindex(), VM_SV_particle(), VM_SV_pointparticles(), VM_SV_pointsound(), VM_SV_setcolor(), VM_SV_setmodelindex(), VM_SV_setpause(), VM_SV_skel_build(), VM_SV_skel_copybones(), VM_SV_skel_create(), VM_SV_skel_delete(), VM_SV_skel_find_bone(), VM_SV_skel_get_boneabs(), VM_SV_skel_get_bonename(), VM_SV_skel_get_boneparent(), VM_SV_skel_get_bonerel(), VM_SV_skel_get_numbones(), VM_SV_skel_mul_bone(), VM_SV_skel_mul_bones(), VM_SV_skel_set_bone(), VM_SV_sound(), VM_SV_tracebox(), VM_SV_traceline(), VM_SV_UpdateCustomStats(), VM_tokenizebyseparator(), VM_UpdateEdictSkeleton(), VM_vectoyaw(), W_GetTextureBGRA(), World_EntitiesInBox(), World_LinkEdict_AreaGrid(), WriteDest(), and XMP_GetSamplesFloat().

PK3_BuildFileList()

static int PK3_BuildFileList ( pack_t * pack, const pk3_endOfCentralDir_t * eocd )

static

Definition at line 712 of file fs.c.

{
    unsigned char *central_dir, *ptr;
    unsigned int ind;
    fs_offset_t remaining;
 
    // Load the central directory in memory
    central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
    if (FILEDESC_SEEK (pack->handle, eocd->cdir_offset, SEEK_SET) == -1)
    {
        Mem_Free (central_dir);
        return -1;
    }
    if(FILEDESC_READ (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
    {
        Mem_Free (central_dir);
        return -1;
    }
 
    // Extract the files properties
    // The parsing is done "by hand" because some fields have variable sizes and
    // the constant part isn't 4-bytes aligned, which makes the use of structs difficult
    remaining = eocd->cdir_size;
    pack->numfiles = 0;
    ptr = central_dir;
    for (ind = 0; ind < eocd->nbentries; ind++)
    {
        fs_offset_t namesize, count;
 
        // Checking the remaining size
        if (remaining < ZIP_CDIR_CHUNK_BASE_SIZE)
        {
            Mem_Free (central_dir);
            return -1;
        }
        remaining -= ZIP_CDIR_CHUNK_BASE_SIZE;
 
        // Check header
        if (BuffBigLong (ptr) != ZIP_CDIR_HEADER)
        {
            Mem_Free (central_dir);
            return -1;
        }
 
        namesize = (unsigned short)BuffLittleShort (&ptr[28]);  // filename length
 
        // Check encryption, compression, and attributes
        // 1st uint8  : general purpose bit flag
        //    Check bits 0 (encryption), 3 (data descriptor after the file), and 5 (compressed patched data (?))
        //
        // LadyHavoc: bit 3 would be a problem if we were scanning the archive
        // but is not a problem in the central directory where the values are
        // always real.
        //
        // bit 3 seems to always be set by the standard Mac OSX zip maker
        //
        // 2nd uint8 : external file attributes
        //    Check bits 3 (file is a directory) and 5 (file is a volume (?))
        if ((ptr[8] & 0x21) == 0 && (ptr[38] & 0x18) == 0)
        {
            // Still enough bytes for the name?
            if (remaining < namesize || namesize >= (int)sizeof (*pack->files))
            {
                Mem_Free (central_dir);
                return -1;
            }
 
            // WinZip doesn't use the "directory" attribute, so we need to check the name directly
            if (ptr[ZIP_CDIR_CHUNK_BASE_SIZE + namesize - 1] != '/')
            {
                char filename [sizeof (pack->files[0].name)];
                fs_offset_t offset, packsize, realsize;
                int flags;
 
                // Extract the name (strip it if necessary)
                namesize = min(namesize, (int)sizeof (filename) - 1);
                memcpy (filename, &ptr[ZIP_CDIR_CHUNK_BASE_SIZE], namesize);
                filename[namesize] = '\0';
 
                if (BuffLittleShort (&ptr[10]))
                    flags = PACKFILE_FLAG_DEFLATED;
                else
                    flags = 0;
                offset = (unsigned int)(BuffLittleLong (&ptr[42]) + eocd->prepended_garbage);
                packsize = (unsigned int)BuffLittleLong (&ptr[20]);
                realsize = (unsigned int)BuffLittleLong (&ptr[24]);
 
                switch(ptr[5]) // C_VERSION_MADE_BY_1
                {
                    case 3: // UNIX_
                    case 2: // VMS_
                    case 16: // BEOS_
                        if((BuffLittleShort(&ptr[40]) & 0120000) == 0120000)
                            // can't use S_ISLNK here, as this has to compile on non-UNIX too
                            flags |= PACKFILE_FLAG_SYMLINK;
                        break;
                }
 
                FS_AddFileToPack (filename, pack, offset, packsize, realsize, flags);
            }
        }
 
        // Skip the name, additionnal field, and comment
        // 1er uint16 : extra field length
        // 2eme uint16 : file comment length
        count = namesize + (unsigned short)BuffLittleShort (&ptr[30]) + (unsigned short)BuffLittleShort (&ptr[32]);
        ptr += ZIP_CDIR_CHUNK_BASE_SIZE + count;
        remaining -= count;
    }
 
    // If the package is empty, central_dir is NULL here
    if (central_dir != NULL)
        Mem_Free (central_dir);
    return pack->numfiles;
}

References BuffBigLong(), BuffLittleLong(), BuffLittleShort(), pk3_endOfCentralDir_t::cdir_offset, pk3_endOfCentralDir_t::cdir_size, count, FILEDESC_READ, FILEDESC_SEEK, pack_t::files, flags, FS_AddFileToPack(), pack_t::handle, int(), Mem_Alloc, Mem_Free, min, packfile_t::name, pk3_endOfCentralDir_t::nbentries, NULL, pack_t::numfiles, offset, PACKFILE_FLAG_DEFLATED, PACKFILE_FLAG_SYMLINK, pk3_endOfCentralDir_t::prepended_garbage, tempmempool, ZIP_CDIR_CHUNK_BASE_SIZE, and ZIP_CDIR_HEADER.

Referenced by FS_LoadPackPK3FromFD().

PK3_CloseLibrary()

static void PK3_CloseLibrary ( void )

static

Definition at line 566 of file fs.c.

{
#ifndef LINK_TO_ZLIB
    Sys_FreeLibrary (&zlib_dll);
#endif
}

References Sys_FreeLibrary(), and zlib_dll.

Referenced by FS_Shutdown().

PK3_GetEndOfCentralDir()

static qbool PK3_GetEndOfCentralDir ( const char * packfile, filedesc_t packhandle, pk3_endOfCentralDir_t * eocd )

static

Definition at line 637 of file fs.c.

{
    fs_offset_t filesize, maxsize;
    unsigned char *buffer, *ptr;
    int ind;
 
    // Get the package size
    filesize = FILEDESC_SEEK (packhandle, 0, SEEK_END);
    if (filesize < ZIP_END_CDIR_SIZE)
        return false;
 
    // Load the end of the file in memory
    if (filesize < ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE)
        maxsize = filesize;
    else
        maxsize = ZIP_MAX_COMMENTS_SIZE + ZIP_END_CDIR_SIZE;
    buffer = (unsigned char *)Mem_Alloc (tempmempool, maxsize);
    FILEDESC_SEEK (packhandle, filesize - maxsize, SEEK_SET);
    if (FILEDESC_READ (packhandle, buffer, maxsize) != (fs_offset_t) maxsize)
    {
        Mem_Free (buffer);
        return false;
    }
 
    // Look for the end of central dir signature around the end of the file
    maxsize -= ZIP_END_CDIR_SIZE;
    ptr = &buffer[maxsize];
    ind = 0;
    while (BuffBigLong (ptr) != ZIP_END_HEADER)
    {
        if (ind == maxsize)
        {
            Mem_Free (buffer);
            return false;
        }
 
        ind++;
        ptr--;
    }
 
    memcpy (eocd, ptr, ZIP_END_CDIR_SIZE);
    eocd->signature = LittleLong (eocd->signature);
    eocd->disknum = LittleShort (eocd->disknum);
    eocd->cdir_disknum = LittleShort (eocd->cdir_disknum);
    eocd->localentries = LittleShort (eocd->localentries);
    eocd->nbentries = LittleShort (eocd->nbentries);
    eocd->cdir_size = LittleLong (eocd->cdir_size);
    eocd->cdir_offset = LittleLong (eocd->cdir_offset);
    eocd->comment_size = LittleShort (eocd->comment_size);
    eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
    eocd->cdir_offset += eocd->prepended_garbage;
 
    Mem_Free (buffer);
 
    if (
            eocd->cdir_size > filesize ||
            eocd->cdir_offset >= filesize ||
            eocd->cdir_offset + eocd->cdir_size > filesize
       )
    {
        // Obviously invalid central directory.
        return false;
    }
 
    return true;
}

References BuffBigLong(), buffer, pk3_endOfCentralDir_t::cdir_disknum, pk3_endOfCentralDir_t::cdir_offset, pk3_endOfCentralDir_t::cdir_size, pk3_endOfCentralDir_t::comment_size, pk3_endOfCentralDir_t::disknum, FILEDESC_READ, FILEDESC_SEEK, LittleLong, LittleShort, pk3_endOfCentralDir_t::localentries, Mem_Alloc, Mem_Free, pk3_endOfCentralDir_t::nbentries, pk3_endOfCentralDir_t::prepended_garbage, pk3_endOfCentralDir_t::signature, tempmempool, ZIP_END_CDIR_SIZE, ZIP_END_HEADER, and ZIP_MAX_COMMENTS_SIZE.

Referenced by FS_LoadPackPK3FromFD().

PK3_GetTrueFileOffset()

static qbool PK3_GetTrueFileOffset ( packfile_t * pfile, pack_t * pack )

static

Definition at line 908 of file fs.c.

{
    unsigned char buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
    fs_offset_t count;
 
    // Already found?
    if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
        return true;
 
    // Load the local file description
    if (FILEDESC_SEEK (pack->handle, pfile->offset, SEEK_SET) == -1)
    {
        Con_Printf ("Can't seek in package %s\n", pack->filename);
        return false;
    }
    count = FILEDESC_READ (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
    if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
    {
        Con_Printf ("Can't retrieve file %s in package %s\n", pfile->name, pack->filename);
        return false;
    }
 
    // Skip name and extra field
    pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
 
    pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
    return true;
}

References BuffBigLong(), buffer, BuffLittleShort(), Con_Printf(), count, FILEDESC_READ, FILEDESC_SEEK, pack_t::filename, packfile_t::flags, pack_t::handle, packfile_t::name, packfile_t::offset, PACKFILE_FLAG_TRUEOFFS, ZIP_DATA_HEADER, and ZIP_LOCAL_CHUNK_BASE_SIZE.

Referenced by FS_OpenPackedFile().

PK3_OpenLibrary()

static qbool PK3_OpenLibrary ( void )

static

Definition at line 581 of file fs.c.

{
#ifdef LINK_TO_ZLIB
    return true;
#else
    const char* dllnames [] =
    {
#if defined(WIN32)
# ifdef ZLIB_USES_WINAPI
        "zlibwapi.dll",
        "zlib.dll",
# else
        "zlib1.dll",
# endif
#elif defined(MACOSX)
        "libz.dylib",
#else
        "libz.so.1",
        "libz.so",
#endif
        NULL
    };
 
    // Already loaded?
    if (zlib_dll)
        return true;
 
    // Load the DLL
    return Sys_LoadDependency (dllnames, &zlib_dll, zlibfuncs);
#endif
}

References NULL, Sys_LoadDependency(), zlib_dll, and zlibfuncs.

Referenced by FS_HasZlib(), and FS_Init().

ReadAll()

static fs_offset_t ReadAll ( const filedesc_t fd, void *const buf, const size_t length )

static

Definition at line 135 of file fs.c.

{
    char *const p = (char *)buf;
    size_t cursor = 0;
    do
    {
        const fs_offset_t result = FILEDESC_READ(fd, p + cursor, length - cursor);
        if (result < 0) // Error
            return result;
        if (result == 0) // EOF
            break;
        cursor += result;
    } while (cursor < length);
    return cursor;
}

References buf, FILEDESC_READ, and length.

WriteAll()

static fs_offset_t WriteAll ( const filedesc_t fd, const void *const buf, const size_t length )

static

Definition at line 159 of file fs.c.

{
    const char *const p = (const char *)buf;
    size_t cursor = 0;
    do
    {
        const fs_offset_t result = FILEDESC_WRITE(fd, p + cursor, length - cursor);
        if (result < 0) // Error
            return result;
        cursor += result;
    } while (cursor < length);
    return cursor;
}

References buf, FILEDESC_WRITE, and length.

Variable Documentation

con_linewidth

int con_linewidth

extern

Definition at line 94 of file console.c.

Referenced by FS_ListDirectory().

cvar_fs_gamedir

cvar_t cvar_fs_gamedir = {CF_CLIENT | CF_SERVER | CF_READONLY | CF_PERSISTENT, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"}

Definition at line 458 of file fs.c.

{CF_CLIENT | CF_SERVER | CF_READONLY | CF_PERSISTENT, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};

Referenced by FS_Init_Commands(), and FS_Rescan().

flush

static int flush

Definition at line 477 of file fs.c.

fs_all_gamedirs

gamedir_t* fs_all_gamedirs = NULL

Definition at line 452 of file fs.c.

Referenced by FS_ListGameDirs(), and VM_M_getgamedirinfo().

fs_all_gamedirs_count

int fs_all_gamedirs_count = 0

Definition at line 453 of file fs.c.

Referenced by FS_ListGameDirs(), and VM_M_getgamedirinfo().

fs_basedir

char fs_basedir[MAX_OSPATH]

Definition at line 444 of file fs.c.

Referenced by Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_LoadFile(), Crypto_SavePubKeyTextFile(), FS_AddGameHierarchy(), FS_CheckGameDir(), FS_ChooseUserDir(), FS_Init_Dir(), FS_ListGameDirs(), Host_LockSession(), and ModList_RebuildList().

fs_checkgamedir_missing

const char* const fs_checkgamedir_missing = "missing"

Definition at line 438 of file fs.c.

Referenced by FS_CheckGameDir(), FS_ListGameDirs(), FS_SetGameDirs(), and ModList_RebuildList().

fs_empty_files_in_pack_mark_deletions

cvar_t fs_empty_files_in_pack_mark_deletions = {CF_CLIENT | CF_SERVER, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"}

Definition at line 456 of file fs.c.

{CF_CLIENT | CF_SERVER, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};

Referenced by FS_FindFile(), and FS_Init_Commands().

fs_gamedir

char fs_gamedir[MAX_OSPATH]

Definition at line 443 of file fs.c.

Referenced by FS_AddGameDirectory(), FS_Init_Dir(), FS_OpenRealFile(), FS_Rescan(), and SCR_ScreenShot_f().

fs_gamedirs

char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH]

Definition at line 449 of file fs.c.

Referenced by COM_ChangeGameTypeForGameDirs(), FS_GameDir_f(), FS_Rescan(), FS_SetGameDirs(), and ModList_RebuildList().

fs_mempool

mempool_t* fs_mempool

Definition at line 434 of file fs.c.

Referenced by COM_InsertFlags(), FS_AddGameDirectory(), FS_AddPack_Fullpath(), FS_AddSelfPack(), FS_FileFromData(), FS_Init(), FS_ListGameDirs(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_LoadPackVirtual(), FS_OpenPackedFile(), FS_Shutdown(), and FS_SysOpen().

fs_mutex

void* fs_mutex = NULL

Definition at line 435 of file fs.c.

Referenced by FS_Init_Dir(), FS_OpenVirtualFile(), and FS_Shutdown().

fs_numgamedirs

int fs_numgamedirs = 0

Definition at line 448 of file fs.c.

Referenced by COM_ChangeGameTypeForGameDirs(), FS_GameDir_f(), FS_Rescan(), FS_SetGameDirs(), and ModList_RebuildList().

fs_searchpaths

searchpath_t* fs_searchpaths = NULL

Definition at line 437 of file fs.c.

Referenced by FS_AddGameDirectory(), FS_AddPack_Fullpath(), FS_AddSelfPack(), FS_ClearSearchPath(), FS_FindFile(), FS_IsRegisteredQuakePack(), FS_Path_f(), FS_Search(), and FS_UnloadPacks_dlcache().

fs_selfpack

pack_t* fs_selfpack = NULL

static

Definition at line 445 of file fs.c.

Referenced by FS_AddSelfPack(), FS_ClearSearchPath(), and FS_Init_SelfPack().

fs_unload_dlcache

cvar_t fs_unload_dlcache = {CF_CLIENT, "fs_unload_dlcache", "1", "if enabled, unload dlcache's loaded pak/pk3 files when changing server and/or map WARNING: disabling unloading can cause servers to override assets of other servers, \"memory leaking\" by dlcache assets never unloading and many more issues"}

Definition at line 457 of file fs.c.

{CF_CLIENT, "fs_unload_dlcache", "1", "if enabled, unload dlcache's loaded pak/pk3 files when changing server and/or map WARNING: disabling unloading can cause servers to override assets of other servers, \"memory leaking\" by dlcache assets never unloading and many more issues"};

Referenced by FS_Init_Commands(), and FS_UnloadPacks_dlcache().

fs_userdir

char fs_userdir[MAX_OSPATH]

Definition at line 442 of file fs.c.

Referenced by Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_LoadFile(), Crypto_SavePubKeyTextFile(), FS_AddGameHierarchy(), FS_CheckGameDir(), FS_Init_Dir(), FS_ListGameDirs(), and Host_LockSession().

level

GLint level

Definition at line 481 of file fs.c.

Referenced by FS_Deflate(), and libavw_message().

memLevel

int int int int memLevel

Definition at line 481 of file fs.c.

method

int int method

Definition at line 481 of file fs.c.

scr_screenshot_name

cvar_t scr_screenshot_name = {CF_CLIENT | CF_PERSISTENT, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"}

Definition at line 455 of file fs.c.

{CF_CLIENT | CF_PERSISTENT, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};

Referenced by FS_Init_Commands(), FS_Rescan(), and SCR_ScreenShot_f().

strategy

int int int int int strategy

Definition at line 481 of file fs.c.

stream_size

static int int int int int const char int stream_size

Definition at line 479 of file fs.c.

version

static int int int int int const char * version

Definition at line 479 of file fs.c.

Referenced by Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_IDS2_Load(), Mod_IDSP_Load(), Mod_PSKMODEL_Load(), Mod_Sprite_SharedSetup(), Protocol_NameForEnum(), Protocol_NumberForEnum(), SV_Loadgame_f(), SV_PrepareEntityForSending(), and VID_Init().

windowBits

static int int int windowBits

Definition at line 479 of file fs.c.

zlib_dll

dllhandle_t zlib_dll = NULL

static

Handle for Zlib DLL.

Definition at line 507 of file fs.c.

Referenced by FS_Deflate(), FS_HasZlib(), FS_Inflate(), FS_OpenPackedFile(), PK3_CloseLibrary(), and PK3_OpenLibrary().

zlibfuncs

dllfunction_t zlibfuncs[]

static

Initial value:

=
{
    {"inflate",         (void **) &qz_inflate},
    {"inflateEnd",      (void **) &qz_inflateEnd},
    {"inflateInit2_",   (void **) &qz_inflateInit2_},
    {"inflateReset",    (void **) &qz_inflateReset},
    {"deflateInit2_",   (void **) &qz_deflateInit2_},
    {"deflateEnd",      (void **) &qz_deflateEnd},
    {"deflate",         (void **) &qz_deflate},
    {NULL, NULL}
}

Definition at line 494 of file fs.c.

{
    {"inflate",         (void **) &qz_inflate},
    {"inflateEnd",      (void **) &qz_inflateEnd},
    {"inflateInit2_",   (void **) &qz_inflateInit2_},
    {"inflateReset",    (void **) &qz_inflateReset},
    {"deflateInit2_",   (void **) &qz_deflateInit2_},
    {"deflateEnd",      (void **) &qz_deflateEnd},
    {"deflate",         (void **) &qz_deflate},
    {NULL, NULL}
};

Referenced by PK3_OpenLibrary().