files.c File Reference

#include "shared/shared.h"
#include "shared/list.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/error.h"
#include "common/files.h"
#include "common/prompt.h"
#include "system/system.h"
#include "client/client.h"
#include "format/pak.h"
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

Go to the source code of this file.

Classes
struct	packfile_s
struct	pack_t
struct	searchpath_s
struct	file_t
struct	symlink_t

Macros
#define	MAX_FILE_HANDLES   32
#define	FS_DPrintf(...)
#define	PATH_NOT_CHECKED   -1
#define	FOR_EACH_SYMLINK(link, list)   LIST_FOR_EACH(symlink_t, link, list, entry)
#define	FOR_EACH_SYMLINK_SAFE(link, next, list)   LIST_FOR_EACH_SAFE(symlink_t, link, next, list, entry)
#define	FS_COUNT_READ   (void)0
#define	FS_COUNT_OPEN   (void)0
#define	FS_COUNT_STRCMP   (void)0
#define	FS_COUNT_STRLWR   (void)0
#define	FS_ERR_READ(fp)   (ferror(fp) ? Q_Errno() : Q_ERR_UNEXPECTED_EOF)
#define	FS_ERR_WRITE(fp)   (ferror(fp) ? Q_Errno() : Q_ERR_FAILURE)
#define	PAK_EXT   ".pak"

Typedefs
typedef struct packfile_s	packfile_t
typedef struct searchpath_s	searchpath_t

Enumerations
enum	filetype_t { FS_FREE, FS_REAL, FS_PAK, FS_BAD }

Functions
static pack_t *	pack_get (pack_t *pack)
static void	pack_put (pack_t *pack)
char *	FS_ReplaceSeparators (char *s, int separator)
static qboolean	validate_char (int c)
int	FS_ValidatePath (const char *s)
void	FS_SanitizeFilenameVariable (cvar_t *var)
size_t	FS_NormalizePath (char *out, const char *in)
size_t	FS_NormalizePathBuffer (char *out, const char *in, size_t size)
static file_t *	alloc_handle (qhandle_t *f)
static file_t *	file_for_handle (qhandle_t f)
static void	cleanup_path (char *s)
static symlink_t *	expand_links (list_t *list, char *buffer, size_t *len_p)
ssize_t	FS_Length (qhandle_t f)
ssize_t	FS_Tell (qhandle_t f)
static qerror_t	seek_pak_file (file_t *file, off_t offset)
qerror_t	FS_Seek (qhandle_t f, off_t offset)
qerror_t	FS_CreatePath (char *path)
qerror_t	FS_FilterFile (qhandle_t f)
void	FS_FCloseFile (qhandle_t f)
static qerror_t	get_path_info (const char *path, file_info_t *info)
static qerror_t	get_fp_info (FILE *fp, file_info_t *info)
static FILE *	fopen_hack (const char *path, const char *mode)
static ssize_t	open_file_write (file_t *file, const char *name)
static ssize_t	open_from_pak (file_t *file, pack_t *pack, packfile_t *entry, qboolean unique)
static ssize_t	open_from_disk (file_t *file, const char *fullpath)
qerror_t	FS_LastModified (char const *file, uint64_t *last_modified)
static ssize_t	open_file_read (file_t *file, const char *normalized, size_t namelen, qboolean unique)
static ssize_t	expand_open_file_read (file_t *file, const char *name, qboolean unique)
static ssize_t	read_pak_file (file_t *file, void *buf, size_t len)
static ssize_t	read_phys_file (file_t *file, void *buf, size_t len)
ssize_t	FS_Read (void *buf, size_t len, qhandle_t f)
ssize_t	FS_ReadLine (qhandle_t f, char *buffer, size_t size)
void	FS_Flush (qhandle_t f)
ssize_t	FS_Write (const void *buf, size_t len, qhandle_t f)
ssize_t	FS_FOpenFile (const char *name, qhandle_t *f, unsigned mode)
static qhandle_t	easy_open_read (char *buf, size_t size, unsigned mode, const char *dir, const char *name, const char *ext)
static qhandle_t	easy_open_write (char *buf, size_t size, unsigned mode, const char *dir, const char *name, const char *ext)
qhandle_t	FS_EasyOpenFile (char *buf, size_t size, unsigned mode, const char *dir, const char *name, const char *ext)
ssize_t	FS_LoadFileEx (const char *path, void **buffer, unsigned flags, memtag_t tag)
qerror_t	FS_WriteFile (const char *path, const void *data, size_t len)
qboolean	FS_EasyWriteFile (char *buf, size_t size, unsigned mode, const char *dir, const char *name, const char *ext, const void *data, size_t len)
ssize_t	FS_FPrintf (qhandle_t f, const char *format,...)
static pack_t *	pack_alloc (FILE *fp, filetype_t type, const char *name, unsigned num_files, size_t names_len)
static void	pack_hash_file (pack_t *pack, packfile_t *file)
static pack_t *	load_pak_file (const char *packfile)
static int	pakcmp (const void *p1, const void *p2)
static void	q_printf (2, 3)
file_info_t *	FS_CopyInfo (const char *name, size_t size, time_t ctime, time_t mtime)
void **	FS_CopyList (void **list, int count)
qboolean	FS_WildCmp (const char *filter, const char *string)
qboolean	FS_ExtCmp (const char *ext, const char *name)
static int	infocmp (const void *p1, const void *p2)
static int	alphacmp (const void *p1, const void *p2)
void **	FS_ListFiles (const char *path, const char *filter, unsigned flags, int *count_p)
void	FS_FreeList (void **list)
void	FS_File_g (const char *path, const char *ext, unsigned flags, genctx_t *ctx)
static void	print_file_list (const char *path, const char *ext, unsigned flags)
static void	FS_FDir_f (void)
static void	FS_Dir_f (void)
static void	FS_WhereIs_f (void)
static void	FS_Path_f (void)
static void	FS_Link_g (genctx_t *ctx)
static void	FS_Link_c (genctx_t *ctx, int argnum)
static void	free_all_links (list_t *list)
static void	FS_UnLink_f (void)
static void	FS_Link_f (void)
static void	free_search_path (searchpath_t *path)
static void	free_all_paths (void)
static void	free_game_paths (void)
static void	setup_base_paths (void)
static void	setup_game_paths (void)
void	FS_Restart (qboolean total)
static void	FS_Restart_f (void)
void	FS_Shutdown (void)
static void	fs_game_changed (cvar_t *self)
void	FS_Init (void)

Variables
char	fs_gamedir [MAX_OSPATH]
static searchpath_t *	fs_searchpaths
static searchpath_t *	fs_base_searchpaths
static list_t	fs_hard_links
static list_t	fs_soft_links
static file_t	fs_files [MAX_FILE_HANDLES]
cvar_t *	fs_game
cvar_t *	fs_shareware
static const cmdreg_t	c_fs []

Macro Definition Documentation

FOR_EACH_SYMLINK

#define FOR_EACH_SYMLINK	(		link,
			list
	)		LIST_FOR_EACH(symlink_t, link, list, entry)

Definition at line 85 of file files.c.

FOR_EACH_SYMLINK_SAFE

#define FOR_EACH_SYMLINK_SAFE	(		link,
			next,
			list
	)		LIST_FOR_EACH_SAFE(symlink_t, link, next, list, entry)

Definition at line 88 of file files.c.

FS_COUNT_OPEN

#define FS_COUNT_OPEN   (void)0

Definition at line 193 of file files.c.

FS_COUNT_READ

#define FS_COUNT_READ   (void)0

Definition at line 192 of file files.c.

FS_COUNT_STRCMP

#define FS_COUNT_STRCMP   (void)0

Definition at line 194 of file files.c.

FS_COUNT_STRLWR

#define FS_COUNT_STRLWR   (void)0

Definition at line 195 of file files.c.

FS_DPrintf

#define FS_DPrintf

(

...

)

Definition at line 80 of file files.c.

FS_ERR_READ

#define FS_ERR_READ

(

fp

)

(ferror(fp) ? Q_Errno() : Q_ERR_UNEXPECTED_EOF)

Definition at line 648 of file files.c.

FS_ERR_WRITE

#define FS_ERR_WRITE

(

fp

)

(ferror(fp) ? Q_Errno() : Q_ERR_FAILURE)

Definition at line 650 of file files.c.

MAX_FILE_HANDLES

#define MAX_FILE_HANDLES   32

Definition at line 59 of file files.c.

PAK_EXT

#define PAK_EXT   ".pak"

PATH_NOT_CHECKED

#define PATH_NOT_CHECKED   -1

Definition at line 83 of file files.c.

Typedef Documentation

packfile_t

typedef struct packfile_s packfile_t

searchpath_t

typedef struct searchpath_s searchpath_t

Enumeration Type Documentation

filetype_t

enum filetype_t

Enumerator
FS_FREE
FS_REAL
FS_PAK
FS_BAD

Definition at line 95 of file files.c.

             {
    FS_FREE,
    FS_REAL,
    FS_PAK,
#if USE_ZLIB
    FS_ZIP,
    FS_GZ,
#endif
    FS_BAD
} filetype_t;

Function Documentation

alloc_handle()

static file_t* alloc_handle ( qhandle_t *  f )

static

Definition at line 415 of file files.c.

{
    file_t *file;
    int i;
 
    for (i = 0, file = fs_files; i < MAX_FILE_HANDLES; i++, file++) {
        if (file->type == FS_FREE) {
            *f = i + 1;
            return file;
        }
    }
 
    return NULL;
}

Referenced by FS_FOpenFile(), and FS_LoadFileEx().

alphacmp()

static int alphacmp ( const void *  p1, const void *  p2  )

static

Definition at line 2703 of file files.c.

{
    char *s1 = *(char **)p1;
    char *s2 = *(char **)p2;
 
    return FS_pathcmp(s1, s2);
}

Referenced by FS_ListFiles(), and pakcmp().

cleanup_path()

static void cleanup_path ( char *  s )

static

Definition at line 447 of file files.c.

{
    for (; *s; s++) {
        if (!validate_char(*s))
            *s = '_';
    }
}

Referenced by easy_open_write().

easy_open_read()

static qhandle_t easy_open_read ( char *  buf, size_t  size, unsigned  mode, const char *  dir, const char *  name, const char *  ext  )

static

Definition at line 1730 of file files.c.

{
    ssize_t len;
    qhandle_t f;
 
    if (*name == '/') {
        // full path is given, ignore directory and extension
        len = Q_strlcpy(buf, name + 1, size);
    } else {
        // first try without extension
        len = Q_concat(buf, size, dir, name, NULL);
        if (len >= size) {
            Q_PrintError("open", Q_ERR_NAMETOOLONG);
            return 0;
        }
 
        // print normalized path in case of error
        FS_NormalizePath(buf, buf);
 
        len = FS_FOpenFile(buf, &f, mode);
        if (f) {
            return f; // succeeded
        }
        if (len != Q_ERR_NOENT) {
            goto fail; // fatal error
        }
        if (!COM_CompareExtension(buf, ext)) {
            goto fail; // name already has the extension
        }
 
        // now try to append extension
        len = Q_strlcat(buf, ext, size);
    }
 
    if (len >= size) {
        Q_PrintError("open", Q_ERR_NAMETOOLONG);
        return 0;
    }
 
    len = FS_FOpenFile(buf, &f, mode);
    if (f) {
        return f;
    }
 
fail:
    Com_Printf("Couldn't open %s: %s\n", buf, Q_ErrorString(len));
    return 0;
}

Referenced by FS_EasyOpenFile().

easy_open_write()

static qhandle_t easy_open_write ( char *  buf, size_t  size, unsigned  mode, const char *  dir, const char *  name, const char *  ext  )

static

Definition at line 1781 of file files.c.

