libcurl.c File Reference

#include "quakedef.h"
#include "fs.h"
#include "libcurl.h"
#include "thread.h"
#include "com_list.h"
#include "image.h"
#include "jpeg.h"
#include "image_png.h"

Include dependency graph for libcurl.c:

Go to the source code of this file.

Data Structures
struct	CURLMsg
struct	downloadinfo
struct	requirement

Macros
#define	CINIT(name, type, number)
#define	CLEAR_AND_RETRY()
#define	CURL_GLOBAL_NOTHING   0
#define	CURL_GLOBAL_SSL   1
#define	CURL_GLOBAL_WIN32   2
#define	CURLINFO_DOUBLE   0x300000
#define	CURLINFO_LONG   0x200000
#define	CURLINFO_MASK   0x0fffff
#define	CURLINFO_SLIST   0x400000
#define	CURLINFO_STRING   0x100000
#define	CURLINFO_TYPEMASK   0xf00000
#define	CURLOPTTYPE_FUNCTIONPOINT   20000
#define	CURLOPTTYPE_LONG   0
#define	CURLOPTTYPE_OBJECTPOINT   10000
#define	CURLOPTTYPE_OFF_T   30000
#define	CURLPROTO_FTP   (1<<2)
#define	CURLPROTO_HTTP   (1<<0)
#define	CURLPROTO_HTTPS   (1<<1)
#define	LOADTYPE_CACHEPIC   2
#define	LOADTYPE_NONE   0
#define	LOADTYPE_PAK   1
#define	LOADTYPE_SKINFRAME   3

Typedefs
typedef struct CURL_s	CURL
typedef struct curl_slist	curl_slist
typedef struct CURLM_s	CURLM

Enumerations
enum	curl_infotype {   CURLINFO_TEXT = 0 , CURLINFO_HEADER_IN , CURLINFO_HEADER_OUT , CURLINFO_DATA_IN ,   CURLINFO_DATA_OUT , CURLINFO_SSL_DATA_IN , CURLINFO_SSL_DATA_OUT , CURLINFO_END }
enum	CURLcode { CURLE_OK = 0 }
enum	CURLINFO {   CURLINFO_NONE , CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1 , CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2 , CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3 ,   CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4 , CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5 , CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6 , CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7 ,   CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8 , CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9 , CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10 , CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11 ,   CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12 , CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13 , CURLINFO_FILETIME = CURLINFO_LONG + 14 , CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15 ,   CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16 , CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17 , CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18 , CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19 ,   CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20 , CURLINFO_PRIVATE = CURLINFO_STRING + 21 , CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22 , CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23 ,   CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24 , CURLINFO_OS_ERRNO = CURLINFO_LONG + 25 , CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26 , CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27 }
enum	CURLMcode { CURLM_CALL_MULTI_PERFORM =-1 , CURLM_OK = 0 }
enum	CURLMSG { CURLMSG_NONE , CURLMSG_DONE , CURLMSG_LAST }
enum	CURLoption {   CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) ,   CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) ,   CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) ,   CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) , CINIT =(WRITEDATA, OBJECTPOINT, 1) ,   CINIT =(WRITEDATA, OBJECTPOINT, 1) }
enum	CurlStatus { CURL_DOWNLOAD_SUCCESS = 0 , CURL_DOWNLOAD_FAILED , CURL_DOWNLOAD_ABORTED , CURL_DOWNLOAD_SERVERERROR }

Functions
static void	CheckPendingDownloads (void)
static const char *	CleanURL (const char *url, char *urlbuf, size_t urlbuflength)
qbool	Curl_Available (void)
static qbool	Curl_Begin (const char *URL, const char *extraheaders, double maxspeed, const char *name, int loadtype, qbool forthismap, const char *post_content_type, const unsigned char *postbuf, size_t postbufsize, unsigned char *buf, size_t bufsize, curl_callback_t callback, void *cbdata)
qbool	Curl_Begin_ToFile (const char *URL, double maxspeed, const char *name, int loadtype, qbool forthismap)
qbool	Curl_Begin_ToMemory (const char *URL, double maxspeed, unsigned char *buf, size_t bufsize, curl_callback_t callback, void *cbdata)
qbool	Curl_Begin_ToMemory_POST (const char *URL, const char *extraheaders, double maxspeed, const char *post_content_type, const unsigned char *postbuf, size_t postbufsize, unsigned char *buf, size_t bufsize, curl_callback_t callback, void *cbdata)
void	Curl_Cancel_ToMemory (curl_callback_t callback, void *cbdata)
void	Curl_CancelAll (void)
static void	Curl_CheckCommandWhenDone (void)
void	Curl_Clear_forthismap (void)
void	Curl_ClearRequirements (void)
static void	CURL_CloseLibrary (void)
static void	Curl_CommandWhenDone (const char *cmd)
static void	Curl_CommandWhenError (const char *cmd)
static void	Curl_Curl_f (cmd_state_t *cmd)
static void	curl_default_callback (int status, size_t length_received, unsigned char *buffer, void *cbdata)
static void	Curl_EndDownload (downloadinfo *di, CurlStatus status, CURLcode error, const char *content_type_)
static downloadinfo *	Curl_Find (const char *filename)
static const char *	Curl_FindPackURL (const char *filename)
void	Curl_Frame (void)
static size_t	CURL_fwrite (void *data, size_t size, size_t nmemb, void *vdi)
static double	Curl_GetDownloadAmount (downloadinfo *di)
Curl_downloadinfo_t *	Curl_GetDownloadInfo (int *nDownloads, const char **additional_info, char *addinfo, size_t addinfolength)
static double	Curl_GetDownloadSpeed (downloadinfo *di)
qbool	Curl_Have_forthismap (void)
static void	Curl_Info_f (cmd_state_t *cmd)
void	Curl_Init (void)
void	Curl_Init_Commands (void)
static qbool	CURL_OpenLibrary (void)
static void	curl_quiet_callback (int status, size_t length_received, unsigned char *buffer, void *cbdata)
void	Curl_Register_predownload (void)
void	Curl_RequireFile (const char *filename)
qbool	Curl_Running (void)
bool	Curl_Select (int timeout_ms)
static qbool	Curl_SendRequirement (const char *filename, qbool foundone, char *sendbuffer, size_t sendbuffer_len)
void	Curl_SendRequirements (void)
void	Curl_Shutdown (void)
static unsigned char *	decode_image (downloadinfo *di, const char *content_type)
	LIST_HEAD (downloads)

Variables
static double	bytes_received = 0
static double	bytes_sent = 0
static char	command_when_done [256] = ""
static char	command_when_error [256] = ""
static dllhandle_t	curl_dll = NULL
static cvar_t	curl_enabled = {CF_SHARED | CF_ARCHIVE, "curl_enabled","1", "whether libcurl may be used to GET files or POST data"}
static cvar_t	curl_maxdownloads = {CF_SHARED | CF_ARCHIVE, "curl_maxdownloads","3", "maximum number of concurrent HTTP/FTP downloads"}
static cvar_t	curl_maxspeed = {CF_SHARED | CF_ARCHIVE, "curl_maxspeed","0", "maximum download speed (KiB/s)"}
void *	curl_mutex = NULL
static cvar_t	curl_useragent = {CF_SHARED, "curl_useragent","1", "send the User-Agent string (note: turning this off may break stuff)"}
static cvar_t	curl_useragent_append = {CF_SHARED, "curl_useragent_append","", "a string to append to the User-Agent string (useful for name and version number of your mod)"}
static dllfunction_t	curlfuncs []
static CURLM *	curlm = NULL
static double	curltime = 0
static cvar_t	developer_curl = {CF_SHARED, "developer_curl","0", "whether verbose libcurl output should be printed to stderr"}
static qbool	noclear = false
static int	numdownloads = 0
static int	numdownloads_added = 0
static int	numdownloads_fail = 0
static int	numdownloads_success = 0
static void(*	qcurl_easy_cleanup )(CURL *handle)
static CURLcode(*	qcurl_easy_getinfo )(CURL *handle, CURLINFO info,...)
static CURL *(*	qcurl_easy_init )(void)
static CURLcode(*	qcurl_easy_setopt )(CURL *handle, CURLoption option,...)
static const char *(*	qcurl_easy_strerror )(CURLcode)
static void(*	qcurl_global_cleanup )(void)
static void(*	qcurl_global_init )(long flags)
static CURLMcode(*	qcurl_multi_add_handle )(CURLM *multi_handle, CURL *easy_handle)
static void(*	qcurl_multi_cleanup )(CURLM *)
static CURLMsg *(*	qcurl_multi_info_read )(CURLM *multi_handle, int *msgs_in_queue)
static CURLM *(*	qcurl_multi_init )(void)
static CURLMcode(*	qcurl_multi_perform )(CURLM *multi_handle, int *running_handles)
static CURLMcode(*	qcurl_multi_remove_handle )(CURLM *multi_handle, CURL *easy_handle)
static const char *(*	qcurl_multi_strerror )(CURLcode)
static CURLMcode(*	qcurl_multi_wait )(CURLM *multi_handle, void *, unsigned int extra_nfds, int timeout_ms, int *ret)
static curl_slist *(*	qcurl_slist_append )(curl_slist *list, const char *string)
static void(*	qcurl_slist_free_all )(curl_slist *list)
static requirement *	requirements = NULL
static cvar_t	sv_curl_defaulturl = {CF_SERVER, "sv_curl_defaulturl","", "default autodownload source URL"}
static cvar_t	sv_curl_maxspeed = {CF_SERVER, "sv_curl_maxspeed","0", "maximum download speed for clients downloading from sv_curl_defaulturl (KiB/s)"}
static cvar_t	sv_curl_serverpackages = {CF_SERVER, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"}

Macro Definition Documentation

CINIT

#define CINIT	(		name,
			type,
			number )

Value:

CURLOPT_ ## name = CURLOPTTYPE_ ## type + number

Definition at line 54 of file libcurl.c.

CLEAR_AND_RETRY

#define CLEAR_AND_RETRY

(

)

Value:

    do \
    { \
        di->stream = FS_OpenRealFile(di->filename, "wb", false); \
        FS_Close(di->stream); \
        if(di->startpos && !di->callback) \
        { \
            Curl_Begin(di->url, di->extraheaders, di->maxspeed, di->filename, di->loadtype, di->forthismap, di->post_content_type, di->postbuf, di->postbufsize, NULL, 0, NULL, NULL); \
            di->forthismap = false; \
        } \
    } \
    while(0)

Referenced by Curl_EndDownload().

CURL_GLOBAL_NOTHING

#define CURL_GLOBAL_NOTHING   0

Definition at line 47 of file libcurl.c.

CURL_GLOBAL_SSL

#define CURL_GLOBAL_SSL   1

Definition at line 48 of file libcurl.c.

Referenced by Curl_Init().

CURL_GLOBAL_WIN32

#define CURL_GLOBAL_WIN32   2

Definition at line 49 of file libcurl.c.

CURLINFO_DOUBLE

#define CURLINFO_DOUBLE   0x300000

Definition at line 94 of file libcurl.c.

CURLINFO_LONG

#define CURLINFO_LONG   0x200000

Definition at line 93 of file libcurl.c.

CURLINFO_MASK

#define CURLINFO_MASK   0x0fffff

Definition at line 96 of file libcurl.c.

CURLINFO_SLIST

#define CURLINFO_SLIST   0x400000

Definition at line 95 of file libcurl.c.

CURLINFO_STRING

#define CURLINFO_STRING   0x100000

Definition at line 92 of file libcurl.c.

