fs.h File Reference

#include <stddef.h>
#include <stdarg.h>
#include "qtypes.h"
#include "qdefs.h"
#include "zone.h"

Include dependency graph for fs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	fssearch_t
struct	gamedir_t
struct	vfs_t

Macros
#define	FS_FILETYPE_DIRECTORY   2
#define	FS_FILETYPE_FILE   1
#define	FS_FILETYPE_NONE   0
#define	MAX_GAMEDIRS   17

Typedefs
typedef int64_t	fs_offset_t

Enumerations
enum	addgamedirs_t { GAMEDIRS_ALLGOOD = -1 , GAMEDIRS_FAILURE = 0 , GAMEDIRS_SUCCESS = 1 }

Functions
qbool	FS_AddPack (const char *pakfile, qbool *already_loaded, qbool keep_plain_dirs, qbool dlcache)
qbool	FS_ChangeGameDirs (int numgamedirs, const char *gamedirs[], qbool failmissing)
const char *	FS_CheckGameDir (const char *gamedir)
int	FS_CheckNastyPath (const char *path, qbool isgamedir)
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)
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)
void	FS_FreeSearch (fssearch_t *search)
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)
void	FS_Init_SelfPack (void)
qbool	FS_IsRegisteredQuakePack (const char *name)
unsigned char *	FS_LoadFile (const char *path, mempool_t *pool, qbool quiet, fs_offset_t *filesizepointer)
qfile_t *	FS_OpenRealFile (const char *filepath, const char *mode, qbool quiet)
qfile_t *	FS_OpenVirtualFile (const char *filepath, qbool quiet)
int	FS_Print (qfile_t *file, const char *msg)
int	FS_Printf (qfile_t *file, const char *format,...) DP_FUNC_PRINTF(2)
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)
void	FS_SanitizePath (char *path)
fssearch_t *	FS_Search (const char *pattern, int caseinsensitive, int quiet, const char *packfile)
int	FS_Seek (qfile_t *file, fs_offset_t offset, int whence)
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)
qbool	FS_SysFileExists (const char *filename)
	Look for a file in the filesystem only.
int	FS_SysFileType (const char *filename)
	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)
fs_offset_t	FS_Tell (qfile_t *file)
int	FS_UnGetc (qfile_t *file, unsigned char c)
void	FS_UnloadPacks_dlcache (void)
int	FS_VPrintf (qfile_t *file, const char *format, va_list ap)
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)

Variables
gamedir_t *	fs_all_gamedirs
int	fs_all_gamedirs_count
char	fs_basedir [MAX_OSPATH]
const char *const	fs_checkgamedir_missing
char	fs_gamedir [MAX_OSPATH]
char	fs_gamedirs [MAX_GAMEDIRS][MAX_QPATH]
int	fs_numgamedirs
char	fs_userdir [MAX_OSPATH]

Macro Definition Documentation

FS_FILETYPE_DIRECTORY

#define FS_FILETYPE_DIRECTORY   2

Definition at line 139 of file fs.h.

Referenced by Con_CompleteCommandLine(), and FS_SysFileType().

FS_FILETYPE_FILE

#define FS_FILETYPE_FILE   1

Definition at line 138 of file fs.h.

Referenced by Con_CompleteCommandLine(), FS_FileType(), and FS_SysFileType().

FS_FILETYPE_NONE

#define FS_FILETYPE_NONE   0

Definition at line 137 of file fs.h.

Referenced by FS_FileType(), FS_SysFileExists(), and FS_SysFileType().

MAX_GAMEDIRS

#define MAX_GAMEDIRS   17

Definition at line 46 of file fs.h.

Referenced by FS_GameDir_f(), FS_Init_Dir(), and FS_SetGameDirs().

Typedef Documentation

fs_offset_t

typedef int64_t fs_offset_t

Definition at line 37 of file fs.h.

Enumeration Type Documentation

addgamedirs_t

enum addgamedirs_t

Enumerator
GAMEDIRS_ALLGOOD
GAMEDIRS_FAILURE
GAMEDIRS_SUCCESS

Definition at line 102 of file fs.h.

                           {
    GAMEDIRS_ALLGOOD = -1,
    GAMEDIRS_FAILURE = 0,
    GAMEDIRS_SUCCESS = 1
} addgamedirs_t;

Function Documentation

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_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, 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 2619 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_Close()

int FS_Close

(

qfile_t *

file

)

Definition at line 2971 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 4159 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 3642 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 4179 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_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 3694 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 2952 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 3475 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 3668 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_FreeSearch()

void FS_FreeSearch

(

fssearch_t *

search

)

Definition at line 3964 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_Getc()

int FS_Getc

(

qfile_t *

file

)

Definition at line 3324 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 4274 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_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 buf, COM_InsertFlags(), FS_AddSelfPack(), FS_LoadFile(), FS_LoadPackPK3FromFD(), fs_selfpack, FS_SysLoadFile(), Mem_Free, NULL, sys, Sys_CheckParm(), and tempmempool.

Referenced by FS_Init().

FS_IsRegisteredQuakePack()

qbool FS_IsRegisteredQuakePack

(

const char *

name

)

Definition at line 4113 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_LoadFile()

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

Definition at line 3541 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_OpenRealFile()

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

Definition at line 2902 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 2929 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_Print()

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

Definition at line 3262 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 3274 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 3488 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 3067 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 3008 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 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, MAX_INPUTLINE, registered, scr_screenshot_name, sys, Sys_CheckParm(), va(), and W_UnloadAll().

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

FS_SanitizePath()

void FS_SanitizePath

(

char *

path

)

Definition at line 2674 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 3757 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, int(), 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 3360 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, 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 3612 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_SysFileExists()

qbool FS_SysFileExists

(

const char *

filename

)

Look for a file in the filesystem only.

Definition at line 3745 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 *

filename

)

Look for a file in the filesystem only.

Definition at line 3709 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 3556 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_Tell()

fs_offset_t FS_Tell

(

qfile_t *

file

)

Definition at line 3462 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 3342 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, 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 3294 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_WhichPack()

const char * FS_WhichPack

(

const char *

filename

)

Definition at line 4092 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 3020 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 3593 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 3570 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(), and FS_Write().

Referenced by FS_WriteFile(), and Image_WriteTGABGR_preflipped().

Variable Documentation

fs_all_gamedirs

gamedir_t* fs_all_gamedirs

extern

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

extern

Definition at line 453 of file fs.c.

Referenced by FS_ListGameDirs(), and VM_M_getgamedirinfo().

fs_basedir

char fs_basedir[MAX_OSPATH]

extern

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

extern

Definition at line 438 of file fs.c.

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

fs_gamedir

char fs_gamedir[MAX_OSPATH]

extern

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]

extern

Definition at line 449 of file fs.c.

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

fs_numgamedirs

int fs_numgamedirs

extern

Definition at line 448 of file fs.c.

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

fs_userdir

char fs_userdir[MAX_OSPATH]

extern

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().