download.c File Reference

#include "client.h"
#include "format/md2.h"
#include "format/sp2.h"

Go to the source code of this file.

Macros
#define	CL_DOWNLOAD_IGNORES   "download-ignores.txt"
#define	check_file(path, type)   check_file_len(path, strlen(path), type)

Enumerations
enum	precache_t { PRECACHE_MODELS, PRECACHE_OTHER, PRECACHE_MAP, PRECACHE_FINAL }

Functions
qerror_t	CL_QueueDownload (const char *path, dltype_t type)
qboolean	CL_IgnoreDownload (const char *path)
void	CL_FinishDownload (dlqueue_t *q)
void	CL_CleanupDownloads (void)
void	CL_LoadDownloadIgnores (void)
static qboolean	start_udp_download (dlqueue_t *q)
void	CL_StartNextDownload (void)
static void	finish_udp_download (const char *msg)
static int	write_udp_download (byte *data, int size)
static int	inflate_udp_download (byte *data, int inlen, int outlen)
void	CL_HandleDownload (byte *data, int size, int percent, int compressed)
qboolean	CL_CheckDownloadExtension (const char *ext)
static qerror_t	check_file_len (const char *path, size_t len, dltype_t type)
static void	check_skins (const char *name)
static void	check_player (const char *name)
static qboolean	downloads_pending (dltype_t type)
void	CL_RequestNextDownload (void)
void	CL_ResetPrecacheCheck (void)
static void	CL_Download_f (void)
void	CL_InitDownloads (void)

Variables
static precache_t	precache_check
static int	precache_sexed_sounds [MAX_SOUNDS]
static int	precache_sexed_total

Macro Definition Documentation

check_file

#define check_file	(		path,
			type
	)		check_file_len(path, strlen(path), type)

Definition at line 570 of file download.c.

CL_DOWNLOAD_IGNORES

#define CL_DOWNLOAD_IGNORES   "download-ignores.txt"

Definition at line 27 of file download.c.

Enumeration Type Documentation

precache_t

enum precache_t

Enumerator
PRECACHE_MODELS
PRECACHE_OTHER
PRECACHE_MAP
PRECACHE_FINAL

Definition at line 29 of file download.c.

             {
    PRECACHE_MODELS,
    PRECACHE_OTHER,
    PRECACHE_MAP,
    PRECACHE_FINAL
} precache_t;

Function Documentation

check_file_len()

static qerror_t check_file_len ( const char *  path, size_t  len, dltype_t  type  )

static

Definition at line 510 of file download.c.

{
    char buffer[MAX_QPATH], *ext;
    qerror_t ret;
    int valid;
 
    // check for oversize path
    if (len >= MAX_QPATH)
        return Q_ERR_NAMETOOLONG;
 
    // normalize path
    len = FS_NormalizePath(buffer, path);
 
    // check for empty path
    if (len == 0)
        return Q_ERR_NAMETOOSHORT;
 
    valid = FS_ValidatePath(buffer);
 
    // check path
    if (valid == PATH_INVALID
        || !Q_ispath(buffer[0])
        || !Q_ispath(buffer[len - 1])
        || strstr(buffer, "..")
        || !strchr(buffer, '/')) {
        // some of these checks are too conservative or even redundant
        // once we have normalized the path, however they have to stay for
        // compatibility reasons with older servers (some would even ban us
        // for sending .. for example)
        return Q_ERR_INVALID_PATH;
    }
 
    // check extension
    ext = COM_FileExtension(buffer);
    if (*ext != '.' || !CL_CheckDownloadExtension(ext + 1))
        return Q_ERR_INVALID_PATH;
 
    if (FS_FileExists(buffer))
        // it exists, no need to download
        return Q_ERR_EXIST;
 
    if (valid == PATH_MIXED_CASE)
        // convert to lower case to make download server happy
        Q_strlwr(buffer);
 
    if (CL_IgnoreDownload(buffer))
        return Q_ERR_PERM;
 
    ret = HTTP_QueueDownload(buffer, type);
    if (ret != Q_ERR_NOSYS)
        return ret;
 
    // queue and start legacy UDP download
    ret = CL_QueueDownload(buffer, type);
    if (ret == Q_ERR_SUCCESS)
        CL_StartNextDownload();
 
    return ret;
}