CURLINFO_TYPEMASK

#define CURLINFO_TYPEMASK   0xf00000

Definition at line 97 of file libcurl.c.

CURLOPTTYPE_FUNCTIONPOINT

#define CURLOPTTYPE_FUNCTIONPOINT   20000

Definition at line 52 of file libcurl.c.

CURLOPTTYPE_LONG

#define CURLOPTTYPE_LONG   0

Definition at line 50 of file libcurl.c.

CURLOPTTYPE_OBJECTPOINT

#define CURLOPTTYPE_OBJECTPOINT   10000

Definition at line 51 of file libcurl.c.

CURLOPTTYPE_OFF_T

#define CURLOPTTYPE_OFF_T   30000

Definition at line 53 of file libcurl.c.

CURLPROTO_FTP

#define CURLPROTO_FTP   (1<<2)

Definition at line 79 of file libcurl.c.

Referenced by CheckPendingDownloads().

CURLPROTO_HTTP

#define CURLPROTO_HTTP   (1<<0)

Definition at line 77 of file libcurl.c.

Referenced by CheckPendingDownloads().

CURLPROTO_HTTPS

#define CURLPROTO_HTTPS   (1<<1)

Definition at line 78 of file libcurl.c.

Referenced by CheckPendingDownloads().

LOADTYPE_CACHEPIC

#define LOADTYPE_CACHEPIC   2

Definition at line 200 of file libcurl.c.

Referenced by Curl_Curl_f(), and Curl_EndDownload().

LOADTYPE_NONE

#define LOADTYPE_NONE   0

Definition at line 198 of file libcurl.c.

Referenced by Curl_Begin(), and Curl_Curl_f().

LOADTYPE_PAK

#define LOADTYPE_PAK   1

Definition at line 199 of file libcurl.c.

Referenced by Curl_Begin(), Curl_Curl_f(), and Curl_EndDownload().

LOADTYPE_SKINFRAME

#define LOADTYPE_SKINFRAME   3

Definition at line 201 of file libcurl.c.

Referenced by Curl_Curl_f(), and Curl_EndDownload().

Typedef Documentation

CURL

typedef struct CURL_s CURL

Definition at line 33 of file libcurl.c.

curl_slist

typedef struct curl_slist curl_slist

Definition at line 35 of file libcurl.c.

CURLM

typedef struct CURLM_s CURLM

Definition at line 34 of file libcurl.c.

Enumeration Type Documentation

curl_infotype

enum curl_infotype

Enumerator
CURLINFO_TEXT
CURLINFO_HEADER_IN
CURLINFO_HEADER_OUT
CURLINFO_DATA_IN
CURLINFO_DATA_OUT
CURLINFO_SSL_DATA_IN
CURLINFO_SSL_DATA_OUT
CURLINFO_END

Definition at line 80 of file libcurl.c.

{
    CURLINFO_TEXT = 0,
    CURLINFO_HEADER_IN,    /* 1 */
    CURLINFO_HEADER_OUT,   /* 2 */
    CURLINFO_DATA_IN,      /* 3 */
    CURLINFO_DATA_OUT,     /* 4 */
    CURLINFO_SSL_DATA_IN,  /* 5 */
    CURLINFO_SSL_DATA_OUT, /* 6 */
    CURLINFO_END
}

CURLcode

enum CURLcode

Enumerator
CURLE_OK

Definition at line 36 of file libcurl.c.

{
    CURLE_OK = 0
}

CURLINFO

enum CURLINFO

Enumerator
CURLINFO_NONE
CURLINFO_EFFECTIVE_URL
CURLINFO_RESPONSE_CODE
CURLINFO_TOTAL_TIME
CURLINFO_NAMELOOKUP_TIME
CURLINFO_CONNECT_TIME
CURLINFO_PRETRANSFER_TIME
CURLINFO_SIZE_UPLOAD
CURLINFO_SIZE_DOWNLOAD
CURLINFO_SPEED_DOWNLOAD
CURLINFO_SPEED_UPLOAD
CURLINFO_HEADER_SIZE
CURLINFO_REQUEST_SIZE
CURLINFO_SSL_VERIFYRESULT
CURLINFO_FILETIME
CURLINFO_CONTENT_LENGTH_DOWNLOAD
CURLINFO_CONTENT_LENGTH_UPLOAD
CURLINFO_STARTTRANSFER_TIME
CURLINFO_CONTENT_TYPE
CURLINFO_REDIRECT_TIME
CURLINFO_REDIRECT_COUNT
CURLINFO_PRIVATE
CURLINFO_HTTP_CONNECTCODE
CURLINFO_HTTPAUTH_AVAIL
CURLINFO_PROXYAUTH_AVAIL
CURLINFO_OS_ERRNO
CURLINFO_NUM_CONNECTS
CURLINFO_SSL_ENGINES

Definition at line 98 of file libcurl.c.

{
    CURLINFO_NONE, /* first, never use this */
    CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,
    CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,
    CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,
    CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,
    CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,
    CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
    CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,
    CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,
    CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,
    CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,
    CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,
    CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,
    CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,
    CURLINFO_FILETIME         = CURLINFO_LONG   + 14,
    CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,
    CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,
    CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
    CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,
    CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,
    CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,
    CURLINFO_PRIVATE          = CURLINFO_STRING + 21,
    CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,
    CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,
    CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,
    CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,
    CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,
    CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27
}

CURLMcode

enum CURLMcode

Enumerator
CURLM_CALL_MULTI_PERFORM
CURLM_OK

Definition at line 41 of file libcurl.c.

{
    CURLM_CALL_MULTI_PERFORM=-1, /* please call curl_multi_perform() soon */
    CURLM_OK = 0
}

CURLMSG

enum CURLMSG

Enumerator
CURLMSG_NONE
CURLMSG_DONE
CURLMSG_LAST

Definition at line 131 of file libcurl.c.

{
    CURLMSG_NONE, /* first, not used */
    CURLMSG_DONE, /* This easy handle has completed. 'result' contains
                     the CURLcode of the transfer */
    CURLMSG_LAST
}

CURLoption

enum CURLoption

Enumerator
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT
CINIT

Definition at line 55 of file libcurl.c.

{
    CINIT(WRITEDATA, OBJECTPOINT, 1),
    CINIT(URL,  OBJECTPOINT, 2),
    CINIT(ERRORBUFFER, OBJECTPOINT, 10),
    CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
    CINIT(POSTFIELDS, OBJECTPOINT, 15),
    CINIT(REFERER, OBJECTPOINT, 16),
    CINIT(USERAGENT, OBJECTPOINT, 18),
    CINIT(LOW_SPEED_LIMIT, LONG , 19),
    CINIT(LOW_SPEED_TIME, LONG, 20),
    CINIT(RESUME_FROM, LONG, 21),
    CINIT(HTTPHEADER, OBJECTPOINT, 23),
    CINIT(VERBOSE, LONG, 41),
    CINIT(POST, LONG, 47),         /* HTTP POST method */
    CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */
    CINIT(POSTFIELDSIZE, LONG, 60),
    CINIT(PRIVATE, OBJECTPOINT, 103),
    CINIT(PROTOCOLS, LONG, 181),
    CINIT(REDIR_PROTOCOLS, LONG, 182)
}

CurlStatus

enum CurlStatus

Enumerator
CURL_DOWNLOAD_SUCCESS
CURL_DOWNLOAD_FAILED
CURL_DOWNLOAD_ABORTED
CURL_DOWNLOAD_SERVERERROR

Definition at line 447 of file libcurl.c.

{
    CURL_DOWNLOAD_SUCCESS = 0,
    CURL_DOWNLOAD_FAILED,
    CURL_DOWNLOAD_ABORTED,
    CURL_DOWNLOAD_SERVERERROR
}

Function Documentation

CheckPendingDownloads()

static void CheckPendingDownloads ( void )

static

Definition at line 683 of file libcurl.c.

{
    const char *h;
    char urlbuf[1024];
    char vabuf[1024];
    if(!curl_dll)
        return;
    if(numdownloads < curl_maxdownloads.integer)
    {
        downloadinfo *di;
        List_For_Each_Entry(di, &downloads, downloadinfo, list)
        {
            if(!di->started)
            {
                if(!di->buffer)
                {
                    Con_Printf("Downloading %s -> %s", CleanURL(di->url, urlbuf, sizeof(urlbuf)), di->filename);
 
                    di->stream = FS_OpenRealFile(di->filename, "ab", false);
                    if(!di->stream)
                    {
                        Con_Printf("\nFAILED: Could not open output file %s\n", di->filename);
                        Curl_EndDownload(di, CURL_DOWNLOAD_FAILED, CURLE_OK, NULL);
                        return;
                    }
                    FS_Seek(di->stream, 0, SEEK_END);
                    di->startpos = FS_Tell(di->stream);
 
                    if(di->startpos > 0)
                        Con_Printf(", resuming from position %ld", (long) di->startpos);
                    Con_Print("...\n");
                }
                else
                {
                    Con_DPrintf("Downloading %s -> memory\n", CleanURL(di->url, urlbuf, sizeof(urlbuf)));
                    di->startpos = 0;
                }
 
                di->curle = qcurl_easy_init();
                di->slist = NULL;
                qcurl_easy_setopt(di->curle, CURLOPT_URL, di->url);
                if(curl_useragent.integer)
                {
                    const char *ua
#ifdef HTTP_USER_AGENT
                        = HTTP_USER_AGENT;
#else
                        = engineversion;
#endif
                    if(!ua)
                        ua = "";
                    if(*curl_useragent_append.string)
                        ua = va(vabuf, sizeof(vabuf), "%s%s%s",
                            ua,
                            (ua[0] && ua[strlen(ua)-1] != ' ')
                                ? " "
                                : "",
                            curl_useragent_append.string);
                    qcurl_easy_setopt(di->curle, CURLOPT_USERAGENT, ua);
                }
                else
                    qcurl_easy_setopt(di->curle, CURLOPT_USERAGENT, "");
                if(developer_curl.integer) 
                    qcurl_easy_setopt(di->curle, CURLOPT_VERBOSE, (long) 1);
                qcurl_easy_setopt(di->curle, CURLOPT_REFERER, di->referer);
                qcurl_easy_setopt(di->curle, CURLOPT_RESUME_FROM, (long) di->startpos);
                qcurl_easy_setopt(di->curle, CURLOPT_FOLLOWLOCATION, 1);
                qcurl_easy_setopt(di->curle, CURLOPT_WRITEFUNCTION, CURL_fwrite);
                qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_LIMIT, (long) 256);
                qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_TIME, (long) 45);
                qcurl_easy_setopt(di->curle, CURLOPT_WRITEDATA, (void *) di);
                qcurl_easy_setopt(di->curle, CURLOPT_PRIVATE, (void *) di);
                qcurl_easy_setopt(di->curle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP);
                if(qcurl_easy_setopt(di->curle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP) != CURLE_OK)
                {
                    Con_Printf("^1WARNING:^7 for security reasons, please upgrade to libcurl 7.19.4 or above. In a later version of DarkPlaces, HTTP redirect support will be disabled for this libcurl version.\n");
                    //qcurl_easy_setopt(di->curle, CURLOPT_FOLLOWLOCATION, 0);
                }
                if(di->post_content_type)
                {
                    qcurl_easy_setopt(di->curle, CURLOPT_POST, 1);
                    qcurl_easy_setopt(di->curle, CURLOPT_POSTFIELDS, di->postbuf);
                    qcurl_easy_setopt(di->curle, CURLOPT_POSTFIELDSIZE, di->postbufsize);
                    di->slist = qcurl_slist_append(di->slist, va(vabuf, sizeof(vabuf), "Content-Type: %s", di->post_content_type));
                }
 
                // parse extra headers into slist
                // \n separated list!
                h = di->extraheaders;
                while(h)
                {
                    const char *hh = strchr(h, '\n');
                    if(hh)
                    {
                        char *buf = (char *) Mem_Alloc(tempmempool, hh - h + 1);
                        memcpy(buf, h, hh - h);
                        buf[hh - h] = 0;
                        di->slist = qcurl_slist_append(di->slist, buf);
                        h = hh + 1;
                    }
                    else
                    {
                        di->slist = qcurl_slist_append(di->slist, h);
                        h = NULL;
                    }
                }
 
                qcurl_easy_setopt(di->curle, CURLOPT_HTTPHEADER, di->slist);
                
                qcurl_multi_add_handle(curlm, di->curle);
                di->started = true;
                ++numdownloads;
                if(numdownloads >= curl_maxdownloads.integer)
                    break;
            }
        }
    }
}

