void UUpdateManager::HotfixAvailabilityCheckComplete(EHotfixResult Result)
{
UE_LOG(LogHotfixManager, Display, TEXT("HotfixAvailabilityCheckComplete %d"), (int32)Result);
auto CompletionDelegate = [this, Result]()
{
UE_LOG(LogHotfixManager, Display, TEXT("External HotfixAvailabilityCheckComplete %d"), (int32)Result);
switch (Result)
{
case EHotfixResult::Success:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess);
break;
case EHotfixResult::SuccessNoChange:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange);
break;
case EHotfixResult::Failed:
CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck);
break;
default:
ensure(0 && "No other result codes should reach here!");
CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck);
break;
}
};
// Debug delay delegate firing
DelayResponse(CompletionDelegate, HotfixAvailabilityCheckCompleteDelay);
}
void UUpdateManager::PlatformEnvironmentCheck_OnLoginConsoleComplete(int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& Error)
{
if (bWasSuccessful)
{
bPlatformEnvironmentDetected = true;
StartHotfixCheck();
}
else
{
UE_LOG(LogHotfixManager, Warning, TEXT("Failed to detect online environment for the platform"));
CheckComplete(EUpdateCompletionStatus::UpdateFailure_NotLoggedIn);
}
}
void UUpdateManager::PatchCheckComplete(EPatchCheckResult PatchResult)
{
LastPatchCheckResult = PatchResult;
if (PatchResult == EPatchCheckResult::NoPatchRequired)
{
StartPlatformEnvironmentCheck();
}
else if (PatchResult == EPatchCheckResult::NoLoggedInUser)
{
CheckComplete(EUpdateCompletionStatus::UpdateFailure_NotLoggedIn);
}
else
{
ensure(PatchResult == EPatchCheckResult::PatchCheckFailure ||
PatchResult == EPatchCheckResult::PatchRequired);
// Skip hotfix check in error states, but still preload data as if there was nothing wrong
StartInitialPreload();
}
}
ssize_t decode(struct tcp_client *client, const char *buf, size_t len) {
ssize_t n;
size_t decode_size = 0;
do {
n = CheckComplete(buf + decode_size, len - decode_size);
if (n < 0) {
assert(0);
return n;
}
if (n == 0) {
// printf("len %zd but node complete\n", len - decode_size);
return decode_size;
}
proc(client, buf + decode_size, n);
decode_size += n;
} while (1);
return decode_size;
}
bool RdfStorePrivate::Add(RdfTriple triple)
{
librdf_statement* statement = RdfTripleToStatement(triple);
if (!CheckComplete(statement))
{
librdf_free_statement(statement);
return false;
}
// Store already contains statement
if (Contains(triple)) return true;
if (librdf_model_add_statement(m_Model, statement) != 0) {
librdf_free_statement(statement);
return false;
}
else
{
librdf_free_statement(statement);
return true;
}
}
bool RdfStorePrivate::Remove(RdfTriple triple)
{
librdf_statement* statement = RdfTripleToStatement(triple);
if (!CheckComplete(statement))
{
librdf_free_statement(statement);
return false;
}
// Store does not contain statement
if (!Contains(triple)) return true;
if (librdf_model_remove_statement(m_Model, statement) != 0) {
librdf_free_statement(statement);
return false;
}
else
{
librdf_free_statement(statement);
return true;
}
return false;
}
void UUpdateManager::InitialPreloadComplete()
{
SetUpdateState(EUpdateState::InitialLoadComplete);
if (LastPatchCheckResult == EPatchCheckResult::PatchCheckFailure)
{
CheckComplete(EUpdateCompletionStatus::UpdateFailure_PatchCheck);
}
else if (LastPatchCheckResult == EPatchCheckResult::PatchRequired)
{
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsPatch);
}
else
{
ensure(LastPatchCheckResult == EPatchCheckResult::NoPatchRequired);
// Patch check success, check hotfix status
switch (LastHotfixResult)
{
case EHotfixResult::Success:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess);
break;
case EHotfixResult::SuccessNoChange:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange);
break;
case EHotfixResult::Failed:
CheckComplete(EUpdateCompletionStatus::UpdateFailure_HotfixCheck);
break;
case EHotfixResult::SuccessNeedsRelaunch:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsRelaunch);
break;
case EHotfixResult::SuccessNeedsReload:
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NeedsReload);
break;
}
}
}
TPicResult
TPXPictureValidator::Scan(LPTSTR input, uint termCh, uint& i, uint& j)
{
tchar ch;
TPicResult rslt = prEmpty;
uint len = ::_tcslen(input);
while (i != termCh && Pic[i] != _T(',')) {
if (j >= len)
return CheckComplete(termCh, i, rslt);
ch = input[j];
switch (Pic[i]) {
case _T('#'):
if (!_istdigit((tchar)ch))
return prError;
else {
input[j++] = ch;
i++;
}
break;
case _T('?'):
if (!_istalpha((tchar)ch))
return prError;
else {
input[j++] = ch;
i++;
}
break;
case _T('&'):
if (!_istalpha((tchar)ch))
return prError;
else {
input[j++] = (tchar)_totupper(ch);
i++;
}
break;
case _T('!'): {
#if defined(BI_DBCS_SUPPORT)
uint n = CharSize(&input[j]) / sizeof(tchar);
if (j + n >= len)
j = len;
else{
if (n == 1)
input[j++] = (tchar)_totupper((tchar)ch);
else
j += n;
}
#else
input[j++] = (tchar)_totupper(ch);
#endif
i++;
break;
}
case _T('@'): {
#if defined(BI_DBCS_SUPPORT)
uint n = CharSize(&input[j]) / sizeof(tchar);
if (j + n >= len)
j = len;
else
j += n;
#else
input[j++] = ch;
#endif
i++;
break;
}
case _T('*'):
rslt = Iteration(input, termCh, i, j);
if (!IsComplete(rslt))
return rslt;
if (rslt == prError)
rslt = prAmbiguous;
break;
case _T('{'):
rslt = Group(input, termCh, i, j);
if (!IsComplete(rslt))
return rslt;
break;
case _T('['):
rslt = Group(input, termCh, i, j);
if (IsIncomplete(rslt))
return rslt;
if (rslt == prError)
rslt = prAmbiguous;
break;
default: {
#if defined(BI_DBCS_SUPPORT)
#if defined(BI_PDOXWINJ_SUPPORT)
// Paradox for Windows/J database program has two special picture to
// support Japanese characters in CodePage 932
//
// '��' 0x81+0x93 - (2 byte '%' symbol)
// 1 byte KATAKANA and KATAKANA symbols (0xA1 - 0xDF)
// '��' 0x81+0x97 - (2 byte '@' symbol)
// any 2 byte characters except 2 byte space (0x81+0x40)
//
// This is hard coded, because we don't know how to get current
// code page in Windows 3.1
//
uint n = CharSize(&input[j]) / sizeof(tchar);
uint n2 = CharSize(((const char *))Pic.c_str() + i) / sizeof(tchar);
if (n2 == 2) {
utchar uc1, uc2;
uc1 = (utchar)Pic[i];
uc2 = (utchar)Pic[i+1];
if (uc1 == 0x81 && uc2 == 0x93) {
if ((utchar)ch >= 0xA1 && (utchar)ch <= 0xDF){
i += n2;
j += n;
break;
}
else
return prError;
}
else if (uc1 == 0x81 && uc2 == 0x97){
if (n == 2 && j + n < len &&
((utchar)ch != 0x81 || (utchar)input[j+1] != 0x40)) {
i += n2;
j += n;
break;
} else
return prError;
}
}
if (n2 == 1 && Pic[i] == ';'){
i++;
n2 = CharSize((const char *)Pic.c_str() + i) / sizeof(tchar);
}
#else
if (Pic[i] == _T(';'))
i++;
uint n = CharSize(&input[j]) / sizeof(tchar);
uint n2 = CharSize((LPCTSTR)Pic.c_str() + i) / sizeof(tchar);
#endif
if (j + n >= len)
n = len - j;
if (n == 1) {
if (ch == _T(' ')) {
#if defined(BI_AUTO_COMPLETION_DBCS_BY_SPACE)
// But, couldn't expand input buffer TValidator classes.
//
if (n < n2) {
memmove(input+n2, input+n, len-n+1);
len += n2 - n;
n = n2;
}
while (n-- > 0)
input[j++] = Pic[i++];
#else
if (n != n2)
return prError;
input[j++] = Pic[i++];
#endif
}
else {
if (n != n2)
return prError;
if (_totupper((tchar)Pic[i]) != _totupper((tchar)ch))
return prError;
input[j++] = Pic[i++];
}
}
else {
if (n > n2)
return prError;
for (uint i1 = 0; i1 < n; i1++)
if (input[j+i1] != Pic[i+i1])
return prError;
while (n-- > 0)
input[j++] = Pic[i++];
}
#else
if (Pic[i] == _T(';'))
i++;
if (_totupper(Pic[i]) != _totupper(ch))
if (ch == _T(' '))
ch = Pic[i];
else
return prError;
input[j++] = Pic[i];
i++;
#endif
}
}
if (rslt == prAmbiguous)
rslt = prIncompNoFill;
else
rslt = prIncomplete;
}
return (rslt == prIncompNoFill) ? prAmbiguous : prComplete;
}
UUpdateManager::EUpdateStartResult UUpdateManager::StartCheckInternal(bool bInCheckHotfixOnly)
{
EUpdateStartResult Result = EUpdateStartResult::None;
if (!ChecksEnabled())
{
UE_LOG(LogHotfixManager, Display, TEXT("Update checks disabled!"));
bInitialUpdateFinished = true;
auto StartDelegate = [this]()
{
CheckComplete(EUpdateCompletionStatus::UpdateSuccess_NoChange);
};
DelayResponse(StartDelegate, 0.1f);
return Result;
}
if (CurrentUpdateState == EUpdateState::UpdateIdle ||
CurrentUpdateState == EUpdateState::UpdatePending ||
CurrentUpdateState == EUpdateState::UpdateComplete)
{
bCheckHotfixAvailabilityOnly = bInCheckHotfixOnly;
// Immediately move into a pending state so the UI state trigger fires
SetUpdateState(EUpdateState::UpdatePending);
const EUpdateCompletionStatus LastResult = LastCompletionResult[bCheckHotfixAvailabilityOnly];
const FTimespan DeltaTime = FDateTime::UtcNow() - LastUpdateCheck[bCheckHotfixAvailabilityOnly];
const bool bForceCheck = LastResult == EUpdateCompletionStatus::UpdateUnknown ||
LastResult == EUpdateCompletionStatus::UpdateFailure_PatchCheck ||
LastResult == EUpdateCompletionStatus::UpdateFailure_HotfixCheck ||
LastResult == EUpdateCompletionStatus::UpdateFailure_NotLoggedIn;
static double CacheTimer = UPDATE_CHECK_SECONDS;
const double TimeSinceCheck = DeltaTime.GetTotalSeconds();
if (bForceCheck || TimeSinceCheck >= CacheTimer)
{
auto StartDelegate = [this]()
{
// Check for a patch first, then hotfix application
StartPatchCheck();
};
// Give the UI state widget a chance to start listening for delegates
DelayResponse(StartDelegate, 0.2f);
Result = EUpdateStartResult::UpdateStarted;
}
else
{
UE_LOG(LogHotfixManager, Display, TEXT("Returning cached update result %d"), (int32)LastResult);
auto StartDelegate = [this, LastResult]()
{
CheckComplete(LastResult, false);
};
DelayResponse(StartDelegate, 0.1f);
Result = EUpdateStartResult::UpdateCached;
}
}
else
{
UE_LOG(LogHotfixManager, Display, TEXT("Update already in progress"));
}
return Result;
}