Referenced by check_player(), and CL_RequestNextDownload().

check_player()

static void check_player ( const char *  name )

static

Definition at line 666 of file download.c.

{
    char fn[MAX_QPATH], model[MAX_QPATH], skin[MAX_QPATH], *p;
    size_t len;
    int i, j;
 
    CL_ParsePlayerSkin(NULL, model, skin, name);
 
    // model
    len = Q_concat(fn, sizeof(fn), "players/", model, "/tris.md2", NULL);
    check_file_len(fn, len, DL_OTHER);
 
    // weapon models
    for (i = 0; i < cl.numWeaponModels; i++) {
        len = Q_concat(fn, sizeof(fn), "players/", model, "/", cl.weaponModels[i], NULL);
        check_file_len(fn, len, DL_OTHER);
    }
 
    // default weapon skin
    len = Q_concat(fn, sizeof(fn), "players/", model, "/weapon.pcx", NULL);
    check_file_len(fn, len, DL_OTHER);
 
    // skin
    len = Q_concat(fn, sizeof(fn), "players/", model, "/", skin, ".pcx", NULL);
    check_file_len(fn, len, DL_OTHER);
 
    // skin_i
    len = Q_concat(fn, sizeof(fn), "players/", model, "/", skin, "_i.pcx", NULL);
    check_file_len(fn, len, DL_OTHER);
 
    // sexed sounds
    for (i = 0; i < precache_sexed_total; i++) {
        j = precache_sexed_sounds[i];
        p = cl.configstrings[CS_SOUNDS + j];
 
        if (*p == '*') {
            len = Q_concat(fn, sizeof(fn), "players/", model, "/", p + 1, NULL);
            check_file_len(fn, len, DL_OTHER);
        }
    }
}

Referenced by CL_RequestNextDownload().

check_skins()

static void check_skins ( const char *  name )

static

Definition at line 573 of file download.c.

{
    size_t          i, num_skins, ofs_skins, end_skins;
    byte            *model;
    size_t          len;
    dmd2header_t    *md2header;
    dsp2header_t    *sp2header;
    char            *md2skin;
    dsp2frame_t     *sp2frame;
    uint32_t        ident;
    char            fn[MAX_QPATH];
 
    len = FS_LoadFile(name, (void **)&model);
    if (!model) {
        // couldn't load it
        return;
    }
 
    if (len < sizeof(ident)) {
        // file too small
        goto done;
    }
 
    // check ident
    ident = LittleLong(*(uint32_t *)model);
    switch (ident) {
    case MD2_IDENT:
        // alias model
        md2header = (dmd2header_t *)model;
        if (len < sizeof(*md2header) ||
            LittleLong(md2header->ident) != MD2_IDENT ||
            LittleLong(md2header->version) != MD2_VERSION) {
            // not an alias model
            goto done;
        }
 
        num_skins = LittleLong(md2header->num_skins);
        ofs_skins = LittleLong(md2header->ofs_skins);
        end_skins = ofs_skins + num_skins * MD2_MAX_SKINNAME;
        if (num_skins > MD2_MAX_SKINS || end_skins < ofs_skins || end_skins > len) {
            // bad alias model
            goto done;
        }
 
        md2skin = (char *)model + ofs_skins;
        for (i = 0; i < num_skins; i++) {
            if (!Q_memccpy(fn, md2skin, 0, sizeof(fn))) {
                // bad alias model
                goto done;
            }
            check_file(fn, DL_OTHER);
            md2skin += MD2_MAX_SKINNAME;
        }
        break;
 
    case SP2_IDENT:
        // sprite model
        sp2header = (dsp2header_t *)model;
        if (len < sizeof(*sp2header) ||
            LittleLong(sp2header->ident) != SP2_IDENT ||
            LittleLong(sp2header->version) != SP2_VERSION) {
            // not a sprite model
            goto done;
        }
 
        num_skins = LittleLong(sp2header->numframes);
        ofs_skins = sizeof(*sp2header);
        end_skins = ofs_skins + num_skins * sizeof(dsp2frame_t);
        if (num_skins > SP2_MAX_FRAMES || end_skins < ofs_skins || end_skins > len) {
            // bad sprite model
            goto done;
        }
 
        sp2frame = (dsp2frame_t *)(model + ofs_skins);
        for (i = 0; i < num_skins; i++) {
            if (!Q_memccpy(fn, sp2frame->name, 0, sizeof(fn))) {
                // bad sprite model
                goto done;
            }
            check_file(fn, DL_OTHER);
            sp2frame++;
        }
        break;
 
    default:
        // unknown file format
        goto done;
    }
 
done:
    FS_FreeFile(model);
}