References buf, downloadinfo::buffer, CleanURL(), Con_DPrintf(), Con_Print(), Con_Printf(), curl_dll, CURL_DOWNLOAD_FAILED, Curl_EndDownload(), CURL_fwrite(), curl_maxdownloads, curl_useragent, curl_useragent_append, downloadinfo::curle, CURLE_OK, curlm, CURLPROTO_FTP, CURLPROTO_HTTP, CURLPROTO_HTTPS, developer_curl, engineversion, downloadinfo::filename, FS_OpenRealFile(), FS_Seek(), FS_Tell(), cvar_t::integer, List_For_Each_Entry, Mem_Alloc, NULL, numdownloads, qcurl_easy_init, qcurl_easy_setopt, qcurl_multi_add_handle, qcurl_slist_append, downloadinfo::referer, downloadinfo::slist, downloadinfo::started, downloadinfo::startpos, downloadinfo::stream, cvar_t::string, strlen(), tempmempool, downloadinfo::url, and va().

Referenced by Curl_Frame().

CleanURL()

static const char * CleanURL ( const char * url, char * urlbuf, size_t urlbuflength )

static

Definition at line 651 of file libcurl.c.

{
    const char *p, *q, *r;
 
    // if URL is of form anything://foo-without-slash@rest, replace by anything://rest
    p = strstr(url, "://");
    if(p)
    {
        q = strchr(p + 3, '@');
        if(q)
        {
            r = strchr(p + 3, '/');
            if(!r || q < r)
            {
                dpsnprintf(urlbuf, urlbuflength, "%.*s%s", (int)(p - url + 3), url, q + 1);
                return urlbuf;
            }
        }
    }
 
    return url;
}

References dpsnprintf(), and r.

Referenced by CheckPendingDownloads(), Curl_Begin(), and Curl_Info_f().

Curl_Available()

qbool Curl_Available

(

void

)

Definition at line 840 of file libcurl.c.

{
    return curl_dll ? true : false;
}

References curl_dll, and true.

Referenced by checkextension().

Curl_Begin()

static qbool Curl_Begin ( const char * URL, const char * extraheaders, double maxspeed, const char * name, int loadtype, qbool forthismap, const char * post_content_type, const unsigned char * postbuf, size_t postbufsize, unsigned char * buf, size_t bufsize, curl_callback_t callback, void * cbdata )

static

Definition at line 886 of file libcurl.c.

{
    if(buf)
        if(loadtype != LOADTYPE_NONE)
            Host_Error("Curl_Begin: loadtype and buffer are both set");
 
    if(!curl_dll || !curl_enabled.integer)
    {
        return false;
    }
    else
    {
        char fn[MAX_OSPATH];
        char urlbuf[1024];
        const char *p, *q;
        size_t length;
        downloadinfo *di;
 
        // if URL is protocol:///* or protocol://:port/*, insert the IP of the current server
        p = strchr(URL, ':');
        if(p)
        {
            if(!strncmp(p, ":///", 4) || !strncmp(p, "://:", 4))
            {
                char addressstring[128];
                *addressstring = 0;
                InfoString_GetValue(cls.userinfo, "*ip", addressstring, sizeof(addressstring));
                q = strchr(addressstring, ':');
                if(!q)
                    q = addressstring + strlen(addressstring);
                if(*addressstring)
                {
                    dpsnprintf(urlbuf, sizeof(urlbuf), "%.*s://%.*s%s", (int) (p - URL), URL, (int) (q - addressstring), addressstring, URL + (p - URL) + 3);
                    URL = urlbuf;
                }
            }
        }
 
        // Note: This extraction of the file name portion is NOT entirely correct.
        //
        // It does the following:
        //
        //   http://host/some/script.cgi/SomeFile.pk3?uid=ABCDE -> SomeFile.pk3
        //   http://host/some/script.php?uid=ABCDE&file=/SomeFile.pk3 -> SomeFile.pk3
        //   http://host/some/script.php?uid=ABCDE&file=SomeFile.pk3 -> script.php
        //
        // However, I'd like to keep this "buggy" behavior so that PHP script
        // authors can write download scripts without having to enable
        // AcceptPathInfo on Apache. They just have to ensure that their script
        // can be called with such a "fake" path name like
        // http://host/some/script.php?uid=ABCDE&file=/SomeFile.pk3
        //
        // By the way, such PHP scripts should either send the file or a
        // "Location:" redirect; PHP code example:
        //
        //   header("Location: http://www.example.com/");
        //
        // By the way, this will set User-Agent to something like
        // "Nexuiz build 22:27:55 Mar 17 2006" (engineversion) and Referer to
        // dp://serverhost:serverport/ so you can filter on this; an example
        // httpd log file line might be:
        //
        //   141.2.16.3 - - [17/Mar/2006:22:32:43 +0100] "GET /maps/tznex07.pk3 HTTP/1.1" 200 1077455 "dp://141.2.16.7:26000/" "Nexuiz Linux 22:07:43 Mar 17 2006"
 
        if (curl_mutex) Thread_LockMutex(curl_mutex);
 
        if(buf)
        {
            if(!name)
                name = CleanURL(URL, urlbuf, sizeof(urlbuf));
        }
        else
        {
            if(!name)
            {
                name = CleanURL(URL, urlbuf, sizeof(urlbuf));
                p = strrchr(name, '/');
                p = p ? (p+1) : name;
                q = strchr(p, '?');
                length = q ? (size_t)(q - p) : strlen(p);
                dpsnprintf(fn, sizeof(fn), "dlcache/%.*s", (int)length, p);
            }
            else
            {
                dpsnprintf(fn, sizeof(fn), "dlcache/%s", name);
            }
 
            name = fn; // make it point back
 
            // already downloading the file?
            {
                downloadinfo *existingdownloadinfo = Curl_Find(fn);
                if(existingdownloadinfo)
                {
                    Con_Printf("Can't download %s, already getting it from %s!\n", fn, CleanURL(existingdownloadinfo->url, urlbuf, sizeof(urlbuf)));
 
                    // however, if it was not for this map yet...
                    if(forthismap && !existingdownloadinfo->forthismap)
                    {
                        existingdownloadinfo->forthismap = true;
                        // this "fakes" a download attempt so the client will wait for
                        // the download to finish and then reconnect
                        ++numdownloads_added;
                    }
 
                    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
                    return false;
                }
            }
 
            if(FS_FileExists(fn))
            {
                if(loadtype == LOADTYPE_PAK)
                {
                    qbool already_loaded;
                    if(FS_AddPack(fn, &already_loaded, true, true))
                    {
                        Con_DPrintf("%s already exists, not downloading!\n", fn);
                        if(already_loaded)
                            Con_DPrintf("(pak was already loaded)\n");
                        else
                        {
                            if(forthismap)
                            {
                                ++numdownloads_added;
                                ++numdownloads_success;
                            }
                        }
 
                        if (curl_mutex) Thread_UnlockMutex(curl_mutex);
                        return false;
                    }
                    else
                    {
                        qfile_t *f = FS_OpenRealFile(fn, "rb", false);
                        if(f)
                        {
                            char b[4] = {0};
                            FS_Read(f, b, sizeof(b)); // no "-1", I will use memcmp
 
                            if(memcmp(b, "PK\x03\x04", 4) && memcmp(b, "PACK", 4))
                            {
                                Con_DPrintf("Detected non-PAK %s, clearing and NOT resuming.\n", fn);
                                FS_Close(f);
                                f = FS_OpenRealFile(fn, "wb", false);
                                if(f)
                                    FS_Close(f);
                            }
                            else
                            {
                                // OK
                                FS_Close(f);
                            }
                        }
                    }
                }
                else
                {
                    // never resume these
                    qfile_t *f = FS_OpenRealFile(fn, "wb", false);
                    if(f)
                        FS_Close(f);
                }
            }
        }
 
        // if we get here, we actually want to download... so first verify the
        // URL scheme (so one can't read local files using file://)
        if(strncmp(URL, "http://", 7) && strncmp(URL, "ftp://", 6) && strncmp(URL, "https://", 8))
        {
            Con_Printf("Curl_Begin(\"%s\"): nasty URL scheme rejected\n", URL);
            if (curl_mutex) Thread_UnlockMutex(curl_mutex);
            return false;
        }
 
        if(forthismap)
            ++numdownloads_added;
        di = (downloadinfo *) Z_Malloc(sizeof(*di));
        dp_strlcpy(di->filename, name, sizeof(di->filename));
        dp_strlcpy(di->url, URL, sizeof(di->url));
        dpsnprintf(di->referer, sizeof(di->referer), "dp://%s/", cls.netcon ? cls.netcon->address : "notconnected.invalid");
        di->forthismap = forthismap;
        di->stream = NULL;
        di->startpos = 0;
        di->curle = NULL;
        di->started = false;
        di->loadtype = loadtype;
        di->maxspeed = maxspeed;
        di->bytes_received = 0;
        di->bytes_received_curl = 0;
        di->bytes_sent_curl = 0;
        di->extraheaders = extraheaders;
        di->buffer = buf;
        di->buffersize = bufsize;
        if(callback == NULL)
        {
            di->callback = curl_default_callback;
            di->callback_data = di;
        }
        else
        {
            di->callback = callback;
            di->callback_data = cbdata;
        }
 
        if(post_content_type)
        {
            di->post_content_type = post_content_type;
            di->postbuf = postbuf;
            di->postbufsize = postbufsize;
        }
        else
        {
            di->post_content_type = NULL;
            di->postbuf = NULL;
            di->postbufsize = 0;
        }
 
        List_Add(&di->list, &downloads);
 
        if (curl_mutex)
            Thread_UnlockMutex(curl_mutex);
 
        return true;
    }
}

References netconn_t::address, b, buf, downloadinfo::buffer, downloadinfo::buffersize, downloadinfo::bytes_received, downloadinfo::bytes_received_curl, downloadinfo::bytes_sent_curl, downloadinfo::callback, downloadinfo::callback_data, CleanURL(), cls, Con_DPrintf(), Con_Printf(), curl_default_callback(), curl_dll, curl_enabled, Curl_Find(), curl_mutex, downloadinfo::curle, dp_strlcpy, dpsnprintf(), downloadinfo::extraheaders, f, downloadinfo::filename, downloadinfo::forthismap, FS_AddPack(), FS_Close(), FS_FileExists(), FS_OpenRealFile(), FS_Read(), Host_Error(), InfoString_GetValue(), cvar_t::integer, length, downloadinfo::list, List_Add(), downloadinfo::loadtype, LOADTYPE_NONE, LOADTYPE_PAK, MAX_OSPATH, downloadinfo::maxspeed, name, client_static_t::netcon, NULL, numdownloads_added, numdownloads_success, downloadinfo::post_content_type, downloadinfo::postbuf, downloadinfo::postbufsize, downloadinfo::referer, downloadinfo::started, downloadinfo::startpos, downloadinfo::stream, strlen(), Thread_LockMutex, Thread_UnlockMutex, downloadinfo::url, client_static_t::userinfo, and Z_Malloc.