{
    char normalized[MAX_OSPATH];
    ssize_t len;
    qhandle_t f;
 
    // make it impossible to escape the destination directory when writing files
    len = FS_NormalizePathBuffer(normalized, name, sizeof(normalized));
    if (len >= sizeof(normalized)) {
        Q_PrintError("open", Q_ERR_NAMETOOLONG);
        return 0;
    }
 
    // reject empty filenames
    if (len == 0) {
        Q_PrintError("open", Q_ERR_NAMETOOSHORT);
        return 0;
    }
 
    // replace any bad characters with underscores to make automatic commands happy
    cleanup_path(normalized);
 
    // don't append the extension if name already has it
    if (!COM_CompareExtension(normalized, ext)) {
        ext = (mode & FS_FLAG_GZIP) ? "" : NULL;
    }
 
    len = Q_concat(buf, size, dir, normalized, ext,
                   (mode & FS_FLAG_GZIP) ? ".gz" : NULL, NULL);
    if (len >= size) {
        Q_PrintError("open", Q_ERR_NAMETOOLONG);
        return 0;
    }
 
    len = FS_FOpenFile(buf, &f, mode);
    if (!f) {
        goto fail1;
    }
 
    if (mode & FS_FLAG_GZIP) {
        len = FS_FilterFile(f);
        if (len) {
            goto fail2;
        }
    }
 
    return f;
 
fail2:
    FS_FCloseFile(f);
fail1:
    Com_EPrintf("Couldn't open %s: %s\n", buf, Q_ErrorString(len));
    return 0;
}

Referenced by FS_EasyOpenFile(), and FS_EasyWriteFile().

expand_links()

static symlink_t* expand_links ( list_t *  list, char *  buffer, size_t *  len_p  )

static

Definition at line 456 of file files.c.

{
    symlink_t   *link;
    size_t      namelen = *len_p;
 
    FOR_EACH_SYMLINK(link, list) {
        if (link->namelen > namelen) {
            continue;
        }
        if (!FS_pathcmpn(buffer, link->name, link->namelen)) {
            size_t newlen = namelen - link->namelen + link->targlen;
 
            if (newlen < MAX_OSPATH) {
                memmove(buffer + link->targlen, buffer + link->namelen,
                        namelen - link->namelen + 1);
                memcpy(buffer, link->target, link->targlen);
            }
 
            *len_p = newlen;
            return link;
        }
    }
 
    return NULL;
}

Referenced by expand_open_file_read(), and FS_WhereIs_f().

expand_open_file_read()

static ssize_t expand_open_file_read ( file_t *  file, const char *  name, qboolean  unique  )

static

Definition at line 1468 of file files.c.

{
    char        normalized[MAX_OSPATH];
    ssize_t     ret;
    size_t      namelen;
 
// normalize path
    namelen = FS_NormalizePathBuffer(normalized, name, MAX_OSPATH);
    if (namelen >= MAX_OSPATH) {
        return Q_ERR_NAMETOOLONG;
    }
 
// expand hard symlinks
    if (expand_links(&fs_hard_links, normalized, &namelen) && namelen >= MAX_OSPATH) {
        return Q_ERR_NAMETOOLONG;
    }
 
// reject empty paths
    if (namelen == 0) {
        return Q_ERR_NAMETOOSHORT;
    }
 
    ret = open_file_read(file, normalized, namelen, unique);
    if (ret == Q_ERR_NOENT) {
// expand soft symlinks
        if (expand_links(&fs_soft_links, normalized, &namelen)) {
            if (namelen >= MAX_OSPATH) {
                return Q_ERR_NAMETOOLONG;
            }
            ret = open_file_read(file, normalized, namelen, unique);
        }
    }
 
    return ret;
}

Referenced by FS_FOpenFile(), and FS_LoadFileEx().

file_for_handle()

static file_t* file_for_handle ( qhandle_t  f )

static

Definition at line 430 of file files.c.

{
    file_t *file;
 
    if (f < 1 || f > MAX_FILE_HANDLES)
        return NULL;
 
    file = &fs_files[f - 1];
    if (file->type == FS_FREE)
        return NULL;
 
    if (file->type < FS_FREE || file->type >= FS_BAD)
        Com_Error(ERR_FATAL, "%s: bad file type", __func__);
 
    return file;
}

Referenced by FS_FCloseFile(), FS_FilterFile(), FS_Flush(), FS_Length(), FS_Read(), FS_ReadLine(), FS_Seek(), FS_Tell(), and FS_Write().

fopen_hack()

static FILE* fopen_hack ( const char *  path, const char *  mode  )

inlinestatic

Definition at line 844 of file files.c.

{
#ifndef _GNU_SOURCE
    if (mode[0] == 'w' && mode[1] == 'x') {
#ifdef _WIN32
        int flags = _O_WRONLY | _O_CREAT | _O_EXCL | _S_IREAD | _S_IWRITE;
        int fd;
        FILE *fp;
 
        if (mode[2] == 'b')
            flags |= _O_BINARY;
 
        fd = _open(path, flags);
        if (fd == -1)
            return NULL;
 
        fp = _fdopen(fd, (flags & _O_BINARY) ? "wb" : "w");
        if (fp == NULL)
            _close(fd);
 
        return fp;
#else
        int flags = O_WRONLY | O_CREAT | O_EXCL;
        int perm = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
        int fd;
        FILE *fp;
 
        fd = open(path, flags, perm);
        if (fd == -1)
            return NULL;
 
        fp = fdopen(fd, "wb");
        if (fp == NULL)
            close(fd);
 
        return fp;
#endif
    }
#endif // _GNU_SOURCE
 
    return fopen(path, mode);
}

Referenced by open_file_write().

free_all_links()

static void free_all_links ( list_t *  list )

static

Definition at line 3339 of file files.c.

{
    symlink_t *link, *next;
 
    FOR_EACH_SYMLINK_SAFE(link, next, list) {
        Z_Free(link->target);
        Z_Free(link);
    }
 
    List_Init(list);
}

Referenced by FS_Shutdown(), and FS_UnLink_f().

free_all_paths()

static void free_all_paths ( void  )

static

Definition at line 3475 of file files.c.

{
    searchpath_t *path, *next;
 
    for (path = fs_searchpaths; path; path = next) {
        next = path->next;
        free_search_path(path);
    }
 
    fs_searchpaths = NULL;
}

Referenced by FS_Restart(), and FS_Shutdown().

free_game_paths()

static void free_game_paths ( void  )

static

Definition at line 3487 of file files.c.

{
    searchpath_t *path, *next;
 
    for (path = fs_searchpaths; path != fs_base_searchpaths; path = next) {
        next = path->next;
        free_search_path(path);
    }
 
    fs_searchpaths = fs_base_searchpaths;
}

Referenced by FS_Restart().

free_search_path()

static void free_search_path ( searchpath_t *  path )

static

Definition at line 3469 of file files.c.

{
    pack_put(path->pack);
    Z_Free(path);
}

Referenced by free_all_paths(), and free_game_paths().

FS_CopyInfo()

file_info_t* FS_CopyInfo	(	const char *	name,
		size_t	size,
		time_t	ctime,
		time_t	mtime
	)

Definition at line 2599 of file files.c.

{
    file_info_t *out;
    size_t len;
 
    if (!name) {
        return NULL;
    }
 
    len = strlen(name);
    out = FS_Mallocz(sizeof(*out) + len);
    out->size = size;
    out->ctime = ctime;
    out->mtime = mtime;
    memcpy(out->name, name, len + 1);
 
    return out;
}

Referenced by copy_info(), and FS_ListFiles().

FS_CopyList()

void** FS_CopyList	(	void **	list,
		int	count
	)

Definition at line 2618 of file files.c.

{
    void **out;
    int i;
 
    if (!count) {
        return NULL;
    }
 
    out = FS_Malloc(sizeof(void *) * (count + 1));
    for (i = 0; i < count; i++) {
        out[i] = list[i];
    }
    out[i] = NULL;
 
    return out;
}

FS_CreatePath()

qerror_t FS_CreatePath

(

char *

path

)

Definition at line 605 of file files.c.

{
    char *ofs;
    int ret;
 
    ofs = path;
 
#ifdef _WIN32
    // check for UNC path and skip "//computer/share/" part
    if (*path == '/' && path[1] == '/') {
        char *p;
 
        p = strchr(path + 2, '/');
        if (p) {
            p = strchr(p + 1, '/');
            if (p) {
                ofs = p + 1;
            }
        }
    }
#endif
 
    // skip leading slash(es)
    for (; *ofs == '/'; ofs++)
        ;
 
    for (; *ofs; ofs++) {
        if (*ofs == '/') {
            // create the directory
            *ofs = 0;
            ret = os_mkdir(path);
            *ofs = '/';
            if (ret == -1) {
                qerror_t err = Q_Errno();
                if (err != Q_ERR_EXIST)
                    return err;
            }
        }
    }
 
    return Q_ERR_SUCCESS;
}

Referenced by copy_file(), open_file_write(), and start_download().

FS_Dir_f()

static void FS_Dir_f ( void  )

static

Definition at line 3029 of file files.c.

{
    char    *path, *ext;
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <directory> [.extension]\n", Cmd_Argv(0));
        return;
    }
 
    path = Cmd_Argv(1);
    if (Cmd_Argc() > 2) {
        ext = Cmd_Argv(2);
    } else {
        ext = NULL;
    }
 
    print_file_list(path, ext, 0);
}

FS_EasyOpenFile()

qhandle_t FS_EasyOpenFile	(	char *	buf,
		size_t	size,
		unsigned	mode,
		const char *	dir,
		const char *	name,
		const char *	ext
	)

Definition at line 1846 of file files.c.

{
    if ((mode & FS_MODE_MASK) == FS_MODE_READ) {
        return easy_open_read(buf, size, mode, dir, name, ext);
    }
 
    return easy_open_write(buf, size, mode, dir, name, ext);
}

Referenced by CL_PlayDemo_f(), CL_Record_f(), CL_WriteConfig_f(), Con_Dump_f(), create_screenshot(), dummy_record_f(), IMG_List_f(), LOC_Write_f(), logfile_open(), MVD_Play_f(), MVD_StreamedRecord_f(), SCR_ScoreShot_f(), SV_MvdRecord_f(), and writeMaterialsTable().

FS_EasyWriteFile()

qboolean FS_EasyWriteFile	(	char *	buf,
		size_t	size,
		unsigned	mode,
		const char *	dir,
		const char *	name,
		const char *	ext,
		const void *	data,
		size_t	len
	)

Definition at line 1960 of file files.c.

{
    qhandle_t f;
    ssize_t write;
    qerror_t ret;
 
    // TODO: write to temp file perhaps?
    f = easy_open_write(buf, size, mode, dir, name, ext);
    if (!f) {
        return qfalse;
    }
 
    write = FS_Write(data, len, f);
    ret = write == len ? Q_ERR_SUCCESS : write < 0 ? write : Q_ERR_FAILURE;
 
    FS_FCloseFile(f);
 
    if (ret) {
        Com_EPrintf("Couldn't write %s: %s\n", buf, Q_ErrorString(ret));
        return qfalse;
    }
 
    return qtrue;
}

Referenced by dump_program(), and SV_DumpEnts_f().

FS_ExtCmp()

qboolean FS_ExtCmp	(	const char *	ext,
		const char *	name
	)

Definition at line 2649 of file files.c.

{
    int        c1, c2;
    const char *e, *n, *l;
 
    if (!name[0] || !ext[0]) {
        return qfalse;
    }
 
    for (l = name; l[1]; l++)
        ;
 
    for (e = ext; e[1]; e++)
        ;
 
rescan:
    n = l;
    do {
        c1 = *e--;
        c2 = *n--;
 
        if (c1 == ';') {
            break; // matched
        }
 
        if (c1 != c2) {
            c1 = Q_tolower(c1);
            c2 = Q_tolower(c2);
            if (c1 != c2) {
                while (e > ext) {
                    c1 = *e--;
                    if (c1 == ';') {
                        goto rescan;
                    }
                }
                return qfalse;
            }
        }
        if (n < name) {
            return qfalse;
        }
    } while (e >= ext);
 
    return qtrue;
}

Referenced by FS_ListFiles(), and Sys_ListFiles_r().

FS_FCloseFile()

void FS_FCloseFile

(

qhandle_t

f

)

Definition at line 759 of file files.c.