Referenced by CL_RequestNextDownload().

CL_CheckDownloadExtension()

qboolean CL_CheckDownloadExtension

(

const char *

ext

)

Definition at line 494 of file download.c.

{
    static const char allowed[][4] = {
        "pcx", "wal", "wav", "md2", "sp2", "tga", "png",
        "jpg", "bsp", "ent", "txt", "dm2", "loc", "md3"
    };
    int i;
 
    for (i = 0; i < q_countof(allowed); i++)
        if (!Q_stricmp(ext, allowed[i]))
            return qtrue;
 
    return qfalse;
}

Referenced by check_and_queue_download(), and check_file_len().

CL_CleanupDownloads()

void CL_CleanupDownloads

(

void

)

Definition at line 136 of file download.c.

{
    dlqueue_t *q, *n;
 
    HTTP_CleanupDownloads();
 
    FOR_EACH_DLQ_SAFE(q, n) {
        Z_Free(q);
    }
 
    List_Init(&cls.download.queue);
    cls.download.pending = 0;
 
    cls.download.current = NULL;
    cls.download.percent = 0;
    cls.download.position = 0;
 
    if (cls.download.file) {
        FS_FCloseFile(cls.download.file);
        cls.download.file = 0;
    }
 
    cls.download.temp[0] = 0;
 
#if USE_ZLIB
    inflateEnd(&cls.download.z);
#endif
}

Referenced by CL_Disconnect().

CL_Download_f()

static void CL_Download_f ( void  )

static

Definition at line 909 of file download.c.

{
    char *path;
    qerror_t ret;
 
    if (cls.state < ca_connected) {
        Com_Printf("Must be connected to a server.\n");
        return;
    }
 
    if (allow_download->integer == -1) {
        Com_Printf("Downloads are permanently disabled.\n");
        return;
    }
 
    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: download <filename>\n");
        return;
    }
 
    path = Cmd_Argv(1);
 
    ret = check_file(path, DL_OTHER);
    if (ret) {
        Com_Printf("Couldn't download %s: %s\n", path, Q_ErrorString(ret));
    }
}

Referenced by CL_InitDownloads().

CL_FinishDownload()

void CL_FinishDownload

(

dlqueue_t *

q

)

Definition at line 115 of file download.c.

{
    if (q->state == DL_DONE) {
        Com_Error(ERR_DROP, "%s: already done", __func__);
    }
    if (!cls.download.pending) {
        Com_Error(ERR_DROP, "%s: bad pending count", __func__);
    }
 
    q->state = DL_DONE;
    cls.download.pending--;
    Com_DPrintf("%s: %s [%d]\n", __func__, q->path, cls.download.pending);
}

Referenced by abort_downloads(), finish_download(), finish_udp_download(), rescan_queue(), start_download(), and start_udp_download().

CL_HandleDownload()

void CL_HandleDownload	(	byte *	data,
		int	size,
		int	percent,
		int	compressed
	)

Definition at line 424 of file download.c.

{
    dlqueue_t *q = cls.download.current;
    qerror_t ret;
 
    if (!q) {
        Com_Error(ERR_DROP, "%s: no download requested", __func__);
    }
 
    if (size == -1) {
        if (!percent) {
            finish_udp_download("FAIL");
        } else {
            finish_udp_download("STOP");
        }
        return;
    }
 
    // open the file if not opened yet
    if (!cls.download.file) {
        ret = FS_FOpenFile(cls.download.temp, &cls.download.file, FS_MODE_WRITE);
        if (!cls.download.file) {
            Com_EPrintf("[UDP] Couldn't open %s for writing: %s\n",
                        cls.download.temp, Q_ErrorString(ret));
            finish_udp_download(NULL);
            return;
        }
    }
 
    if (compressed) {
        if (inflate_udp_download(data, size, compressed))
            return;
    } else {
        if (write_udp_download(data, size))
            return;
    }
 
    if (percent != 100) {
        // request next block
        // change display routines by zoid
        cls.download.percent = percent;
        cls.download.position += size;
 
        CL_ClientCommand("nextdl");
    } else {
        // close the file before renaming
        FS_FCloseFile(cls.download.file);
        cls.download.file = 0;
 
        // rename the temp file to its final name
        ret = FS_RenameFile(cls.download.temp, q->path);
        if (ret) {
            Com_EPrintf("[UDP] Couldn't rename %s to %s: %s\n",
                        cls.download.temp, q->path, Q_ErrorString(ret));
            finish_udp_download(NULL);
        } else {
            finish_udp_download("DONE");
        }
    }
}