Referenced by Curl_Begin_ToFile(), Curl_Begin_ToMemory(), and Curl_Begin_ToMemory_POST().

Curl_Begin_ToFile()

qbool Curl_Begin_ToFile	(	const char *	URL,
		double	maxspeed,
		const char *	name,
		int	loadtype,
		qbool	forthismap )

Definition at line 1113 of file libcurl.c.

{
    return Curl_Begin(URL, NULL, maxspeed, name, loadtype, forthismap, NULL, NULL, 0, NULL, 0, NULL, NULL);
}

References Curl_Begin(), name, and NULL.

Referenced by Curl_Curl_f().

Curl_Begin_ToMemory()

qbool Curl_Begin_ToMemory	(	const char *	URL,
		double	maxspeed,
		unsigned char *	buf,
		size_t	bufsize,
		curl_callback_t	callback,
		void *	cbdata )

Definition at line 1117 of file libcurl.c.

{
    return Curl_Begin(URL, NULL, maxspeed, NULL, false, false, NULL, NULL, 0, buf, bufsize, callback, cbdata);
}

References buf, Curl_Begin(), and NULL.

Referenced by Crypto_KeyGen_f().

Curl_Begin_ToMemory_POST()

qbool Curl_Begin_ToMemory_POST	(	const char *	URL,
		const char *	extraheaders,
		double	maxspeed,
		const char *	post_content_type,
		const unsigned char *	postbuf,
		size_t	postbufsize,
		unsigned char *	buf,
		size_t	bufsize,
		curl_callback_t	callback,
		void *	cbdata )

Definition at line 1121 of file libcurl.c.

{
    return Curl_Begin(URL, extraheaders, maxspeed, NULL, false, false, post_content_type, postbuf, postbufsize, buf, bufsize, callback, cbdata);
}

References buf, Curl_Begin(), and NULL.

Referenced by VM_uri_get().

Curl_Cancel_ToMemory()

void Curl_Cancel_ToMemory	(	curl_callback_t	callback,
		void *	cbdata )

Definition at line 863 of file libcurl.c.

{
    downloadinfo *di, *ndi;
    if(!curl_dll)
        return;
    List_For_Each_Entry_Safe(di, ndi, &downloads, downloadinfo, list)
    {
        if(di->callback == callback && di->callback_data == cbdata)
        {
            di->callback = curl_quiet_callback; // do NOT call the callback
            Curl_EndDownload(di, CURL_DOWNLOAD_ABORTED, CURLE_OK, NULL);
        }
    }
}

References downloadinfo::callback, downloadinfo::callback_data, curl_dll, CURL_DOWNLOAD_ABORTED, Curl_EndDownload(), curl_quiet_callback(), CURLE_OK, List_For_Each_Entry_Safe, and NULL.

Curl_CancelAll()

void Curl_CancelAll

(

void

)

Definition at line 1284 of file libcurl.c.

{
    if(!curl_dll)
        return;
 
    if (curl_mutex) Thread_LockMutex(curl_mutex);
 
    while(!List_Is_Empty(&downloads))
    {
        Curl_EndDownload(List_First_Entry(&downloads, downloadinfo, list), CURL_DOWNLOAD_ABORTED, CURLE_OK, NULL);
        // INVARIANT: downloads will point to the next download after that!
    }
 
    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
}

References curl_dll, CURL_DOWNLOAD_ABORTED, Curl_EndDownload(), curl_mutex, CURLE_OK, List_First_Entry, List_Is_Empty(), NULL, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by CL_StopDownload_f(), Curl_Curl_f(), and Curl_Shutdown().

Curl_CheckCommandWhenDone()

static void Curl_CheckCommandWhenDone ( void )

static

Definition at line 331 of file libcurl.c.

{
    if(!curl_dll)
        return;
    if(numdownloads_added && ((numdownloads_success + numdownloads_fail) == numdownloads_added))
    {
        if(numdownloads_fail == 0)
        {
            Con_DPrintf("cURL downloads occurred, executing %s\n", command_when_done);
            Cbuf_AddText(cmd_local, "\n");
            Cbuf_AddText(cmd_local, command_when_done);
            Cbuf_AddText(cmd_local, "\n");
        }
        else
        {
            Con_DPrintf("cURL downloads FAILED, executing %s\n", command_when_error);
            Cbuf_AddText(cmd_local, "\n");
            Cbuf_AddText(cmd_local, command_when_error);
            Cbuf_AddText(cmd_local, "\n");
        }
        Curl_Clear_forthismap();
    }
}

References Cbuf_AddText(), cmd_local, command_when_done, command_when_error, Con_DPrintf(), Curl_Clear_forthismap(), curl_dll, numdownloads_added, numdownloads_fail, and numdownloads_success.

Referenced by Curl_Curl_f(), and Curl_Frame().

Curl_Clear_forthismap()

void Curl_Clear_forthismap

(

void

)

Definition at line 287 of file libcurl.c.

{
    downloadinfo *di;
    if(noclear)
        return;
    if (curl_mutex) Thread_LockMutex(curl_mutex);
    List_For_Each_Entry(di, &downloads, downloadinfo, list)
        di->forthismap = false;
    Curl_CommandWhenError(NULL);
    Curl_CommandWhenDone(NULL);
    numdownloads_fail = 0;
    numdownloads_success = 0;
    numdownloads_added = 0;
    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
}

References Curl_CommandWhenDone(), Curl_CommandWhenError(), curl_mutex, downloadinfo::forthismap, List_For_Each_Entry, noclear, NULL, numdownloads_added, numdownloads_fail, numdownloads_success, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by CL_DisconnectEx(), Curl_CheckCommandWhenDone(), and Curl_Curl_f().

Curl_ClearRequirements()

void Curl_ClearRequirements

(

void

)

Definition at line 1795 of file libcurl.c.

{
    while(requirements)
    {
        requirement *req = requirements;
        requirements = requirements->next;
        Z_Free(req);
    }
}

References requirement::next, requirements, and Z_Free.

Referenced by Curl_Shutdown(), and SV_SpawnServer().

CURL_CloseLibrary()

static void CURL_CloseLibrary ( void )

static

Definition at line 397 of file libcurl.c.

{
    Sys_FreeLibrary (&curl_dll);
}

References curl_dll, and Sys_FreeLibrary().

Referenced by Curl_Shutdown().

Curl_CommandWhenDone()

static void Curl_CommandWhenDone ( const char * cmd )

static

Definition at line 254 of file libcurl.c.

{
    if(!curl_dll)
        return;
    if(cmd)
        dp_strlcpy(command_when_done, cmd, sizeof(command_when_done));
    else
        *command_when_done = 0;
}

References cmd(), command_when_done, curl_dll, and dp_strlcpy.

Referenced by Curl_Clear_forthismap(), Curl_Curl_f(), and Curl_Register_predownload().

Curl_CommandWhenError()

static void Curl_CommandWhenError ( const char * cmd )

static

Definition at line 270 of file libcurl.c.

{
    if(!curl_dll)
        return;
    if(cmd)
        dp_strlcpy(command_when_error, cmd, sizeof(command_when_error));
    else
        *command_when_error = 0;
}

References cmd(), command_when_error, curl_dll, and dp_strlcpy.

Referenced by Curl_Clear_forthismap(), and Curl_Register_predownload().

Curl_Curl_f()

static void Curl_Curl_f ( cmd_state_t * cmd )

static

Definition at line 1424 of file libcurl.c.

{
    double maxspeed = 0;
    int i;
    int end;
    int loadtype = LOADTYPE_NONE;
    qbool forthismap = false;
    const char *url;
    const char *name = 0;
 
    if(!curl_dll)
    {
        Con_Print("libcurl DLL not found, this command is inactive.\n");
        return;
    }
 
    if(!curl_enabled.integer)
    {
        Con_Print("curl support not enabled. Set cl_curl_enabled to 1 to enable.\n");
        return;
    }
 
    if(Cmd_Argc(cmd) < 2)
    {
        Con_Print("usage:\ncurl --info, curl --cancel [filename], curl url\n");
        return;
    }
 
    url = Cmd_Argv(cmd, Cmd_Argc(cmd) - 1);
    end = Cmd_Argc(cmd);
 
    for(i = 1; i != end; ++i)
    {
        const char *a = Cmd_Argv(cmd, i);
        if(!strcmp(a, "--info"))
        {
            Curl_Info_f(cmd);
            return;
        }
        else if(!strcmp(a, "--cancel"))
        {
            if(i == end - 1) // last argument
                Curl_CancelAll();
            else
            {
                downloadinfo *di = Curl_Find(url);
                if(di)
                    Curl_EndDownload(di, CURL_DOWNLOAD_ABORTED, CURLE_OK, NULL);
                else
                    Con_Print("download not found\n");
            }
            return;
        }
        else if(!strcmp(a, "--pak"))
        {
            loadtype = LOADTYPE_PAK;
        }
        else if(!strcmp(a, "--cachepic"))
        {
            loadtype = LOADTYPE_CACHEPIC;
        }
        else if(!strcmp(a, "--skinframe"))
        {
            loadtype = LOADTYPE_SKINFRAME;
        }
        else if(!strcmp(a, "--for")) // must be last option
        {
            for(i = i + 1; i != end - 1; ++i)
            {
                if(!FS_FileExists(Cmd_Argv(cmd, i)))
                    goto needthefile; // why can't I have a "double break"?
            }
            // if we get here, we have all the files...
            return;
        }
        else if(!strcmp(a, "--forthismap"))
        {
            forthismap = true;
        }
        else if(!strcmp(a, "--as"))
        {
            if(i < end - 1)
            {
                ++i;
                name = Cmd_Argv(cmd, i);
            }
        }
        else if(!strcmp(a, "--clear_autodownload"))
        {
            // mark all running downloads as "not for this map", so if they
            // fail, it does not matter
            Curl_Clear_forthismap();
            return;
        }
        else if(!strcmp(a, "--finish_autodownload"))
        {
            if(numdownloads_added)
            {
                char donecommand[256];
                if(cls.netcon)
                {
                    if(cl.loadbegun) // curling won't inhibit loading the map any more when at this stage, so bail out and force a reconnect
                    {
                        dpsnprintf(donecommand, sizeof(donecommand), "connect %s", cls.netcon->address);
                        Curl_CommandWhenDone(donecommand);
                        noclear = true;
                        CL_Disconnect();
                        noclear = false;
                        Curl_CheckCommandWhenDone();
                    }
                    else
                        Curl_Register_predownload();
                }
            }
            return;
        }
        else if(!strncmp(a, "--maxspeed=", 11))
        {
            maxspeed = atof(a + 11);
        }
        else if(*a == '-')
        {
            Con_Printf("curl: invalid option %s\n", a);
            // but we ignore the option
        }
    }
 
needthefile:
    Curl_Begin_ToFile(url, maxspeed, name, loadtype, forthismap);
}