{
    file_t *file = file_for_handle(f);
 
    if (!file)
        return;
 
    switch (file->type) {
    case FS_REAL:
        fclose(file->fp);
        break;
    case FS_PAK:
        if (file->unique) {
            fclose(file->fp);
            pack_put(file->pack);
        }
        break;
#if USE_ZLIB
    case FS_GZ:
        gzclose(file->zfp);
        fclose(file->fp);
        break;
    case FS_ZIP:
        if (file->unique) {
            close_zip_file(file);
            pack_put(file->pack);
        }
        break;
#endif
    default:
        break;
    }
 
    memset(file, 0, sizeof(*file));
}

Referenced by CL_CleanupDemos(), CL_CleanupDownloads(), CL_GetDemoInfo(), CL_HandleDownload(), CL_PlayDemo_f(), CL_Stop_f(), CL_WriteConfig(), CL_WriteConfig_f(), Con_Dump_f(), demo_destroy(), demo_play_next(), dummy_record_f(), easy_open_write(), finish_udp_download(), FS_EasyWriteFile(), FS_LoadFileEx(), FS_Shutdown(), FS_WriteFile(), get_image_dimensions(), IMG_List_f(), LOC_Write_f(), logfile_close(), logfile_write(), make_screenshot(), MVD_Play_f(), MVD_StopRecord(), Prompt_LoadHistory(), Prompt_SaveHistory(), read_binary_file(), rec_stop(), SCR_ScoreShot_f(), SCR_StopCinematic(), SV_BeginDownload_f(), SV_MvdRecord_f(), WriteCache(), and writeMaterialsTable().

FS_FDir_f()

static void FS_FDir_f ( void  )

static

Definition at line 3004 of file files.c.

{
    unsigned flags;
    char *filter;
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <filter> [full_path]\n", Cmd_Argv(0));
        return;
    }
 
    filter = Cmd_Argv(1);
 
    flags = FS_SEARCH_BYFILTER;
    if (Cmd_Argc() > 2) {
        flags |= FS_SEARCH_SAVEPATH;
    }
 
    print_file_list(NULL, filter, flags);
}

FS_File_g()

void FS_File_g	(	const char *	path,
		const char *	ext,
		unsigned	flags,
		genctx_t *	ctx
	)

Definition at line 2954 of file files.c.

{
    int i, numFiles;
    void **list;
    char *s;
 
    list = FS_ListFiles(path, ext, flags, &numFiles);
    if (!list) {
        return;
    }
 
    for (i = 0; i < numFiles; i++) {
        s = list[i];
        if (ctx->count < ctx->size && !strncmp(s, ctx->partial, ctx->length)) {
            ctx->matches[ctx->count++] = s;
        } else {
            Z_Free(s);
        }
    }
 
    Z_Free(list);
}

Referenced by CL_Demo_c(), CL_PlaySound_c(), Cmd_Config_g(), Con_Dump_c(), MVD_File_g(), SV_Map_c(), and SV_Savegame_c().

FS_FilterFile()

qerror_t FS_FilterFile

(

qhandle_t

f

)

Definition at line 661 of file files.c.

{
#if USE_ZLIB
    file_t *file = file_for_handle(f);
    unsigned mode;
    char *modeStr;
    void *zfp;
    uint32_t magic;
    size_t length;
    int fd;
 
    if (!file)
        return Q_ERR_BADF;
 
    switch (file->type) {
    case FS_GZ:
        return Q_ERR_SUCCESS;
    case FS_REAL:
        break;
    default:
        return Q_ERR_NOSYS;
    }
 
    mode = file->mode & FS_MODE_MASK;
    switch (mode) {
    case FS_MODE_READ:
        // should have at least 10 bytes of header and 8 bytes of trailer
        if (file->length < 18) {
            return Q_ERR_FILE_TOO_SMALL;
        }
 
        // seek to the header
        if (fseek(file->fp, 0, SEEK_SET) == -1) {
            return Q_Errno();
        }
 
        // read magic
        if (fread(&magic, 1, 4, file->fp) != 4) {
            return FS_ERR_READ(file->fp);
        }
 
        // check for gzip header
        if (!CHECK_GZIP_HEADER(magic)) {
            return Q_ERR_INVALID_FORMAT;
        }
 
        // seek to the trailer
        if (fseek(file->fp, file->length - 4, SEEK_SET) == -1) {
            return Q_Errno();
        }
 
        // read uncompressed length
        if (fread(&magic, 1, 4, file->fp) != 4) {
            return FS_ERR_READ(file->fp);
        }
 
        length = LittleLong(magic);
        modeStr = "rb";
        break;
 
    case FS_MODE_WRITE:
        length = 0;
        modeStr = "wb";
        break;
 
    default:
        return Q_ERR_NOSYS;
    }
 
    // rewind back to beginning
    if (fseek(file->fp, 0, SEEK_SET) == -1) {
        return Q_Errno();
    }
 
    fd = os_fileno(file->fp);
    if (fd == -1)
        return Q_Errno();
 
    zfp = gzdopen(fd, modeStr);
    if (!zfp) {
        return Q_ERR_FAILURE;
    }
 
    file->length = length;
    file->zfp = zfp;
    file->type = FS_GZ;
    return Q_ERR_SUCCESS;
#else
    return Q_ERR_NOSYS;
#endif
}

Referenced by demo_read_first(), easy_open_write(), and read_first_message().

FS_Flush()

void FS_Flush

(

qhandle_t

f

)

Definition at line 1617 of file files.c.

{
    file_t *file = file_for_handle(f);
 
    if (!file)
        return;
 
    switch (file->type) {
    case FS_REAL:
        fflush(file->fp);
        break;
#if USE_ZLIB
    case FS_GZ:
        gzflush(file->zfp, Z_SYNC_FLUSH);
        break;
#endif
    default:
        break;
    }
}

Referenced by Com_Error().

FS_FOpenFile()

ssize_t FS_FOpenFile	(	const char *	name,
		qhandle_t *	f,
		unsigned	mode
	)

Definition at line 1692 of file files.c.

{
    file_t *file;
    qhandle_t handle;
    ssize_t ret;
 
    if (!name || !f) {
        Com_Error(ERR_FATAL, "%s: NULL", __func__);
    }
 
    *f = 0;
 
    if (!fs_searchpaths) {
        return Q_ERR_AGAIN; // not yet initialized
    }
 
    // allocate new file handle
    file = alloc_handle(&handle);
    if (!file) {
        return Q_ERR_MFILE;
    }
 
    file->mode = mode;
 
    if ((mode & FS_MODE_MASK) == FS_MODE_READ) {
        ret = expand_open_file_read(file, name, qtrue);
    } else {
        ret = open_file_write(file, name);
    }
 
    if (ret >= 0) {
        *f = handle;
    }
 
    return ret;
}

Referenced by CL_GetDemoInfo(), CL_HandleDownload(), CL_WriteConfig(), create_screenshot(), demo_play_next(), easy_open_read(), easy_open_write(), FS_WriteFile(), get_image_dimensions(), Prompt_LoadHistory(), Prompt_SaveHistory(), read_binary_file(), SCR_PlayCinematic(), SCR_ScoreShot_f(), start_udp_download(), SV_BeginDownload_f(), and WriteCache().

FS_FPrintf()

ssize_t FS_FPrintf	(	qhandle_t	f,
		const char *	format,
			...
	)

Definition at line 2039 of file files.c.

{
    va_list argptr;
    char string[MAXPRINTMSG];
    size_t len;
 
    va_start(argptr, format);
    len = Q_vsnprintf(string, sizeof(string), format, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        return Q_ERR_STRING_TRUNCATED;
    }
 
    return FS_Write(string, len, f);
}

Referenced by CL_WriteConfig(), CL_WriteConfig_f(), Com_Error(), Con_Dump_f(), IMG_List_f(), Key_WriteBindings(), LOC_Write_f(), Prompt_SaveHistory(), WriteCache(), and writeMaterialsTable().

FS_FreeList()

void FS_FreeList

(

void **

list

)

Definition at line 2939 of file files.c.

{
    void **p;
 
    if (!list) {
        return;
    }
 
    for (p = list; *p; p++) {
        Z_Free(*p);
    }
 
    Z_Free(list);
}

Referenced by BSP_Test_f(), BuildList(), copy_save_dir(), PlayerModel_Load(), print_file_list(), and wipe_save_dir().

fs_game_changed()

static void fs_game_changed ( cvar_t *  self )

static

Definition at line 3650 of file files.c.

{
    char *s = self->string;
 
    // validate it
    if (*s) {
        if (!Q_stricmp(s, BASEGAME)) {
            Cvar_Reset(self);
        } else if (!COM_IsPath(s)) {
            Com_Printf("'%s' should contain characters [A-Za-z0-9_-] only.\n", self->name);
            Cvar_Reset(self);
        }
    }
 
    // check for the first time startup
    if (!fs_base_searchpaths) {
        // start up with baseq2 by default
        setup_base_paths();
 
        // check for game override
        setup_game_paths();
 
        FS_Path_f();
 
        // Detect if we're running full version of the game.
        // Shareware version can't have multiplayer enabled for legal reasons.
        if (FS_FileExists("maps/base1.bsp"))
            Cvar_Set("fs_shareware", "0");
        else
            Cvar_Set("fs_shareware", "1");
 
        if (!FS_FileExists("pics/colormap.pcx") || !FS_FileExists("pics/conchars.pcx") || !FS_FileExists("default.cfg"))
        {
            Com_Error(ERR_FATAL, "No game data files detected. Please make sure that there are .pak files"
                " in the game directory: %s.\nReinstalling the game can fix the issue.", fs_gamedir);
        }
 
        return;
    }
 
    // otherwise, restart the filesystem
    CL_RestartFilesystem(qfalse);
 
    // FIXME: if baseq2/autoexec.cfg exists DO NOT exec default.cfg and config.cfg.
    // this assumes user prefers to do configuration via autoexec.cfg and doesn't
    // want settings and binds messed up whenever gamedir changes after startup.
    if (!FS_FileExistsEx(COM_AUTOEXEC_CFG, FS_TYPE_REAL | FS_PATH_BASE)) {
        Com_AddConfigFile(COM_DEFAULT_CFG, FS_PATH_GAME);
        Com_AddConfigFile(COM_Q2RTX_CFG, 0);
        Com_AddConfigFile(COM_CONFIG_CFG, FS_TYPE_REAL | FS_PATH_GAME);
    }
 
    // exec autoexec.cfg (must be a real file within the game directory)
    Com_AddConfigFile(COM_AUTOEXEC_CFG, FS_TYPE_REAL | FS_PATH_GAME);
 
    // exec postexec.cfg (must be a real file)
    Com_AddConfigFile(COM_POSTEXEC_CFG, FS_TYPE_REAL);
}

Referenced by FS_Init().

FS_Init()

void FS_Init

(

void

)

Definition at line 3714 of file files.c.

{
    Com_Printf("------- FS_Init -------\n");
 
    List_Init(&fs_hard_links);
    List_Init(&fs_soft_links);
 
    Cmd_Register(c_fs);
 
#ifdef _DEBUG
    fs_debug = Cvar_Get("fs_debug", "0", 0);
#endif
 
    fs_shareware = Cvar_Get("fs_shareware", "0", CVAR_ROM);
 
    // get the game cvar and start the filesystem
    fs_game = Cvar_Get("game", DEFGAME, CVAR_LATCH | CVAR_SERVERINFO);
    fs_game->changed = fs_game_changed;
    fs_game_changed(fs_game);
 
    Com_Printf("-----------------------\n");
}

Referenced by Qcommon_Init().

FS_LastModified()

qerror_t FS_LastModified	(	char const *	file,
		uint64_t *	last_modified
	)

Definition at line 1310 of file files.c.