Referenced by CL_ParseDownload().

CL_IgnoreDownload()

qboolean CL_IgnoreDownload

(

const char *

path

)

Definition at line 95 of file download.c.

{
    string_entry_t *entry;
 
    for (entry = cls.download.ignores; entry; entry = entry->next) {
        if (Com_WildCmp(entry->string, path)) {
            return qtrue;
        }
    }
 
    return qfalse;
}

Referenced by check_and_queue_download(), and check_file_len().

CL_InitDownloads()

void CL_InitDownloads

(

void

)

Definition at line 937 of file download.c.

{
    Cmd_AddCommand("download", CL_Download_f);
 
    List_Init(&cls.download.queue);
}

Referenced by CL_InitLocal().

CL_LoadDownloadIgnores()

void CL_LoadDownloadIgnores

(

void

)

Definition at line 173 of file download.c.

{
    string_entry_t *entry, *next;
    char *raw, *data, *p;
    int count, line;
    ssize_t len;
 
    // free previous entries
    for (entry = cls.download.ignores; entry; entry = next) {
        next = entry->next;
        Z_Free(entry);
    }
 
    cls.download.ignores = NULL;
 
    // load new list
    len = FS_LoadFile(CL_DOWNLOAD_IGNORES, (void **)&raw);
    if (!raw) {
        if (len != Q_ERR_NOENT)
            Com_EPrintf("Couldn't load %s: %s\n",
                        CL_DOWNLOAD_IGNORES, Q_ErrorString(len));
        return;
    }
 
    count = 0;
    line = 1;
    data = raw;
 
    while (*data) {
        p = strchr(data, '\n');
        if (p) {
            if (p > data && *(p - 1) == '\r')
                *(p - 1) = 0;
            *p = 0;
        }
 
        // ignore empty lines and comments
        if (*data && *data != '#' && *data != '/') {
            len = strlen(data);
            if (len < MAX_QPATH) {
                entry = Z_Malloc(sizeof(*entry) + len);
                memcpy(entry->string, data, len + 1);
                entry->next = cls.download.ignores;
                cls.download.ignores = entry;
                count++;
            } else {
                Com_WPrintf("Oversize filter on line %d in %s\n",
                            line, CL_DOWNLOAD_IGNORES);
            }
        }
 
        if (!p)
            break;
 
        data = p + 1;
        line++;
    }
 
    Com_DPrintf("Loaded %d filters from %s\n", count, CL_DOWNLOAD_IGNORES);
 
    FS_FreeFile(raw);
}

Referenced by CL_Init(), and CL_RestartFilesystem().

CL_QueueDownload()

qerror_t CL_QueueDownload	(	const char *	path,
		dltype_t	type
	)

Definition at line 49 of file download.c.

{
    dlqueue_t *q;
    size_t len;
 
    FOR_EACH_DLQ(q) {
        // avoid sending duplicate requests
        if (!FS_pathcmp(path, q->path)) {
            Com_DPrintf("%s: %s [DUP]\n", __func__, path);
            return Q_ERR_EXIST;
        }
    }
 
    len = strlen(path);
    if (len >= MAX_QPATH) {
        Com_Error(ERR_DROP, "%s: oversize quake path", __func__);
    }
 
    q = Z_Malloc(sizeof(*q) + len);
    memcpy(q->path, path, len + 1);
    q->type = type;
    q->state = DL_PENDING;
 
#if USE_CURL
    // paks get bumped to the top and HTTP switches to single downloading.
    // this prevents someone on 28k dialup trying to do both the main .pak
    // and referenced configstrings data at once.
    if (type == DL_PAK)
        List_Insert(&cls.download.queue, &q->entry);
    else
#endif
        List_Append(&cls.download.queue, &q->entry);
 
    cls.download.pending++;
    Com_DPrintf("%s: %s [%d]\n", __func__, path, cls.download.pending);
    return Q_ERR_SUCCESS;
}