References a, netconn_t::address, cl, CL_Disconnect(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), Curl_Begin_ToFile(), Curl_CancelAll(), Curl_CheckCommandWhenDone(), Curl_Clear_forthismap(), Curl_CommandWhenDone(), curl_dll, CURL_DOWNLOAD_ABORTED, curl_enabled, Curl_EndDownload(), Curl_Find(), Curl_Info_f(), Curl_Register_predownload(), CURLE_OK, dpsnprintf(), FS_FileExists(), i, cvar_t::integer, client_state_t::loadbegun, LOADTYPE_CACHEPIC, LOADTYPE_NONE, LOADTYPE_PAK, LOADTYPE_SKINFRAME, name, client_static_t::netcon, noclear, NULL, and numdownloads_added.

Referenced by Curl_Init_Commands().

curl_default_callback()

static void curl_default_callback ( int status, size_t length_received, unsigned char * buffer, void * cbdata )

static

Definition at line 456 of file libcurl.c.

{
    downloadinfo *di = (downloadinfo *) cbdata;
    switch(status)
    {
        case CURLCBSTATUS_OK:
            Con_DPrintf("Download of %s: OK\n", di->filename);
            break;
        case CURLCBSTATUS_FAILED:
            Con_DPrintf("Download of %s: FAILED\n", di->filename);
            break;
        case CURLCBSTATUS_ABORTED:
            Con_DPrintf("Download of %s: ABORTED\n", di->filename);
            break;
        case CURLCBSTATUS_SERVERERROR:
            Con_DPrintf("Download of %s: (unknown server error)\n", di->filename);
            break;
        case CURLCBSTATUS_UNKNOWN:
            Con_DPrintf("Download of %s: (unknown client error)\n", di->filename);
            break;
        default:
            Con_DPrintf("Download of %s: %d\n", di->filename, status);
            break;
    }
}

References Con_DPrintf(), CURLCBSTATUS_ABORTED, CURLCBSTATUS_FAILED, CURLCBSTATUS_OK, CURLCBSTATUS_SERVERERROR, CURLCBSTATUS_UNKNOWN, and downloadinfo::filename.

Referenced by Curl_Begin(), and curl_quiet_callback().

Curl_EndDownload()

static void Curl_EndDownload ( downloadinfo * di, CurlStatus status, CURLcode error, const char * content_type_ )

static

Definition at line 521 of file libcurl.c.

{
    char content_type[64];
    qbool ok = false;
    if(!curl_dll)
        return;
    switch(status)
    {
        case CURL_DOWNLOAD_SUCCESS:
            ok = true;
            di->callback(CURLCBSTATUS_OK, di->bytes_received, di->buffer, di->callback_data);
            break;
        case CURL_DOWNLOAD_FAILED:
            di->callback(CURLCBSTATUS_FAILED, di->bytes_received, di->buffer, di->callback_data);
            break;
        case CURL_DOWNLOAD_ABORTED:
            di->callback(CURLCBSTATUS_ABORTED, di->bytes_received, di->buffer, di->callback_data);
            break;
        case CURL_DOWNLOAD_SERVERERROR:
            // reopen to enforce it to have zero bytes again
            if(di->stream)
            {
                FS_Close(di->stream);
                di->stream = FS_OpenRealFile(di->filename, "wb", false);
            }
 
            if(di->callback)
                di->callback(error ? (int) error : CURLCBSTATUS_SERVERERROR, di->bytes_received, di->buffer, di->callback_data);
            break;
        default:
            if(di->callback)
                di->callback(CURLCBSTATUS_UNKNOWN, di->bytes_received, di->buffer, di->callback_data);
            break;
    }
    if(content_type_)
        dp_strlcpy(content_type, content_type_, sizeof(content_type));
    else
        *content_type = 0;
 
    if(di->curle)
    {
        qcurl_multi_remove_handle(curlm, di->curle);
        qcurl_easy_cleanup(di->curle);
        if(di->slist)
            qcurl_slist_free_all(di->slist);
    }
 
    if(!di->callback && ok && !di->bytes_received)
    {
        Con_Printf("ERROR: empty file\n");
        ok = false;
    }
 
    if(di->stream)
        FS_Close(di->stream);
 
#define CLEAR_AND_RETRY() \
    do \
    { \
        di->stream = FS_OpenRealFile(di->filename, "wb", false); \
        FS_Close(di->stream); \
        if(di->startpos && !di->callback) \
        { \
            Curl_Begin(di->url, di->extraheaders, di->maxspeed, di->filename, di->loadtype, di->forthismap, di->post_content_type, di->postbuf, di->postbufsize, NULL, 0, NULL, NULL); \
            di->forthismap = false; \
        } \
    } \
    while(0)
 
    if(ok && di->loadtype == LOADTYPE_PAK)
    {
        ok = FS_AddPack(di->filename, NULL, true, true);
        if(!ok)
            CLEAR_AND_RETRY();
    }
    else if(ok && di->loadtype == LOADTYPE_CACHEPIC)
    {
        const char *p;
        unsigned char *pixels = NULL;
 
        p = di->filename;
#ifdef WE_ARE_EVIL
        if(!strncmp(p, "dlcache/", 8))
            p += 8;
#endif
 
        pixels = decode_image(di, content_type);
        if(pixels)
            Draw_NewPic(p, image_width, image_height, pixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP);
        else
            CLEAR_AND_RETRY();
    }
    else if(ok && di->loadtype == LOADTYPE_SKINFRAME)
    {
        const char *p;
        unsigned char *pixels = NULL;
 
        p = di->filename;
#ifdef WE_ARE_EVIL
        if(!strncmp(p, "dlcache/", 8))
            p += 8;
#endif
 
        pixels = decode_image(di, content_type);
        if(pixels)
            R_SkinFrame_LoadInternalBGRA(p, TEXF_FORCE_RELOAD | TEXF_MIPMAP | TEXF_ALPHA, pixels, image_width, image_height, 0, 0, 0, false); // TODO what sRGB argument to put here?
        else
            CLEAR_AND_RETRY();
    }
 
    List_Delete(&di->list);
 
    --numdownloads;
    if(di->forthismap)
    {
        if(ok)
            ++numdownloads_success;
        else
            ++numdownloads_fail;
    }
    Z_Free(di);
}

References downloadinfo::buffer, downloadinfo::bytes_received, downloadinfo::callback, downloadinfo::callback_data, CLEAR_AND_RETRY, Con_Printf(), curl_dll, CURL_DOWNLOAD_ABORTED, CURL_DOWNLOAD_FAILED, CURL_DOWNLOAD_SERVERERROR, CURL_DOWNLOAD_SUCCESS, CURLCBSTATUS_ABORTED, CURLCBSTATUS_FAILED, CURLCBSTATUS_OK, CURLCBSTATUS_SERVERERROR, CURLCBSTATUS_UNKNOWN, downloadinfo::curle, curlm, decode_image(), dp_strlcpy, Draw_NewPic(), error(), downloadinfo::filename, downloadinfo::forthismap, FS_AddPack(), FS_Close(), FS_OpenRealFile(), image_height, image_width, downloadinfo::list, List_Delete(), downloadinfo::loadtype, LOADTYPE_CACHEPIC, LOADTYPE_PAK, LOADTYPE_SKINFRAME, NULL, numdownloads, numdownloads_fail, numdownloads_success, pixels, qcurl_easy_cleanup, qcurl_multi_remove_handle, qcurl_slist_free_all, R_SkinFrame_LoadInternalBGRA(), downloadinfo::slist, downloadinfo::stream, TEXF_ALPHA, TEXF_CLAMP, TEXF_FORCE_RELOAD, TEXF_MIPMAP, TEXTYPE_BGRA, and Z_Free.

Referenced by CheckPendingDownloads(), Curl_Cancel_ToMemory(), Curl_CancelAll(), Curl_Curl_f(), and Curl_Frame().

Curl_Find()

static downloadinfo * Curl_Find ( const char * filename )

static

Definition at line 852 of file libcurl.c.

{
    downloadinfo *di;
    if(!curl_dll)
        return NULL;
    List_For_Each_Entry(di, &downloads, downloadinfo, list)
        if(!strcasecmp(di->filename, filename))
            return di;
    return NULL;
}

References curl_dll, downloadinfo::filename, List_For_Each_Entry, and NULL.

Referenced by Curl_Begin(), and Curl_Curl_f().

Curl_FindPackURL()

static const char * Curl_FindPackURL ( const char * filename )

static

Definition at line 1701 of file libcurl.c.

{
    static char foundurl[1024]; // invoked only by server
    fs_offset_t filesize;
    char *buf = (char *) FS_LoadFile("curl_urls.txt", tempmempool, true, &filesize);
    if(buf && filesize)
    {
        // read lines of format "pattern url"
        char *p = buf;
        char *pattern = NULL, *patternend = NULL, *url = NULL, *urlend = NULL;
        qbool eof = false;
 
        pattern = p;
        while(!eof)
        {
            switch(*p)
            {
                case 0:
                    eof = true;
                    // fallthrough
                case '\n':
                case '\r':
                    if(pattern && url && patternend)
                    {
                        if(!urlend)
                            urlend = p;
                        *patternend = 0;
                        *urlend = 0;
                        if(matchpattern(filename, pattern, true))
                        {
                            dp_strlcpy(foundurl, url, sizeof(foundurl));
                            Z_Free(buf);
                            return foundurl;
                        }
                    }
                    pattern = NULL;
                    patternend = NULL;
                    url = NULL;
                    urlend = NULL;
                    break;
                case ' ':
                case '\t':
                    if(pattern && !patternend)
                        patternend = p;
                    else if(url && !urlend)
                        urlend = p;
                    break;
                default:
                    if(!pattern)
                        pattern = p;
                    else if(pattern && patternend && !url)
                        url = p;
                    break;
            }
            ++p;
        }
    }
    if(buf)
        Z_Free(buf);
    return sv_curl_defaulturl.string;
}

References buf, dp_strlcpy, FS_LoadFile(), matchpattern(), NULL, cvar_t::string, sv_curl_defaulturl, tempmempool, and Z_Free.

Referenced by Curl_SendRequirement().

Curl_Frame()

void Curl_Frame

(

void

)

Definition at line 1134 of file libcurl.c.

