#include "jpeg.h"
#include "image_png.h"
-static cvar_t cl_curl_maxdownloads = {CVAR_SAVE, "cl_curl_maxdownloads","1", "maximum number of concurrent HTTP/FTP downloads"};
-static cvar_t cl_curl_maxspeed = {CVAR_SAVE, "cl_curl_maxspeed","300", "maximum download speed (KiB/s)"};
-static cvar_t sv_curl_defaulturl = {CVAR_SAVE, "sv_curl_defaulturl","", "default autodownload source URL"};
-static cvar_t sv_curl_serverpackages = {CVAR_SAVE, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"};
-static cvar_t sv_curl_maxspeed = {CVAR_SAVE, "sv_curl_maxspeed","0", "maximum download speed for clients downloading from sv_curl_defaulturl (KiB/s)"};
-static cvar_t cl_curl_enabled = {CVAR_SAVE, "cl_curl_enabled","1", "whether client's download support is enabled"};
-static cvar_t cl_curl_useragent = {0, "cl_curl_useragent","1", "send the User-Agent string (note: turning this off may break stuff)"};
-static cvar_t cl_curl_useragent_append = {0, "cl_curl_useragent_append","", "a string to append to the User-Agent string (useful for name and version number of your mod)"};
+static cvar_t cl_curl_maxdownloads = {CF_CLIENT | CF_ARCHIVE, "cl_curl_maxdownloads","1", "maximum number of concurrent HTTP/FTP downloads"};
+static cvar_t cl_curl_maxspeed = {CF_CLIENT | CF_ARCHIVE, "cl_curl_maxspeed","300", "maximum download speed (KiB/s)"};
+static cvar_t sv_curl_defaulturl = {CF_SERVER | CF_ARCHIVE, "sv_curl_defaulturl","", "default autodownload source URL"};
+static cvar_t sv_curl_serverpackages = {CF_SERVER | CF_ARCHIVE, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"};
+static cvar_t sv_curl_maxspeed = {CF_SERVER | CF_ARCHIVE, "sv_curl_maxspeed","0", "maximum download speed for clients downloading from sv_curl_defaulturl (KiB/s)"};
+static cvar_t cl_curl_enabled = {CF_CLIENT | CF_ARCHIVE, "cl_curl_enabled","1", "whether client's download support is enabled"};
+static cvar_t cl_curl_useragent = {CF_CLIENT, "cl_curl_useragent","1", "send the User-Agent string (note: turning this off may break stuff)"};
+static cvar_t cl_curl_useragent_append = {CF_CLIENT, "cl_curl_useragent_append","", "a string to append to the User-Agent string (useful for name and version number of your mod)"};
/*
=================================================================
qfile_t *stream;
fs_offset_t startpos;
CURL *curle;
- qboolean started;
+ qbool started;
int loadtype;
- unsigned long bytes_received; // for buffer
+ size_t bytes_received; // for buffer
double bytes_received_curl; // for throttling
double bytes_sent_curl; // for throttling
struct downloadinfo_s *next, *prev;
- qboolean forthismap;
+ qbool forthismap;
double maxspeed;
curl_slist *slist; // http headers
static downloadinfo *downloads = NULL;
static int numdownloads = 0;
-static qboolean noclear = FALSE;
+static qbool noclear = false;
static int numdownloads_fail = 0;
static int numdownloads_success = 0;
Returns true if a download needed for the current game is running.
====================
*/
-qboolean Curl_Have_forthismap(void)
+qbool Curl_Have_forthismap(void)
{
return numdownloads_added != 0;
}
if(numdownloads_fail == 0)
{
Con_DPrintf("cURL downloads occurred, executing %s\n", command_when_done);
- Cbuf_AddText("\n");
- Cbuf_AddText(command_when_done);
- Cbuf_AddText("\n");
+ 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("\n");
- Cbuf_AddText(command_when_error);
- Cbuf_AddText("\n");
+ Cbuf_AddText(cmd_local, "\n");
+ Cbuf_AddText(cmd_local, command_when_error);
+ Cbuf_AddText(cmd_local, "\n");
}
Curl_Clear_forthismap();
}
Load the cURL DLL
====================
*/
-static qboolean CURL_OpenLibrary (void)
+static qbool CURL_OpenLibrary (void)
{
const char* dllnames [] =
{
return true;
// Load the DLL
- return Sys_LoadLibrary (dllnames, &curl_dll, curlfuncs);
+ return Sys_LoadDependency (dllnames, &curl_dll, curlfuncs);
}
*/
static void CURL_CloseLibrary (void)
{
- Sys_UnloadLibrary (&curl_dll);
+ Sys_FreeLibrary (&curl_dll);
}
di->bytes_received += bytes;
- return ret; // why not ret / nmemb?
+ return ret;
+ // Why not ret / nmemb?
+ // Because CURLOPT_WRITEFUNCTION docs say to return the number of bytes.
+ // Yes, this is incompatible to fwrite(2).
}
typedef enum
code from libcurl, or 0, if another error has occurred.
====================
*/
-static qboolean Curl_Begin(const char *URL, const char *extraheaders, double maxspeed, const char *name, int loadtype, qboolean 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 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 void Curl_EndDownload(downloadinfo *di, CurlStatus status, CURLcode error, const char *content_type_)
{
char content_type[64];
- qboolean ok = false;
+ qbool ok = false;
if(!curl_dll)
return;
switch(status)
pixels = decode_image(di, content_type);
if(pixels)
- Draw_NewPic(p, image_width, image_height, true, pixels);
+ Draw_NewPic(p, image_width, image_height, pixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP);
else
CLEAR_AND_RETRY();
}
pixels = decode_image(di, content_type);
if(pixels)
- R_SkinFrame_LoadInternalBGRA(p, TEXF_FORCE_RELOAD | TEXF_MIPMAP | TEXF_ALPHA, pixels, image_width, image_height, false); // TODO what sRGB argument to put here?
+ 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();
}
if given) in the "dlcache/" folder.
====================
*/
-static qboolean Curl_Begin(const char *URL, const char *extraheaders, double maxspeed, const char *name, int loadtype, qboolean 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 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)
{
if(buf)
if(loadtype != LOADTYPE_NONE)
Host_Error("Curl_Begin: loadtype and buffer are both set");
- if(!curl_dll)
+ if(!curl_dll || !cl_curl_enabled.integer)
{
return false;
}
// already downloading the file?
{
- downloadinfo *di = Curl_Find(fn);
- if(di)
+ downloadinfo *existingdownloadinfo = Curl_Find(fn);
+ if(existingdownloadinfo)
{
- Con_Printf("Can't download %s, already getting it from %s!\n", fn, CleanURL(di->url, urlbuf, sizeof(urlbuf)));
+ 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 && !di->forthismap)
+ if(forthismap && !existingdownloadinfo->forthismap)
{
- di->forthismap = true;
+ 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(loadtype == LOADTYPE_PAK)
{
- qboolean already_loaded;
+ qbool already_loaded;
if(FS_AddPack(fn, &already_loaded, true))
{
Con_DPrintf("%s already exists, not downloading!\n", fn);
}
}
+ if (curl_mutex) Thread_UnlockMutex(curl_mutex);
return false;
}
else
qfile_t *f = FS_OpenRealFile(fn, "rb", false);
if(f)
{
- char buf[4] = {0};
- FS_Read(f, buf, sizeof(buf)); // no "-1", I will use memcmp
+ char b[4] = {0};
+ FS_Read(f, b, sizeof(b)); // no "-1", I will use memcmp
- if(memcmp(buf, "PK\x03\x04", 4) && memcmp(buf, "PACK", 4))
+ 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);
}
}
-qboolean Curl_Begin_ToFile(const char *URL, double maxspeed, const char *name, int loadtype, qboolean forthismap)
+qbool Curl_Begin_ToFile(const char *URL, double maxspeed, const char *name, int loadtype, qbool forthismap)
{
return Curl_Begin(URL, NULL, maxspeed, name, loadtype, forthismap, NULL, NULL, 0, NULL, 0, NULL, NULL);
}
-qboolean Curl_Begin_ToMemory(const char *URL, double maxspeed, unsigned char *buf, size_t bufsize, curl_callback_t callback, void *cbdata)
+qbool Curl_Begin_ToMemory(const char *URL, double maxspeed, unsigned char *buf, size_t bufsize, curl_callback_t callback, void *cbdata)
{
return Curl_Begin(URL, NULL, maxspeed, NULL, false, false, NULL, NULL, 0, buf, bufsize, callback, cbdata);
}
-qboolean 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)
+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)
{
return Curl_Begin(URL, extraheaders, maxspeed, NULL, false, false, post_content_type, postbuf, postbufsize, buf, bufsize, callback, cbdata);
}
/*
====================
-Curl_Run
+Curl_Frame
call this regularily as this will always download as much as possible without
blocking.
====================
*/
-void Curl_Run(void)
+void Curl_Frame(void)
{
double maxspeed;
downloadinfo *di;
- noclear = FALSE;
+ noclear = false;
if(!cl_curl_enabled.integer)
return;
return;
}
- if(realtime < curltime) // throttle
+ if(host.realtime < curltime) // throttle
{
if (curl_mutex) Thread_UnlockMutex(curl_mutex);
return;
if(maxspeed > 0)
{
double bytes = bytes_sent + bytes_received; // maybe smoothen a bit?
- curltime = realtime + bytes / (cl_curl_maxspeed.value * 1024.0);
+ curltime = host.realtime + bytes / (maxspeed * 1024.0);
bytes_sent = 0;
bytes_received = 0;
}
else
- curltime = realtime;
+ curltime = host.realtime;
if (curl_mutex) Thread_UnlockMutex(curl_mutex);
}
====================
Curl_Running
-returns true iff there is a download running.
+returns true if there is a download running.
====================
*/
-qboolean Curl_Running(void)
+qbool Curl_Running(void)
{
if(!curl_dll)
return false;
====================
*/
// TODO rewrite using Curl_GetDownloadInfo?
-static void Curl_Info_f(void)
+static void Curl_Info_f(cmd_state_t *cmd)
{
downloadinfo *di;
char urlbuf[1024];
once the last download completes successfully, reconnect to the current server
====================
*/
-static void Curl_Curl_f(void)
+static void Curl_Curl_f(cmd_state_t *cmd)
{
double maxspeed = 0;
int i;
int end;
int loadtype = LOADTYPE_NONE;
- qboolean forthismap = false;
+ qbool forthismap = false;
const char *url;
const char *name = 0;
return;
}
- if(Cmd_Argc() < 2)
+ if(Cmd_Argc(cmd) < 2)
{
Con_Print("usage:\ncurl --info, curl --cancel [filename], curl url\n");
return;
}
- url = Cmd_Argv(Cmd_Argc() - 1);
- end = Cmd_Argc();
+ url = Cmd_Argv(cmd, Cmd_Argc(cmd) - 1);
+ end = Cmd_Argc(cmd);
for(i = 1; i != end; ++i)
{
- const char *a = Cmd_Argv(i);
+ const char *a = Cmd_Argv(cmd, i);
if(!strcmp(a, "--info"))
{
- Curl_Info_f();
+ Curl_Info_f(cmd);
return;
}
else if(!strcmp(a, "--cancel"))
{
for(i = i + 1; i != end - 1; ++i)
{
- if(!FS_FileExists(Cmd_Argv(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...
if(i < end - 1)
{
++i;
- name = Cmd_Argv(i);
+ name = Cmd_Argv(cmd, i);
}
}
else if(!strcmp(a, "--clear_autodownload"))
{
dpsnprintf(donecommand, sizeof(donecommand), "connect %s", cls.netcon->address);
Curl_CommandWhenDone(donecommand);
- noclear = TRUE;
+ noclear = true;
CL_Disconnect();
- noclear = FALSE;
+ noclear = false;
Curl_CheckCommandWhenDone();
}
else
Z_Free(buffer);
}
-void Curl_CurlCat_f(void)
+void Curl_CurlCat_f(cmd_state_t *cmd)
{
unsigned char *buf;
- const char *url = Cmd_Argv(1);
+ const char *url = Cmd_Argv(cmd, 1);
buf = Z_Malloc(16384);
Curl_Begin_ToMemory(url, buf, 16384, curl_curlcat_callback, NULL);
}
Cvar_RegisterVariable (&sv_curl_maxspeed);
Cvar_RegisterVariable (&cl_curl_useragent);
Cvar_RegisterVariable (&cl_curl_useragent_append);
- Cmd_AddCommand ("curl", Curl_Curl_f, "download data from an URL and add to search path");
- //Cmd_AddCommand ("curlcat", Curl_CurlCat_f, "display data from an URL (debugging command)");
+ 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)");
}
/*
// read lines of format "pattern url"
char *p = buf;
char *pattern = NULL, *patternend = NULL, *url = NULL, *urlend = NULL;
- qboolean eof = false;
+ qbool eof = false;
pattern = p;
while(!eof)
curl --finish_autodownload
====================
*/
-static qboolean Curl_SendRequirement(const char *filename, qboolean foundone, char *sendbuffer, size_t sendbuffer_len)
+static qbool Curl_SendRequirement(const char *filename, qbool foundone, char *sendbuffer, size_t sendbuffer_len)
{
const char *p;
const char *thispack = FS_WhichPack(filename);
const char *packurl;
- if(!thispack)
+ if(!thispack || !*thispack)
return false;
p = strrchr(thispack, '/');
// for each requirement, find the pack name
char sendbuffer[4096] = "";
requirement *req;
- qboolean foundone = false;
+ qbool foundone = false;
const char *p;
for(req = requirements; req; req = req->next)
strlcat(sendbuffer, "curl --finish_autodownload\n", sizeof(sendbuffer));
if(strlen(sendbuffer) + 1 < sizeof(sendbuffer))
- Host_ClientCommands("%s", sendbuffer);
+ SV_ClientCommands("%s", sendbuffer);
else
Con_Printf("Could not initiate autodownload due to URL buffer overflow\n");
}
projects / xonotic / darkplaces.git / blobdiff