2014-10-29 12:37:38 +00:00
|
|
|
#include <base/system.h>
|
|
|
|
#include <engine/storage.h>
|
2015-05-09 23:36:29 +00:00
|
|
|
#include <engine/shared/config.h>
|
2014-10-29 12:37:38 +00:00
|
|
|
#include "fetcher.h"
|
|
|
|
|
2017-07-16 08:45:41 +00:00
|
|
|
CFetchTask::CFetchTask(bool canTimeout, bool useDDNetCA)
|
2014-10-29 12:37:38 +00:00
|
|
|
{
|
|
|
|
m_pNext = NULL;
|
2015-05-09 23:53:26 +00:00
|
|
|
m_CanTimeout = canTimeout;
|
2017-07-16 08:45:41 +00:00
|
|
|
m_UseDDNetCA = useDDNetCA;
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CFetcher::CFetcher()
|
|
|
|
{
|
|
|
|
m_pStorage = NULL;
|
|
|
|
m_pHandle = NULL;
|
|
|
|
m_Lock = lock_create();
|
2017-08-31 10:30:42 +00:00
|
|
|
sphore_init(&m_Queued);
|
2014-10-29 12:37:38 +00:00
|
|
|
m_pFirst = NULL;
|
|
|
|
m_pLast = NULL;
|
2017-08-30 21:14:00 +00:00
|
|
|
m_Running = true;
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool CFetcher::Init()
|
|
|
|
{
|
|
|
|
m_pStorage = Kernel()->RequestInterface<IStorage>();
|
|
|
|
if(!curl_global_init(CURL_GLOBAL_DEFAULT) && (m_pHandle = curl_easy_init()))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
CFetcher::~CFetcher()
|
|
|
|
{
|
2017-08-30 21:14:00 +00:00
|
|
|
if(m_pThHandle)
|
|
|
|
{
|
|
|
|
m_Running = false;
|
2017-08-31 10:30:42 +00:00
|
|
|
sphore_signal(&m_Queued);
|
2017-08-30 21:14:00 +00:00
|
|
|
thread_wait(m_pThHandle);
|
|
|
|
}
|
|
|
|
lock_destroy(m_Lock);
|
2017-08-31 10:30:42 +00:00
|
|
|
sphore_destroy(&m_Queued);
|
2017-08-30 21:14:00 +00:00
|
|
|
|
2014-10-29 12:37:38 +00:00
|
|
|
if(m_pHandle)
|
|
|
|
curl_easy_cleanup(m_pHandle);
|
|
|
|
curl_global_cleanup();
|
|
|
|
}
|
|
|
|
|
2015-01-19 22:00:08 +00:00
|
|
|
void CFetcher::QueueAdd(CFetchTask *pTask, const char *pUrl, const char *pDest, int StorageType, void *pUser, COMPFUNC pfnCompCb, PROGFUNC pfnProgCb)
|
2014-10-29 12:37:38 +00:00
|
|
|
{
|
2015-08-29 20:39:44 +00:00
|
|
|
str_copy(pTask->m_aUrl, pUrl, sizeof(pTask->m_aUrl));
|
|
|
|
str_copy(pTask->m_aDest, pDest, sizeof(pTask->m_aDest));
|
2014-10-29 12:37:38 +00:00
|
|
|
pTask->m_StorageType = StorageType;
|
|
|
|
pTask->m_pfnProgressCallback = pfnProgCb;
|
|
|
|
pTask->m_pfnCompCallback = pfnCompCb;
|
|
|
|
pTask->m_pUser = pUser;
|
|
|
|
pTask->m_Size = pTask->m_Progress = 0;
|
2015-01-28 12:13:56 +00:00
|
|
|
pTask->m_Abort = false;
|
2014-10-29 12:37:38 +00:00
|
|
|
|
|
|
|
lock_wait(m_Lock);
|
2015-02-27 21:06:19 +00:00
|
|
|
if(!m_pThHandle)
|
|
|
|
{
|
2015-04-07 17:07:38 +00:00
|
|
|
m_pThHandle = thread_init(&FetcherThread, this);
|
2015-02-27 21:06:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-19 22:00:08 +00:00
|
|
|
if(!m_pFirst)
|
|
|
|
{
|
2014-10-29 12:37:38 +00:00
|
|
|
m_pFirst = pTask;
|
|
|
|
m_pLast = m_pFirst;
|
|
|
|
}
|
2015-01-19 22:00:08 +00:00
|
|
|
else
|
|
|
|
{
|
2014-10-29 12:37:38 +00:00
|
|
|
m_pLast->m_pNext = pTask;
|
|
|
|
m_pLast = pTask;
|
|
|
|
}
|
|
|
|
pTask->m_State = CFetchTask::STATE_QUEUED;
|
2015-04-07 17:07:38 +00:00
|
|
|
lock_unlock(m_Lock);
|
2017-08-31 10:30:42 +00:00
|
|
|
sphore_signal(&m_Queued);
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
|
2015-02-12 17:58:54 +00:00
|
|
|
void CFetcher::Escape(char *pBuf, size_t size, const char *pStr)
|
|
|
|
{
|
|
|
|
char *pEsc = curl_easy_escape(0, pStr, 0);
|
|
|
|
str_copy(pBuf, pEsc, size);
|
|
|
|
curl_free(pEsc);
|
|
|
|
}
|
|
|
|
|
2014-10-29 12:37:38 +00:00
|
|
|
void CFetcher::FetcherThread(void *pUser)
|
|
|
|
{
|
2015-01-19 22:00:08 +00:00
|
|
|
CFetcher *pFetcher = (CFetcher *)pUser;
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "thread started...");
|
2017-08-30 21:14:00 +00:00
|
|
|
while(pFetcher->m_Running)
|
2015-01-19 22:00:08 +00:00
|
|
|
{
|
2017-08-31 10:30:42 +00:00
|
|
|
sphore_wait(&pFetcher->m_Queued);
|
2014-10-29 12:37:38 +00:00
|
|
|
lock_wait(pFetcher->m_Lock);
|
2015-01-19 22:00:08 +00:00
|
|
|
CFetchTask *pTask = pFetcher->m_pFirst;
|
|
|
|
if(pTask)
|
|
|
|
pFetcher->m_pFirst = pTask->m_pNext;
|
2015-04-07 17:07:38 +00:00
|
|
|
lock_unlock(pFetcher->m_Lock);
|
2015-01-19 22:00:08 +00:00
|
|
|
if(pTask)
|
|
|
|
{
|
2017-07-25 17:23:10 +00:00
|
|
|
dbg_msg("fetcher", "task got %s -> %s", pTask->m_aUrl, pTask->m_aDest);
|
2015-07-09 00:08:14 +00:00
|
|
|
pFetcher->FetchFile(pTask);
|
2015-03-28 22:46:43 +00:00
|
|
|
if(pTask->m_pfnCompCallback)
|
|
|
|
pTask->m_pfnCompCallback(pTask, pTask->m_pUser);
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-13 19:17:23 +00:00
|
|
|
void CFetcher::FetchFile(CFetchTask *pTask)
|
2014-10-29 12:37:38 +00:00
|
|
|
{
|
2015-03-14 19:01:18 +00:00
|
|
|
char aPath[512];
|
|
|
|
if(pTask->m_StorageType == -2)
|
2015-08-29 20:39:44 +00:00
|
|
|
m_pStorage->GetBinaryPath(pTask->m_aDest, aPath, sizeof(aPath));
|
2015-03-14 19:01:18 +00:00
|
|
|
else
|
2015-08-29 20:39:44 +00:00
|
|
|
m_pStorage->GetCompletePath(pTask->m_StorageType, pTask->m_aDest, aPath, sizeof(aPath));
|
2015-08-29 20:40:10 +00:00
|
|
|
|
2016-05-01 12:20:55 +00:00
|
|
|
if(fs_makedir_rec_for(aPath) < 0)
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "i/o error, cannot create folder for: %s", aPath);
|
2015-08-29 20:40:10 +00:00
|
|
|
|
2015-02-27 21:06:19 +00:00
|
|
|
IOHANDLE File = io_open(aPath, IOFLAG_WRITE);
|
|
|
|
|
2017-03-04 14:43:49 +00:00
|
|
|
if(!File)
|
|
|
|
{
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "i/o error, cannot open file: %s", pTask->m_aDest);
|
2015-03-28 22:41:58 +00:00
|
|
|
pTask->m_State = CFetchTask::STATE_ERROR;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-29 12:37:38 +00:00
|
|
|
char aErr[CURL_ERROR_SIZE];
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_ERRORBUFFER, aErr);
|
|
|
|
|
2015-02-05 18:41:48 +00:00
|
|
|
//curl_easy_setopt(m_pHandle, CURLOPT_VERBOSE, 1L);
|
2015-05-09 23:53:26 +00:00
|
|
|
if(pTask->m_CanTimeout)
|
|
|
|
{
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_CONNECTTIMEOUT_MS, (long)g_Config.m_ClHTTPConnectTimeoutMs);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_LOW_SPEED_LIMIT, (long)g_Config.m_ClHTTPLowSpeedLimit);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_LOW_SPEED_TIME, (long)g_Config.m_ClHTTPLowSpeedTime);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_CONNECTTIMEOUT_MS, 0);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_LOW_SPEED_LIMIT, 0);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_LOW_SPEED_TIME, 0);
|
|
|
|
}
|
2015-01-19 23:01:30 +00:00
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_FOLLOWLOCATION, 1L);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_MAXREDIRS, 4L);
|
2014-10-29 12:37:38 +00:00
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_FAILONERROR, 1L);
|
2017-07-16 08:45:41 +00:00
|
|
|
if(pTask->m_UseDDNetCA)
|
|
|
|
{
|
|
|
|
char aCAFile[512];
|
|
|
|
m_pStorage->GetBinaryPath("data/ca-ddnet.pem", aCAFile, sizeof aCAFile);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_CAINFO, aCAFile);
|
|
|
|
}
|
2015-08-29 20:39:44 +00:00
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_URL, pTask->m_aUrl);
|
2014-10-29 12:37:38 +00:00
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_WRITEDATA, File);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_WRITEFUNCTION, &CFetcher::WriteToFile);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_NOPROGRESS, 0);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_PROGRESSDATA, pTask);
|
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_PROGRESSFUNCTION, &CFetcher::ProgressCallback);
|
2016-09-28 05:18:51 +00:00
|
|
|
curl_easy_setopt(m_pHandle, CURLOPT_NOSIGNAL, 1L);
|
2017-02-21 16:10:08 +00:00
|
|
|
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "downloading %s", pTask->m_aDest);
|
2014-10-29 12:37:38 +00:00
|
|
|
pTask->m_State = CFetchTask::STATE_RUNNING;
|
2015-01-28 12:13:56 +00:00
|
|
|
int ret = curl_easy_perform(m_pHandle);
|
2015-07-09 00:08:14 +00:00
|
|
|
io_close(File);
|
2015-01-28 12:13:56 +00:00
|
|
|
if(ret != CURLE_OK)
|
2015-01-19 22:00:08 +00:00
|
|
|
{
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "task failed. libcurl error: %s", aErr);
|
2015-01-28 12:13:56 +00:00
|
|
|
pTask->m_State = (ret == CURLE_ABORTED_BY_CALLBACK) ? CFetchTask::STATE_ABORTED : CFetchTask::STATE_ERROR;
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
2015-03-13 19:17:23 +00:00
|
|
|
else
|
|
|
|
{
|
2016-05-02 19:35:32 +00:00
|
|
|
dbg_msg("fetcher", "task done %s", pTask->m_aDest);
|
2015-03-13 19:17:23 +00:00
|
|
|
pTask->m_State = CFetchTask::STATE_DONE;
|
|
|
|
}
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
|
2017-08-30 19:01:19 +00:00
|
|
|
size_t CFetcher::WriteToFile(char *pData, size_t size, size_t nmemb, void *pFile)
|
2014-10-29 12:37:38 +00:00
|
|
|
{
|
2017-08-30 19:01:19 +00:00
|
|
|
return io_write((IOHANDLE)pFile, pData, size*nmemb);
|
2014-10-29 12:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int CFetcher::ProgressCallback(void *pUser, double DlTotal, double DlCurr, double UlTotal, double UlCurr)
|
|
|
|
{
|
|
|
|
CFetchTask *pTask = (CFetchTask *)pUser;
|
|
|
|
pTask->m_Current = DlCurr;
|
2015-01-28 11:57:11 +00:00
|
|
|
pTask->m_Size = DlTotal;
|
2015-01-19 22:00:08 +00:00
|
|
|
pTask->m_Progress = (100 * DlCurr) / (DlTotal ? DlTotal : 1);
|
2014-10-29 12:37:38 +00:00
|
|
|
if(pTask->m_pfnProgressCallback)
|
|
|
|
pTask->m_pfnProgressCallback(pTask, pTask->m_pUser);
|
2015-01-28 12:13:56 +00:00
|
|
|
return pTask->m_Abort ? -1 : 0;
|
2015-01-19 21:19:27 +00:00
|
|
|
}
|