{
    double maxspeed;
    downloadinfo *di;
 
    noclear = false;
 
    if(!curl_enabled.integer && cls.state != ca_dedicated)
        return;
 
    if(!curl_dll)
        return;
 
    if (curl_mutex) Thread_LockMutex(curl_mutex);
 
    Curl_CheckCommandWhenDone();
 
    if(List_Is_Empty(&downloads))
    {
        if (curl_mutex) Thread_UnlockMutex(curl_mutex);
        return;
    }
 
    if(host.realtime < curltime) // throttle
    {
        if (curl_mutex) Thread_UnlockMutex(curl_mutex);
        return;
    }
 
    {
        int remaining;
        CURLMcode mc;
 
        do
        {
            mc = qcurl_multi_perform(curlm, &remaining);
        }
        while(mc == CURLM_CALL_MULTI_PERFORM);
 
        List_For_Each_Entry(di, &downloads, downloadinfo, list)
        {
            double b = 0;
            if(di->curle)
            {
                qcurl_easy_getinfo(di->curle, CURLINFO_SIZE_UPLOAD, &b);
                bytes_sent += (b - di->bytes_sent_curl);
                di->bytes_sent_curl = b;
                qcurl_easy_getinfo(di->curle, CURLINFO_SIZE_DOWNLOAD, &b);
                bytes_sent += (b - di->bytes_received_curl);
                di->bytes_received_curl = b;
            }
        }
 
        for(;;)
        {
            CURLMsg *msg = qcurl_multi_info_read(curlm, &remaining);
            if(!msg)
                break;
            if(msg->msg == CURLMSG_DONE)
            {
                const char *ct = NULL;
                CurlStatus failed = CURL_DOWNLOAD_SUCCESS;
                CURLcode result;
                qcurl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &di);
                result = msg->data.result;
                if(result)
                {
                    failed = CURL_DOWNLOAD_FAILED;
                }
                else
                {
                    long code;
                    qcurl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &code);
                    switch(code / 100)
                    {
                        case 4: // e.g. 404?
                        case 5: // e.g. 500?
                            failed = CURL_DOWNLOAD_SERVERERROR;
                            result = (CURLcode) code;
                            break;
                    }
                    qcurl_easy_getinfo(msg->easy_handle, CURLINFO_CONTENT_TYPE, &ct);
                }
 
                Curl_EndDownload(di, failed, result, ct);
            }
        }
    }
 
    CheckPendingDownloads();
 
    // when will we curl the next time?
    // we will wait a bit to ensure our download rate is kept.
    // we now know that realtime >= curltime... so set up a new curltime
 
    // use the slowest allowing download to derive the maxspeed... this CAN
    // be done better, but maybe later
    maxspeed = curl_maxspeed.value;
    List_For_Each_Entry(di, &downloads, downloadinfo, list)
        if(di->maxspeed > 0)
            if(di->maxspeed < maxspeed || maxspeed <= 0)
                maxspeed = di->maxspeed;
 
    if(maxspeed > 0)
    {
        double bytes = bytes_sent + bytes_received; // maybe smoothen a bit?
        curltime = host.realtime + bytes / (maxspeed * 1024.0);
        bytes_sent = 0;
        bytes_received = 0;
    }
    else
        curltime = host.realtime;
 
    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
}

References b, bytes_received, downloadinfo::bytes_received_curl, bytes_sent, downloadinfo::bytes_sent_curl, ca_dedicated, CheckPendingDownloads(), cls, Curl_CheckCommandWhenDone(), curl_dll, CURL_DOWNLOAD_FAILED, CURL_DOWNLOAD_SERVERERROR, CURL_DOWNLOAD_SUCCESS, curl_enabled, Curl_EndDownload(), curl_maxspeed, curl_mutex, downloadinfo::curle, CURLINFO_CONTENT_TYPE, CURLINFO_PRIVATE, CURLINFO_RESPONSE_CODE, CURLINFO_SIZE_DOWNLOAD, CURLINFO_SIZE_UPLOAD, curlm, CURLM_CALL_MULTI_PERFORM, CURLMSG_DONE, curltime, CURLMsg::data, CURLMsg::easy_handle, host, cvar_t::integer, List_For_Each_Entry, List_Is_Empty(), downloadinfo::maxspeed, CURLMsg::msg, noclear, NULL, qcurl_easy_getinfo, qcurl_multi_info_read, qcurl_multi_perform, host_static_t::realtime, CURLMsg::result, client_static_t::state, Thread_LockMutex, Thread_UnlockMutex, and cvar_t::value.

Referenced by Host_Frame().

CURL_fwrite()

static size_t CURL_fwrite ( void * data, size_t size, size_t nmemb, void * vdi )

static

Definition at line 416 of file libcurl.c.

{
    fs_offset_t ret = -1;
    size_t bytes = size * nmemb;
    downloadinfo *di = (downloadinfo *) vdi;
 
    if(di->buffer)
    {
        if(di->bytes_received + bytes <= di->buffersize)
        {
            memcpy(di->buffer + di->bytes_received, data, bytes);
            ret = bytes;
        }
        // otherwise: buffer overrun, ret stays -1
    }
 
    if(di->stream)
    {
        ret = FS_Write(di->stream, data, bytes);
    }
 
    di->bytes_received += bytes;
 
    //Con_Printf("CURL_fwrite callback timestamp: %f bytes: %ld\n", host.realtime, ret);
 
    return ret;
    // Why not ret / nmemb?
    // Because CURLOPT_WRITEFUNCTION docs say to return the number of bytes.
    // Yes, this is incompatible to fwrite(2).
}

References downloadinfo::buffer, downloadinfo::bytes_received, data, FS_Write(), ret, size, and downloadinfo::stream.

Referenced by CheckPendingDownloads().

Curl_GetDownloadAmount()

static double Curl_GetDownloadAmount ( downloadinfo * di )

static

Definition at line 1323 of file libcurl.c.

{
    if(!curl_dll)
        return -2;
    if(di->curle)
    {
        double length;
        qcurl_easy_getinfo(di->curle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length);
        if(length > 0)
            return (di->startpos + di->bytes_received) / (di->startpos + length);
        else
            return 0;
    }
    else
        return -1;
}

References downloadinfo::bytes_received, curl_dll, downloadinfo::curle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, length, qcurl_easy_getinfo, and downloadinfo::startpos.

Referenced by Curl_GetDownloadInfo(), and Curl_Info_f().

Curl_GetDownloadInfo()

Curl_downloadinfo_t * Curl_GetDownloadInfo	(	int *	nDownloads,
		const char **	additional_info,
		char *	addinfo,
		size_t	addinfolength )

Definition at line 1612 of file libcurl.c.

{
    int i;
    downloadinfo *di;
    Curl_downloadinfo_t *downinfo;
 
    if(!curl_dll)
    {
        *nDownloads = 0;
        if(additional_info)
            *additional_info = NULL;
        return NULL;
    }
 
    if (curl_mutex) Thread_LockMutex(curl_mutex);
 
    i = 0;
    List_For_Each_Entry(di, &downloads, downloadinfo, list)
        ++i;
 
    downinfo = (Curl_downloadinfo_t *) Z_Malloc(sizeof(*downinfo) * i);
    i = 0;
    List_For_Each_Entry(di, &downloads, downloadinfo, list)
    {
        // do not show infobars for background downloads
        if(developer.integer <= 0)
            if(di->buffer)
                continue;
        dp_strlcpy(downinfo[i].filename, di->filename, sizeof(downinfo[i].filename));
        if(di->curle)
        {
            downinfo[i].progress = Curl_GetDownloadAmount(di);
            downinfo[i].speed = Curl_GetDownloadSpeed(di);
            downinfo[i].queued = false;
        }
        else
        {
            downinfo[i].queued = true;
        }
        ++i;
    }
 
    if(additional_info)
    {
        // TODO: can I clear command_when_done as soon as the first download fails?
        if(*command_when_done && !numdownloads_fail && numdownloads_added)
        {
            if(!strncmp(command_when_done, "connect ", 8))
                dpsnprintf(addinfo, addinfolength, "(will join %s when done)", command_when_done + 8);
            else if(!strcmp(command_when_done, "cl_begindownloads"))
                dpsnprintf(addinfo, addinfolength, "(will enter the game when done)");
            else
                dpsnprintf(addinfo, addinfolength, "(will do '%s' when done)", command_when_done);
            *additional_info = addinfo;
        }
        else
            *additional_info = NULL;
    }
 
    *nDownloads = i;
    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
    return downinfo;
}

References downloadinfo::buffer, command_when_done, curl_dll, Curl_GetDownloadAmount(), Curl_GetDownloadSpeed(), curl_mutex, downloadinfo::curle, developer, dp_strlcpy, dpsnprintf(), Curl_downloadinfo_t::filename, downloadinfo::filename, i, cvar_t::integer, List_For_Each_Entry, NULL, numdownloads_added, numdownloads_fail, Curl_downloadinfo_t::progress, Curl_downloadinfo_t::queued, Curl_downloadinfo_t::speed, Thread_LockMutex, Thread_UnlockMutex, and Z_Malloc.

Referenced by SCR_DrawCurlDownload(), and SCR_InfobarHeight().

Curl_GetDownloadSpeed()

static double Curl_GetDownloadSpeed ( downloadinfo * di )

static

Definition at line 1347 of file libcurl.c.

{
    if(!curl_dll)
        return -2;
    if(di->curle)
    {
        double speed;
        qcurl_easy_getinfo(di->curle, CURLINFO_SPEED_DOWNLOAD, &speed);
        return speed;
    }
    else
        return -1;
}

References curl_dll, downloadinfo::curle, CURLINFO_SPEED_DOWNLOAD, and qcurl_easy_getinfo.

Referenced by Curl_GetDownloadInfo(), and Curl_Info_f().

Curl_Have_forthismap()

qbool Curl_Have_forthismap

(

void

)

Definition at line 310 of file libcurl.c.

{
    return numdownloads_added != 0;
}

References numdownloads_added.

Referenced by CL_BeginDownloads().

Curl_Info_f()

static void Curl_Info_f ( cmd_state_t * cmd )

static

Definition at line 1369 of file libcurl.c.

{
    downloadinfo *di;
    char urlbuf[1024];
    if(!curl_dll)
        return;
    if(Curl_Running())
    {
        if (curl_mutex) Thread_LockMutex(curl_mutex);
        Con_Print("Currently running downloads:\n");
        List_For_Each_Entry(di, &downloads, downloadinfo, list)
        {
            double speed, percent;
            Con_Printf("  %s -> %s ",  CleanURL(di->url, urlbuf, sizeof(urlbuf)), di->filename);
            percent = 100.0 * Curl_GetDownloadAmount(di);
            speed = Curl_GetDownloadSpeed(di);
            if(percent >= 0)
                Con_Printf("(%.1f%% @ %.1f KiB/s)\n", percent, speed / 1024.0);
            else
                Con_Print("(queued)\n");
        }
        if (curl_mutex) Thread_UnlockMutex(curl_mutex);
    }
    else
    {
        Con_Print("No downloads running.\n");
    }
}

References CleanURL(), Con_Print(), Con_Printf(), curl_dll, Curl_GetDownloadAmount(), Curl_GetDownloadSpeed(), curl_mutex, Curl_Running(), downloadinfo::filename, List_For_Each_Entry, Thread_LockMutex, Thread_UnlockMutex, and downloadinfo::url.

Referenced by Curl_Curl_f().

Curl_Init()

void Curl_Init

(

void

)

Definition at line 810 of file libcurl.c.

{
    CURL_OpenLibrary();
    if(!curl_dll)
        return;
    if (Thread_HasThreads()) curl_mutex = Thread_CreateMutex();
    qcurl_global_init(CURL_GLOBAL_SSL);
    curlm = qcurl_multi_init();
}

References curl_dll, CURL_GLOBAL_SSL, curl_mutex, CURL_OpenLibrary(), curlm, qcurl_global_init, qcurl_multi_init, Thread_CreateMutex, and Thread_HasThreads().

Referenced by Host_Init().

Curl_Init_Commands()

void Curl_Init_Commands

(

void

)

Definition at line 1578 of file libcurl.c.

{
    Cvar_RegisterVariable (&curl_enabled);
    Cvar_RegisterVariable (&curl_maxdownloads);
    Cvar_RegisterVariable (&curl_maxspeed);
    Cvar_RegisterVariable (&curl_useragent);
    Cvar_RegisterVariable (&curl_useragent_append);
    Cvar_RegisterVirtual  (&curl_enabled,          "cl_curl_enabled");
    Cvar_RegisterVirtual  (&curl_maxdownloads,     "cl_curl_maxdownloads");
    Cvar_RegisterVirtual  (&curl_maxspeed,         "cl_curl_maxspeed");
    Cvar_RegisterVirtual  (&curl_useragent,        "cl_curl_useragent");
    Cvar_RegisterVirtual  (&curl_useragent_append, "cl_curl_useragent_append");
 
    Cvar_RegisterVariable (&sv_curl_defaulturl);
    Cvar_RegisterVariable (&sv_curl_serverpackages);
    Cvar_RegisterVariable (&sv_curl_maxspeed);
 
    Cvar_RegisterVariable (&developer_curl);
 
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "curl", Curl_Curl_f, "download data from an URL and add to search path");
    //Cmd_AddCommand(cmd_local, "curlcat", Curl_CurlCat_f, "display data from an URL (debugging command)");
}