Referenced by check_and_queue_download(), check_file_len(), and HTTP_QueueDownload().

CL_RequestNextDownload()

void CL_RequestNextDownload

(

void

)

Definition at line 735 of file download.c.

{
    char fn[MAX_QPATH], *name;
    size_t len;
    int i;
 
    if (cls.state != ca_connected && cls.state != ca_loading)
        return;
 
    if (allow_download->integer <= 0 || NET_IsLocalAddress(&cls.serverAddress)) {
        if (precache_check <= PRECACHE_MAP) {
            CL_RegisterBspModels();
        }
 
        CL_Begin();
        return;
    }
 
    switch (precache_check) {
    case PRECACHE_MODELS:
        // confirm map
        if (allow_download_maps->integer)
            check_file(cl.configstrings[CS_MODELS + 1], DL_MAP);
 
        // checking for models
        if (allow_download_models->integer) {
            for (i = 2; i < MAX_MODELS; i++) {
                name = cl.configstrings[CS_MODELS + i];
                if (!name[0]) {
                    break;
                }
                if (name[0] == '*' || name[0] == '#') {
                    continue;
                }
                check_file(name, DL_MODEL);
            }
        }
 
        precache_check = PRECACHE_OTHER;
        // fall through
 
    case PRECACHE_OTHER:
        if (allow_download_models->integer) {
            if (downloads_pending(DL_MODEL)) {
                // pending downloads (models), let's wait here before we can check skins.
                Com_DPrintf("%s: waiting for models...\n", __func__);
                return;
            }
 
            for (i = 2; i < MAX_MODELS; i++) {
                name = cl.configstrings[CS_MODELS + i];
                if (!name[0]) {
                    break;
                }
                if (name[0] == '*' || name[0] == '#') {
                    continue;
                }
                check_skins(name);
            }
        }
 
        if (allow_download_sounds->integer) {
            for (i = 1; i < MAX_SOUNDS; i++) {
                name = cl.configstrings[CS_SOUNDS + i];
                if (!name[0]) {
                    break;
                }
                if (name[0] == '*') {
                    continue;
                }
                if (name[0] == '#') {
                    len = Q_strlcpy(fn, name + 1, sizeof(fn));
                } else {
                    len = Q_concat(fn, sizeof(fn), "sound/", name, NULL);
                }
                check_file_len(fn, len, DL_OTHER);
            }
        }
 
        if (allow_download_pics->integer) {
            for (i = 1; i < MAX_IMAGES; i++) {
                name = cl.configstrings[CS_IMAGES + i];
                if (!name[0]) {
                    break;
                }
                if (name[0] == '/' || name[0] == '\\') {
                    len = Q_strlcpy(fn, name + 1, sizeof(fn));
                } else {
                    len = Q_concat(fn, sizeof(fn), "pics/", name, ".pcx", NULL);
                }
                check_file_len(fn, len, DL_OTHER);
            }
        }
 
        if (allow_download_players->integer) {
            // find sexed sounds
            precache_sexed_total = 0;
            for (i = 1; i < MAX_SOUNDS; i++) {
                if (cl.configstrings[CS_SOUNDS + i][0] == '*') {
                    precache_sexed_sounds[precache_sexed_total++] = i;
                }
            }
 
            for (i = 0; i < MAX_CLIENTS; i++) {
                name = cl.configstrings[CS_PLAYERSKINS + i];
                if (!name[0]) {
                    continue;
                }
                check_player(name);
            }
        }
 
        if (allow_download_textures->integer) {
            static const char env_suf[6][3] = {
                "rt", "bk", "lf", "ft", "up", "dn"
            };
 
            for (i = 0; i < 6; i++) {
                len = Q_concat(fn, sizeof(fn), "env/", cl.configstrings[CS_SKY], env_suf[i], ".tga", NULL);
                check_file_len(fn, len, DL_OTHER);
            }
        }
 
        precache_check = PRECACHE_MAP;
        // fall through
 
    case PRECACHE_MAP:
        if (downloads_pending(DL_MAP)) {
            // map might still be downloading?
            Com_DPrintf("%s: waiting for map...\n", __func__);
            return;
        }
 
        // load the map file before checking textures
        CL_RegisterBspModels();
 
        if (allow_download_textures->integer) {
            for (i = 0; i < cl.bsp->numtexinfo; i++) {
                len = Q_concat(fn, sizeof(fn), "textures/", cl.bsp->texinfo[i].name, ".wal", NULL);
                check_file_len(fn, len, DL_OTHER);
            }
        }
 
        precache_check = PRECACHE_FINAL;
        // fall through
 
    case PRECACHE_FINAL:
        if (downloads_pending(DL_OTHER)) {
            // pending downloads (possibly textures), let's wait here.
            Com_DPrintf("%s: waiting for others...\n", __func__);
            return;
        }
 
        // all done, tell server we are ready
        CL_Begin();
        break;
 
    default:
        Com_Error(ERR_DROP, "%s: bad precache_check\n", __func__);
    }
}

