/*

* This file is part of the CitizenFX project - http://citizen.re/

*

* See LICENSE and MENTIONS in the root of the source tree for information

* regarding licensing.

*/

#include "StdInc.h"

#include <Error.h>

#if defined(COMPILING_LAUNCH) && !defined(LAUNCHER_PERSONALITY_MAIN) && !defined(COMPILING_DIAG)

#define NON_CRT_LAUNCHER

#endif

#if !defined(COMPILING_LAUNCH) && !defined(COMPILING_CONSOLE) && !defined(IS_FXSERVER)

#include <ICoreGameInit.h>

#endif

#include <fnv.h>

#if !defined(IS_FXSERVER)

#define RAPIDJSON_ASSERT(x) (void)0

#include <rapidjson/document.h>

#include <rapidjson/writer.h>

template<typename T>

static std::string FormatErrorPickup(std::string_view buffer, const T& thisError)

{

rapidjson::Document document;

document.SetObject();

document.AddMember("message", rapidjson::Value(buffer.data(), rapidjson::SizeType(buffer.length())), document.GetAllocator());

document.AddMember("file", rapidjson::Value(std::get<0>(thisError).data(), rapidjson::SizeType(std::get<0>(thisError).length())), document.GetAllocator());

document.AddMember("line", rapidjson::Value(std::get<1>(thisError)), document.GetAllocator());

document.AddMember("sigHash", rapidjson::Value(std::get<2>(thisError)), document.GetAllocator());

rapidjson::StringBuffer sbuffer;

rapidjson::Writer<rapidjson::StringBuffer> writer(sbuffer);

document.Accept(writer);

return std::string{ sbuffer.GetString(), sbuffer.GetSize() };

}

#endif

#include <CrossBuildRuntime.h>

#define ERR_NORMAL 0 // will continue game execution, but not here

#define ERR_FATAL 1

#define BUFFER_LENGTH 32768

#ifdef _WIN32

#include <wtsapi32.h>

#else

#include <signal.h>

#endif

#if defined(ERROR_CRASH_MAGIC) && defined(_WIN32)

bool IsErrorException(PEXCEPTION_POINTERS ep)

{

return (ep->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && ep->ExceptionRecord->ExceptionInformation[1] == ERROR_CRASH_MAGIC);

}

#endif

static thread_local std::tuple<std::string_view, int, uint32_t> g_thisError;

static bool IsUserConnected()

{

#ifdef _WIN32

auto wtsapi = LoadLibraryW(L"wtsapi32.dll");

if (wtsapi)

{

auto _WTSQuerySessionInformationW = (decltype(&WTSQuerySessionInformationW))GetProcAddress(wtsapi, "WTSQuerySessionInformationW");

auto _WTSFreeMemory = (decltype(&WTSFreeMemory))GetProcAddress(wtsapi, "WTSFreeMemory");

if (_WTSQuerySessionInformationW)

{

LPWSTR data;

DWORD dataSize;

if (_WTSQuerySessionInformationW(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSConnectState, &data, &dataSize))

{

auto connectState = *(WTS_CONNECTSTATE_CLASS*)data;

bool rv = (connectState == WTSActive);

_WTSFreeMemory(data);

return rv;

}

}

}

#endif

return true;

}

#if defined(COMPILING_LAUNCH) && !defined(COMPILING_DIAG)

extern bool MinidumpInitialized();

#endif

static int SysError(const char* buffer)

{

#ifdef WIN32

HWND wnd = CoreGetGameWindow();

#if !defined(COMPILING_LAUNCH) && !defined(COMPILING_CONSOLE)

if (CoreIsDebuggerPresent())

#else

if (IsDebuggerPresent())

#endif

{

__debugbreak();

}

#if !defined(COMPILING_CONSOLE) && !defined(IS_FXSERVER)

auto errorPickup = FormatErrorPickup(buffer, g_thisError);

FILE* f = _wfopen(MakeRelativeCitPath(L"data\\cache\\error-pickup").c_str(), L"wb");

if (f)

{

fprintf(f, "%s", errorPickup.c_str());

fclose(f);

#if defined(COMPILING_LAUNCH) && !defined(COMPILING_DIAG)

if (MinidumpInitialized())

#endif

{

return -1;

}

}

#endif

#if defined(IS_FXSERVER)

fprintf(stderr, "Fatal Error: %s", buffer);

#endif

if (IsUserConnected())

{

MessageBoxW(wnd, ToWide(buffer).c_str(), L"Fatal Error", MB_OK | MB_ICONSTOP);

}

#ifdef _DEBUG

#ifndef IS_FXSERVER

assert(!"breakpoint time");

#endif

#endif

TerminateProcess(GetCurrentProcess(), 1);

#else

fprintf(stderr, "%s", buffer);

raise(SIGTERM);

#endif

return 0;

}

struct ErrorDataPerProcess

{

bool inFatalError = false;

std::string lastFatalError;

};

struct ErrorData

{

ErrorDataPerProcess* perProcess;

bool inRecursiveError = false;

std::string lastRecursiveError;

bool inError = false;

std::string lastError;

};

#if defined(COMPILING_CORE) || defined(COMPILING_LAUNCH)