{
#ifndef NO_TEXTURE_RELOADS
    char          fullpath[MAX_OSPATH];
    searchpath_t  *search;
    int           valid;
    size_t        len;
 
    valid = PATH_NOT_CHECKED;
 
    for (search = fs_searchpaths; search; search = search->next) {
 
        // skip paks
        if (search->pack)
            continue;
 
        // don't error out immediately if the path is found to be invalid,
        // just stop looking for it in directory tree but continue to search
        // for it in packs, to give broken maps or mods a chance to work
        if (valid == PATH_NOT_CHECKED) {
            valid = FS_ValidatePath(file);
        }
        if (valid == PATH_INVALID) {
            continue;
        }
 
        // check a file in the directory tree
        len = Q_concat(fullpath, sizeof(fullpath), search->filename, "/", file, NULL);
        if (len >= sizeof(fullpath)) {
            return Q_ERR_NAMETOOLONG;
        }
 
        struct stat lstat;
        if (stat(fullpath, &lstat) == 0) {
            if (last_modified)
                *last_modified = lstat.st_mtime;
            return Q_ERR_SUCCESS;
        }
    }
#else
    if (last_modified)
        *last_modified = 0;
#endif
    return Q_ERR_INVALID_PATH;
}

Referenced by _try_image_format(), find_or_load_image(), and IMG_ReloadAll().

FS_Length()

ssize_t FS_Length

(

qhandle_t

f

)

Definition at line 487 of file files.c.

{
    file_t *file = file_for_handle(f);
 
    if (!file)
        return Q_ERR_BADF;
 
    if ((file->mode & FS_MODE_MASK) == FS_MODE_READ)
        return file->length;
 
    return Q_ERR_NOSYS;
}

Referenced by CL_FirstDemoFrame(), and demo_play_next().

FS_Link_c()

static void FS_Link_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 3332 of file files.c.

{
    if (argnum == 1) {
        FS_Link_g(ctx);
    }
}

FS_Link_f()

static void FS_Link_f ( void  )

static

Definition at line 3403 of file files.c.

{
    int argc, count;
    list_t *list;
    symlink_t *link;
    size_t namelen, targlen;
    char name[MAX_OSPATH];
    char target[MAX_OSPATH];
 
    if (!strncmp(Cmd_Argv(0), "soft", 4))
        list = &fs_soft_links;
    else
        list = &fs_hard_links;
 
    argc = Cmd_Argc();
    if (argc == 1) {
        count = 0;
        FOR_EACH_SYMLINK(link, list) {
            Com_Printf("%s --> %s\n", link->name, link->target);
            count++;
        }
        Com_Printf("------------------\n"
                   "%d symbolic link%s listed.\n", count, count == 1 ? "" : "s");
        return;
    }
 
    if (argc != 3) {
        Com_Printf("Usage: %s <name> <target>\n"
                   "Creates symbolic link to target with the specified name.\n"
                   "Virtual quake paths are accepted.\n"
                   "Links are effective only for reading.\n",
                   Cmd_Argv(0));
        return;
    }
 
    namelen = FS_NormalizePathBuffer(name, Cmd_Argv(1), sizeof(name));
    if (namelen == 0 || namelen >= sizeof(name)) {
        Com_Printf("Invalid symbolic link name.\n");
        return;
    }
 
    targlen = FS_NormalizePathBuffer(target, Cmd_Argv(2), sizeof(target));
    if (targlen == 0 || targlen >= sizeof(target)) {
        Com_Printf("Invalid symbolic link target.\n");
        return;
    }
 
    // search for existing link with this name
    FOR_EACH_SYMLINK(link, list) {
        if (!FS_pathcmp(link->name, name)) {
            Z_Free(link->target);
            goto update;
        }
    }
 
    // create new link
    link = FS_Malloc(sizeof(*link) + namelen);
    memcpy(link->name, name, namelen + 1);
    link->namelen = namelen;
    List_Append(list, &link->entry);
 
update:
    link->target = FS_CopyString(target);
    link->targlen = targlen;
}

FS_Link_g()

static void FS_Link_g ( genctx_t *  ctx )

static

Definition at line 3315 of file files.c.

{
    list_t *list;
    symlink_t *link;
 
    if (!strncmp(Cmd_Argv(ctx->argnum - 1), "soft", 4))
        list = &fs_soft_links;
    else
        list = &fs_hard_links;
 
    FOR_EACH_SYMLINK(link, list) {
        if (!Prompt_AddMatch(ctx, link->name)) {
            break;
        }
    }
}

Referenced by FS_Link_c().

FS_ListFiles()

void** FS_ListFiles	(	const char *	path,
		const char *	filter,
		unsigned	flags,
		int *	count_p
	)

Definition at line 2716 of file files.c.

{
    searchpath_t    *search;
    packfile_t      *file;
    void            *files[MAX_LISTED_FILES], *info;
    int             i, j, count, total;
    char            normalized[MAX_OSPATH], buffer[MAX_OSPATH];
    void            **list;
    size_t          len, pathlen;
    char            *s, *p;
    int             valid;
 
    count = 0;
    valid = PATH_NOT_CHECKED;
 
    if (!path) {
        path = "";
        pathlen = 0;
    } else {
        // normalize the path
        pathlen = FS_NormalizePathBuffer(normalized, path, sizeof(normalized));
        if (pathlen >= sizeof(normalized)) {
            goto fail;
        }
 
        path = normalized;
    }
 
    // can't mix directory search with other flags
    if ((flags & FS_SEARCH_DIRSONLY) && (flags & FS_SEARCH_MASK & ~FS_SEARCH_DIRSONLY)) {
        goto fail;
    }
 
    for (search = fs_searchpaths; search; search = search->next) {
        if (flags & FS_PATH_MASK) {
            if ((flags & search->mode & FS_PATH_MASK) == 0) {
                continue;
            }
        }
        if (search->pack) {
            if ((flags & FS_TYPE_MASK) == FS_TYPE_REAL) {
                continue; // don't search in paks
            }
 
            for (i = 0; i < search->pack->num_files; i++) {
                file = &search->pack->files[i];
                s = file->name;
 
                // check path
                if (pathlen) {
                    if (file->namelen < pathlen) {
                        continue;
                    }
                    if (FS_pathcmpn(s, path, pathlen)) {
                        continue;
                    }
                    if (s[pathlen] != '/') {
                        continue;   // matched prefix must be a directory
                    }
                    if (flags & FS_SEARCH_BYFILTER) {
                        s += pathlen + 1;
                    }
                } else if (path == normalized) {
                    if (!(flags & FS_SEARCH_DIRSONLY) && strchr(s, '/')) {
                        continue;   // must be a file in the root directory
                    }
                }
 
                // check filter
                if (filter) {
                    if (flags & FS_SEARCH_BYFILTER) {
                        if (!FS_WildCmp(filter, s)) {
                            continue;
                        }
                    } else {
                        if (!FS_ExtCmp(filter, s)) {
                            continue;
                        }
                    }
                }
 
                // copy name off
                if (flags & (FS_SEARCH_DIRSONLY | FS_SEARCH_STRIPEXT)) {
                    s = strcpy(buffer, s);
                }
 
                // hacky directory search support for pak files
                if (flags & FS_SEARCH_DIRSONLY) {
                    p = s;
                    if (pathlen) {
                        p += pathlen + 1;
                    }
                    p = strchr(p, '/');
                    if (!p) {
                        continue;   // does not have directory component
                    }
                    *p = 0;
                    for (j = 0; j < count; j++) {
                        if (!FS_pathcmp(files[j], s)) {
                            break;
                        }
                    }
                    if (j != count) {
                        continue;   // already listed this directory
                    }
                }
 
                // strip path
                if (!(flags & FS_SEARCH_SAVEPATH)) {
                    s = COM_SkipPath(s);
                }
 
                // strip extension
                if (flags & FS_SEARCH_STRIPEXT) {
                    *COM_FileExtension(s) = 0;
                }
 
                if (!*s) {
                    continue;
                }
 
                // copy info off
                if (flags & FS_SEARCH_EXTRAINFO) {
                    info = FS_CopyInfo(s, file->filelen, 0, 0);
                } else {
                    info = FS_CopyString(s);
                }
 
                files[count++] = info;
 
                if (count >= MAX_LISTED_FILES) {
                    break;
                }
            }
        } else {
            if ((flags & FS_TYPE_MASK) == FS_TYPE_PAK) {
                continue; // don't search in filesystem
            }
 
            len = strlen(search->filename);
 
            if (pathlen) {
                if (len + pathlen + 1 >= MAX_OSPATH) {
                    continue;
                }
                if (valid == PATH_NOT_CHECKED) {
                    valid = FS_ValidatePath(path);
                }
                if (valid == PATH_INVALID) {
                    continue;
                }
                s = memcpy(buffer, search->filename, len);
                s[len++] = '/';
                memcpy(s + len, path, pathlen + 1);
            } else {
                s = search->filename;
            }
 
            if (flags & FS_SEARCH_BYFILTER) {
                len += pathlen + 1;
            }
 
            Sys_ListFiles_r(s, filter, flags, len, &count, files, 0);
        }
 
        if (count >= MAX_LISTED_FILES) {
            break;
        }
    }
 
    if (!count) {
fail:
        if (count_p) {
            *count_p = 0;
        }
        return NULL;
    }
 
    if (flags & FS_SEARCH_EXTRAINFO) {
        // TODO
        qsort(files, count, sizeof(files[0]), infocmp);
        total = count;
    } else {
        // sort alphabetically
        qsort(files, count, sizeof(files[0]), alphacmp);
 
        // remove duplicates
        total = 1;
        for (i = 1; i < count; i++) {
            if (!FS_pathcmp(files[i - 1], files[i])) {
                Z_Free(files[i - 1]);
                files[i - 1] = NULL;
            } else {
                total++;
            }
        }
    }
 
    list = FS_Malloc(sizeof(void *) * (total + 1));
 
    total = 0;
    for (i = 0; i < count; i++) {
        if (files[i]) {
            list[total++] = files[i];
        }
    }
    list[total] = NULL;
 
    if (count_p) {
        *count_p = total;
    }
 
    return list;
}

Referenced by BSP_Test_f(), BuildList(), Com_MapList_m(), FS_File_g(), list_save_dir(), PlayerModel_Load(), and print_file_list().

FS_LoadFileEx()

ssize_t FS_LoadFileEx	(	const char *	path,
		void **	buffer,
		unsigned	flags,
		memtag_t	tag
	)

Definition at line 1864 of file files.c.

{
    file_t *file;
    qhandle_t f;
    byte *buf;
    ssize_t len, read;
 
    if (!path) {
        Com_Error(ERR_FATAL, "%s: NULL", __func__);
    }
 
    if (buffer) {
        *buffer = NULL;
    }
 
    if (!fs_searchpaths) {
        return Q_ERR_AGAIN; // not yet initialized
    }
 
    // allocate new file handle
    file = alloc_handle(&f);
    if (!file) {
        return Q_ERR_MFILE;
    }
 
    file->mode = (flags & ~FS_MODE_MASK) | FS_MODE_READ;
 
    // look for it in the filesystem or pack files
    len = expand_open_file_read(file, path, qfalse);
    if (len < 0) {
        return len;
    }
 
    // NULL buffer just checks for file existence
    if (!buffer) {
        goto done;
    }
 
    // sanity check file size
    if (len > MAX_LOADFILE) {
        len = Q_ERR_FBIG;
        goto done;
    }
 
    // allocate chunk of memory, +1 for NUL
    buf = Z_TagMalloc(len + 1, tag);
 
    // read entire file
    read = FS_Read(buf, len, f);
    if (read != len) {
        len = read < 0 ? read : Q_ERR_UNEXPECTED_EOF;
        Z_Free(buf);
        goto done;
    }
 
    *buffer = buf;
    buf[len] = 0;
 
done:
    FS_FCloseFile(f);
    return len;
}

Referenced by Cmd_ExecuteFile(), and LoadCache().

FS_NormalizePath()

size_t FS_NormalizePath	(	char *	out,
		const char *	in
	)

Definition at line 331 of file files.c.