Referenced by abort_downloads(), CL_Precache_f(), finish_download(), finish_udp_download(), and start_download().

CL_ResetPrecacheCheck()

void CL_ResetPrecacheCheck

(

void

)

Definition at line 897 of file download.c.

{
    precache_check = PRECACHE_MODELS;
}

Referenced by CL_Precache_f().

CL_StartNextDownload()

void CL_StartNextDownload

(

void

)

Definition at line 294 of file download.c.

{
    dlqueue_t *q;
 
    if (!cls.download.pending || cls.download.current) {
        return;
    }
 
    FOR_EACH_DLQ(q) {
        if (q->state == DL_PENDING) {
            if (start_udp_download(q)) {
                break;
            }
        }
    }
}

Referenced by abort_downloads(), check_file_len(), and finish_udp_download().

downloads_pending()

static qboolean downloads_pending ( dltype_t  type )

static

Definition at line 709 of file download.c.

{
    dlqueue_t *q;
 
    // DL_OTHER just checks for any download
    if (type == DL_OTHER) {
        return !!cls.download.pending;
    }
 
    // see if there are pending downloads of the given type
    FOR_EACH_DLQ(q) {
        if (q->state != DL_DONE && q->type == type) {
            return qtrue;
        }
    }
 
    return qfalse;
}

Referenced by CL_RequestNextDownload().

finish_udp_download()

static void finish_udp_download ( const char *  msg )

static

Definition at line 311 of file download.c.

{
    dlqueue_t *q = cls.download.current;
 
    // finished with current path
    CL_FinishDownload(q);
 
    cls.download.current = NULL;
    cls.download.percent = 0;
    cls.download.position = 0;
 
    if (cls.download.file) {
        FS_FCloseFile(cls.download.file);
        cls.download.file = 0;
    }
 
    cls.download.temp[0] = 0;
 
#if USE_ZLIB
    inflateReset(&cls.download.z);
#endif
 
    if (msg) {
        Com_Printf("[UDP] %s [%s] [%d remaining file%s]\n",
                   q->path, msg, cls.download.pending,
                   cls.download.pending == 1 ? "" : "s");
    }
 
    // get another file if needed
    CL_RequestNextDownload();
    CL_StartNextDownload();
}

Referenced by CL_HandleDownload(), inflate_udp_download(), and write_udp_download().

inflate_udp_download()

static int inflate_udp_download ( byte *  data, int  inlen, int  outlen  )

static

Definition at line 361 of file download.c.