extern "C" DLL_EXPORT ErrorData* GetErrorData()

{

static thread_local ErrorData errorData;

if (!errorData.perProcess)

{

static ErrorDataPerProcess edpp;

errorData.perProcess = &edpp;

}

return &errorData;

}

#elif defined(_WIN32)

inline ErrorData* GetErrorData()

{

using TCoreFunc = decltype(&GetErrorData);

static TCoreFunc func;

if (!func)

{

auto hCore = GetModuleHandleW(L"CoreRT.dll");

if (hCore)

{

func = (TCoreFunc)GetProcAddress(hCore, "GetErrorData");

}

}

return (func) ? func() : 0;

}

#else

extern "C" ErrorData* GetErrorData();

#endif

static int GlobalErrorHandler(int eType, const char* buffer)

{

auto errorData = GetErrorData();

if (!errorData)

{

static thread_local ErrorData dummyErrorData;

if (!dummyErrorData.perProcess)

{

static ErrorDataPerProcess edpp;

dummyErrorData.perProcess = &edpp;

}

errorData = &dummyErrorData;

}

bool& inError = errorData->inError;

std::string& lastError = errorData->lastError;

bool& inFatalError = errorData->perProcess->inFatalError;

std::string& lastFatalError = errorData->perProcess->lastFatalError;

trace("Error: %s\n", buffer);

if (inError || (eType == ERR_FATAL && inFatalError))

{

bool& inRecursiveError = errorData->inRecursiveError;

std::string& lastRecursiveError = errorData->lastRecursiveError;

if (inRecursiveError)

{

return SysError(va("Recursive-recursive error: %s\n%s", buffer, lastRecursiveError));

}

auto e = va("Recursive error: %s\nOriginal error: %s",

buffer,

lastFatalError.empty()

? lastError

: lastFatalError);

inRecursiveError = true;

lastRecursiveError = e;

return SysError(e);

}

inError = true;

lastError = buffer;

if (eType == ERR_NORMAL)

{

#if !defined(COMPILING_LAUNCH) && !defined(COMPILING_CONSOLE) && !defined(IS_FXSERVER)

ICoreGameInit* gameInit = Instance<ICoreGameInit>::Get();

bool handled = false;

if (gameInit && gameInit->TriggerError(buffer))

{

handled = true;

}

if (gameInit && gameInit->GetGameLoaded())

{

gameInit->KillNetwork(ToWide(buffer).c_str());

handled = true;

}

if (!handled)

#endif

{

return SysError(buffer);

}

}

else

{

inFatalError = true;

lastFatalError = buffer;

return SysError(buffer);

}

inError = false;

return 0;

}

struct ScopedError

{

ScopedError(std::string_view file, int line, uint32_t stringHash)

{

g_thisError = std::make_tuple(file, line, stringHash);

}

~ScopedError()

{

g_thisError = std::make_tuple(std::string_view{}, 0, 0);

}

};

#if defined(COMPILING_LAUNCHER)

void FatalErrorV(const char* string, fmt::printf_args formatList)

{

GlobalErrorHandler(ERR_FATAL, fmt::vsprintf(string, formatList).c_str());

}

#endif

#if (!defined(COMPILING_DIAG) && !defined(COMPILING_CONSOLE) && !defined(COMPILING_SHARED_LIBC)) || defined(NON_CRT_LAUNCHER)

int GlobalErrorRealV(const char* file, int line, uint32_t stringHash, const char* string, fmt::printf_args formatList)

{

ScopedError error(file, line, stringHash);

return GlobalErrorHandler(ERR_NORMAL, fmt::vsprintf(string, formatList).c_str());

}

int FatalErrorRealV(const char* file, int line, uint32_t stringHash, const char* string, fmt::printf_args formatList)

{

ScopedError error(file, line, stringHash);

return GlobalErrorHandler(ERR_FATAL, fmt::vsprintf(string, formatList).c_str());

}

int FatalErrorNoExceptRealV(const char* file, int line, uint32_t stringHash, const char* string, fmt::printf_args formatList)

{

#if !defined(IS_FXSERVER) && !defined(COMPILING_LAUNCH)

FatalErrorRealV(file, line, stringHash, string, formatList);

return -1;

#endif

return FatalErrorRealV(file, line, stringHash, string, formatList);

}

#else

void GlobalErrorV(const char* string, fmt::printf_args formatList)

{

GlobalErrorHandler(ERR_NORMAL, fmt::vsprintf(string, formatList).c_str());

}

void FatalErrorV(const char* string, fmt::printf_args formatList)

{

GlobalErrorHandler(ERR_FATAL, fmt::vsprintf(string, formatList).c_str());

}

#endif

#if (defined(COMPILING_LAUNCH) || defined(COMPILING_CONSOLE) || defined(COMPILING_SHARED_LIBC)) && !defined(NON_CRT_LAUNCHER)

#undef _wassert

#undef NDEBUG

#include <assert.h>

void __cdecl _wwassert(

_In_z_ wchar_t const* _Message,

_In_z_ wchar_t const* _File,

_In_ unsigned _Line

)

{

_wassert(_Message, _File, _Line);

}

#endif