ddnet/src/engine/client/updater.cpp

379 lines
9.1 KiB
C++
Raw Normal View History

#include "updater.h"
#include <base/lock_scope.h>
2014-12-31 14:29:34 +00:00
#include <base/system.h>
#include <engine/client.h>
#include <engine/engine.h>
2014-12-31 14:29:34 +00:00
#include <engine/external/json-parser/json.h>
2022-05-29 13:51:38 +00:00
#include <engine/shared/http.h>
#include <engine/shared/json.h>
#include <engine/storage.h>
2014-12-31 14:29:34 +00:00
2022-02-14 23:22:52 +00:00
#include <cstdlib> // system
2015-03-13 14:13:19 +00:00
using std::map;
using std::string;
2014-12-31 14:29:34 +00:00
class CUpdaterFetchTask : public CHttpRequest
{
char m_aBuf[256];
char m_aBuf2[256];
CUpdater *m_pUpdater;
void OnProgress() override;
protected:
int OnCompletion(int State) override;
public:
CUpdaterFetchTask(CUpdater *pUpdater, const char *pFile, const char *pDestPath);
};
static const char *GetUpdaterUrl(char *pBuf, int BufSize, const char *pFile)
{
str_format(pBuf, BufSize, "https://update6.ddnet.tw/%s", pFile);
return pBuf;
}
static const char *GetUpdaterDestPath(char *pBuf, int BufSize, const char *pFile, const char *pDestPath)
{
if(!pDestPath)
{
pDestPath = pFile;
}
str_format(pBuf, BufSize, "update/%s", pDestPath);
return pBuf;
}
CUpdaterFetchTask::CUpdaterFetchTask(CUpdater *pUpdater, const char *pFile, const char *pDestPath) :
CHttpRequest(GetUpdaterUrl(m_aBuf, sizeof(m_aBuf), pFile)),
m_pUpdater(pUpdater)
{
WriteToFile(pUpdater->m_pStorage, GetUpdaterDestPath(m_aBuf2, sizeof(m_aBuf2), pFile, pDestPath), -2);
}
void CUpdaterFetchTask::OnProgress()
{
CLockScope ls(m_pUpdater->m_Lock);
str_copy(m_pUpdater->m_aStatus, Dest(), sizeof(m_pUpdater->m_aStatus));
m_pUpdater->m_Percent = Progress();
}
int CUpdaterFetchTask::OnCompletion(int State)
{
State = CHttpRequest::OnCompletion(State);
const char *b = 0;
for(const char *a = Dest(); *a; a++)
if(*a == '/')
b = a + 1;
b = b ? b : Dest();
if(!str_comp(b, "update.json"))
{
if(State == HTTP_DONE)
m_pUpdater->SetCurrentState(IUpdater::GOT_MANIFEST);
else if(State == HTTP_ERROR)
m_pUpdater->SetCurrentState(IUpdater::FAIL);
}
else if(!str_comp(b, m_pUpdater->m_aLastFile))
{
if(State == HTTP_DONE)
m_pUpdater->SetCurrentState(IUpdater::MOVE_FILES);
else if(State == HTTP_ERROR)
m_pUpdater->SetCurrentState(IUpdater::FAIL);
}
return State;
}
CUpdater::CUpdater()
2014-12-31 14:29:34 +00:00
{
2015-03-13 14:13:19 +00:00
m_pClient = NULL;
m_pStorage = NULL;
m_pEngine = NULL;
2015-03-13 14:13:19 +00:00
m_State = CLEAN;
m_Percent = 0;
m_Lock = lock_create();
IStorage::FormatTmpPath(m_aClientExecTmp, sizeof(m_aClientExecTmp), CLIENT_EXEC);
IStorage::FormatTmpPath(m_aServerExecTmp, sizeof(m_aServerExecTmp), SERVER_EXEC);
2014-12-31 14:29:34 +00:00
}
void CUpdater::Init()
2014-12-31 14:29:34 +00:00
{
2015-03-13 14:13:19 +00:00
m_pClient = Kernel()->RequestInterface<IClient>();
m_pStorage = Kernel()->RequestInterface<IStorage>();
m_pEngine = Kernel()->RequestInterface<IEngine>();
2014-12-31 14:29:34 +00:00
}
CUpdater::~CUpdater()
2014-12-31 14:29:34 +00:00
{
lock_destroy(m_Lock);
2014-12-31 14:29:34 +00:00
}
void CUpdater::SetCurrentState(int NewState)
2014-12-31 14:29:34 +00:00
{
CLockScope ls(m_Lock);
m_State = NewState;
}
int CUpdater::GetCurrentState()
{
CLockScope ls(m_Lock);
return m_State;
}
void CUpdater::GetCurrentFile(char *pBuf, int BufSize)
{
CLockScope ls(m_Lock);
str_copy(pBuf, m_aStatus, BufSize);
}
int CUpdater::GetCurrentPercent()
{
CLockScope ls(m_Lock);
return m_Percent;
2014-12-31 14:29:34 +00:00
}
void CUpdater::FetchFile(const char *pFile, const char *pDestPath)
2014-12-31 14:29:34 +00:00
{
m_pEngine->AddJob(std::make_shared<CUpdaterFetchTask>(this, pFile, pDestPath));
}
2017-02-21 16:10:08 +00:00
bool CUpdater::MoveFile(const char *pFile)
{
char aBuf[256];
size_t len = str_length(pFile);
bool Success = true;
#if !defined(CONF_FAMILY_WINDOWS)
if(!str_comp_nocase(pFile + len - 4, ".dll"))
return Success;
#endif
#if !defined(CONF_PLATFORM_LINUX)
2021-06-14 05:47:54 +00:00
if(!str_comp_nocase(pFile + len - 3, ".so"))
return Success;
#endif
if(!str_comp_nocase(pFile + len - 4, ".dll") || !str_comp_nocase(pFile + len - 4, ".ttf") || !str_comp_nocase(pFile + len - 3, ".so"))
{
str_format(aBuf, sizeof(aBuf), "%s.old", pFile);
m_pStorage->RenameBinaryFile(pFile, aBuf);
str_format(aBuf, sizeof(aBuf), "update/%s", pFile);
Success &= m_pStorage->RenameBinaryFile(aBuf, pFile);
}
else
{
str_format(aBuf, sizeof(aBuf), "update/%s", pFile);
Success &= m_pStorage->RenameBinaryFile(aBuf, pFile);
}
return Success;
2014-12-31 14:29:34 +00:00
}
void CUpdater::Update()
2014-12-31 14:29:34 +00:00
{
2015-03-13 14:13:19 +00:00
switch(m_State)
{
case IUpdater::GOT_MANIFEST:
PerformUpdate();
break;
case IUpdater::MOVE_FILES:
CommitUpdate();
break;
default:
return;
2015-03-13 14:13:19 +00:00
}
2014-12-31 14:29:34 +00:00
}
void CUpdater::AddFileJob(const char *pFile, bool Job)
2014-12-31 14:29:34 +00:00
{
m_FileJobs[string(pFile)] = Job;
2014-12-31 14:29:34 +00:00
}
bool CUpdater::ReplaceClient()
2014-12-31 14:29:34 +00:00
{
dbg_msg("updater", "replacing " PLAT_CLIENT_EXEC);
bool Success = true;
char aPath[IO_MAX_PATH_LENGTH];
2015-03-13 14:13:19 +00:00
// Replace running executable by renaming twice...
2021-08-23 10:05:01 +00:00
m_pStorage->RemoveBinaryFile(CLIENT_EXEC ".old");
Success &= m_pStorage->RenameBinaryFile(PLAT_CLIENT_EXEC, CLIENT_EXEC ".old");
str_format(aPath, sizeof(aPath), "update/%s", m_aClientExecTmp);
Success &= m_pStorage->RenameBinaryFile(aPath, PLAT_CLIENT_EXEC);
#if !defined(CONF_FAMILY_WINDOWS)
m_pStorage->GetBinaryPath(PLAT_CLIENT_EXEC, aPath, sizeof aPath);
char aBuf[512];
str_format(aBuf, sizeof aBuf, "chmod +x %s", aPath);
if(system(aBuf))
{
dbg_msg("updater", "ERROR: failed to set client executable bit");
Success = false;
}
#endif
return Success;
2015-03-13 14:13:19 +00:00
}
bool CUpdater::ReplaceServer()
2015-03-13 14:13:19 +00:00
{
dbg_msg("updater", "replacing " PLAT_SERVER_EXEC);
bool Success = true;
char aPath[IO_MAX_PATH_LENGTH];
2015-03-13 14:13:19 +00:00
//Replace running executable by renaming twice...
m_pStorage->RemoveBinaryFile(SERVER_EXEC ".old");
Success &= m_pStorage->RenameBinaryFile(PLAT_SERVER_EXEC, SERVER_EXEC ".old");
str_format(aPath, sizeof(aPath), "update/%s", m_aServerExecTmp);
Success &= m_pStorage->RenameBinaryFile(aPath, PLAT_SERVER_EXEC);
#if !defined(CONF_FAMILY_WINDOWS)
m_pStorage->GetBinaryPath(PLAT_SERVER_EXEC, aPath, sizeof aPath);
char aBuf[512];
str_format(aBuf, sizeof aBuf, "chmod +x %s", aPath);
if(system(aBuf))
{
dbg_msg("updater", "ERROR: failed to set server executable bit");
Success = false;
}
#endif
return Success;
2014-12-31 14:29:34 +00:00
}
void CUpdater::ParseUpdate()
2014-12-31 14:29:34 +00:00
{
char aPath[IO_MAX_PATH_LENGTH];
void *pBuf;
unsigned Length;
if(!m_pStorage->ReadFile(m_pStorage->GetBinaryPath("update/update.json", aPath, sizeof aPath), IStorage::TYPE_ABSOLUTE, &pBuf, &Length))
return;
json_value *pVersions = json_parse((json_char *)pBuf, Length);
free(pBuf);
2015-03-13 14:13:19 +00:00
if(pVersions && pVersions->type == json_array)
{
for(int i = 0; i < json_array_length(pVersions); i++)
2015-03-13 14:13:19 +00:00
{
const json_value *pTemp;
const json_value *pCurrent = json_array_get(pVersions, i);
if(str_comp(json_string_get(json_object_get(pCurrent, "version")), GAME_RELEASE_VERSION))
2015-03-13 14:13:19 +00:00
{
if(json_boolean_get(json_object_get(pCurrent, "client")))
m_ClientUpdate = true;
if(json_boolean_get(json_object_get(pCurrent, "server")))
m_ServerUpdate = true;
if((pTemp = json_object_get(pCurrent, "download"))->type == json_array)
{
for(int j = 0; j < json_array_length(pTemp); j++)
AddFileJob(json_string_get(json_array_get(pTemp, j)), true);
}
if((pTemp = json_object_get(pCurrent, "remove"))->type == json_array)
2015-03-13 14:13:19 +00:00
{
for(int j = 0; j < json_array_length(pTemp); j++)
AddFileJob(json_string_get(json_array_get(pTemp, j)), false);
2015-03-13 14:13:19 +00:00
}
}
else
break;
2015-03-13 14:13:19 +00:00
}
}
2014-12-31 14:29:34 +00:00
}
void CUpdater::InitiateUpdate()
2014-12-31 14:29:34 +00:00
{
2015-03-13 14:13:19 +00:00
m_State = GETTING_MANIFEST;
FetchFile("update.json");
2014-12-31 14:29:34 +00:00
}
void CUpdater::PerformUpdate()
2014-12-31 14:29:34 +00:00
{
2015-03-13 14:13:19 +00:00
m_State = PARSING_UPDATE;
dbg_msg("updater", "parsing update.json");
2015-03-13 14:13:19 +00:00
ParseUpdate();
m_State = DOWNLOADING;
const char *pLastFile;
pLastFile = "";
2017-03-04 14:43:49 +00:00
for(map<string, bool>::reverse_iterator it = m_FileJobs.rbegin(); it != m_FileJobs.rend(); ++it)
{
if(it->second)
{
pLastFile = it->first.c_str();
break;
}
2015-03-13 14:13:19 +00:00
}
2020-10-26 14:14:07 +00:00
for(auto &FileJob : m_FileJobs)
2015-03-13 14:13:19 +00:00
{
2020-10-26 14:14:07 +00:00
if(FileJob.second)
{
2020-10-26 14:14:07 +00:00
const char *pFile = FileJob.first.c_str();
size_t len = str_length(pFile);
if(!str_comp_nocase(pFile + len - 4, ".dll"))
{
#if defined(CONF_FAMILY_WINDOWS)
char aBuf[512];
str_copy(aBuf, pFile, sizeof(aBuf)); // SDL
str_copy(aBuf + len - 4, "-" PLAT_NAME, sizeof(aBuf) - len + 4); // -win32
str_append(aBuf, pFile + len - 4, sizeof(aBuf)); // .dll
FetchFile(aBuf, pFile);
#endif
// Ignore DLL downloads on other platforms
}
else if(!str_comp_nocase(pFile + len - 3, ".so"))
{
#if defined(CONF_PLATFORM_LINUX)
char aBuf[512];
str_copy(aBuf, pFile, sizeof(aBuf)); // libsteam_api
str_copy(aBuf + len - 3, "-" PLAT_NAME, sizeof(aBuf) - len + 3); // -linux-x86_64
str_append(aBuf, pFile + len - 3, sizeof(aBuf)); // .so
FetchFile(aBuf, pFile);
#endif
// Ignore DLL downloads on other platforms, on Linux we statically link anyway
}
else
{
FetchFile(pFile);
}
pLastFile = pFile;
}
else
2020-10-26 14:14:07 +00:00
m_pStorage->RemoveBinaryFile(FileJob.first.c_str());
2015-03-13 14:13:19 +00:00
}
2015-03-13 14:13:19 +00:00
if(m_ServerUpdate)
{
FetchFile(PLAT_SERVER_DOWN, m_aServerExecTmp);
pLastFile = m_aServerExecTmp;
}
2015-03-13 14:13:19 +00:00
if(m_ClientUpdate)
{
FetchFile(PLAT_CLIENT_DOWN, m_aClientExecTmp);
pLastFile = m_aClientExecTmp;
}
str_copy(m_aLastFile, pLastFile, sizeof(m_aLastFile));
}
void CUpdater::CommitUpdate()
{
bool Success = true;
2020-10-26 14:14:07 +00:00
for(auto &FileJob : m_FileJobs)
if(FileJob.second)
Success &= MoveFile(FileJob.first.c_str());
if(m_ClientUpdate)
Success &= ReplaceClient();
if(m_ServerUpdate)
Success &= ReplaceServer();
if(!Success)
m_State = FAIL;
else if(m_pClient->State() == IClient::STATE_ONLINE || m_pClient->EditorHasUnsavedData())
m_State = NEED_RESTART;
else
{
2021-08-23 10:05:01 +00:00
m_pClient->Restart();
}
2015-03-13 14:13:19 +00:00
}