{
#if USE_ZLIB
 
#define CHUNK   0x10000
 
    z_streamp   z = &cls.download.z;
    byte        buffer[CHUNK];
    int         ret;
 
    // initialize stream if not done yet
    if (z->state == NULL && inflateInit2(z, -MAX_WBITS) != Z_OK)
        Com_Error(ERR_FATAL, "%s: inflateInit2() failed", __func__);
 
    z->next_in = data;
    z->avail_in = inlen;
 
    // run inflate() until output buffer not full
    do {
        z->next_out = buffer;
        z->avail_out = CHUNK;
 
        ret = inflate(z, Z_SYNC_FLUSH);
        if (ret != Z_OK && ret != Z_STREAM_END) {
            Com_EPrintf("[UDP] inflate() failed: %s\n", z->msg);
            finish_udp_download(NULL);
            return -1;
        }
 
        Com_DDPrintf("%s: %u --> %u [%d]\n",
                     __func__,
                     inlen - z->avail_in,
                     CHUNK - z->avail_out,
                     ret);
 
        if (write_udp_download(buffer, CHUNK - z->avail_out))
            return -1;
    } while (z->avail_out == 0);
 
    // check uncompressed length if known
    if (outlen > 0 && outlen != z->total_out)
        Com_WPrintf("[UDP] Decompressed length mismatch: %d != %lu\n", outlen, z->total_out);
 
    // prepare for the next stream if done
    if (ret == Z_STREAM_END)
        inflateReset(z);
 
    return 0;
#else
    // should never happen
    Com_Error(ERR_DROP, "Compressed server packet received, "
              "but no zlib support linked in.");
    return 0;
#endif
}

Referenced by CL_HandleDownload().

start_udp_download()

static qboolean start_udp_download ( dlqueue_t *  q )

static

Definition at line 236 of file download.c.

{
    size_t len;
    qhandle_t f;
    ssize_t ret;
 
    len = strlen(q->path);
    if (len >= MAX_QPATH) {
        Com_Error(ERR_DROP, "%s: oversize quake path", __func__);
    }
 
    // download to a temp name, and only rename
    // to the real name when done, so if interrupted
    // a runt file wont be left
    memcpy(cls.download.temp, q->path, len);
    memcpy(cls.download.temp + len, ".tmp", 5);
 
    // check to see if we already have a tmp for this file, if so, try to resume
    // open the file if not opened yet
    ret = FS_FOpenFile(cls.download.temp, &f, FS_MODE_RDWR);
    if (ret >= 0) {  // it exists
        cls.download.file = f;
        cls.download.position = ret;
        // give the server an offset to start the download
        Com_DPrintf("[UDP] Resuming %s\n", q->path);
#if USE_ZLIB
        if (cls.serverProtocol == PROTOCOL_VERSION_R1Q2)
            CL_ClientCommand(va("download \"%s\" %"PRIz" udp-zlib", q->path, ret));
        else
#endif
            CL_ClientCommand(va("download \"%s\" %"PRIz, q->path, ret));
    } else if (ret == Q_ERR_NOENT) {  // it doesn't exist
        Com_DPrintf("[UDP] Downloading %s\n", q->path);
#if USE_ZLIB
        if (cls.serverProtocol == PROTOCOL_VERSION_R1Q2)
            CL_ClientCommand(va("download \"%s\" %"PRIz" udp-zlib", q->path, (size_t)0));
        else
#endif
            CL_ClientCommand(va("download \"%s\"", q->path));
    } else { // error happened
        Com_EPrintf("[UDP] Couldn't open %s for appending: %s\n",
                    cls.download.temp, Q_ErrorString(ret));
        CL_FinishDownload(q);
        return qfalse;
    }
 
    q->state = DL_RUNNING;
    cls.download.current = q;
    return qtrue;
}

Referenced by CL_StartNextDownload().

write_udp_download()

static int write_udp_download ( byte *  data, int  size  )

static

Definition at line 344 of file download.c.

{
    ssize_t ret;
 
    ret = FS_Write(data, size, cls.download.file);
    if (ret != size) {
        Com_EPrintf("[UDP] Couldn't write %s: %s\n",
                    cls.download.temp, Q_ErrorString(ret));
        finish_udp_download(NULL);
        return -1;
    }
 
    return 0;
}

Referenced by CL_HandleDownload(), and inflate_udp_download().

Variable Documentation

precache_check

precache_t precache_check

static

Definition at line 36 of file download.c.

Referenced by CL_RequestNextDownload(), and CL_ResetPrecacheCheck().

precache_sexed_sounds

int precache_sexed_sounds[MAX_SOUNDS]

static

Definition at line 37 of file download.c.

Referenced by check_player(), and CL_RequestNextDownload().

precache_sexed_total

int precache_sexed_total

static

Definition at line 38 of file download.c.

Referenced by check_player(), and CL_RequestNextDownload().