{
    char *start = out;
    uint32_t pre = '/';
 
    while (1) {
        int c = *in++;
 
        if (c == '/' || c == '\\' || c == 0) {
            if ((pre & 0xffffff) == (('/' << 16) | ('.' << 8) | '.')) {
                out -= 4;
                if (out < start) {
                    // can't go past root
                    out = start;
                    if (c == 0)
                        break;
                } else {
                    while (out > start && *out != '/')
                        out--;
                    if (c == 0)
                        break;
                    if (out > start)
                        // save the slash
                        out++;
                }
                pre = '/';
                continue;
            }
 
            if ((pre & 0xffff) == (('/' << 8) | '.')) {
                // eat the dot
                out--;
                if (c == 0) {
                    if (out > start)
                        // eat the slash
                        out--;
                    break;
                }
                pre = '/';
                continue;
            }
 
            if ((pre & 0xff) == '/') {
                if (c == 0)
                    break;
                continue;
            }
 
            if (c == 0)
                break;
            c = '/';
        }
 
        pre = (pre << 8) | c;
        *out++ = c;
    }
 
    *out = 0;
    return out - start;
}

Referenced by bsp_mesh_register_textures(), check_and_queue_download(), check_file_len(), Com_TestNorm_f(), easy_open_read(), FS_NormalizePathBuffer(), GL_LoadWorld(), MOD_LoadMD2(), MOD_LoadMD2_GL(), MOD_LoadMD2_RTX(), MOD_LoadSP2(), pack_hash_file(), ProcessTexinfo(), R_RegisterImage(), R_SetSky(), R_SetSky_GL(), R_SetSky_RTX(), S_RegisterSexedSound(), S_RegisterSound(), SV_BeginDownload_f(), and vkpt_textures_prefetch().

FS_NormalizePathBuffer()

size_t FS_NormalizePathBuffer	(	char *	out,
		const char *	in,
		size_t	size
	)

Definition at line 400 of file files.c.

{
    size_t len = strlen(in);
 
    if (len >= size) {
        if (size)
            *out = 0;
        return len;
    }
 
    return FS_NormalizePath(out, in);
}

Referenced by Cmd_Exec_f(), easy_open_write(), expand_open_file_read(), FS_Link_f(), FS_ListFiles(), FS_WhereIs_f(), open_file_write(), R_RegisterImage(), R_RegisterModel(), and S_RegisterSound().

FS_Path_f()

static void FS_Path_f ( void  )

static

Definition at line 3223 of file files.c.

{
    searchpath_t *s;
    int numFilesInPAK = 0;
#if USE_ZLIB
    int numFilesInZIP = 0;
#endif
    Com_Printf("Current search path:\n");
    for (s = fs_searchpaths; s; s = s->next) {
        if (s->pack) {
#if USE_ZLIB
            if (s->pack->type == FS_ZIP)
                numFilesInZIP += s->pack->num_files;
            else
#endif
                numFilesInPAK += s->pack->num_files;
            Com_Printf("%s (%i files)\n", s->pack->filename, s->pack->num_files);
        } else {
            Com_Printf("%s\n", s->filename);
        }
    }
 
    if (numFilesInPAK) {
        Com_Printf("%i files in PAK files\n", numFilesInPAK);
    }
 
#if USE_ZLIB
    if (numFilesInZIP) {
        Com_Printf("%i files in PKZ files\n", numFilesInZIP);
    }
#endif
}

Referenced by fs_game_changed(), and FS_Restart().

FS_Read()

ssize_t FS_Read	(	void *	buf,
		size_t	len,
		qhandle_t	f
	)

Definition at line 1547 of file files.c.

{
    file_t *file = file_for_handle(f);
#if USE_ZLIB
    int ret;
#endif
 
    if (!file)
        return Q_ERR_BADF;
 
    if ((file->mode & FS_MODE_MASK) != FS_MODE_READ)
        return Q_ERR_INVAL;
 
    // can't continue after error
    if (file->error)
        return file->error;
 
    if (len > SSIZE_MAX)
        return Q_ERR_INVAL;
 
    if (len == 0)
        return 0;
 
    switch (file->type) {
    case FS_REAL:
        return read_phys_file(file, buf, len);
    case FS_PAK:
        return read_pak_file(file, buf, len);
#if USE_ZLIB
    case FS_GZ:
        ret = gzread(file->zfp, buf, len);
        if (ret < 0) {
            return Q_ERR_LIBRARY_ERROR;
        }
        return ret;
    case FS_ZIP:
        return read_zip_file(file, buf, len);
#endif
    default:
        return Q_ERR_NOSYS;
    }
}

Referenced by demo_load_message(), demo_read_first(), FS_LoadFileEx(), get_image_dimensions(), Huff1TableInit(), read_binary_file(), read_first_message(), read_next_message(), SCR_PlayCinematic(), SCR_ReadNextFrame(), and SV_BeginDownload_f().

FS_ReadLine()

ssize_t FS_ReadLine	(	qhandle_t	f,
		char *	buffer,
		size_t	size
	)

Definition at line 1590 of file files.c.

{
    file_t *file = file_for_handle(f);
    char *s;
    size_t len;
 
    if (!file)
        return Q_ERR_BADF;
 
    if ((file->mode & FS_MODE_MASK) != FS_MODE_READ)
        return Q_ERR_INVAL;
 
    if (file->type != FS_REAL)
        return Q_ERR_NOSYS;
 
    do {
        s = fgets(buffer, size, file->fp);
        if (!s) {
            return ferror(file->fp) ? Q_Errno() : 0;
        }
        len = strlen(s);
    } while (len < 2);
 
    s[len - 1] = 0;
    return len - 1;
}

Referenced by Prompt_LoadHistory().

FS_ReplaceSeparators()

char* FS_ReplaceSeparators	(	char *	s,
		int	separator
	)

Definition at line 235 of file files.c.

{
    char *p;
 
    p = s;
    while (*p) {
        if (*p == '/' || *p == '\\') {
            *p = separator;
        }
        p++;
    }
 
    return s;
}

Referenced by FS_Restart(), q_printf(), and Sys_ListFiles_r().

FS_Restart()

void FS_Restart

(

qboolean

total

)

Definition at line 3556 of file files.c.

{
    Com_Printf("----- FS_Restart -----\n");
 
    if (total) {
        // perform full reset
        free_all_paths();
        setup_base_paths();
    } else {
        // just change gamedir
        free_game_paths();
        Q_snprintf(fs_gamedir, sizeof(fs_gamedir), "%s/"BASEGAME, sys_basedir->string);
#ifdef _WIN32
        FS_ReplaceSeparators(fs_gamedir, '/');
#endif
    }
 
    setup_game_paths();
 
    FS_Path_f();
 
    Com_Printf("----------------------\n");
}

Referenced by CL_RestartFilesystem().

FS_Restart_f()

static void FS_Restart_f ( void  )

static

Definition at line 3587 of file files.c.

{
    CL_RestartFilesystem(qtrue);
}

FS_SanitizeFilenameVariable()

void FS_SanitizeFilenameVariable

(

cvar_t *

var

)

Definition at line 294 of file files.c.

{
    if (!FS_ValidatePath(var->string)) {
        Com_Printf("'%s' contains invalid characters for a filename.\n", var->name);
        goto reset;
    }
 
    if (strchr(var->string, '/') || strchr(var->string, '\\')) {
        Com_Printf("'%s' should be a single filename, not a path.\n", var->name);
        goto reset;
    }
 
    return;
 
reset:
    Com_Printf("...falling back to %s\n", var->default_string);
    Cvar_Reset(var);
}

Referenced by QAL_Init(), and VID_Init().

FS_Seek()

qerror_t FS_Seek	(	qhandle_t	f,
		off_t	offset
	)

Definition at line 564 of file files.c.

{
    file_t *file = file_for_handle(f);
 
    if (!file)
        return Q_ERR_BADF;
 
    if (offset > LONG_MAX)
        return Q_ERR_INVAL;
 
    if (offset < 0)
        offset = 0;
 
    switch (file->type) {
    case FS_REAL:
        if (fseek(file->fp, (long)offset, SEEK_SET) == -1) {
            return Q_Errno();
        }
        return Q_ERR_SUCCESS;
    case FS_PAK:
        return seek_pak_file(file, offset);
#if USE_ZLIB
    case FS_GZ:
        if (gzseek(file->zfp, (z_off_t)offset, SEEK_SET) == -1) {
            return Q_Errno();
        }
        return Q_ERR_SUCCESS;
#endif
    default:
        return Q_ERR_NOSYS;
    }
}

Referenced by CL_Seek_f(), and MVD_Seek_f().

FS_Shutdown()

void FS_Shutdown

(

void

)

Definition at line 3614 of file files.c.

{
    file_t *file;
    int i;
 
    if (!fs_searchpaths) {
        return;
    }
 
    // close file handles
    for (i = 0, file = fs_files; i < MAX_FILE_HANDLES; i++, file++) {
        if (file->type != FS_FREE) {
            Com_WPrintf("%s: closing handle %d\n", __func__, i + 1);
            FS_FCloseFile(i + 1);
        }
    }
 
    // free symbolic links
    free_all_links(&fs_hard_links);
    free_all_links(&fs_soft_links);
 
    // free search paths
    free_all_paths();
 
#if USE_ZLIB
    inflateEnd(&fs_zipstream.stream);
#endif
 
    Z_LeakTest(TAG_FILESYSTEM);
 
    Cmd_Deregister(c_fs);
}

Referenced by Com_Error(), and Com_Quit().

FS_Tell()

ssize_t FS_Tell

(

qhandle_t

f

)

Definition at line 505 of file files.c.

{
    file_t *file = file_for_handle(f);
    long ret;
 
    if (!file)
        return Q_ERR_BADF;
 
    switch (file->type) {
    case FS_REAL:
        ret = ftell(file->fp);
        if (ret == -1) {
            return Q_Errno();
        }
        return ret;
    case FS_PAK:
        return file->length - file->rest_out;
#if USE_ZLIB
    case FS_ZIP:
        return tell_zip_file(file);
    case FS_GZ:
        ret = gztell(file->zfp);
        if (ret == -1) {
            return Q_ERR_LIBRARY_ERROR;
        }
        return ret;
#endif
    default:
        return Q_ERR_NOSYS;
    }
}

Referenced by CL_EmitDemoSnapshot(), CL_FirstDemoFrame(), demo_emit_snapshot(), demo_play_next(), demo_update(), format_demo_size(), list_recordings(), rec_frame(), and update_status().

FS_UnLink_f()

static void FS_UnLink_f ( void  )

static

Definition at line 3351 of file files.c.

{
    static const cmd_option_t options[] = {
        { "a", "all", "delete all links" },
        { "h", "help", "display this message" },
        { NULL }
    };
    list_t *list;
    symlink_t *link;
    char *name;
    int c;
 
    if (!strncmp(Cmd_Argv(0), "soft", 4))
        list = &fs_soft_links;
    else
        list = &fs_hard_links;
 
    while ((c = Cmd_ParseOptions(options)) != -1) {
        switch (c) {
        case 'h':
            Cmd_PrintUsage(options, "<name>");
            Com_Printf("Deletes a symbolic link with the specified name.");
            Cmd_PrintHelp(options);
            return;
        case 'a':
            free_all_links(list);
            Com_Printf("Deleted all symbolic links.\n");
            return;
        default:
            return;
        }
    }
 
    name = cmd_optarg;
    if (!name[0]) {
        Com_Printf("Missing name argument.\n");
        Cmd_PrintHint();
        return;
    }
 
    FOR_EACH_SYMLINK(link, list) {
        if (!FS_pathcmp(link->name, name)) {
            List_Remove(&link->entry);
            Z_Free(link->target);
            Z_Free(link);
            return;
        }
    }
 
    Com_Printf("Symbolic link '%s' does not exist.\n", name);
}

FS_ValidatePath()

int FS_ValidatePath

(

const char *

s

)

Definition at line 271 of file files.c.

{
    int res = PATH_VALID;
 
    for (; *s; s++) {
        if (!validate_char(*s))
            return PATH_INVALID;
 
        if (Q_isupper(*s))
            res = PATH_MIXED_CASE;
    }
 
    return res;
}

Referenced by check_and_queue_download(), check_file_len(), FS_LastModified(), FS_ListFiles(), FS_SanitizeFilenameVariable(), FS_WhereIs_f(), open_file_read(), and open_file_write().

FS_WhereIs_f()

static void FS_WhereIs_f ( void  )