References CF_CLIENT, CF_CLIENT_FROM_SERVER, Cmd_AddCommand(), Curl_Curl_f(), curl_enabled, curl_maxdownloads, curl_maxspeed, curl_useragent, curl_useragent_append, Cvar_RegisterVariable(), Cvar_RegisterVirtual(), developer_curl, sv_curl_defaulturl, sv_curl_maxspeed, and sv_curl_serverpackages.

Referenced by Host_Init().

CURL_OpenLibrary()

static qbool CURL_OpenLibrary ( void )

static

Definition at line 362 of file libcurl.c.

{
    const char* dllnames [] =
    {
#if defined(WIN32)
        "libcurl-4.dll",
        "libcurl-3.dll",
#elif defined(MACOSX)
        "libcurl.4.dylib", // Mac OS X Notyetreleased
        "libcurl.3.dylib", // Mac OS X Tiger
        "libcurl.2.dylib", // Mac OS X Panther
#else
        "libcurl.so.4",
        "libcurl.so.3",
        "libcurl.so", // FreeBSD
#endif
        NULL
    };
 
    // Already loaded?
    if (curl_dll)
        return true;
 
    // Load the DLL
    return Sys_LoadDependency (dllnames, &curl_dll, curlfuncs);
}

References curl_dll, curlfuncs, NULL, and Sys_LoadDependency().

Referenced by Curl_Init().

curl_quiet_callback()

static void curl_quiet_callback ( int status, size_t length_received, unsigned char * buffer, void * cbdata )

static

Definition at line 482 of file libcurl.c.

{
    curl_default_callback(status, length_received, buffer, cbdata);
}

References buffer, and curl_default_callback().

Referenced by Curl_Cancel_ToMemory().

Curl_Register_predownload()

void Curl_Register_predownload

(

void

)

Definition at line 315 of file libcurl.c.

{
    if (curl_mutex) Thread_LockMutex(curl_mutex);
    Curl_CommandWhenDone("cl_begindownloads");
    Curl_CommandWhenError("cl_begindownloads");
    if (curl_mutex) Thread_UnlockMutex(curl_mutex);
}

References Curl_CommandWhenDone(), Curl_CommandWhenError(), curl_mutex, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by CL_BeginDownloads(), and Curl_Curl_f().

Curl_RequireFile()

void Curl_RequireFile

(

const char *

filename

)

Definition at line 1779 of file libcurl.c.

{
    requirement *req = (requirement *) Z_Malloc(sizeof(*requirements));
    req->next = requirements;
    dp_strlcpy(req->filename, filename, sizeof(req->filename));
    requirements = req;
}

References dp_strlcpy, requirement::filename, requirement::next, requirements, and Z_Malloc.

Referenced by SV_SpawnServer().

Curl_Running()

qbool Curl_Running

(

void

)

Definition at line 1307 of file libcurl.c.

{
    if(!curl_dll)
        return false;
 
    return !List_Is_Empty(&downloads);
}

References curl_dll, and List_Is_Empty().

Referenced by Curl_Info_f().

Curl_Select()

bool Curl_Select

(

int

timeout_ms

)

Definition at line 1263 of file libcurl.c.

{
    CURLMcode err;
 
    if (List_Is_Empty(&downloads))
        return false;
 
    err = qcurl_multi_wait(curlm, NULL, 0, timeout_ms, NULL);
    if (err == CURLM_OK)
        return true;
    Con_Printf(CON_ERROR "curl_multi_wait() failed with code %d\n", err);
    return false;
}

References CON_ERROR, Con_Printf(), curlm, CURLM_OK, List_Is_Empty(), NULL, and qcurl_multi_wait.

Referenced by Sys_Sleep().

Curl_SendRequirement()

static qbool Curl_SendRequirement ( const char * filename, qbool foundone, char * sendbuffer, size_t sendbuffer_len )

static

Definition at line 1817 of file libcurl.c.

{
    const char *p;
    const char *thispack = FS_WhichPack(filename);
    const char *packurl;
 
    if(!thispack || !*thispack)
        return false;
 
    p = strrchr(thispack, '/');
    if(p)
        thispack = p + 1;
 
    packurl = Curl_FindPackURL(thispack);
 
    if(packurl && *packurl && strcmp(packurl, "-"))
    {
        if(!foundone)
            dp_strlcat(sendbuffer, "curl --clear_autodownload\n", sendbuffer_len);
 
        dp_strlcat(sendbuffer, "curl --pak --forthismap --as ", sendbuffer_len);
        dp_strlcat(sendbuffer, thispack, sendbuffer_len);
        if(sv_curl_maxspeed.value > 0)
            dpsnprintf(sendbuffer + strlen(sendbuffer), sendbuffer_len - strlen(sendbuffer), " --maxspeed=%.1f", sv_curl_maxspeed.value);
        dp_strlcat(sendbuffer, " --for ", sendbuffer_len);
        dp_strlcat(sendbuffer, filename, sendbuffer_len);
        dp_strlcat(sendbuffer, " ", sendbuffer_len);
        dp_strlcat(sendbuffer, packurl, sendbuffer_len);
        dp_strlcat(sendbuffer, thispack, sendbuffer_len);
        dp_strlcat(sendbuffer, "\n", sendbuffer_len);
 
        return true;
    }
 
    return false;
}

References Curl_FindPackURL(), dp_strlcat, dpsnprintf(), FS_WhichPack(), strlen(), sv_curl_maxspeed, and cvar_t::value.

Referenced by Curl_SendRequirements().

Curl_SendRequirements()

void Curl_SendRequirements

(

void

)

Definition at line 1853 of file libcurl.c.

{
    // for each requirement, find the pack name
    char sendbuffer[4096] = "";
    requirement *req;
    qbool foundone = false;
    const char *p;
 
    for(req = requirements; req; req = req->next)
        foundone = Curl_SendRequirement(req->filename, foundone, sendbuffer, sizeof(sendbuffer)) || foundone;
 
    p = sv_curl_serverpackages.string;
    while(COM_ParseToken_Simple(&p, false, false, true))
        foundone = Curl_SendRequirement(com_token, foundone, sendbuffer, sizeof(sendbuffer)) || foundone;
 
    if(foundone)
        dp_strlcat(sendbuffer, "curl --finish_autodownload\n", sizeof(sendbuffer));
 
    if(strlen(sendbuffer) + 1 < sizeof(sendbuffer))
        SV_ClientCommands("%s", sendbuffer);
    else
        Con_Printf("Could not initiate autodownload due to URL buffer overflow\n");
}

References COM_ParseToken_Simple(), com_token, Con_Printf(), Curl_SendRequirement(), dp_strlcat, requirement::filename, requirement::next, requirements, cvar_t::string, strlen(), SV_ClientCommands(), and sv_curl_serverpackages.

Referenced by SV_SendServerinfo().

Curl_Shutdown()

void Curl_Shutdown

(

void

)

Definition at line 828 of file libcurl.c.

{
    if(!curl_dll)
        return;
    Curl_ClearRequirements();
    Curl_CancelAll();
    if (curl_mutex) Thread_DestroyMutex(curl_mutex);
    CURL_CloseLibrary();
    curl_dll = NULL;
}

References Curl_CancelAll(), Curl_ClearRequirements(), CURL_CloseLibrary(), curl_dll, curl_mutex, NULL, and Thread_DestroyMutex.

Referenced by Host_Shutdown().

decode_image()

static unsigned char * decode_image ( downloadinfo * di, const char * content_type )

static

Definition at line 487 of file libcurl.c.

{
    unsigned char *pixels = NULL;
    fs_offset_t filesize = 0;
    unsigned char *data = FS_LoadFile(di->filename, tempmempool, true, &filesize);
    if(data)
    {
        int mip = 0;
        if(!strcmp(content_type, "image/jpeg"))
            pixels = JPEG_LoadImage_BGRA(data, filesize, &mip);
        else if(!strcmp(content_type, "image/png"))
            pixels = PNG_LoadImage_BGRA(data, filesize, &mip);
        else if(filesize >= 7 && !strncmp((char *) data, "\xFF\xD8", 7))
            pixels = JPEG_LoadImage_BGRA(data, filesize, &mip);
        else if(filesize >= 7 && !strncmp((char *) data, "\x89PNG\x0D\x0A\x1A\x0A", 7))
            pixels = PNG_LoadImage_BGRA(data, filesize, &mip);
        else
            Con_Printf("Did not detect content type: %s\n", content_type);
        Mem_Free(data);
    }
    // do we call Image_MakeLinearColorsFromsRGB or not?
    return pixels;
}

References Con_Printf(), data, downloadinfo::filename, FS_LoadFile(), JPEG_LoadImage_BGRA(), Mem_Free, NULL, pixels, PNG_LoadImage_BGRA(), and tempmempool.

Referenced by Curl_EndDownload().

LIST_HEAD()

LIST_HEAD

(

downloads

)

Variable Documentation

bytes_received

double bytes_received = 0

static

Definition at line 404 of file libcurl.c.

Referenced by Curl_Frame().

bytes_sent

double bytes_sent = 0

static

Definition at line 405 of file libcurl.c.

Referenced by Curl_Frame().

command_when_done

char command_when_done[256] = ""

static

Definition at line 242 of file libcurl.c.

Referenced by Curl_CheckCommandWhenDone(), Curl_CommandWhenDone(), and Curl_GetDownloadInfo().

command_when_error

char command_when_error[256] = ""

static

Definition at line 243 of file libcurl.c.

Referenced by Curl_CheckCommandWhenDone(), and Curl_CommandWhenError().

curl_dll

dllhandle_t curl_dll = NULL

static

Definition at line 195 of file libcurl.c.

Referenced by CheckPendingDownloads(), Curl_Available(), Curl_Begin(), Curl_Cancel_ToMemory(), Curl_CancelAll(), Curl_CheckCommandWhenDone(), CURL_CloseLibrary(), Curl_CommandWhenDone(), Curl_CommandWhenError(), Curl_Curl_f(), Curl_EndDownload(), Curl_Find(), Curl_Frame(), Curl_GetDownloadAmount(), Curl_GetDownloadInfo(), Curl_GetDownloadSpeed(), Curl_Info_f(), Curl_Init(), CURL_OpenLibrary(), Curl_Running(), and Curl_Shutdown().

curl_enabled

cvar_t curl_enabled = {CF_SHARED | CF_ARCHIVE, "curl_enabled","1", "whether libcurl may be used to GET files or POST data"}

static

Definition at line 10 of file libcurl.c.

{CF_SHARED | CF_ARCHIVE, "curl_enabled","1", "whether libcurl may be used to GET files or POST data"};

Referenced by Curl_Begin(), Curl_Curl_f(), Curl_Frame(), and Curl_Init_Commands().

curl_maxdownloads

cvar_t curl_maxdownloads = {CF_SHARED | CF_ARCHIVE, "curl_maxdownloads","3", "maximum number of concurrent HTTP/FTP downloads"}

static

Definition at line 11 of file libcurl.c.

{CF_SHARED | CF_ARCHIVE, "curl_maxdownloads","3", "maximum number of concurrent HTTP/FTP downloads"};

