BeamMP-Launcher/src/Launcher.cpp
2022-08-16 17:16:18 +03:00

285 lines
8.1 KiB
C++

///
/// Created by Anonymous275 on 12/26/21
/// Copyright (c) 2021-present Anonymous275 read the LICENSE file for more info.
///
#define WIN32_LEAN_AND_MEAN
#include "Launcher.h"
#include <ShlObj.h>
#include <comutil.h>
#include <shellapi.h>
#include <windows.h>
#include <csignal>
#include <mutex>
#include "HttpAPI.h"
#include "Logger.h"
#include "Memory/Memory.h"
LONG WINAPI CrashHandler(EXCEPTION_POINTERS* p) {
LOG(ERROR) << "CAUGHT EXCEPTION! Code 0x" << std::hex << std::uppercase
<< p->ExceptionRecord->ExceptionCode;
return EXCEPTION_EXECUTE_HANDLER;
}
Launcher::Launcher() :
CurrentPath(std::filesystem::current_path()),
DiscordMessage("Just launched") {
Shutdown.store(false);
Exit.store(false);
Launcher::StaticAbort(this);
DiscordTime = std::time(nullptr);
WindowsInit();
SetUnhandledExceptionFilter(CrashHandler);
LOG(INFO) << "Starting Launcher V" << FullVersion;
UpdateCheck();
}
void Launcher::Abort() {
Shutdown.store(true);
ServerHandler.Close();
if (DiscordRPC.joinable()) {
DiscordRPC.join();
}
if (IPCSystem.joinable()) {
IPCSystem.join();
}
if (!MPUserPath.empty()) {
ResetMods();
}
if (GamePID != 0) {
auto Handle = OpenProcess(PROCESS_TERMINATE, false, DWORD(GamePID));
TerminateProcess(Handle, 0);
CloseHandle(Handle);
}
}
Launcher::~Launcher() {
if (!Shutdown.load()) {
Abort();
}
}
void ShutdownHandler(int sig) {
Launcher::StaticAbort();
while (HTTP::isDownload) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
LOG(INFO) << "Got termination signal (" << sig << ")";
while (!Launcher::getExit()) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
void Launcher::StaticAbort(Launcher* Instance) {
static Launcher* Address;
if (Instance) {
Address = Instance;
return;
}
Address->Abort();
}
void Launcher::WindowsInit() {
system("cls");
SetConsoleTitleA(("BeamMP Launcher v" + FullVersion).c_str());
signal(SIGINT, ShutdownHandler);
signal(SIGTERM, ShutdownHandler);
signal(SIGABRT, ShutdownHandler);
signal(SIGBREAK, ShutdownHandler);
}
void Launcher::LaunchGame() {
VersionParser GameVersion(BeamVersion);
if (GameVersion.data[1] > SupportedVersion.data[1]) {
LOG(FATAL) << "BeamNG V" << BeamVersion
<< " not yet supported, please wait until we update BeamMP!";
throw ShutdownException("Fatal Error");
} else if (GameVersion.data[1] < SupportedVersion.data[1]) {
LOG(FATAL) << "BeamNG V" << BeamVersion
<< " not supported, please update and launch the new update!";
throw ShutdownException("Fatal Error");
} else if (GameVersion > SupportedVersion) {
LOG(WARNING)
<< "BeamNG V" << BeamVersion
<< " is slightly newer than recommended, this might cause issues!";
} else if (GameVersion < SupportedVersion) {
LOG(WARNING)
<< "BeamNG V" << BeamVersion
<< " is slightly older than recommended, this might cause issues!";
}
if (Memory::GetBeamNGPID({}) == 0) {
LOG(INFO) << "Launching BeamNG from steam";
ShellExecuteA(nullptr, nullptr, "steam://rungameid/284160", nullptr,
nullptr, SW_SHOWNORMAL);
// ShowWindow(GetConsoleWindow(), HIDE_WINDOW);
}
LOG(INFO) << "Waiting for a game process, please start BeamNG manually in "
"case of steam issues";
}
void Launcher::WaitForGame() {
std::set<uint32_t> BlackList;
do {
auto PID = Memory::GetBeamNGPID(BlackList);
if (PID != 0 && IPC::mem_used(PID)) {
BlackList.emplace(PID);
} else {
GamePID = PID;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
} while (GamePID == 0 && !Shutdown.load());
if (Shutdown.load()) return;
if (GamePID == 0) {
LOG(FATAL) << "Game process not found! aborting";
throw ShutdownException("Fatal Error");
}
LOG(INFO) << "Game found! PID " << GamePID;
IPCToGame = std::make_unique<IPC>(GamePID, 0x1900000);
IPCFromGame = std::make_unique<IPC>(GamePID + 1, 0x1900000);
IPCSystem = std::thread(&Launcher::ListenIPC, this);
Memory::Inject(GamePID);
setDiscordMessage("In menus");
while (!Shutdown.load() && Memory::GetBeamNGPID(BlackList) != 0) {
std::this_thread::sleep_for(std::chrono::seconds(2));
}
LOG(INFO) << "Game process was lost";
GamePID = 0;
}
void Launcher::ListenIPC() {
while (!Shutdown.load()) {
IPCFromGame->receive();
if (!IPCFromGame->receive_timed_out()) {
auto& MSG = IPCFromGame->msg();
if (MSG[0] == 'C') {
HandleIPC(IPCFromGame->msg().substr(1));
} else {
ServerHandler.ServerSend(IPCFromGame->msg().substr(1), false);
}
IPCFromGame->confirm_receive();
}
}
}
void Launcher::SendIPC(const std::string& Data, bool core) {
static std::mutex Lock;
std::scoped_lock Guard(Lock);
if (core) IPCToGame->send("C" + Data);
else IPCToGame->send("G" + Data);
if (IPCToGame->send_timed_out()) {
LOG(WARNING) << "Timed out while sending \"" << Data << "\"";
}
}
std::string Launcher::QueryValue(HKEY& hKey, const char* Name) {
DWORD keySize;
BYTE buffer[16384];
if (RegQueryValueExA(hKey, Name, nullptr, nullptr, buffer, &keySize) ==
ERROR_SUCCESS) {
return {(char*)buffer, keySize - 1};
}
return {};
}
std::string Launcher::GetLocalAppdata() {
PWSTR folderPath = nullptr;
HRESULT hr =
SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &folderPath);
if (!SUCCEEDED(hr)) {
LOG(FATAL) << "Failed to get path of localAppData";
throw ShutdownException("Fatal Error");
}
_bstr_t bstrPath(folderPath);
std::string Path((char*)bstrPath);
CoTaskMemFree(folderPath);
if (!Path.empty()) {
Path += "\\BeamNG.drive\\";
VersionParser GameVer(BeamVersion);
Path += GameVer.split[0] + '.' + GameVer.split[1] + '\\';
return Path;
}
return {};
}
void Launcher::QueryRegistry() {
HKEY BeamNG;
LONG RegRes =
RegOpenKeyExA(HKEY_CURRENT_USER, R"(Software\BeamNG\BeamNG.drive)", 0,
KEY_READ, &BeamNG);
if (RegRes == ERROR_SUCCESS) {
BeamRoot = QueryValue(BeamNG, "rootpath");
BeamVersion = QueryValue(BeamNG, "version");
BeamUserPath = QueryValue(BeamNG, "userpath_override");
RegCloseKey(BeamNG);
if (BeamUserPath.empty() && !BeamVersion.empty()) {
BeamUserPath = GetLocalAppdata();
} else if (!BeamUserPath.empty() && !BeamVersion.empty()) {
VersionParser GameVer(BeamVersion);
BeamUserPath += GameVer.split[0] + '.' + GameVer.split[1] + '\\';
}
if (!BeamUserPath.empty()) {
MPUserPath = BeamUserPath + "mods\\multiplayer";
}
if (!BeamRoot.empty() && !BeamVersion.empty() && !BeamUserPath.empty())
return;
}
LOG(FATAL)
<< "Please launch the game at least once, failed to read registry "
"key Software\\BeamNG\\BeamNG.drive";
throw ShutdownException("Fatal Error");
}
void Launcher::AdminRelaunch() {
system("cls");
ShellExecuteA(nullptr, "runas", CurrentPath.string().c_str(), nullptr,
nullptr, SW_SHOWNORMAL);
ShowWindow(GetConsoleWindow(), 0);
throw ShutdownException("Relaunching");
}
void Launcher::Relaunch() {
ShellExecuteA(nullptr, "open", CurrentPath.string().c_str(), nullptr,
nullptr, SW_SHOWNORMAL);
ShowWindow(GetConsoleWindow(), 0);
std::this_thread::sleep_for(std::chrono::seconds(1));
throw ShutdownException("Relaunching");
}
const std::string& Launcher::getFullVersion() {
return FullVersion;
}
const std::string& Launcher::getVersion() {
return Version;
}
const std::string& Launcher::getUserRole() {
return UserRole;
}
bool Launcher::Terminated() noexcept {
return Shutdown.load();
}
bool Launcher::getExit() noexcept {
return Exit.load();
}
void Launcher::setExit(bool exit) noexcept {
Exit.store(exit);
}
const std::string& Launcher::getMPUserPath() {
return MPUserPath;
}
const std::string& Launcher::getPublicKey() {
return PublicKey;
}