static

Definition at line 3055 of file files.c.

{
    char            normalized[MAX_OSPATH], fullpath[MAX_OSPATH];
    searchpath_t    *search;
    pack_t          *pak;
    packfile_t      *entry;
    symlink_t       *link;
    unsigned        hash;
    file_info_t     info;
    qerror_t        ret;
    int             total, valid;
    size_t          len, namelen;
    qboolean        report_all;
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <path> [all]\n", Cmd_Argv(0));
        return;
    }
 
// normalize path
    namelen = FS_NormalizePathBuffer(normalized, Cmd_Argv(1), MAX_OSPATH);
    if (namelen >= MAX_OSPATH) {
        Com_Printf("Refusing to lookup oversize path.\n");
        return;
    }
 
// expand hard symlinks
    link = expand_links(&fs_hard_links, normalized, &namelen);
    if (link) {
        if (namelen >= MAX_OSPATH) {
            Com_Printf("Oversize symbolic link ('%s --> '%s').\n",
                       link->name, link->target);
            return;
        }
 
        Com_Printf("Symbolic link ('%s' --> '%s') in effect.\n",
                   link->name, link->target);
    }
 
    report_all = Cmd_Argc() >= 3;
    total = 0;
    link = NULL;
 
// reject empty paths
    if (namelen == 0) {
        Com_Printf("Refusing to lookup empty path.\n");
        return;
    }
 
recheck:
 
// warn about non-standard path length
    if (namelen >= MAX_QPATH) {
        Com_Printf("Not searching for '%s' in pack files "
                   "since path length exceedes %d characters.\n",
                   normalized, MAX_QPATH - 1);
    }
 
    hash = FS_HashPath(normalized, 0);
 
    valid = PATH_NOT_CHECKED;
 
// 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) {
            // don't bother searching in paks if length exceedes MAX_QPATH
            if (namelen >= MAX_QPATH) {
                continue;
            }
            // look through all the pak file elements
            pak = search->pack;
            entry = pak->file_hash[hash & (pak->hash_size - 1)];
            for (; entry; entry = entry->hash_next) {
                if (entry->namelen != namelen) {
                    continue;
                }
                if (!FS_pathcmp(entry->name, normalized)) {
                    // found it!
                    Com_Printf("%s/%s (%"PRIz" bytes)\n", pak->filename,
                               normalized, entry->filelen);
                    if (!report_all) {
                        return;
                    }
                    total++;
                }
            }
        } else {
            if (valid == PATH_NOT_CHECKED) {
                valid = FS_ValidatePath(normalized);
                if (valid == PATH_INVALID) {
                    // warn about invalid path
                    Com_Printf("Not searching for '%s' in physical file "
                               "system since path contains invalid characters.\n",
                               normalized);
                }
            }
            if (valid == PATH_INVALID) {
                continue;
            }
 
            // check a file in the directory tree
            len = Q_concat(fullpath, MAX_OSPATH,
                           search->filename, "/", normalized, NULL);
            if (len >= MAX_OSPATH) {
                Com_WPrintf("Full path length '%s/%s' exceeded %d characters.\n",
                            search->filename, normalized, MAX_OSPATH - 1);
                if (!report_all) {
                    return;
                }
                continue;
            }
 
            ret = get_path_info(fullpath, &info);
 
#ifndef _WIN32
            if (ret == Q_ERR_NOENT && valid == PATH_MIXED_CASE) {
                Q_strlwr(fullpath + strlen(search->filename) + 1);
                ret = get_path_info(fullpath, &info);
                if (ret == Q_ERR_SUCCESS)
                    Com_Printf("Physical path found after converting to lower case.\n");
            }
#endif
 
            if (ret == Q_ERR_SUCCESS) {
                Com_Printf("%s (%"PRIz" bytes)\n", fullpath, info.size);
                if (!report_all) {
                    return;
                }
                total++;
            } else if (ret != Q_ERR_NOENT) {
                Com_EPrintf("Couldn't get info on '%s': %s\n",
                            fullpath, Q_ErrorString(ret));
                if (!report_all) {
                    return;
                }
            }
        }
    }
 
    if ((total == 0 || report_all) && link == NULL) {
        // expand soft symlinks
        link = expand_links(&fs_soft_links, normalized, &namelen);
        if (link) {
            if (namelen >= MAX_OSPATH) {
                Com_Printf("Oversize symbolic link ('%s --> '%s').\n",
                           link->name, link->target);
                return;
            }
 
            Com_Printf("Symbolic link ('%s' --> '%s') in effect.\n",
                       link->name, link->target);
            goto recheck;
        }
    }
 
    if (total) {
        Com_Printf("%d instances of %s\n", total, normalized);
    } else {
        Com_Printf("%s was not found\n", normalized);
    }
}

FS_WildCmp()

qboolean FS_WildCmp	(	const char *	filter,
		const char *	string
	)

Definition at line 2636 of file files.c.

{
    do {
        if (Com_WildCmpEx(filter, string, ';', qtrue)) {
            return qtrue;
        }
        filter = strchr(filter, ';');
        if (filter) filter++;
    } while (filter);
 
    return qfalse;
}

Referenced by FS_ListFiles(), and Sys_ListFiles_r().

FS_Write()

ssize_t FS_Write	(	const void *	buf,
		size_t	len,
		qhandle_t	f
	)

Definition at line 1643 of file files.c.

{
    file_t  *file = file_for_handle(f);
    size_t  result;
 
    if (!file)
        return Q_ERR_BADF;
 
    if ((file->mode & FS_MODE_MASK) == FS_MODE_READ)
        return Q_ERR_INVAL;
 
    // can't continue after error
    if (file->error)
        return file->error;
 
    if (len > SSIZE_MAX)
        return Q_ERR_INVAL;
 
    if (len == 0)
        return 0;
 
    switch (file->type) {
    case FS_REAL:
        result = fwrite(buf, 1, len, file->fp);
        if (result != len) {
            file->error = FS_ERR_WRITE(file->fp);
            return file->error;
        }
        break;
#if USE_ZLIB
    case FS_GZ:
        if (gzwrite(file->zfp, buf, len) == 0) {
            file->error = Q_ERR_LIBRARY_ERROR;
            return file->error;
        }
        break;
#endif
    default:
        Com_Error(ERR_FATAL, "%s: bad file type", __func__);
    }
 
    return len;
}

Referenced by CL_Stop_f(), CL_WriteDemoMessage(), FS_EasyWriteFile(), FS_FPrintf(), FS_WriteFile(), logfile_write(), MVD_StopRecord(), MVD_StreamedRecord_f(), MVD_WriteDemoMessage(), rec_frame(), rec_start(), rec_stop(), rec_write(), SCR_ScoreShot_f(), stbi_write(), and write_udp_download().

FS_WriteFile()

qerror_t FS_WriteFile	(	const char *	path,
		const void *	data,
		size_t	len
	)

Definition at line 1932 of file files.c.

{
    qhandle_t f;
    ssize_t write;
    qerror_t ret;
 
    // TODO: write to temp file perhaps?
    write = FS_FOpenFile(path, &f, FS_MODE_WRITE);
    if (!f) {
        return write;
    }
 
    write = FS_Write(data, len, f);
    ret = write == len ? Q_ERR_SUCCESS : write < 0 ? write : Q_ERR_FAILURE;
 
    FS_FCloseFile(f);
    return ret;
}

Referenced by BSP_SavePatchedPVS(), write_level_file(), and write_server_file().

get_fp_info()

static qerror_t get_fp_info ( FILE *  fp, file_info_t *  info  )

static

Definition at line 817 of file files.c.

{
    Q_STATBUF st;
    int fd;
 
    fd = os_fileno(fp);
    if (fd == -1)
        return Q_Errno();
 
    if (os_fstat(fd, &st) == -1)
        return Q_Errno();
 
    if (Q_ISDIR(st.st_mode))
        return Q_ERR_ISDIR;
 
    if (!Q_ISREG(st.st_mode))
        return Q_ERR_FILE_NOT_REGULAR;
 
    if (info) {
        info->size = st.st_size;
        info->ctime = st.st_ctime;
        info->mtime = st.st_mtime;
    }
 
    return Q_ERR_SUCCESS;
}

Referenced by open_file_write(), and open_from_disk().

get_path_info()

static qerror_t get_path_info ( const char *  path, file_info_t *  info  )

static

Definition at line 795 of file files.c.

{
    Q_STATBUF st;
 
    if (os_stat(path, &st) == -1)
        return Q_Errno();
 
    if (Q_ISDIR(st.st_mode))
        return Q_ERR_ISDIR;
 
    if (!Q_ISREG(st.st_mode))
        return Q_ERR_FILE_NOT_REGULAR;
 
    if (info) {
        info->size = st.st_size;
        info->ctime = st.st_ctime;
        info->mtime = st.st_mtime;
    }
 
    return Q_ERR_SUCCESS;
}

Referenced by FS_WhereIs_f().

infocmp()

static int infocmp ( const void *  p1, const void *  p2  )

static

Definition at line 2695 of file files.c.

{
    file_info_t *n1 = *(file_info_t **)p1;
    file_info_t *n2 = *(file_info_t **)p2;
 
    return FS_pathcmp(n1->name, n2->name);
}

Referenced by FS_ListFiles().

load_pak_file()

static pack_t* load_pak_file ( const char *  packfile )

static

Definition at line 2123 of file files.c.

{
    dpackheader_t   header;
    packfile_t      *file;
    dpackfile_t     *dfile;
    unsigned        i, num_files;
    char            *name;
    size_t          len, names_len;
    pack_t          *pack;
    FILE            *fp;
    dpackfile_t     info[MAX_FILES_IN_PACK];
 
    fp = fopen(packfile, "rb");
    if (!fp) {
        Com_Printf("Couldn't open %s: %s\n", packfile, strerror(errno));
        return NULL;
    }
 
    if (fread(&header, 1, sizeof(header), fp) != sizeof(header)) {
        Com_Printf("Reading header failed on %s\n", packfile);
        goto fail;
    }
 
    if (LittleLong(header.ident) != IDPAKHEADER) {
        Com_Printf("%s is not a 'PACK' file\n", packfile);
        goto fail;
    }
 
    header.dirlen = LittleLong(header.dirlen);
    if (header.dirlen > INT_MAX || header.dirlen % sizeof(dpackfile_t)) {
        Com_Printf("%s has bad directory length\n", packfile);
        goto fail;
    }
 
    num_files = header.dirlen / sizeof(dpackfile_t);
    if (num_files < 1) {
        Com_Printf("%s has no files\n", packfile);
        goto fail;
    }
    if (num_files > MAX_FILES_IN_PACK) {
        Com_Printf("%s has too many files: %u > %u\n", packfile, num_files, MAX_FILES_IN_PACK);
        goto fail;
    }
 
    header.dirofs = LittleLong(header.dirofs);
    if (header.dirofs > LONG_MAX - header.dirlen) {
        Com_Printf("%s has bad directory offset\n", packfile);
        goto fail;
    }
    if (fseek(fp, (long)header.dirofs, SEEK_SET)) {
        Com_Printf("Seeking to directory failed on %s\n", packfile);
        goto fail;
    }
    if (fread(info, 1, header.dirlen, fp) != header.dirlen) {
        Com_Printf("Reading directory failed on %s\n", packfile);
        goto fail;
    }
 
    names_len = 0;
    for (i = 0, dfile = info; i < num_files; i++, dfile++) {
        dfile->filepos = LittleLong(dfile->filepos);
        dfile->filelen = LittleLong(dfile->filelen);
        if (dfile->filelen > INT_MAX || dfile->filepos > INT_MAX - dfile->filelen) {
            Com_Printf("%s has bad directory structure\n", packfile);
            goto fail;
        }
        dfile->name[sizeof(dfile->name) - 1] = 0;
        names_len += strlen(dfile->name) + 1;
    }
 
// allocate the pack
    pack = pack_alloc(fp, FS_PAK, packfile, num_files, names_len);
 
// parse the directory
    file = pack->files;
    name = pack->names;
    for (i = 0, dfile = info; i < num_files; i++, dfile++) {
        len = strlen(dfile->name) + 1;
 
        file->name = memcpy(name, dfile->name, len);
        name += len;
 
        file->filepos = dfile->filepos;
        file->filelen = dfile->filelen;
#if USE_ZLIB
        file->coherent = qtrue;
#endif
 
        pack_hash_file(pack, file);
        file++;
    }
 
    FS_DPrintf("%s: %u files, %u hash\n",
               packfile, pack->num_files, pack->hash_size);
 
    return pack;
 
fail:
    fclose(fp);
    return NULL;
}