Referenced by CheckPendingDownloads(), and Curl_Init_Commands().

curl_maxspeed

cvar_t curl_maxspeed = {CF_SHARED | CF_ARCHIVE, "curl_maxspeed","0", "maximum download speed (KiB/s)"}

static

Definition at line 12 of file libcurl.c.

{CF_SHARED | CF_ARCHIVE, "curl_maxspeed","0", "maximum download speed (KiB/s)"};

Referenced by Curl_Frame(), and Curl_Init_Commands().

curl_mutex

void* curl_mutex = NULL

Definition at line 203 of file libcurl.c.

Referenced by Curl_Begin(), Curl_CancelAll(), Curl_Clear_forthismap(), Curl_Frame(), Curl_GetDownloadInfo(), Curl_Info_f(), Curl_Init(), Curl_Register_predownload(), and Curl_Shutdown().

curl_useragent

cvar_t curl_useragent = {CF_SHARED, "curl_useragent","1", "send the User-Agent string (note: turning this off may break stuff)"}

static

Definition at line 13 of file libcurl.c.

{CF_SHARED, "curl_useragent","1", "send the User-Agent string (note: turning this off may break stuff)"};

Referenced by CheckPendingDownloads(), and Curl_Init_Commands().

curl_useragent_append

cvar_t curl_useragent_append = {CF_SHARED, "curl_useragent_append","", "a string to append to the User-Agent string (useful for name and version number of your mod)"}

static

Definition at line 14 of file libcurl.c.

{CF_SHARED, "curl_useragent_append","", "a string to append to the User-Agent string (useful for name and version number of your mod)"};

Referenced by CheckPendingDownloads(), and Curl_Init_Commands().

curlfuncs

dllfunction_t curlfuncs[]

static

Initial value:

=
{
    {"curl_global_init",        (void **) &qcurl_global_init},
    {"curl_global_cleanup",     (void **) &qcurl_global_cleanup},
    {"curl_easy_init",          (void **) &qcurl_easy_init},
    {"curl_easy_cleanup",       (void **) &qcurl_easy_cleanup},
    {"curl_easy_setopt",        (void **) &qcurl_easy_setopt},
    {"curl_easy_strerror",      (void **) &qcurl_easy_strerror},
    {"curl_easy_getinfo",       (void **) &qcurl_easy_getinfo},
    {"curl_multi_init",         (void **) &qcurl_multi_init},
    {"curl_multi_perform",      (void **) &qcurl_multi_perform},
    {"curl_multi_wait",     (void **) &qcurl_multi_wait},
    {"curl_multi_add_handle",   (void **) &qcurl_multi_add_handle},
    {"curl_multi_remove_handle",(void **) &qcurl_multi_remove_handle},
    {"curl_multi_info_read",    (void **) &qcurl_multi_info_read},
    {"curl_multi_cleanup",      (void **) &qcurl_multi_cleanup},
    {"curl_multi_strerror",     (void **) &qcurl_multi_strerror},
    {"curl_slist_append",       (void **) &qcurl_slist_append},
    {"curl_slist_free_all",     (void **) &qcurl_slist_free_all},
    {NULL, NULL}
}

Definition at line 172 of file libcurl.c.

{
    {"curl_global_init",        (void **) &qcurl_global_init},
    {"curl_global_cleanup",     (void **) &qcurl_global_cleanup},
    {"curl_easy_init",          (void **) &qcurl_easy_init},
    {"curl_easy_cleanup",       (void **) &qcurl_easy_cleanup},
    {"curl_easy_setopt",        (void **) &qcurl_easy_setopt},
    {"curl_easy_strerror",      (void **) &qcurl_easy_strerror},
    {"curl_easy_getinfo",       (void **) &qcurl_easy_getinfo},
    {"curl_multi_init",         (void **) &qcurl_multi_init},
    {"curl_multi_perform",      (void **) &qcurl_multi_perform},
    {"curl_multi_wait",     (void **) &qcurl_multi_wait},
    {"curl_multi_add_handle",   (void **) &qcurl_multi_add_handle},
    {"curl_multi_remove_handle",(void **) &qcurl_multi_remove_handle},
    {"curl_multi_info_read",    (void **) &qcurl_multi_info_read},
    {"curl_multi_cleanup",      (void **) &qcurl_multi_cleanup},
    {"curl_multi_strerror",     (void **) &qcurl_multi_strerror},
    {"curl_slist_append",       (void **) &qcurl_slist_append},
    {"curl_slist_free_all",     (void **) &qcurl_slist_free_all},
    {NULL, NULL}
};

Referenced by CURL_OpenLibrary().

curlm

CURLM* curlm = NULL

static

Definition at line 403 of file libcurl.c.

Referenced by CheckPendingDownloads(), Curl_EndDownload(), Curl_Frame(), Curl_Init(), and Curl_Select().

curltime

double curltime = 0

static

Definition at line 406 of file libcurl.c.

Referenced by Curl_Frame().

developer_curl

cvar_t developer_curl = {CF_SHARED, "developer_curl","0", "whether verbose libcurl output should be printed to stderr"}

static

Definition at line 20 of file libcurl.c.

{CF_SHARED, "developer_curl","0", "whether verbose libcurl output should be printed to stderr"};

Referenced by CheckPendingDownloads(), and Curl_Init_Commands().

noclear

qbool noclear = false

static

Definition at line 237 of file libcurl.c.

Referenced by Curl_Clear_forthismap(), Curl_Curl_f(), and Curl_Frame().

numdownloads

int numdownloads = 0

static

Definition at line 235 of file libcurl.c.

Referenced by CheckPendingDownloads(), and Curl_EndDownload().

numdownloads_added

int numdownloads_added = 0

static

Definition at line 241 of file libcurl.c.

Referenced by Curl_Begin(), Curl_CheckCommandWhenDone(), Curl_Clear_forthismap(), Curl_Curl_f(), Curl_GetDownloadInfo(), and Curl_Have_forthismap().

numdownloads_fail

int numdownloads_fail = 0

static

Definition at line 239 of file libcurl.c.

Referenced by Curl_CheckCommandWhenDone(), Curl_Clear_forthismap(), Curl_EndDownload(), and Curl_GetDownloadInfo().

numdownloads_success

int numdownloads_success = 0

static

Definition at line 240 of file libcurl.c.

Referenced by Curl_Begin(), Curl_CheckCommandWhenDone(), Curl_Clear_forthismap(), and Curl_EndDownload().

qcurl_easy_cleanup

void(* qcurl_easy_cleanup) (CURL *handle) ( CURL * handle )

static

Definition at line 156 of file libcurl.c.

Referenced by Curl_EndDownload().

qcurl_easy_getinfo

CURLcode(* qcurl_easy_getinfo) (CURL *handle, CURLINFO info,...) ( CURL * handle, CURLINFO info, ... )

static

Definition at line 158 of file libcurl.c.

Referenced by Curl_Frame(), Curl_GetDownloadAmount(), and Curl_GetDownloadSpeed().

qcurl_easy_init

CURL *(* qcurl_easy_init) (void) ( void )

static

Definition at line 155 of file libcurl.c.

Referenced by CheckPendingDownloads().

qcurl_easy_setopt

CURLcode(* qcurl_easy_setopt) (CURL *handle, CURLoption option,...) ( CURL * handle, CURLoption option, ... )

static

Definition at line 157 of file libcurl.c.

Referenced by CheckPendingDownloads().

qcurl_easy_strerror

const char *(* qcurl_easy_strerror) (CURLcode) ( CURLcode )

static

Definition at line 159 of file libcurl.c.

qcurl_global_cleanup

void(* qcurl_global_cleanup) (void) ( void )

static

Definition at line 153 of file libcurl.c.

qcurl_global_init

void(* qcurl_global_init) (long flags) ( long flags )

static

Definition at line 152 of file libcurl.c.

Referenced by Curl_Init().

qcurl_multi_add_handle

CURLMcode(* qcurl_multi_add_handle) (CURLM *multi_handle, CURL *easy_handle) ( CURLM * multi_handle, CURL * easy_handle )

static

Definition at line 164 of file libcurl.c.

Referenced by CheckPendingDownloads().

qcurl_multi_cleanup

void(* qcurl_multi_cleanup) (CURLM *) ( CURLM * )

static

Definition at line 167 of file libcurl.c.

qcurl_multi_info_read

CURLMsg *(* qcurl_multi_info_read) (CURLM *multi_handle, int *msgs_in_queue) ( CURLM * multi_handle, int * msgs_in_queue )

static

Definition at line 166 of file libcurl.c.

Referenced by Curl_Frame().

qcurl_multi_init

CURLM *(* qcurl_multi_init) (void) ( void )

static

Definition at line 161 of file libcurl.c.

Referenced by Curl_Init().

qcurl_multi_perform

CURLMcode(* qcurl_multi_perform) (CURLM *multi_handle, int *running_handles) ( CURLM * multi_handle, int * running_handles )

static

Definition at line 162 of file libcurl.c.

Referenced by Curl_Frame().

qcurl_multi_remove_handle

CURLMcode(* qcurl_multi_remove_handle) (CURLM *multi_handle, CURL *easy_handle) ( CURLM * multi_handle, CURL * easy_handle )

static

Definition at line 165 of file libcurl.c.

Referenced by Curl_EndDownload().

qcurl_multi_strerror

const char *(* qcurl_multi_strerror) (CURLcode) ( CURLcode )

static

Definition at line 168 of file libcurl.c.

qcurl_multi_wait

CURLMcode(* qcurl_multi_wait) (CURLM *multi_handle, void *, unsigned int extra_nfds, int timeout_ms, int *ret) ( CURLM * multi_handle, void * , unsigned int extra_nfds, int timeout_ms, int * ret )

static

Definition at line 163 of file libcurl.c.

Referenced by Curl_Select().

qcurl_slist_append

curl_slist *(* qcurl_slist_append) (curl_slist *list, const char *string) ( curl_slist * list, const char * string )

static

Definition at line 169 of file libcurl.c.

Referenced by CheckPendingDownloads().

qcurl_slist_free_all

void(* qcurl_slist_free_all) (curl_slist *list) ( curl_slist * list )

static

Definition at line 170 of file libcurl.c.

Referenced by Curl_EndDownload().

requirements

requirement* requirements = NULL

static

Definition at line 1769 of file libcurl.c.

Referenced by Curl_ClearRequirements(), Curl_RequireFile(), and Curl_SendRequirements().

sv_curl_defaulturl

cvar_t sv_curl_defaulturl = {CF_SERVER, "sv_curl_defaulturl","", "default autodownload source URL"}

static

Definition at line 16 of file libcurl.c.

{CF_SERVER, "sv_curl_defaulturl","", "default autodownload source URL"};

Referenced by Curl_FindPackURL(), and Curl_Init_Commands().

sv_curl_maxspeed

cvar_t sv_curl_maxspeed = {CF_SERVER, "sv_curl_maxspeed","0", "maximum download speed for clients downloading from sv_curl_defaulturl (KiB/s)"}

static

Definition at line 18 of file libcurl.c.

{CF_SERVER, "sv_curl_maxspeed","0", "maximum download speed for clients downloading from sv_curl_defaulturl (KiB/s)"};

Referenced by Curl_Init_Commands(), and Curl_SendRequirement().

sv_curl_serverpackages

cvar_t sv_curl_serverpackages = {CF_SERVER, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"}

static

Definition at line 17 of file libcurl.c.

{CF_SERVER, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"};

Referenced by Curl_Init_Commands(), and Curl_SendRequirements().