huge audit of dprints throughout engine, all notices of successfully
[divverent/darkplaces.git] / libcurl.c
1 #include "quakedef.h"
2 #include "fs.h"
3 #include "libcurl.h"
4
5 static cvar_t cl_curl_maxdownloads = {CVAR_SAVE, "cl_curl_maxdownloads","1", "maximum number of concurrent HTTP/FTP downloads"};
6 static cvar_t cl_curl_maxspeed = {CVAR_SAVE, "cl_curl_maxspeed","100", "maximum download speed (KiB/s)"};
7 static cvar_t sv_curl_defaulturl = {CVAR_SAVE, "sv_curl_defaulturl","", "default autodownload source URL"};
8 static cvar_t sv_curl_serverpackages = {CVAR_SAVE, "sv_curl_serverpackages","", "list of required files for the clients, separated by spaces"};
9 static cvar_t cl_curl_enabled = {CVAR_SAVE, "cl_curl_enabled","1", "whether client's download support is enabled"};
10
11 /*
12 =================================================================
13
14   Minimal set of definitions from libcurl
15
16   WARNING: for a matter of simplicity, several pointer types are
17   casted to "void*", and most enumerated values are not included
18
19 =================================================================
20 */
21
22 typedef struct CURL_s CURL;
23 typedef struct CURLM_s CURLM;
24 typedef enum
25 {
26         CURLE_OK = 0
27 }
28 CURLcode;
29 typedef enum
30 {
31         CURLM_CALL_MULTI_PERFORM=-1, /* please call curl_multi_perform() soon */
32         CURLM_OK = 0
33 }
34 CURLMcode;
35 #define CURL_GLOBAL_NOTHING 0
36 #define CURL_GLOBAL_SSL 1
37 #define CURL_GLOBAL_WIN32 2
38 #define CURLOPTTYPE_LONG          0
39 #define CURLOPTTYPE_OBJECTPOINT   10000
40 #define CURLOPTTYPE_FUNCTIONPOINT 20000
41 #define CURLOPTTYPE_OFF_T         30000
42 #define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number
43 typedef enum
44 {
45         CINIT(WRITEDATA, OBJECTPOINT, 1),
46         CINIT(URL,  OBJECTPOINT, 2),
47         CINIT(ERRORBUFFER, OBJECTPOINT, 10),
48         CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
49         CINIT(REFERER, OBJECTPOINT, 16),
50         CINIT(USERAGENT, OBJECTPOINT, 18),
51         CINIT(RESUME_FROM, LONG, 21),
52         CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */
53         CINIT(PRIVATE, OBJECTPOINT, 103),
54         CINIT(LOW_SPEED_LIMIT, LONG , 19),
55         CINIT(LOW_SPEED_TIME, LONG, 20),
56 }
57 CURLoption;
58 typedef enum
59 {
60         CURLINFO_TEXT = 0,
61         CURLINFO_HEADER_IN,    /* 1 */
62         CURLINFO_HEADER_OUT,   /* 2 */
63         CURLINFO_DATA_IN,      /* 3 */
64         CURLINFO_DATA_OUT,     /* 4 */
65         CURLINFO_SSL_DATA_IN,  /* 5 */
66         CURLINFO_SSL_DATA_OUT, /* 6 */
67         CURLINFO_END
68 }
69 curl_infotype;
70 #define CURLINFO_STRING   0x100000
71 #define CURLINFO_LONG     0x200000
72 #define CURLINFO_DOUBLE   0x300000
73 #define CURLINFO_SLIST    0x400000
74 #define CURLINFO_MASK     0x0fffff
75 #define CURLINFO_TYPEMASK 0xf00000
76 typedef enum
77 {
78         CURLINFO_NONE, /* first, never use this */
79         CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,
80         CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,
81         CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,
82         CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,
83         CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,
84         CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
85         CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,
86         CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,
87         CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,
88         CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,
89         CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,
90         CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,
91         CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,
92         CURLINFO_FILETIME         = CURLINFO_LONG   + 14,
93         CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,
94         CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,
95         CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
96         CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,
97         CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,
98         CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,
99         CURLINFO_PRIVATE          = CURLINFO_STRING + 21,
100         CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,
101         CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,
102         CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,
103         CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,
104         CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,
105         CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27,
106 }
107 CURLINFO;
108
109 typedef enum
110 {
111         CURLMSG_NONE, /* first, not used */
112         CURLMSG_DONE, /* This easy handle has completed. 'result' contains
113                                          the CURLcode of the transfer */
114         CURLMSG_LAST
115 }
116 CURLMSG;
117 typedef struct
118 {
119         CURLMSG msg;       /* what this message means */
120         CURL *easy_handle; /* the handle it concerns */
121         union
122         {
123                 void *whatever;    /* message-specific data */
124                 CURLcode result;   /* return code for transfer */
125         }
126         data;
127 }
128 CURLMsg;
129
130 static void (*qcurl_global_init) (long flags);
131 static void (*qcurl_global_cleanup) ();
132
133 static CURL * (*qcurl_easy_init) ();
134 static void (*qcurl_easy_cleanup) (CURL *handle);
135 static CURLcode (*qcurl_easy_setopt) (CURL *handle, CURLoption option, ...);
136 static CURLcode (*qcurl_easy_getinfo) (CURL *handle, CURLINFO info, ...);
137 static const char * (*qcurl_easy_strerror) (CURLcode);
138
139 static CURLM * (*qcurl_multi_init) ();
140 static CURLMcode (*qcurl_multi_perform) (CURLM *multi_handle, int *running_handles);
141 static CURLMcode (*qcurl_multi_add_handle) (CURLM *multi_handle, CURL *easy_handle);
142 static CURLMcode (*qcurl_multi_remove_handle) (CURLM *multi_handle, CURL *easy_handle);
143 static CURLMsg * (*qcurl_multi_info_read) (CURLM *multi_handle, int *msgs_in_queue);
144 static void (*qcurl_multi_cleanup) (CURLM *);
145 static const char * (*qcurl_multi_strerror) (CURLcode);
146
147 static dllfunction_t curlfuncs[] =
148 {
149         {"curl_global_init",            (void **) &qcurl_global_init},
150         {"curl_global_cleanup",         (void **) &qcurl_global_cleanup},
151         {"curl_easy_init",                      (void **) &qcurl_easy_init},
152         {"curl_easy_cleanup",           (void **) &qcurl_easy_cleanup},
153         {"curl_easy_setopt",            (void **) &qcurl_easy_setopt},
154         {"curl_easy_strerror",          (void **) &qcurl_easy_strerror},
155         {"curl_easy_getinfo",           (void **) &qcurl_easy_getinfo},
156         {"curl_multi_init",                     (void **) &qcurl_multi_init},
157         {"curl_multi_perform",          (void **) &qcurl_multi_perform},
158         {"curl_multi_add_handle",       (void **) &qcurl_multi_add_handle},
159         {"curl_multi_remove_handle",(void **) &qcurl_multi_remove_handle},
160         {"curl_multi_info_read",        (void **) &qcurl_multi_info_read},
161         {"curl_multi_cleanup",          (void **) &qcurl_multi_cleanup},
162         {"curl_multi_strerror",         (void **) &qcurl_multi_strerror},
163         {NULL, NULL}
164 };
165
166 // Handle for CURL DLL
167 static dllhandle_t curl_dll = NULL;
168 // will be checked at many places to find out if qcurl calls are allowed
169
170 typedef struct downloadinfo_s
171 {
172         char filename[MAX_QPATH];
173         char url[256];
174         char referer[256];
175         qfile_t *stream;
176         fs_offset_t startpos;
177         CURL *curle;
178         qboolean started;
179         qboolean ispak;
180         unsigned long bytes_received;
181         struct downloadinfo_s *next, *prev;
182         qboolean forthismap;
183 }
184 downloadinfo;
185 static downloadinfo *downloads = NULL;
186 static int numdownloads = 0;
187
188 static qboolean noclear = FALSE;
189
190 static int numdownloads_fail = 0;
191 static int numdownloads_success = 0;
192 static int numdownloads_added = 0;
193 static char command_when_done[256] = "";
194 static char command_when_error[256] = "";
195
196 /*
197 ====================
198 Curl_CommandWhenDone
199
200 Sets the command which is to be executed when the last download completes AND
201 all downloads since last server connect ended with a successful status.
202 Setting the command to NULL clears it.
203 ====================
204 */
205 void Curl_CommandWhenDone(const char *cmd)
206 {
207         if(!curl_dll)
208                 return;
209         if(cmd)
210                 strlcpy(command_when_done, cmd, sizeof(command_when_done));
211         else
212                 *command_when_done = 0;
213 }
214
215 /*
216 FIXME
217 Do not use yet. Not complete.
218 Problem: what counts as an error?
219 */
220
221 void Curl_CommandWhenError(const char *cmd)
222 {
223         if(!curl_dll)
224                 return;
225         if(cmd)
226                 strlcpy(command_when_error, cmd, sizeof(command_when_error));
227         else
228                 *command_when_error = 0;
229 }
230
231 /*
232 ====================
233 Curl_Clear_forthismap
234
235 Clears the "will disconnect on failure" flags.
236 ====================
237 */
238 void Curl_Clear_forthismap()
239 {
240         downloadinfo *di;
241         if(noclear)
242                 return;
243         for(di = downloads; di; di = di->next)
244                 di->forthismap = false;
245         Curl_CommandWhenError(NULL);
246         Curl_CommandWhenDone(NULL);
247         numdownloads_fail = 0;
248         numdownloads_success = 0;
249         numdownloads_added = 0;
250 }
251
252 /*
253 ====================
254 Curl_Have_forthismap
255
256 Returns true if a download needed for the current game is running.
257 ====================
258 */
259 qboolean Curl_Have_forthismap()
260 {
261         return numdownloads_added;
262 }
263
264 void Curl_Register_predownload()
265 {
266         Curl_CommandWhenDone("cl_begindownloads");
267         Curl_CommandWhenError("cl_begindownloads");
268 }
269
270 /*
271 ====================
272 Curl_CheckCommandWhenDone
273
274 Checks if a "done command" is to be executed.
275 All downloads finished, at least one success since connect, no single failure
276 -> execute the command.
277 */
278 static void Curl_CheckCommandWhenDone()
279 {
280         if(!curl_dll)
281                 return;
282         if(numdownloads_added && (numdownloads_success == numdownloads_added) && *command_when_done)
283         {
284                 Con_DPrintf("cURL downloads occurred, executing %s\n", command_when_done);
285                 Cbuf_AddText("\n");
286                 Cbuf_AddText(command_when_done);
287                 Cbuf_AddText("\n");
288                 Curl_Clear_forthismap();
289         }
290         else if(numdownloads_added && numdownloads_fail && *command_when_error)
291         {
292                 Con_DPrintf("cURL downloads FAILED, executing %s\n", command_when_error);
293                 Cbuf_AddText("\n");
294                 Cbuf_AddText(command_when_error);
295                 Cbuf_AddText("\n");
296                 Curl_Clear_forthismap();
297         }
298 }
299
300 /*
301 ====================
302 CURL_CloseLibrary
303
304 Load the cURL DLL
305 ====================
306 */
307 static qboolean CURL_OpenLibrary (void)
308 {
309         const char* dllnames [] =
310         {
311 #if defined(WIN64)
312                 "libcurl64.dll",
313 #elif defined(WIN32)
314                 "libcurl-4.dll",
315                 "libcurl-3.dll",
316 #elif defined(MACOSX)
317                 "libcurl.4.dylib", // Mac OS X Notyetreleased
318                 "libcurl.3.dylib", // Mac OS X Tiger
319                 "libcurl.2.dylib", // Mac OS X Panther
320 #else
321                 "libcurl.so.4",
322                 "libcurl.so.3",
323                 "libcurl.so", // FreeBSD
324 #endif
325                 NULL
326         };
327
328         // Already loaded?
329         if (curl_dll)
330                 return true;
331
332         // Load the DLL
333         return Sys_LoadLibrary (dllnames, &curl_dll, curlfuncs);
334 }
335
336
337 /*
338 ====================
339 CURL_CloseLibrary
340
341 Unload the cURL DLL
342 ====================
343 */
344 static void CURL_CloseLibrary (void)
345 {
346         Sys_UnloadLibrary (&curl_dll);
347 }
348
349
350 static CURLM *curlm = NULL;
351 static unsigned long bytes_received = 0; // used for bandwidth throttling
352 static double curltime = 0;
353
354 /*
355 ====================
356 CURL_fwrite
357
358 fwrite-compatible function that writes the data to a file. libcurl can call
359 this.
360 ====================
361 */
362 static size_t CURL_fwrite(void *data, size_t size, size_t nmemb, void *vdi)
363 {
364         fs_offset_t ret;
365         size_t bytes = size * nmemb;
366         downloadinfo *di = (downloadinfo *) vdi;
367
368         bytes_received += bytes;
369         di->bytes_received += bytes;
370
371         ret = FS_Write(di->stream, data, bytes);
372
373         return ret; // why not ret / nmemb?
374 }
375
376 typedef enum
377 {
378         CURL_DOWNLOAD_SUCCESS = 0,
379         CURL_DOWNLOAD_FAILED,
380         CURL_DOWNLOAD_ABORTED,
381         CURL_DOWNLOAD_SERVERERROR
382 }
383 CurlStatus;
384
385 /*
386 ====================
387 Curl_EndDownload
388
389 stops a download. It receives a status (CURL_DOWNLOAD_SUCCESS,
390 CURL_DOWNLOAD_FAILED or CURL_DOWNLOAD_ABORTED) and in the second case the error
391 code from libcurl, or 0, if another error has occurred.
392 ====================
393 */
394 static void Curl_EndDownload(downloadinfo *di, CurlStatus status, CURLcode error)
395 {
396         qboolean ok = false;
397         if(!curl_dll)
398                 return;
399         switch(status)
400         {
401                 case CURL_DOWNLOAD_SUCCESS:
402                         Con_Printf("Download of %s: OK\n", di->filename);
403                         ok = true;
404                         break;
405                 case CURL_DOWNLOAD_FAILED:
406                         Con_Printf("Download of %s: FAILED\n", di->filename);
407                         if(error)
408                                 Con_Printf("Reason given by libcurl: %s\n", qcurl_easy_strerror(error));
409                         break;
410                 case CURL_DOWNLOAD_ABORTED:
411                         Con_Printf("Download of %s: ABORTED\n", di->filename);
412                         break;
413                 case CURL_DOWNLOAD_SERVERERROR:
414                         Con_Printf("Download of %s: %d\n", di->filename, (int) error);
415
416                         // reopen to enforce it to have zero bytes again
417                         FS_Close(di->stream);
418                         di->stream = FS_Open(di->filename, "w", false, false);
419
420                         break;
421         }
422
423         if(di->curle)
424         {
425                 qcurl_multi_remove_handle(curlm, di->curle);
426                 qcurl_easy_cleanup(di->curle);
427         }
428
429         if(ok && !di->bytes_received)
430         {
431                 Con_Printf("ERROR: empty file\n");
432                 ok = false;
433         }
434
435         if(di->stream)
436                 FS_Close(di->stream);
437
438         if(ok && di->ispak)
439                 ok = FS_AddPack(di->filename, NULL, true);
440
441         if(di->prev)
442                 di->prev->next = di->next;
443         else
444                 downloads = di->next;
445         if(di->next)
446                 di->next->prev = di->prev;
447
448         --numdownloads;
449         if(di->forthismap)
450         {
451                 if(ok)
452                         ++numdownloads_success;
453                 else
454                         ++numdownloads_fail;
455         }
456         Z_Free(di);
457 }
458
459 /*
460 ====================
461 CheckPendingDownloads
462
463 checks if there are free download slots to start new downloads in.
464 To not start too many downloads at once, only one download is added at a time,
465 up to a maximum number of cl_curl_maxdownloads are running.
466 ====================
467 */
468 static void CheckPendingDownloads()
469 {
470         if(!curl_dll)
471                 return;
472         if(numdownloads < cl_curl_maxdownloads.integer)
473         {
474                 downloadinfo *di;
475                 for(di = downloads; di; di = di->next)
476                 {
477                         if(!di->started)
478                         {
479                                 Con_Printf("Downloading %s -> %s", di->url, di->filename);
480
481                                 di->stream = FS_Open(di->filename, "ab", false, false);
482                                 if(!di->stream)
483                                 {
484                                         Con_Printf("\nFAILED: Could not open output file %s\n", di->filename);
485                                         Curl_EndDownload(di, CURL_DOWNLOAD_FAILED, CURLE_OK);
486                                         return;
487                                 }
488
489                                 FS_Seek(di->stream, 0, SEEK_END);
490                                 di->startpos = FS_Tell(di->stream);
491                                 if(di->startpos > 0)
492                                         Con_Printf(", resuming from position %ld", (long) di->startpos);
493                                 Con_Print("...\n");
494
495                                 di->curle = qcurl_easy_init();
496                                 qcurl_easy_setopt(di->curle, CURLOPT_URL, di->url);
497                                 qcurl_easy_setopt(di->curle, CURLOPT_USERAGENT, engineversion);
498                                 qcurl_easy_setopt(di->curle, CURLOPT_REFERER, di->referer);
499                                 qcurl_easy_setopt(di->curle, CURLOPT_RESUME_FROM, (long) di->startpos);
500                                 qcurl_easy_setopt(di->curle, CURLOPT_FOLLOWLOCATION, 1);
501                                 qcurl_easy_setopt(di->curle, CURLOPT_WRITEFUNCTION, CURL_fwrite);
502                                 qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_LIMIT, (long) 256);
503                                 qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_TIME, (long) 45);
504                                 qcurl_easy_setopt(di->curle, CURLOPT_WRITEDATA, (void *) di);
505                                 qcurl_easy_setopt(di->curle, CURLOPT_PRIVATE, (void *) di);
506                                 qcurl_multi_add_handle(curlm, di->curle);
507                                 di->started = true;
508                                 ++numdownloads;
509                                 if(numdownloads >= cl_curl_maxdownloads.integer)
510                                         break;
511                         }
512                 }
513         }
514 }
515
516 /*
517 ====================
518 Curl_Init
519
520 this function MUST be called before using anything else in this file.
521 On Win32, this must be called AFTER WSAStartup has been done!
522 ====================
523 */
524 void Curl_Init()
525 {
526         CURL_OpenLibrary();
527         if(!curl_dll)
528                 return;
529         qcurl_global_init(CURL_GLOBAL_NOTHING);
530         curlm = qcurl_multi_init();
531 }
532
533 /*
534 ====================
535 Curl_Shutdown
536
537 Surprise... closes all the stuff. Please do this BEFORE shutting down LHNET.
538 ====================
539 */
540 void Curl_ClearRequirements();
541 void Curl_Shutdown()
542 {
543         if(!curl_dll)
544                 return;
545         Curl_ClearRequirements();
546         Curl_CancelAll();
547         CURL_CloseLibrary();
548         curl_dll = NULL;
549 }
550
551 /*
552 ====================
553 Curl_Find
554
555 Finds the internal information block for a download given by file name.
556 ====================
557 */
558 static downloadinfo *Curl_Find(const char *filename)
559 {
560         downloadinfo *di;
561         if(!curl_dll)
562                 return NULL;
563         for(di = downloads; di; di = di->next)
564                 if(!strcasecmp(di->filename, filename))
565                         return di;
566         return NULL;
567 }
568
569 /*
570 ====================
571 Curl_Begin
572
573 Starts a download of a given URL to the file name portion of this URL (or name
574 if given) in the "dlcache/" folder.
575 ====================
576 */
577 void Curl_Begin(const char *URL, const char *name, qboolean ispak, qboolean forthismap)
578 {
579         if(!curl_dll)
580                 return;
581         else
582         {
583                 char fn[MAX_QPATH];
584                 const char *p, *q;
585                 size_t length;
586                 downloadinfo *di;
587
588                 // Note: This extraction of the file name portion is NOT entirely correct.
589                 //
590                 // It does the following:
591                 //
592                 //   http://host/some/script.cgi/SomeFile.pk3?uid=ABCDE -> SomeFile.pk3
593                 //   http://host/some/script.php?uid=ABCDE&file=/SomeFile.pk3 -> SomeFile.pk3
594                 //   http://host/some/script.php?uid=ABCDE&file=SomeFile.pk3 -> script.php
595                 //
596                 // However, I'd like to keep this "buggy" behavior so that PHP script
597                 // authors can write download scripts without having to enable
598                 // AcceptPathInfo on Apache. They just have to ensure that their script
599                 // can be called with such a "fake" path name like
600                 // http://host/some/script.php?uid=ABCDE&file=/SomeFile.pk3
601                 //
602                 // By the way, such PHP scripts should either send the file or a
603                 // "Location:" redirect; PHP code example:
604                 //
605                 //   header("Location: http://www.example.com/");
606                 //
607                 // By the way, this will set User-Agent to something like
608                 // "Nexuiz build 22:27:55 Mar 17 2006" (engineversion) and Referer to
609                 // dp://serverhost:serverport/ so you can filter on this; an example
610                 // httpd log file line might be:
611                 //
612                 //   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"
613
614                 if(!name)
615                         name = URL;
616                 p = strrchr(name, '/');
617                 p = p ? (p+1) : name;
618                 q = strchr(p, '?');
619                 length = q ? (size_t)(q - p) : strlen(p);
620                 dpsnprintf(fn, sizeof(fn), "dlcache/%.*s", (int)length, p);
621
622
623                 // already downloading the file?
624                 {
625                         downloadinfo *di = Curl_Find(fn);
626                         if(di)
627                         {
628                                 Con_Printf("Can't download %s, already getting it from %s!\n", fn, di->url);
629
630                                 // however, if it was not for this map yet...
631                                 if(forthismap && !di->forthismap)
632                                 {
633                                         di->forthismap = true;
634                                         // this "fakes" a download attempt so the client will wait for
635                                         // the download to finish and then reconnect
636                                         ++numdownloads_added;
637                                 }
638
639                                 return;
640                         }
641                 }
642
643                 if(ispak && FS_FileExists(fn))
644                 {
645                         qboolean already_loaded;
646                         if(FS_AddPack(fn, &already_loaded, true))
647                         {
648                                 Con_DPrintf("%s already exists, not downloading!\n", fn);
649                                 if(already_loaded)
650                                         Con_DPrintf("(pak was already loaded)\n");
651                                 else
652                                 {
653                                         if(forthismap)
654                                         {
655                                                 ++numdownloads_added;
656                                                 ++numdownloads_success;
657                                         }
658                                 }
659                                 return;
660                         }
661                         else
662                         {
663                                 qfile_t *f = FS_Open(fn, "rb", false, false);
664                                 if(f)
665                                 {
666                                         char buf[4] = {0};
667                                         FS_Read(f, buf, sizeof(buf)); // no "-1", I will use memcmp
668
669                                         if(memcmp(buf, "PK\x03\x04", 4) && memcmp(buf, "PACK", 4))
670                                         {
671                                                 Con_DPrintf("Detected non-PAK %s, clearing and NOT resuming.\n", fn);
672                                                 FS_Close(f);
673                                                 f = FS_Open(fn, "w", false, false);
674                                                 if(f)
675                                                         FS_Close(f);
676                                         }
677                                         else
678                                         {
679                                                 // OK
680                                                 FS_Close(f);
681                                         }
682                                 }
683                         }
684                 }
685
686                 if(forthismap)
687                         ++numdownloads_added;
688                 di = (downloadinfo *) Z_Malloc(sizeof(*di));
689                 strlcpy(di->filename, fn, sizeof(di->filename));
690                 strlcpy(di->url, URL, sizeof(di->url));
691                 dpsnprintf(di->referer, sizeof(di->referer), "dp://%s/", cls.netcon ? cls.netcon->address : "notconnected.invalid");
692                 di->forthismap = forthismap;
693                 di->stream = NULL;
694                 di->startpos = 0;
695                 di->curle = NULL;
696                 di->started = false;
697                 di->ispak = ispak;
698                 di->bytes_received = 0;
699                 di->next = downloads;
700                 di->prev = NULL;
701                 if(di->next)
702                         di->next->prev = di;
703                 downloads = di;
704         }
705 }
706
707
708 /*
709 ====================
710 Curl_Run
711
712 call this regularily as this will always download as much as possible without
713 blocking.
714 ====================
715 */
716 void Curl_Run()
717 {
718         noclear = FALSE;
719
720         if(!cl_curl_enabled.integer)
721                 return;
722
723         if(!curl_dll)
724                 return;
725
726         Curl_CheckCommandWhenDone();
727
728         if(!downloads)
729                 return;
730
731         if(realtime < curltime) // throttle
732                 return;
733
734         {
735                 int remaining;
736                 CURLMcode mc;
737
738                 do
739                 {
740                         mc = qcurl_multi_perform(curlm, &remaining);
741                 }
742                 while(mc == CURLM_CALL_MULTI_PERFORM);
743
744                 for(;;)
745                 {
746                         CURLMsg *msg = qcurl_multi_info_read(curlm, &remaining);
747                         if(!msg)
748                                 break;
749                         if(msg->msg == CURLMSG_DONE)
750                         {
751                                 downloadinfo *di;
752                                 CurlStatus failed = CURL_DOWNLOAD_SUCCESS;
753                                 CURLcode result;
754                                 qcurl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &di);
755                                 result = msg->data.result;
756                                 if(result)
757                                 {
758                                         failed = CURL_DOWNLOAD_FAILED;
759                                 }
760                                 else
761                                 {
762                                         long code;
763                                         qcurl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &code);
764                                         switch(code / 100)
765                                         {
766                                                 case 4: // e.g. 404?
767                                                 case 5: // e.g. 500?
768                                                         failed = CURL_DOWNLOAD_SERVERERROR;
769                                                         result = code;
770                                                         break;
771                                         }
772                                 }
773
774                                 Curl_EndDownload(di, failed, result);
775                         }
776                 }
777         }
778
779         CheckPendingDownloads();
780
781         // when will we curl the next time?
782         // we will wait a bit to ensure our download rate is kept.
783         // we now know that realtime >= curltime... so set up a new curltime
784         if(cl_curl_maxspeed.value > 0)
785         {
786                 unsigned long bytes = bytes_received; // maybe smoothen a bit?
787                 curltime = realtime + bytes / (cl_curl_maxspeed.value * 1024.0);
788                 bytes_received -= bytes;
789         }
790         else
791                 curltime = realtime;
792 }
793
794 /*
795 ====================
796 Curl_CancelAll
797
798 Stops ALL downloads.
799 ====================
800 */
801 void Curl_CancelAll()
802 {
803         if(!curl_dll)
804                 return;
805
806         while(downloads)
807         {
808                 Curl_EndDownload(downloads, CURL_DOWNLOAD_ABORTED, CURLE_OK);
809                 // INVARIANT: downloads will point to the next download after that!
810         }
811 }
812
813 /*
814 ====================
815 Curl_Running
816
817 returns true iff there is a download running.
818 ====================
819 */
820 qboolean Curl_Running()
821 {
822         if(!curl_dll)
823                 return false;
824
825         return downloads != NULL;
826 }
827
828 /*
829 ====================
830 Curl_GetDownloadAmount
831
832 returns a value from 0.0 to 1.0 which represents the downloaded amount of data
833 for the given download.
834 ====================
835 */
836 static double Curl_GetDownloadAmount(downloadinfo *di)
837 {
838         if(!curl_dll)
839                 return -2;
840         if(di->curle)
841         {
842                 double length;
843                 qcurl_easy_getinfo(di->curle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length);
844                 if(length > 0)
845                         return di->bytes_received / length;
846                 else
847                         return 0;
848         }
849         else
850                 return -1;
851 }
852
853 /*
854 ====================
855 Curl_GetDownloadSpeed
856
857 returns the speed of the given download in bytes per second
858 ====================
859 */
860 static double Curl_GetDownloadSpeed(downloadinfo *di)
861 {
862         if(!curl_dll)
863                 return -2;
864         if(di->curle)
865         {
866                 double speed;
867                 qcurl_easy_getinfo(di->curle, CURLINFO_SPEED_DOWNLOAD, &speed);
868                 return speed;
869         }
870         else
871                 return -1;
872 }
873
874 /*
875 ====================
876 Curl_Info_f
877
878 prints the download list
879 ====================
880 */
881 // TODO rewrite using Curl_GetDownloadInfo?
882 static void Curl_Info_f()
883 {
884         downloadinfo *di;
885         if(!curl_dll)
886                 return;
887         if(Curl_Running())
888         {
889                 Con_Print("Currently running downloads:\n");
890                 for(di = downloads; di; di = di->next)
891                 {
892                         double speed, percent;
893                         Con_Printf("  %s -> %s ",  di->url, di->filename);
894                         percent = 100.0 * Curl_GetDownloadAmount(di);
895                         speed = Curl_GetDownloadSpeed(di);
896                         if(percent >= 0)
897                                 Con_Printf("(%.1f%% @ %.1f KiB/s)\n", percent, speed / 1024.0);
898                         else
899                                 Con_Print("(queued)\n");
900                 }
901         }
902         else
903         {
904                 Con_Print("No downloads running.\n");
905         }
906 }
907
908 /*
909 ====================
910 Curl_Curl_f
911
912 implements the "curl" console command
913
914 curl --info
915 curl --cancel
916 curl --cancel filename
917 curl url
918
919 For internal use:
920
921 curl [--pak] [--forthismap] [--for filename filename...] url
922         --pak: after downloading, load the package into the virtual file system
923         --for filename...: only download of at least one of the named files is missing
924         --forthismap: don't reconnect on failure
925
926 curl --clear_autodownload
927         clears the download success/failure counters
928
929 curl --finish_autodownload
930         if at least one download has been started, disconnect and drop to the menu
931         once the last download completes successfully, reconnect to the current server
932 ====================
933 */
934 void Curl_Curl_f(void)
935 {
936         int i;
937         int end;
938         qboolean pak = false;
939         qboolean forthismap = false;
940         const char *url;
941         const char *name = 0;
942
943         if(!curl_dll)
944         {
945                 Con_Print("libcurl DLL not found, this command is inactive.\n");
946                 return;
947         }
948
949         if(!cl_curl_enabled.integer)
950         {
951                 Con_Print("curl support not enabled. Set cl_curl_enabled to 1 to enable.\n");
952                 return;
953         }
954
955         for(i = 0; i != Cmd_Argc(); ++i)
956                 Con_DPrintf("%s ", Cmd_Argv(i));
957         Con_DPrint("\n");
958
959         if(Cmd_Argc() < 2)
960         {
961                 Con_Print("usage:\ncurl --info, curl --cancel [filename], curl url\n");
962                 return;
963         }
964
965         url = Cmd_Argv(Cmd_Argc() - 1);
966         end = Cmd_Argc();
967
968         for(i = 1; i != end; ++i)
969         {
970                 const char *a = Cmd_Argv(i);
971                 if(!strcmp(a, "--info"))
972                 {
973                         Curl_Info_f();
974                         return;
975                 }
976                 else if(!strcmp(a, "--cancel"))
977                 {
978                         if(i == end - 1) // last argument
979                                 Curl_CancelAll();
980                         else
981                         {
982                                 downloadinfo *di = Curl_Find(url);
983                                 if(di)
984                                         Curl_EndDownload(di, CURL_DOWNLOAD_ABORTED, CURLE_OK);
985                                 else
986                                         Con_Print("download not found\n");
987                         }
988                         return;
989                 }
990                 else if(!strcmp(a, "--pak"))
991                 {
992                         pak = true;
993                 }
994                 else if(!strcmp(a, "--for"))
995                 {
996                         for(i = i + 1; i != end - 1; ++i)
997                         {
998                                 if(!FS_FileExists(Cmd_Argv(i)))
999                                         goto needthefile; // why can't I have a "double break"?
1000                         }
1001                         // if we get here, we have all the files...
1002                         return;
1003                 }
1004                 else if(!strcmp(a, "--forthismap"))
1005                 {
1006                         forthismap = true;
1007                 }
1008                 else if(!strcmp(a, "--as"))
1009                 {
1010                         if(i < end - 1)
1011                         {
1012                                 ++i;
1013                                 name = Cmd_Argv(i);
1014                         }
1015                 }
1016                 else if(!strcmp(a, "--clear_autodownload"))
1017                 {
1018                         // mark all running downloads as "not for this map", so if they
1019                         // fail, it does not matter
1020                         Curl_Clear_forthismap();
1021                         return;
1022                 }
1023                 else if(!strcmp(a, "--finish_autodownload"))
1024                 {
1025                         if(numdownloads_added)
1026                         {
1027                                 char donecommand[256];
1028                                 if(cls.netcon)
1029                                 {
1030                                         if(cl.loadbegun) // curling won't inhibit loading the map any more when at this stage, so bail out and force a reconnect
1031                                         {
1032                                                 dpsnprintf(donecommand, sizeof(donecommand), "connect %s", cls.netcon->address);
1033                                                 Curl_CommandWhenDone(donecommand);
1034                                                 noclear = TRUE;
1035                                                 CL_Disconnect();
1036                                                 noclear = FALSE;
1037                                                 Curl_CheckCommandWhenDone();
1038                                         }
1039                                         else
1040                                                 Curl_Register_predownload();
1041                                 }
1042                         }
1043                         return;
1044                 }
1045                 else if(*a == '-')
1046                 {
1047                         Con_Printf("invalid option %s\n", a);
1048                         return;
1049                 }
1050         }
1051
1052 needthefile:
1053         Curl_Begin(url, name, pak, forthismap);
1054 }
1055
1056 /*
1057 ====================
1058 Curl_Init_Commands
1059
1060 loads the commands and cvars this library uses
1061 ====================
1062 */
1063 void Curl_Init_Commands(void)
1064 {
1065         Cvar_RegisterVariable (&cl_curl_enabled);
1066         Cvar_RegisterVariable (&cl_curl_maxdownloads);
1067         Cvar_RegisterVariable (&cl_curl_maxspeed);
1068         Cvar_RegisterVariable (&sv_curl_defaulturl);
1069         Cvar_RegisterVariable (&sv_curl_serverpackages);
1070         Cmd_AddCommand ("curl", Curl_Curl_f, "download data from an URL and add to search path");
1071 }
1072
1073 /*
1074 ====================
1075 Curl_GetDownloadInfo
1076
1077 returns an array of Curl_downloadinfo_t structs for usage by GUIs.
1078 The number of elements in the array is returned in int *nDownloads.
1079 const char **additional_info may be set to a string of additional user
1080 information, or to NULL if no such display shall occur. The returned
1081 array must be freed later using Z_Free.
1082 ====================
1083 */
1084 Curl_downloadinfo_t *Curl_GetDownloadInfo(int *nDownloads, const char **additional_info)
1085 {
1086         int n, i;
1087         downloadinfo *di;
1088         Curl_downloadinfo_t *downinfo;
1089         static char addinfo[128];
1090
1091         if(!curl_dll)
1092         {
1093                 *nDownloads = 0;
1094                 if(additional_info)
1095                         *additional_info = NULL;
1096                 return NULL;
1097         }
1098
1099         n = 0;
1100         for(di = downloads; di; di = di->next)
1101                 ++n;
1102
1103         downinfo = (Curl_downloadinfo_t *) Z_Malloc(sizeof(*downinfo) * n);
1104         i = 0;
1105         for(di = downloads; di; di = di->next)
1106         {
1107                 strlcpy(downinfo[i].filename, di->filename, sizeof(downinfo[i].filename));
1108                 if(di->curle)
1109                 {
1110                         downinfo[i].progress = Curl_GetDownloadAmount(di);
1111                         downinfo[i].speed = Curl_GetDownloadSpeed(di);
1112                         downinfo[i].queued = false;
1113                 }
1114                 else
1115                 {
1116                         downinfo[i].queued = true;
1117                 }
1118                 ++i;
1119         }
1120
1121         if(additional_info)
1122         {
1123                 // TODO: can I clear command_when_done as soon as the first download fails?
1124                 if(*command_when_done && !numdownloads_fail && numdownloads_added)
1125                 {
1126                         if(!strncmp(command_when_done, "connect ", 8))
1127                                 dpsnprintf(addinfo, sizeof(addinfo), "(will join %s when done)", command_when_done + 8);
1128                         else if(!strcmp(command_when_done, "cl_begindownloads"))
1129                                 dpsnprintf(addinfo, sizeof(addinfo), "(will enter the game when done)");
1130                         else
1131                                 dpsnprintf(addinfo, sizeof(addinfo), "(will do '%s' when done)", command_when_done);
1132                         *additional_info = addinfo;
1133                 }
1134                 else
1135                         *additional_info = NULL;
1136         }
1137
1138         *nDownloads = n;
1139         return downinfo;
1140 }
1141
1142
1143 /*
1144 ====================
1145 Curl_FindPackURL
1146
1147 finds the URL where to find a given package.
1148
1149 For this, it reads a file "curl_urls.txt" of the following format:
1150
1151         data*.pk3       -
1152         revdm*.pk3      http://revdm/downloads/are/here/
1153         *                       http://any/other/stuff/is/here/
1154
1155 The URLs should end in /. If not, downloads will still work, but the cached files
1156 can't be just put into the data directory with the same download configuration
1157 (you might want to do this if you want to tag downloaded files from your
1158 server, but you should not). "-" means "don't download".
1159
1160 If no single pattern matched, the cvar sv_curl_defaulturl is used as download
1161 location instead.
1162
1163 Note: pak1.pak and data*.pk3 are excluded from autodownload at another point in
1164 this file for obvious reasons.
1165 ====================
1166 */
1167 static const char *Curl_FindPackURL(const char *filename)
1168 {
1169         static char foundurl[256];
1170         fs_offset_t filesize;
1171         char *buf = (char *) FS_LoadFile("curl_urls.txt", tempmempool, true, &filesize);
1172         if(buf && filesize)
1173         {
1174                 // read lines of format "pattern url"
1175                 char *p = buf;
1176                 char *pattern = NULL, *patternend = NULL, *url = NULL, *urlend = NULL;
1177                 qboolean eof = false;
1178
1179                 pattern = p;
1180                 while(!eof)
1181                 {
1182                         switch(*p)
1183                         {
1184                                 case 0:
1185                                         eof = true;
1186                                         // fallthrough
1187                                 case '\n':
1188                                 case '\r':
1189                                         if(pattern && url && patternend)
1190                                         {
1191                                                 if(!urlend)
1192                                                         urlend = p;
1193                                                 *patternend = 0;
1194                                                 *urlend = 0;
1195                                                 if(matchpattern(filename, pattern, true))
1196                                                 {
1197                                                         strlcpy(foundurl, url, sizeof(foundurl));
1198                                                         Z_Free(buf);
1199                                                         return foundurl;
1200                                                 }
1201                                         }
1202                                         pattern = NULL;
1203                                         patternend = NULL;
1204                                         url = NULL;
1205                                         urlend = NULL;
1206                                         break;
1207                                 case ' ':
1208                                 case '\t':
1209                                         if(pattern && !patternend)
1210                                                 patternend = p;
1211                                         else if(url && !urlend)
1212                                                 urlend = p;
1213                                         break;
1214                                 default:
1215                                         if(!pattern)
1216                                                 pattern = p;
1217                                         else if(pattern && patternend && !url)
1218                                                 url = p;
1219                                         break;
1220                         }
1221                         ++p;
1222                 }
1223         }
1224         if(buf)
1225                 Z_Free(buf);
1226         return sv_curl_defaulturl.string;
1227 }
1228
1229 typedef struct requirement_s
1230 {
1231         struct requirement_s *next;
1232         char filename[MAX_QPATH];
1233 }
1234 requirement;
1235 static requirement *requirements = NULL;
1236
1237
1238 /*
1239 ====================
1240 Curl_RequireFile
1241
1242 Adds the given file to the list of requirements.
1243 ====================
1244 */
1245 void Curl_RequireFile(const char *filename)
1246 {
1247         requirement *req = (requirement *) Z_Malloc(sizeof(*requirements));
1248         req->next = requirements;
1249         strlcpy(req->filename, filename, sizeof(req->filename));
1250         requirements = req;
1251 }
1252
1253 /*
1254 ====================
1255 Curl_ClearRequirements
1256
1257 Clears the list of required files for playing on the current map.
1258 This should be called at every map change.
1259 ====================
1260 */
1261 void Curl_ClearRequirements()
1262 {
1263         const char *p;
1264         while(requirements)
1265         {
1266                 requirement *req = requirements;
1267                 requirements = requirements->next;
1268                 Z_Free(req);
1269         }
1270         p = sv_curl_serverpackages.string;
1271         Con_DPrintf("Require all of: %s\n", p);
1272         while(COM_ParseToken_Simple(&p, false, false))
1273         {
1274                 Con_DPrintf("Require: %s\n", com_token);
1275                 Curl_RequireFile(com_token);
1276         }
1277 }
1278
1279 /*
1280 ====================
1281 Curl_SendRequirements
1282
1283 Makes the current host_clients download all files he needs.
1284 This is done by sending him the following console commands:
1285
1286         curl --clear_autodownload
1287         curl --pak --for maps/pushmoddm1.bsp --forthismap http://where/this/darn/map/is/pushmoddm1.pk3
1288         curl --finish_autodownload
1289 ====================
1290 */
1291 void Curl_SendRequirements()
1292 {
1293         // for each requirement, find the pack name
1294         char sendbuffer[4096] = "";
1295         requirement *req;
1296         qboolean foundone = false;
1297
1298         for(req = requirements; req; req = req->next)
1299         {
1300                 const char *p;
1301                 const char *thispack = FS_WhichPack(req->filename);
1302                 const char *packurl;
1303
1304                 if(!thispack)
1305                         continue;
1306
1307                 p = strrchr(thispack, '/');
1308                 if(p)
1309                         thispack = p + 1;
1310
1311                 packurl = Curl_FindPackURL(thispack);
1312
1313                 if(packurl && *packurl && strcmp(packurl, "-"))
1314                 {
1315                         if(!foundone)
1316                                 strlcat(sendbuffer, "curl --clear_autodownload\n", sizeof(sendbuffer));
1317
1318                         strlcat(sendbuffer, "curl --pak --forthismap --as ", sizeof(sendbuffer));
1319                         strlcat(sendbuffer, thispack, sizeof(sendbuffer));
1320                         strlcat(sendbuffer, " --for ", sizeof(sendbuffer));
1321                         strlcat(sendbuffer, req->filename, sizeof(sendbuffer));
1322                         strlcat(sendbuffer, " ", sizeof(sendbuffer));
1323                         strlcat(sendbuffer, packurl, sizeof(sendbuffer));
1324                         strlcat(sendbuffer, thispack, sizeof(sendbuffer));
1325                         strlcat(sendbuffer, "\n", sizeof(sendbuffer));
1326
1327                         foundone = true;
1328                 }
1329         }
1330
1331         if(foundone)
1332                 strlcat(sendbuffer, "curl --finish_autodownload\n", sizeof(sendbuffer));
1333
1334         if(strlen(sendbuffer) + 1 < sizeof(sendbuffer))
1335                 Host_ClientCommands("%s", sendbuffer);
1336         else
1337                 Con_Printf("Could not initiate autodownload due to URL buffer overflow\n");
1338 }