Referenced by q_printf().

open_file_read()

static ssize_t open_file_read ( file_t *  file, const char *  normalized, size_t  namelen, qboolean  unique  )

static

Definition at line 1359 of file files.c.

{
    char            fullpath[MAX_OSPATH];
    searchpath_t    *search;
    pack_t          *pak;
    unsigned        hash;
    packfile_t      *entry;
    ssize_t         ret;
    int             valid;
    size_t          len;
 
    FS_COUNT_READ;
 
    hash = FS_HashPath(normalized, 0);
 
    valid = PATH_NOT_CHECKED;
 
// search through the path, one element at a time
    for (search = fs_searchpaths; search; search = search->next) {
        if (file->mode & FS_PATH_MASK) {
            if ((file->mode & search->mode & FS_PATH_MASK) == 0) {
                continue;
            }
        }
 
        // is the element a pak file?
        if (search->pack) {
            if ((file->mode & FS_TYPE_MASK) == FS_TYPE_REAL) {
                continue;
            }
            // don't bother searching in paks if length exceedes MAX_QPATH
            if (namelen >= MAX_QPATH) {
                continue;
            }
            pak = search->pack;
#if USE_ZLIB
            if ((file->mode & FS_FLAG_DEFLATE) && pak->type != FS_ZIP) {
                continue;
            }
#endif
            // look through all the pak file elements
            entry = pak->file_hash[hash & (pak->hash_size - 1)];
            for (; entry; entry = entry->hash_next) {
                if (entry->namelen != namelen) {
                    continue;
                }
#if USE_ZLIB
                if ((file->mode & FS_FLAG_DEFLATE) && entry->compmtd != Z_DEFLATED) {
                    continue;
                }
#endif
                FS_COUNT_STRCMP;
                if (!FS_pathcmp(entry->name, normalized)) {
                    // found it!
                    return open_from_pak(file, pak, entry, unique);
                }
            }
        } else {
            if ((file->mode & FS_TYPE_MASK) == FS_TYPE_PAK) {
                continue;
            }
#if USE_ZLIB
            if (file->mode & FS_FLAG_DEFLATE) {
                continue;
            }
#endif
            // don't error out immediately if the path is found to be invalid,
            // just stop looking for it in directory tree but continue to search
            // for it in packs, to give broken maps or mods a chance to work
            if (valid == PATH_NOT_CHECKED) {
                valid = FS_ValidatePath(normalized);
            }
            if (valid == PATH_INVALID) {
                continue;
            }
            // check a file in the directory tree
            len = Q_concat(fullpath, sizeof(fullpath),
                           search->filename, "/", normalized, NULL);
            if (len >= sizeof(fullpath)) {
                ret = Q_ERR_NAMETOOLONG;
                goto fail;
            }
 
            ret = open_from_disk(file, fullpath);
            if (ret != Q_ERR_NOENT)
                return ret;
 
#ifndef _WIN32
            if (valid == PATH_MIXED_CASE) {
                // convert to lower case and retry
                FS_COUNT_STRLWR;
                Q_strlwr(fullpath + strlen(search->filename) + 1);
                ret = open_from_disk(file, fullpath);
                if (ret != Q_ERR_NOENT)
                    return ret;
            }
#endif
        }
    }
 
    // return error if path was checked and found to be invalid
    ret = valid ? Q_ERR_NOENT : Q_ERR_INVALID_PATH;
 
fail:
    FS_DPrintf("%s: %s: %s\n", __func__, normalized, Q_ErrorString(ret));
    return ret;
}

Referenced by expand_open_file_read().

open_file_write()

static ssize_t open_file_write ( file_t *  file, const char *  name  )

static

Definition at line 887 of file files.c.

{
    char normalized[MAX_OSPATH], fullpath[MAX_OSPATH];
    FILE *fp;
    char mode_str[8];
    unsigned mode;
    size_t len;
    long pos;
    qerror_t ret;
 
    // normalize the path
    len = FS_NormalizePathBuffer(normalized, name, sizeof(normalized));
    if (len >= sizeof(normalized)) {
        return Q_ERR_NAMETOOLONG;
    }
 
    // reject empty paths
    if (len == 0) {
        return Q_ERR_NAMETOOSHORT;
    }
 
    // check for bad characters
    if (!FS_ValidatePath(normalized)) {
        ret = Q_ERR_INVALID_PATH;
        goto fail1;
    }
 
    // expand the path
    if ((file->mode & FS_PATH_MASK) == FS_PATH_BASE) {
        if (sys_homedir->string[0]) {
            len = Q_concat(fullpath, sizeof(fullpath),
                           sys_homedir->string, "/" BASEGAME "/", normalized, NULL);
        } else {
            len = Q_concat(fullpath, sizeof(fullpath),
                           sys_basedir->string, "/" BASEGAME "/", normalized, NULL);
        }
    } else {
        len = Q_concat(fullpath, sizeof(fullpath),
                       fs_gamedir, "/", normalized, NULL);
    }
    if (len >= sizeof(fullpath)) {
        ret = Q_ERR_NAMETOOLONG;
        goto fail1;
    }
 
    mode = file->mode & FS_MODE_MASK;
    switch (mode) {
    case FS_MODE_APPEND:
        strcpy(mode_str, "a");
        break;
    case FS_MODE_WRITE:
        strcpy(mode_str, "w");
        if (file->mode & FS_FLAG_EXCL)
            strcat(mode_str, "x");
        break;
    case FS_MODE_RDWR:
        // this mode is only used by client downloading code
        // similar to FS_MODE_APPEND, but does not create
        // the file if it does not exist
        strcpy(mode_str, "r+");
        break;
    default:
        ret = Q_ERR_INVAL;
        goto fail1;
    }
 
    // open in binary mode by default
    if (!(file->mode & FS_FLAG_TEXT))
        strcat(mode_str, "b");
 
    ret = FS_CreatePath(fullpath);
    if (ret) {
        goto fail1;
    }
 
    fp = fopen_hack(fullpath, mode_str);
    if (!fp) {
        ret = Q_Errno();
        goto fail1;
    }
 
#ifndef _WIN32
    // check if this is a regular file
    ret = get_fp_info(fp, NULL);
    if (ret) {
        goto fail2;
    }
#endif
 
    switch (file->mode & FS_BUF_MASK) {
    case FS_BUF_NONE:
        // make it unbuffered
        setvbuf(fp, NULL, _IONBF, BUFSIZ);
        break;
    case FS_BUF_LINE:
        // make it line buffered
        setvbuf(fp, NULL, _IOLBF, BUFSIZ);
        break;
    case FS_BUF_FULL:
        // make it fully buffered
        setvbuf(fp, NULL, _IOFBF, BUFSIZ);
        break;
    default:
        // use default mode (normally fully buffered)
        break;
    }
 
    if (mode == FS_MODE_RDWR) {
        // seek to the end of file for appending
        if (fseek(fp, 0, SEEK_END) == -1) {
            ret = Q_Errno();
            goto fail2;
        }
    }
 
    // return current position (non-zero for appending modes)
    pos = ftell(fp);
    if (pos == -1) {
        ret = Q_Errno();
        goto fail2;
    }
 
    FS_DPrintf("%s: %s: %lu bytes\n", __func__, fullpath, pos);
 
    file->type = FS_REAL;
    file->fp = fp;
    file->unique = qtrue;
    file->error = Q_ERR_SUCCESS;
    file->length = 0;
 
    return pos;
 
fail2:
    fclose(fp);
fail1:
    FS_DPrintf("%s: %s: %s\n", __func__, normalized, Q_ErrorString(ret));
    return ret;
}

Referenced by FS_FOpenFile().

open_from_disk()

static ssize_t open_from_disk ( file_t *  file, const char *  fullpath  )

static

Definition at line 1276 of file files.c.

{
    FILE *fp;
    file_info_t info;
    qerror_t ret;
 
    FS_COUNT_OPEN;
 
    fp = fopen(fullpath, "rb");
    if (!fp) {
        ret = Q_Errno();
        goto fail;
    }
 
    ret = get_fp_info(fp, &info);
    if (ret) {
        fclose(fp);
        goto fail;
    }
 
    file->type = FS_REAL;
    file->fp = fp;
    file->unique = qtrue;
    file->error = Q_ERR_SUCCESS;
    file->length = info.size;
 
    FS_DPrintf("%s: %s: %"PRIz" bytes\n", __func__, fullpath, info.size);
    return info.size;
 
fail:
    FS_DPrintf("%s: %s: %s\n", __func__, fullpath, Q_ErrorString(ret));
    return ret;
}

Referenced by open_file_read().

open_from_pak()

static ssize_t open_from_pak ( file_t *  file, pack_t *  pack, packfile_t *  entry, qboolean  unique  )

static

Definition at line 1202 of file files.c.

{
    FILE *fp;
    qerror_t ret;
 
    if (unique) {
        fp = fopen(pack->filename, "rb");
        if (!fp) {
            ret = Q_Errno();
            goto fail1;
        }
    } else {
        fp = pack->fp;
        clearerr(fp);
    }
 
#if USE_ZLIB
    if (pack->type == FS_ZIP && !entry->coherent) {
        ret = check_header_coherency(fp, entry);
        if (ret) {
            goto fail2;
        }
    }
#endif
 
    if (fseek(fp, (long)entry->filepos, SEEK_SET) == -1) {
        ret = Q_Errno();
        goto fail2;
    }
 
    file->type = pack->type;
    file->fp = fp;
    file->entry = entry;
    file->pack = pack;
    file->unique = unique;
    file->error = Q_ERR_SUCCESS;
    file->rest_out = entry->filelen;
    file->length = entry->filelen;
 
#if USE_ZLIB
    if (pack->type == FS_ZIP) {
        if (file->mode & FS_FLAG_DEFLATE) {
            // server wants raw deflated data for downloads
            file->type = FS_PAK;
            file->rest_out = entry->complen;
            file->length = entry->complen;
        } else if (entry->compmtd) {
            open_zip_file(file);
        } else {
            // stored, just pretend it's a packfile
            file->type = FS_PAK;
        }
    }
#endif
 
    if (unique) {
        // reference source pak
        pack_get(pack);
    }
 
    FS_DPrintf("%s: %s/%s: %"PRIz" bytes\n",
               __func__, pack->filename, entry->name, file->length);
 
    return file->length;
 
fail2:
    if (unique) {
        fclose(fp);
    }
fail1:
    FS_DPrintf("%s: %s/%s: %s\n", __func__, pack->filename, entry->name, Q_ErrorString(ret));
    return ret;
}

Referenced by open_file_read().

pack_alloc()

static pack_t* pack_alloc ( FILE *  fp, filetype_t  type, const char *  name, unsigned  num_files, size_t  names_len  )

static

Definition at line 2080 of file files.c.

{
    pack_t *pack;
    unsigned hash_size;
    size_t len;
 
    hash_size = npot32(num_files / 3);
 
    len = strlen(name) + 1;
    pack = FS_Malloc(sizeof(pack_t) +
                     num_files * sizeof(packfile_t) +
                     hash_size * sizeof(packfile_t *) +
                     len + names_len);
    pack->type = type;
    pack->refcount = 0;
    pack->fp = fp;
    pack->num_files = num_files;
    pack->hash_size = hash_size;
    pack->files = (packfile_t *)(pack + 1);
    pack->file_hash = (packfile_t **)(pack->files + num_files);
    pack->filename = (char *)(pack->file_hash + hash_size);
    pack->names = pack->filename + len;
    memcpy(pack->filename, name, len);
    memset(pack->file_hash, 0, hash_size * sizeof(packfile_t *));
 
    return pack;
}

Referenced by load_pak_file().

pack_get()

static pack_t * pack_get ( pack_t *  pack )

static

Definition at line 2057 of file files.c.

{
    pack->refcount++;
    return pack;
}

Referenced by open_from_pak(), and q_printf().

pack_hash_file()

static void pack_hash_file ( pack_t *  pack, packfile_t *  file  )

static

Definition at line 2110 of file files.c.

{
    unsigned hash;
 
    file->namelen = FS_NormalizePath(file->name, file->name);
 
    hash = FS_HashPath(file->name, pack->hash_size);
    file->hash_next = pack->file_hash[hash];
    pack->file_hash[hash] = file;
}

Referenced by load_pak_file().

pack_put()

static void pack_put ( pack_t *  pack )

static

Definition at line 2064 of file files.c.

{
    if (!pack) {
        return;
    }
    if (!pack->refcount) {
        Com_Error(ERR_FATAL, "%s: refcount already zero", __func__);
    }
    if (!--pack->refcount) {
        FS_DPrintf("Freeing packfile %s\n", pack->filename);
        fclose(pack->fp);
        Z_Free(pack);
    }
}

Referenced by free_search_path(), and FS_FCloseFile().

pakcmp()

static int pakcmp ( const void *  p1, const void *  p2  )

static

Definition at line 2487 of file files.c.

{
    char *s1 = *(char **)p1;
    char *s2 = *(char **)p2;
 
    if (!Q_stricmpn(s1, "pak", 3)) {
        if (!Q_stricmpn(s2, "pak", 3)) {
            unsigned long n1 = strtoul(s1 + 3, &s1, 10);
            unsigned long n2 = strtoul(s2 + 3, &s2, 10);
            if (n1 > n2) {
                return 1;
            }
            if (n1 < n2) {
                return -1;
            }
            goto alphacmp;
        }
        return -1;
    }
    if (!Q_stricmpn(s2, "pak", 3)) {
        return 1;
    }
 
alphacmp:
    return Q_stricmp(s1, s2);
}

Referenced by q_printf().

print_file_list()

static void print_file_list ( const char *  path, const char *  ext, unsigned  flags  )

static

Definition at line 2977 of file files.c.

{
    void    **list;
    int     i, listed, total;
 
    list = FS_ListFiles(path, ext, flags, &total);
 
    // don't list too many files to avoid console spam
    listed = total > 128 ? 128 : total;
    for (i = 0; i < listed; i++) {
        Com_Printf("%s\n", (char *)list[i]);
    }
 
    FS_FreeList(list);
 
    if (listed == total) {
        Com_Printf("%i files listed\n", listed);
    } else {
        Com_Printf("%i files listed (%d files more)\n", listed, total - listed);
    }
}

Referenced by FS_Dir_f(), and FS_FDir_f().

q_printf()

static void q_printf ( 2  , 3    )

static

Definition at line 2516 of file files.c.

{
    va_list         argptr;
    searchpath_t    *search;
    pack_t          *pack;
    void            *files[MAX_LISTED_FILES];
    int             i, count;
    char            path[MAX_OSPATH];
    size_t          len;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(fs_gamedir, sizeof(fs_gamedir), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(fs_gamedir)) {
        Com_EPrintf("%s: refusing oversize path\n", __func__);
        return;
    }
 
#ifdef _WIN32
    FS_ReplaceSeparators(fs_gamedir, '/');
#endif
 
#if USE_ZLIB
#define PAK_EXT  ".pak;.pkz"
#else
#define PAK_EXT  ".pak"
#endif
 
    // add any pack files
    count = 0;
    Sys_ListFiles_r(fs_gamedir, PAK_EXT, 0, 0, &count, files, 0);
 
    // Can't exit early for game directory
    if (!(mode & FS_PATH_GAME) && !count) {
        return;
    }
 
    qsort(files, count, sizeof(files[0]), pakcmp);
 
    for (i = 0; i < count; i++) {
        len = Q_concat(path, sizeof(path), fs_gamedir, "/", files[i], NULL);
        if (len >= sizeof(path)) {
            Com_EPrintf("%s: refusing oversize path\n", __func__);
            continue;
        }
#if USE_ZLIB
        // FIXME: guess packfile type by contents instead?
        if (len > 4 && !Q_stricmp(path + len - 4, ".pkz"))
            pack = load_zip_file(path);
        else
#endif
            pack = load_pak_file(path);
        if (!pack)
            continue;
        search = FS_Malloc(sizeof(searchpath_t));
        search->mode = mode;
        search->filename[0] = 0;
        search->pack = pack_get(pack);
        search->next = fs_searchpaths;
        fs_searchpaths = search;
    }
 
    for (i = 0; i < count; i++) {
        Z_Free(files[i]);
    }
 
    // add the directory to the search path
    // the directory has priority over the pak files
    search = FS_Malloc(sizeof(searchpath_t) + len);
    search->mode = mode;
    search->pack = NULL;
    memcpy(search->filename, fs_gamedir, len + 1);
    search->next = fs_searchpaths;
    fs_searchpaths = search;
 
}

read_pak_file()

static ssize_t read_pak_file ( file_t *  file, void *  buf, size_t  len  )

static

Definition at line 1504 of file files.c.

{
    size_t result;
 
    if (len > file->rest_out) {
        len = file->rest_out;
    }
    if (!len) {
        return 0;
    }
 
    result = fread(buf, 1, len, file->fp);
    if (result != len) {
        file->error = FS_ERR_READ(file->fp);
        if (!result) {
            return file->error;
        }
    }
 
    file->rest_out -= result;
    return result;
}

Referenced by FS_Read().

read_phys_file()

static ssize_t read_phys_file ( file_t *  file, void *  buf, size_t  len  )

static

Definition at line 1527 of file files.c.

{
    size_t result;
 
    result = fread(buf, 1, len, file->fp);
    if (result != len && ferror(file->fp)) {
        file->error = Q_Errno();
        if (!result) {
            return file->error;
        }
    }
 
    return result;
}

Referenced by FS_Read().

seek_pak_file()

static qerror_t seek_pak_file ( file_t *  file, off_t  offset  )

static

Definition at line 537 of file files.c.

{
    packfile_t *entry = file->entry;
    long filepos;
 
    if (offset > entry->filelen)
        offset = entry->filelen;
 
    if (entry->filepos > LONG_MAX - offset)
        return Q_ERR_INVAL;
 
    filepos = entry->filepos + offset;
    if (fseek(file->fp, filepos, SEEK_SET) == -1)
        return Q_Errno();
 
    file->rest_out = entry->filelen - offset;
 
    return Q_ERR_SUCCESS;
}

Referenced by FS_Seek().

setup_base_paths()

static void setup_base_paths ( void  )

static

Definition at line 3499 of file files.c.

{
    // base paths have both BASE and GAME bits set by default
    // the GAME bit will be removed once gamedir is set,
    // and will be put back once gamedir is reset to basegame
    add_game_dir(FS_PATH_BASE | FS_PATH_GAME, "%s/"BASEGAME, sys_basedir->string);
    fs_base_searchpaths = fs_searchpaths;
}

Referenced by fs_game_changed(), and FS_Restart().

setup_game_paths()

static void setup_game_paths ( void  )

static

Definition at line 3509 of file files.c.

{
    searchpath_t *path;
 
    if (fs_game->string[0]) {
        // add system path first
        add_game_dir(FS_PATH_GAME, "%s/%s", sys_basedir->string, fs_game->string);
 
        // home paths override system paths
        if (sys_homedir->string[0]) {
            add_game_dir(FS_PATH_BASE, "%s/"BASEGAME, sys_homedir->string);
            add_game_dir(FS_PATH_GAME, "%s/%s", sys_homedir->string, fs_game->string);
        }
 
        // remove the game bit from base paths
        for (path = fs_base_searchpaths; path; path = path->next) {
            path->mode &= ~FS_PATH_GAME;
        }
 
        // this var is set for compatibility with server browsers, etc
        Cvar_FullSet("gamedir", fs_game->string, CVAR_ROM | CVAR_SERVERINFO, FROM_CODE);
 
    } else {
        if (sys_homedir->string[0]) {
            add_game_dir(FS_PATH_BASE | FS_PATH_GAME,
                         "%s/"BASEGAME, sys_homedir->string);
        }
 
        // add the game bit to base paths
        for (path = fs_base_searchpaths; path; path = path->next) {
            path->mode |= FS_PATH_GAME;
        }
 
        Cvar_FullSet("gamedir", "", CVAR_ROM, FROM_CODE);
    }
 
    // this var is used by the game library to find it's home directory
    Cvar_FullSet("fs_gamedir", fs_gamedir, CVAR_ROM, FROM_CODE);
}

Referenced by fs_game_changed(), and FS_Restart().

validate_char()

static qboolean validate_char ( int  c )

inlinestatic

Definition at line 251 of file files.c.

{
    if (!Q_isprint(c))
        return qfalse;
 
#ifdef _WIN32
    if (strchr("<>:\"|?*", c))
        return qfalse;
#endif
 
    return qtrue;
}

Referenced by cleanup_path(), and FS_ValidatePath().

Variable Documentation

c_fs

const cmdreg_t c_fs[]

static

Initial value:

= {
    { "path", FS_Path_f },
    { "fdir", FS_FDir_f },
    { "dir", FS_Dir_f },
 
 
 
    { "whereis", FS_WhereIs_f },
    { "link", FS_Link_f, FS_Link_c },
    { "unlink", FS_UnLink_f, FS_Link_c },
    { "softlink", FS_Link_f, FS_Link_c },
    { "softunlink", FS_UnLink_f, FS_Link_c },
    { "fs_restart", FS_Restart_f },
 
    { NULL }
}

Definition at line 3592 of file files.c.

Referenced by FS_Init(), and FS_Shutdown().

fs_base_searchpaths

searchpath_t* fs_base_searchpaths

static

Definition at line 175 of file files.c.

Referenced by free_game_paths(), fs_game_changed(), setup_base_paths(), and setup_game_paths().

fs_files

file_t fs_files[MAX_FILE_HANDLES]

static

Definition at line 180 of file files.c.

Referenced by alloc_handle(), file_for_handle(), and FS_Shutdown().

fs_game

cvar_t* fs_game

Definition at line 202 of file files.c.

Referenced by adjust_shell_fx(), CL_ClearState(), CL_ParseServerData(), Cvar_ResetAll_f(), emit_gamestate(), FS_Init(), http_gamedir(), setup_game_paths(), SV_InitGameProgs(), and SVC_DirectConnect().

fs_gamedir

char fs_gamedir[MAX_OSPATH]

Definition at line 171 of file files.c.

Referenced by copy_file(), Expose(), finish_download(), fs_game_changed(), FS_Restart(), OGG_InitTrackList(), open_file_write(), q_printf(), read_level_file(), read_server_file(), remove_file(), setup_game_paths(), start_download(), SV_SpawnServer(), write_level_file(), and write_server_file().

fs_hard_links

list_t fs_hard_links

static

Definition at line 177 of file files.c.

Referenced by expand_open_file_read(), FS_Init(), FS_Link_f(), FS_Link_g(), FS_Shutdown(), FS_UnLink_f(), and FS_WhereIs_f().

fs_searchpaths

searchpath_t* fs_searchpaths

static

Definition at line 174 of file files.c.

Referenced by free_all_paths(), free_game_paths(), FS_FOpenFile(), FS_LastModified(), FS_ListFiles(), FS_LoadFileEx(), FS_Path_f(), FS_Shutdown(), FS_WhereIs_f(), open_file_read(), q_printf(), and setup_base_paths().

fs_shareware

cvar_t* fs_shareware

Definition at line 204 of file files.c.

Referenced by CL_Connect_f(), FS_Init(), and Qcommon_Init().

fs_soft_links

list_t fs_soft_links

static

Definition at line 178 of file files.c.

Referenced by expand_open_file_read(), FS_Init(), FS_Link_f(), FS_Link_g(), FS_Shutdown(), FS_UnLink_f(), and FS_WhereIs_f().