mirror of
https://github.com/BeamMP/BeamMP-Launcher.git
synced 2025-07-04 00:47:23 +00:00
Compare commits
No commits in common. "master" and "v2.4.0" have entirely different histories.
52
README.md
52
README.md
@ -2,7 +2,57 @@
|
||||
|
||||
The launcher is the way we communitcate to outside the game, it does a few automated actions such as but not limited to: downloading the mod, launching the game, and create a connection to a server.
|
||||
|
||||
## [Getting started](https://docs.beammp.com/game/getting-started/)
|
||||
**To clone this repository**: `git clone --recurse-submodules https://github.com/BeamMP/BeamMP-Launcher.git`
|
||||
|
||||
## How to build for Windows
|
||||
|
||||
Make sure you have the necessary development tools installed:
|
||||
|
||||
[vcpkg](https://vcpkg.io/en/)
|
||||
|
||||
### Release
|
||||
|
||||
In the root directory of the project,
|
||||
1. `cmake -DCMAKE_BUILD_TYPE=Release . -B bin -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static`
|
||||
2. `cmake --build bin --parallel --config Release`
|
||||
|
||||
Remember to change `C:/vcpkg` to wherever you have vcpkg installed.
|
||||
|
||||
### Debug
|
||||
|
||||
In the root directory of the project,
|
||||
1. `cmake . -B bin -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static`
|
||||
2. `cmake --build bin --parallel`
|
||||
|
||||
Remember to change `C:/vcpkg` to wherever you have vcpkg installed.
|
||||
|
||||
## How to build for Linux
|
||||
|
||||
Make sure you have `vcpkg` installed, as well as basic development tools, often found in packages, for example:
|
||||
|
||||
- Debian: `sudo apt install build-essential`
|
||||
- Fedora: `sudo dnf groupinstall "Development Tools"`
|
||||
- Arch: `sudo pacman -S base-devel`
|
||||
- openSUSE: `zypper in -t pattern devel-basis`
|
||||
|
||||
### Release
|
||||
|
||||
In the root directory of the project,
|
||||
1. `cmake -DCMAKE_BUILD_TYPE=Release . -B bin -DCMAKE_TOOLCHAIN_FILE=~/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-linux`
|
||||
2. `cmake --build bin --parallel --config Release`
|
||||
|
||||
### Debug
|
||||
|
||||
In the root directory of the project,
|
||||
1. `cmake . -B bin -DCMAKE_TOOLCHAIN_FILE=~/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-linux`
|
||||
2. `cmake --build bin --parallel`
|
||||
|
||||
## Running out of RAM while building
|
||||
|
||||
Should you run out of RAM while building, you can ommit the `--parallel` instruction, it will then use less RAM due to building only on one CPU thread.
|
||||
|
||||
You can also specify a number of threads to use, for example `--parallel 4` will use four CPU threads, but due to the small project size, you may be faster just omitting `--parallel` instead of trying to find the highest possible multithread number
|
||||
|
||||
|
||||
## License
|
||||
|
||||
|
||||
@ -6,12 +6,10 @@
|
||||
|
||||
#pragma once
|
||||
#include "Logger.h"
|
||||
#include "Utils.h"
|
||||
|
||||
#include <string>
|
||||
class HTTP {
|
||||
public:
|
||||
static bool Download(const std::string& IP, const beammp_fs_string& Path);
|
||||
static bool Download(const std::string& IP, const std::string& Path);
|
||||
static std::string Post(const std::string& IP, const std::string& Fields);
|
||||
static std::string Get(const std::string& IP);
|
||||
static bool ProgressBar(size_t c, size_t t);
|
||||
|
||||
@ -14,11 +14,4 @@ void debug(const std::string& toPrint);
|
||||
void error(const std::string& toPrint);
|
||||
void info(const std::string& toPrint);
|
||||
void warn(const std::string& toPrint);
|
||||
|
||||
void except(const std::wstring& toPrint);
|
||||
void fatal(const std::wstring& toPrint);
|
||||
void debug(const std::wstring& toPrint);
|
||||
void error(const std::wstring& toPrint);
|
||||
void info(const std::wstring& toPrint);
|
||||
void warn(const std::wstring& toPrint);
|
||||
std::string getDate();
|
||||
|
||||
@ -6,7 +6,6 @@
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <filesystem>
|
||||
#include <string>
|
||||
|
||||
#ifdef __linux__
|
||||
@ -30,8 +29,7 @@ extern bool Terminate;
|
||||
extern uint64_t UDPSock;
|
||||
extern uint64_t TCPSock;
|
||||
extern std::string Branch;
|
||||
extern std::filesystem::path CachingDirectory;
|
||||
extern bool deleteDuplicateMods;
|
||||
extern std::string CachingDirectory;
|
||||
extern bool TCPTerminate;
|
||||
extern std::string LastIP;
|
||||
extern std::string MStatus;
|
||||
|
||||
@ -19,7 +19,6 @@ struct Options {
|
||||
bool no_download = false;
|
||||
bool no_update = false;
|
||||
bool no_launch = false;
|
||||
const char* user_path = nullptr;
|
||||
const char **game_arguments = nullptr;
|
||||
int game_arguments_length = 0;
|
||||
const char** argv = nullptr;
|
||||
|
||||
@ -6,9 +6,9 @@
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
void PreGame(const beammp_fs_string& GamePath);
|
||||
std::string CheckVer(const std::filesystem::path& path);
|
||||
void InitGame(const beammp_fs_string& Dir);
|
||||
beammp_fs_string GetGameDir();
|
||||
void PreGame(const std::string& GamePath);
|
||||
std::string CheckVer(const std::string& path);
|
||||
void InitGame(const std::string& Dir);
|
||||
std::string GetGameDir();
|
||||
void LegitimacyCheck();
|
||||
void CheckLocalKey();
|
||||
@ -5,16 +5,14 @@
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "Utils.h"
|
||||
|
||||
#include <compare>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
void InitLauncher();
|
||||
beammp_fs_string GetEP(const beammp_fs_char* P = nullptr);
|
||||
std::filesystem::path GetGamePath();
|
||||
std::string GetEP(const char* P = nullptr);
|
||||
std::string GetGamePath();
|
||||
std::string GetVer();
|
||||
std::string GetPatch();
|
||||
beammp_fs_string GetEN();
|
||||
std::string GetEN();
|
||||
void ConfigInit();
|
||||
|
||||
223
include/Utils.h
223
include/Utils.h
@ -5,31 +5,10 @@
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cassert>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <locale>
|
||||
#include <map>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <regex>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#ifdef _WIN32
|
||||
#define beammp_fs_string std::wstring
|
||||
#define beammp_fs_char wchar_t
|
||||
#define beammp_wide(str) L##str
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#else
|
||||
#define beammp_fs_string std::string
|
||||
#define beammp_fs_char char
|
||||
#define beammp_wide(str) str
|
||||
#endif
|
||||
|
||||
namespace Utils {
|
||||
|
||||
inline std::vector<std::string> Split(const std::string& String, const std::string& delimiter) {
|
||||
std::vector<std::string> Val;
|
||||
size_t pos;
|
||||
@ -44,206 +23,4 @@ namespace Utils {
|
||||
Val.push_back(s);
|
||||
return Val;
|
||||
};
|
||||
inline std::string ExpandEnvVars(const std::string& input) {
|
||||
std::string result;
|
||||
std::regex envPattern(R"(%([^%]+)%|\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([^}]+)\})");
|
||||
|
||||
std::sregex_iterator begin(input.begin(), input.end(), envPattern);
|
||||
std::sregex_iterator end;
|
||||
|
||||
size_t lastPos = 0;
|
||||
|
||||
for (auto it = begin; it != end; ++it) {
|
||||
const auto& match = *it;
|
||||
|
||||
result.append(input, lastPos, match.position() - lastPos);
|
||||
|
||||
std::string varName;
|
||||
if (match[1].matched) varName = match[1].str(); // %VAR%
|
||||
else if (match[2].matched) varName = match[2].str(); // $VAR
|
||||
else if (match[3].matched) varName = match[3].str(); // ${VAR}
|
||||
|
||||
if (const char* envValue = std::getenv(varName.c_str())) {
|
||||
result.append(envValue);
|
||||
}
|
||||
|
||||
lastPos = match.position() + match.length();
|
||||
}
|
||||
|
||||
result.append(input, lastPos, input.length() - lastPos);
|
||||
|
||||
return result;
|
||||
}
|
||||
#ifdef _WIN32
|
||||
inline std::wstring ExpandEnvVars(const std::wstring& input) {
|
||||
std::wstring result;
|
||||
std::wregex envPattern(LR"(%([^%]+)%|\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([^}]+)\})");
|
||||
|
||||
std::wsregex_iterator begin(input.begin(), input.end(), envPattern);
|
||||
std::wsregex_iterator end;
|
||||
|
||||
size_t lastPos = 0;
|
||||
|
||||
for (auto it = begin; it != end; ++it) {
|
||||
const auto& match = *it;
|
||||
|
||||
result.append(input, lastPos, match.position() - lastPos);
|
||||
|
||||
std::wstring varName;
|
||||
assert(match.size() == 4 && "Input regex has incorrect amount of capturing groups");
|
||||
if (match[1].matched) varName = match[1].str(); // %VAR%
|
||||
else if (match[2].matched) varName = match[2].str(); // $VAR
|
||||
else if (match[3].matched) varName = match[3].str(); // ${VAR}
|
||||
|
||||
if (const wchar_t* envValue = _wgetenv(varName.c_str())) {
|
||||
if (envValue != nullptr) {
|
||||
result.append(envValue);
|
||||
}
|
||||
}
|
||||
|
||||
lastPos = match.position() + match.length();
|
||||
}
|
||||
|
||||
result.append(input, lastPos, input.length() - lastPos);
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
inline std::map<std::string, std::map<std::string, std::string>> ParseINI(const std::string& contents) {
|
||||
std::map<std::string, std::map<std::string, std::string>> ini;
|
||||
|
||||
std::string currentSection;
|
||||
auto sections = Split(contents, "\n");
|
||||
|
||||
for (size_t i = 0; i < sections.size(); i++) {
|
||||
std::string line = sections[i];
|
||||
if (line.empty() || line[0] == ';' || line[0] == '#')
|
||||
continue;
|
||||
|
||||
for (auto& c : line) {
|
||||
if (c == '#' || c == ';') {
|
||||
line = line.substr(0, &c - &line[0]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
auto invalidLineLog = [&]{
|
||||
warn("Invalid INI line: " + line);
|
||||
warn("Surrounding lines: \n" +
|
||||
(i > 0 ? sections[i - 1] : "") + "\n" +
|
||||
(i < sections.size() - 1 ? sections[i + 1] : ""));
|
||||
};
|
||||
|
||||
if (line[0] == '[') {
|
||||
currentSection = line.substr(1, line.find(']') - 1);
|
||||
} else {
|
||||
|
||||
if (currentSection.empty()) {
|
||||
invalidLineLog();
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string key, value;
|
||||
size_t pos = line.find('=');
|
||||
if (pos != std::string::npos) {
|
||||
key = line.substr(0, pos);
|
||||
value = line.substr(pos + 1);
|
||||
ini[currentSection][key] = value;
|
||||
} else {
|
||||
invalidLineLog();
|
||||
continue;
|
||||
}
|
||||
|
||||
key.erase(key.find_last_not_of(" \t") + 1);
|
||||
value.erase(0, value.find_first_not_of(" \t"));
|
||||
value.erase(value.find_last_not_of(" \t") + 1);
|
||||
|
||||
ini[currentSection][key] = value;
|
||||
}
|
||||
}
|
||||
|
||||
return ini;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
inline std::wstring ToWString(const std::string& s) {
|
||||
if (s.empty()) return std::wstring();
|
||||
|
||||
int size_needed = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0);
|
||||
if (size_needed <= 0) {
|
||||
return L"";
|
||||
}
|
||||
|
||||
std::wstring result(size_needed, 0);
|
||||
|
||||
MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &result[0], size_needed);
|
||||
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
inline std::string ToWString(const std::string& s) {
|
||||
return s;
|
||||
}
|
||||
#endif
|
||||
inline std::string GetSha256HashReallyFast(const beammp_fs_string& filename) {
|
||||
try {
|
||||
EVP_MD_CTX* mdctx;
|
||||
const EVP_MD* md;
|
||||
uint8_t sha256_value[EVP_MAX_MD_SIZE];
|
||||
md = EVP_sha256();
|
||||
if (md == nullptr) {
|
||||
throw std::runtime_error("EVP_sha256() failed");
|
||||
}
|
||||
|
||||
mdctx = EVP_MD_CTX_new();
|
||||
if (mdctx == nullptr) {
|
||||
throw std::runtime_error("EVP_MD_CTX_new() failed");
|
||||
}
|
||||
if (!EVP_DigestInit_ex2(mdctx, md, NULL)) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestInit_ex2() failed");
|
||||
}
|
||||
|
||||
std::ifstream stream(filename, std::ios::binary);
|
||||
|
||||
const size_t FileSize = std::filesystem::file_size(filename);
|
||||
size_t Read = 0;
|
||||
std::vector<char> Data;
|
||||
while (Read < FileSize) {
|
||||
Data.resize(size_t(std::min<size_t>(FileSize - Read, 4096)));
|
||||
size_t RealDataSize = Data.size();
|
||||
stream.read(Data.data(), std::streamsize(Data.size()));
|
||||
if (stream.eof() || stream.fail()) {
|
||||
RealDataSize = size_t(stream.gcount());
|
||||
}
|
||||
Data.resize(RealDataSize);
|
||||
if (RealDataSize == 0) {
|
||||
break;
|
||||
}
|
||||
if (RealDataSize > 0 && !EVP_DigestUpdate(mdctx, Data.data(), Data.size())) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestUpdate() failed");
|
||||
}
|
||||
Read += RealDataSize;
|
||||
}
|
||||
unsigned int sha256_len = 0;
|
||||
if (!EVP_DigestFinal_ex(mdctx, sha256_value, &sha256_len)) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestFinal_ex() failed");
|
||||
}
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
|
||||
std::string result;
|
||||
for (size_t i = 0; i < sha256_len; i++) {
|
||||
char buf[3];
|
||||
sprintf(buf, "%02x", sha256_value[i]);
|
||||
buf[2] = 0;
|
||||
result += buf;
|
||||
}
|
||||
return result;
|
||||
} catch (const std::exception& e) {
|
||||
error(beammp_wide("Sha256 hashing of '") + filename + beammp_wide("' failed: ") + ToWString(e.what()));
|
||||
return "";
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -6,17 +6,15 @@
|
||||
|
||||
#include "Logger.h"
|
||||
#include "Network/network.hpp"
|
||||
#include "Options.h"
|
||||
#include "Utils.h"
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <nlohmann/json.hpp>
|
||||
#include "Options.h"
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
std::string Branch;
|
||||
std::filesystem::path CachingDirectory = std::filesystem::path("./Resources");
|
||||
bool deleteDuplicateMods = false;
|
||||
std::string CachingDirectory = "./Resources";
|
||||
|
||||
void ParseConfig(const nlohmann::json& d) {
|
||||
if (d["Port"].is_number()) {
|
||||
@ -33,8 +31,8 @@ void ParseConfig(const nlohmann::json& d) {
|
||||
c = char(tolower(c));
|
||||
}
|
||||
if (d.contains("CachingDirectory") && d["CachingDirectory"].is_string()) {
|
||||
CachingDirectory = std::filesystem::path(d["CachingDirectory"].get<std::string>());
|
||||
info(beammp_wide("Mod caching directory: ") + beammp_fs_string(CachingDirectory.relative_path()));
|
||||
CachingDirectory = d["CachingDirectory"].get<std::string>();
|
||||
info("Mod caching directory: " + CachingDirectory);
|
||||
}
|
||||
|
||||
if (d.contains("Dev") && d["Dev"].is_boolean()) {
|
||||
@ -44,11 +42,6 @@ void ParseConfig(const nlohmann::json& d) {
|
||||
options.no_launch = dev;
|
||||
options.no_update = dev;
|
||||
}
|
||||
|
||||
if (d.contains(("DeleteDuplicateMods")) && d["DeleteDuplicateMods"].is_boolean()) {
|
||||
deleteDuplicateMods = d["DeleteDuplicateMods"].get<bool>();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void ConfigInit() {
|
||||
|
||||
@ -4,7 +4,9 @@
|
||||
SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
*/
|
||||
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <windows.h>
|
||||
#include <shlobj.h>
|
||||
#elif defined(__linux__)
|
||||
#include "vdf_parser.hpp"
|
||||
@ -16,86 +18,50 @@
|
||||
#endif
|
||||
|
||||
#include "Logger.h"
|
||||
#include "Options.h"
|
||||
#include "Startup.h"
|
||||
#include "Utils.h"
|
||||
#include <Security/Init.h>
|
||||
#include <filesystem>
|
||||
#include <thread>
|
||||
|
||||
#include <fstream>
|
||||
#include "Options.h"
|
||||
|
||||
unsigned long GamePID = 0;
|
||||
#if defined(_WIN32)
|
||||
std::wstring QueryKey(HKEY hKey, int ID);
|
||||
std::filesystem::path GetGamePath() {
|
||||
static std::filesystem::path Path;
|
||||
std::string QueryKey(HKEY hKey, int ID);
|
||||
std::string GetGamePath() {
|
||||
static std::string Path;
|
||||
if (!Path.empty())
|
||||
return Path.wstring();
|
||||
return Path;
|
||||
|
||||
if (options.user_path) {
|
||||
if (std::filesystem::exists(options.user_path)) {
|
||||
Path = options.user_path;
|
||||
debug(L"Using custom user folder path: " + Path.wstring());
|
||||
} else
|
||||
warn(L"Invalid or non-existent path (" + Utils::ToWString(options.user_path) + L") specified using --user-path, skipping");
|
||||
HKEY hKey;
|
||||
LPCTSTR sk = "Software\\BeamNG\\BeamNG.drive";
|
||||
LONG openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
|
||||
if (openRes != ERROR_SUCCESS) {
|
||||
fatal("Please launch the game at least once!");
|
||||
}
|
||||
Path = QueryKey(hKey, 4);
|
||||
|
||||
if (const auto startupIniPath = std::filesystem::path(GetGameDir()) / "startup.ini"; exists(startupIniPath)) {
|
||||
|
||||
if (std::ifstream startupIni(startupIniPath); startupIni.is_open()) {
|
||||
std::string contents((std::istreambuf_iterator(startupIni)), std::istreambuf_iterator<char>());
|
||||
startupIni.close();
|
||||
|
||||
auto ini = Utils::ParseINI(contents);
|
||||
if (ini.empty())
|
||||
warn("Failed to parse startup.ini");
|
||||
else
|
||||
debug("Successfully parsed startup.ini");
|
||||
|
||||
std::wstring userPath;
|
||||
if (ini.contains("filesystem") && ini["filesystem"].contains("UserPath"))
|
||||
userPath = Utils::ToWString(ini["filesystem"]["UserPath"]);
|
||||
|
||||
if (!userPath.empty())
|
||||
if (userPath = Utils::ExpandEnvVars(userPath); std::filesystem::exists(userPath)) {
|
||||
Path = userPath;
|
||||
debug(L"Using custom user folder path from startup.ini: " + Path.wstring());
|
||||
} else
|
||||
warn(L"Found custom user folder path (" + userPath + L") in startup.ini but it doesn't exist, skipping");
|
||||
if (Path.empty()) {
|
||||
Path = "";
|
||||
char appDataPath[MAX_PATH];
|
||||
HRESULT result = SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);
|
||||
if (SUCCEEDED(result)) {
|
||||
Path = appDataPath;
|
||||
}
|
||||
|
||||
if (Path.empty()) {
|
||||
HKEY hKey;
|
||||
LPCTSTR sk = "Software\\BeamNG\\BeamNG.drive";
|
||||
LONG openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
|
||||
if (openRes != ERROR_SUCCESS) {
|
||||
fatal("Please launch the game at least once!");
|
||||
}
|
||||
Path = QueryKey(hKey, 4);
|
||||
|
||||
if (Path.empty()) {
|
||||
wchar_t* appDataPath = new wchar_t[MAX_PATH];
|
||||
HRESULT result = SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);
|
||||
|
||||
if (!SUCCEEDED(result)) {
|
||||
fatal("Cannot get Local Appdata directory");
|
||||
}
|
||||
|
||||
Path = std::filesystem::path(appDataPath) / "BeamNG.drive";
|
||||
|
||||
delete[] appDataPath;
|
||||
}
|
||||
fatal("Cannot get Local Appdata directory");
|
||||
}
|
||||
|
||||
Path += "\\BeamNG.drive\\";
|
||||
}
|
||||
|
||||
std::string Ver = CheckVer(GetGameDir());
|
||||
Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
|
||||
Path /= Utils::ToWString(Ver);
|
||||
Path += Ver + "\\";
|
||||
return Path;
|
||||
}
|
||||
#elif defined(__linux__)
|
||||
std::filesystem::path GetGamePath() {
|
||||
std::string GetGamePath() {
|
||||
// Right now only steam is supported
|
||||
struct passwd* pw = getpwuid(getuid());
|
||||
std::string homeDir = pw->pw_dir;
|
||||
@ -109,44 +75,29 @@ std::filesystem::path GetGamePath() {
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32)
|
||||
void StartGame(std::wstring Dir) {
|
||||
void StartGame(std::string Dir) {
|
||||
BOOL bSuccess = FALSE;
|
||||
PROCESS_INFORMATION pi;
|
||||
STARTUPINFOW si = { 0 };
|
||||
STARTUPINFO si = { 0 };
|
||||
si.cb = sizeof(si);
|
||||
std::wstring BaseDir = Dir; //+"\\Bin64";
|
||||
std::string BaseDir = Dir; //+"\\Bin64";
|
||||
// Dir += R"(\Bin64\BeamNG.drive.x64.exe)";
|
||||
Dir += L"\\BeamNG.drive.exe";
|
||||
std::wstring gameArgs = L"";
|
||||
Dir += "\\BeamNG.drive.exe";
|
||||
std::string gameArgs = "";
|
||||
|
||||
for (int i = 0; i < options.game_arguments_length; i++) {
|
||||
gameArgs += L" ";
|
||||
gameArgs += Utils::ToWString(options.game_arguments[i]);
|
||||
gameArgs += " ";
|
||||
gameArgs += options.game_arguments[i];
|
||||
}
|
||||
|
||||
debug(L"BeamNG executable path: " + Dir);
|
||||
|
||||
bSuccess = CreateProcessW(nullptr, (wchar_t*)(Dir + gameArgs).c_str(), nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
|
||||
bSuccess = CreateProcessA(nullptr, (LPSTR)(Dir + gameArgs).c_str(), nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
|
||||
if (bSuccess) {
|
||||
info("Game Launched!");
|
||||
GamePID = pi.dwProcessId;
|
||||
WaitForSingleObject(pi.hProcess, INFINITE);
|
||||
error("Game Closed! launcher closing soon");
|
||||
} else {
|
||||
std::string err = "";
|
||||
|
||||
DWORD dw = GetLastError();
|
||||
LPVOID lpErrorMsgBuffer;
|
||||
|
||||
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw,
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpErrorMsgBuffer, 0, nullptr)
|
||||
== 0) {
|
||||
err = "Unknown error code: " + std::to_string(dw);
|
||||
} else {
|
||||
err = "Error " + std::to_string(dw) + ": " + (char*)lpErrorMsgBuffer;
|
||||
}
|
||||
|
||||
error("Failed to Launch the game! launcher closing soon. " + err);
|
||||
error("Failed to Launch the game! launcher closing soon");
|
||||
}
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
exit(2);
|
||||
@ -182,7 +133,7 @@ void StartGame(std::string Dir) {
|
||||
}
|
||||
#endif
|
||||
|
||||
void InitGame(const beammp_fs_string& Dir) {
|
||||
void InitGame(const std::string& Dir) {
|
||||
if (!options.no_launch) {
|
||||
std::thread Game(StartGame, Dir);
|
||||
Game.detach();
|
||||
|
||||
@ -7,7 +7,6 @@
|
||||
|
||||
#include "Logger.h"
|
||||
#include "Startup.h"
|
||||
#include "Utils.h"
|
||||
#include <chrono>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
@ -37,7 +36,7 @@ std::string getDate() {
|
||||
}
|
||||
void InitLog() {
|
||||
std::ofstream LFS;
|
||||
LFS.open(GetEP() + beammp_wide("Launcher.log"));
|
||||
LFS.open(GetEP() + "Launcher.log");
|
||||
if (!LFS.is_open()) {
|
||||
error("logger file init failed!");
|
||||
} else
|
||||
@ -45,13 +44,7 @@ void InitLog() {
|
||||
}
|
||||
void addToLog(const std::string& Line) {
|
||||
std::ofstream LFS;
|
||||
LFS.open(GetEP() + beammp_wide("Launcher.log"), std::ios_base::app);
|
||||
LFS << Line.c_str();
|
||||
LFS.close();
|
||||
}
|
||||
void addToLog(const std::wstring& Line) {
|
||||
std::wofstream LFS;
|
||||
LFS.open(GetEP() + beammp_wide("Launcher.log"), std::ios_base::app);
|
||||
LFS.open(GetEP() + "Launcher.log", std::ios_base::app);
|
||||
LFS << Line.c_str();
|
||||
LFS.close();
|
||||
}
|
||||
@ -89,41 +82,3 @@ void except(const std::string& toPrint) {
|
||||
std::cout << Print;
|
||||
addToLog(Print);
|
||||
}
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
void info(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[INFO] " + toPrint + L"\n";
|
||||
std::wcout << Print;
|
||||
addToLog(Print);
|
||||
}
|
||||
void debug(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[DEBUG] " + toPrint + L"\n";
|
||||
if (options.verbose) {
|
||||
std::wcout << Print;
|
||||
}
|
||||
addToLog(Print);
|
||||
}
|
||||
void warn(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[WARN] " + toPrint + L"\n";
|
||||
std::wcout << Print;
|
||||
addToLog(Print);
|
||||
}
|
||||
void error(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[ERROR] " + toPrint + L"\n";
|
||||
std::wcout << Print;
|
||||
addToLog(Print);
|
||||
}
|
||||
void fatal(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[FATAL] " + toPrint + L"\n";
|
||||
std::wcout << Print;
|
||||
addToLog(Print);
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
std::exit(1);
|
||||
}
|
||||
void except(const std::wstring& toPrint) {
|
||||
std::wstring Print = Utils::ToWString(getDate()) + L"[EXCEP] " + toPrint + L"\n";
|
||||
std::wcout << Print;
|
||||
addToLog(Print);
|
||||
}
|
||||
#endif
|
||||
@ -12,7 +12,6 @@
|
||||
#if defined(_WIN32)
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#include <shellapi.h>
|
||||
#elif defined(__linux__)
|
||||
#include <cstring>
|
||||
#include <errno.h>
|
||||
@ -142,7 +141,7 @@ void GetServerInfo(std::string Data) {
|
||||
const std::string buffer = ([&]() -> std::string {
|
||||
int32_t Header;
|
||||
std::vector<char> data(sizeof(Header));
|
||||
int Temp = recv(ISock, data.data(), sizeof(Header), MSG_WAITALL);
|
||||
int32_t Temp = recv(ISock, data.data(), sizeof(Header), MSG_WAITALL);
|
||||
|
||||
auto checkBytes = ([&](const int32_t bytes) -> bool {
|
||||
if (bytes == 0) {
|
||||
@ -201,17 +200,7 @@ bool IsAllowedLink(const std::string& Link) {
|
||||
return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0;
|
||||
}
|
||||
|
||||
std::vector<std::future<void>> futures;
|
||||
|
||||
void Parse(std::string Data, SOCKET CSocket) {
|
||||
std::erase_if(futures, [](const std::future<void>& f) {
|
||||
if (f.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
|
||||
|
||||
char Code = Data.at(0), SubCode = 0;
|
||||
if (Data.length() > 1)
|
||||
SubCode = Data.at(1);
|
||||
@ -224,9 +213,9 @@ void Parse(std::string Data, SOCKET CSocket) {
|
||||
Terminate = true;
|
||||
TCPTerminate = true;
|
||||
Data.clear();
|
||||
futures.push_back(std::async(std::launch::async, []() {
|
||||
auto future = std::async(std::launch::async, []() {
|
||||
CoreSend("B" + HTTP::Get("https://backend.beammp.com/servers-info"));
|
||||
}));
|
||||
});
|
||||
}
|
||||
break;
|
||||
case 'C':
|
||||
@ -323,9 +312,9 @@ void Parse(std::string Data, SOCKET CSocket) {
|
||||
}
|
||||
Data = "N" + Auth.dump();
|
||||
} else {
|
||||
futures.push_back(std::async(std::launch::async, [data = std::move(Data)]() {
|
||||
auto future = std::async(std::launch::async, [data = std::move(Data)]() {
|
||||
CoreSend("N" + Login(data.substr(data.find(':') + 1)));
|
||||
}));
|
||||
});
|
||||
Data.clear();
|
||||
}
|
||||
break;
|
||||
@ -353,8 +342,7 @@ void Parse(std::string Data, SOCKET CSocket) {
|
||||
}
|
||||
void GameHandler(SOCKET Client) {
|
||||
CoreSocket = Client;
|
||||
int32_t Size, Rcv;
|
||||
int Temp;
|
||||
int32_t Size, Temp, Rcv;
|
||||
char Header[10] = { 0 };
|
||||
do {
|
||||
Rcv = 0;
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include "Options.h"
|
||||
#include <chrono>
|
||||
|
||||
std::chrono::time_point<std::chrono::high_resolution_clock> PingStart, PingEnd;
|
||||
bool GConnected = false;
|
||||
@ -262,8 +261,7 @@ void TCPGameServer(const std::string& IP, int Port) {
|
||||
NetMainThread = std::make_unique<std::thread>(NetMain, IP, Port);
|
||||
CServer = false;
|
||||
}
|
||||
int32_t Size, Rcv;
|
||||
int Temp;
|
||||
int32_t Size, Temp, Rcv;
|
||||
char Header[10] = { 0 };
|
||||
|
||||
// Read byte by byte until '>' is rcved then get the size and read based on it
|
||||
|
||||
@ -127,7 +127,7 @@ std::string HTTP::Post(const std::string& IP, const std::string& Fields) {
|
||||
return Ret;
|
||||
}
|
||||
|
||||
bool HTTP::Download(const std::string& IP, const beammp_fs_string& Path) {
|
||||
bool HTTP::Download(const std::string& IP, const std::string& Path) {
|
||||
static std::mutex Lock;
|
||||
std::scoped_lock Guard(Lock);
|
||||
|
||||
@ -145,7 +145,7 @@ bool HTTP::Download(const std::string& IP, const beammp_fs_string& Path) {
|
||||
File.close();
|
||||
info("Download Complete!");
|
||||
} else {
|
||||
error(beammp_wide("Failed to open file directory: ") + Path);
|
||||
error("Failed to open file directory: " + Path);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -164,12 +164,9 @@ std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
|
||||
do {
|
||||
// receive at most some MB at a time
|
||||
int Len = std::min(int(Size - Rcv), 1 * 1024 * 1024);
|
||||
int Temp = recv(Sock, &File[Rcv], Len, MSG_WAITALL);
|
||||
if (Temp == -1 || Temp == 0) {
|
||||
debug("Recv returned: " + std::to_string(Temp));
|
||||
if (Temp == -1) {
|
||||
error("Socket error during download: " + std::to_string(WSAGetLastError()));
|
||||
}
|
||||
int32_t Temp = recv(Sock, &File[Rcv], Len, MSG_WAITALL);
|
||||
if (Temp < 1) {
|
||||
info(std::to_string(Temp));
|
||||
UUl("Socket Closed Code 1");
|
||||
KillSocket(Sock);
|
||||
Terminate = true;
|
||||
@ -180,8 +177,8 @@ std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
|
||||
|
||||
auto end = std::chrono::high_resolution_clock::now();
|
||||
auto difference = end - start;
|
||||
double bits_per_s = double(Rcv * 8) / double(std::chrono::duration_cast<std::chrono::milliseconds>(difference).count());
|
||||
double megabits_per_s = bits_per_s / 1000;
|
||||
float bits_per_s = float(Rcv * 8) / float(std::chrono::duration_cast<std::chrono::milliseconds>(difference).count());
|
||||
float megabits_per_s = bits_per_s / 1000;
|
||||
DownloadSpeed = megabits_per_s;
|
||||
// every 8th iteration print the speed
|
||||
if (i % 8 == 0) {
|
||||
@ -301,6 +298,68 @@ void InvalidResource(const std::string& File) {
|
||||
Terminate = true;
|
||||
}
|
||||
|
||||
std::string GetSha256HashReallyFast(const std::string& filename) {
|
||||
try {
|
||||
EVP_MD_CTX* mdctx;
|
||||
const EVP_MD* md;
|
||||
uint8_t sha256_value[EVP_MAX_MD_SIZE];
|
||||
md = EVP_sha256();
|
||||
if (md == nullptr) {
|
||||
throw std::runtime_error("EVP_sha256() failed");
|
||||
}
|
||||
|
||||
mdctx = EVP_MD_CTX_new();
|
||||
if (mdctx == nullptr) {
|
||||
throw std::runtime_error("EVP_MD_CTX_new() failed");
|
||||
}
|
||||
if (!EVP_DigestInit_ex2(mdctx, md, NULL)) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestInit_ex2() failed");
|
||||
}
|
||||
|
||||
std::ifstream stream(filename, std::ios::binary);
|
||||
|
||||
const size_t FileSize = std::filesystem::file_size(filename);
|
||||
size_t Read = 0;
|
||||
std::vector<char> Data;
|
||||
while (Read < FileSize) {
|
||||
Data.resize(size_t(std::min<size_t>(FileSize - Read, 4096)));
|
||||
size_t RealDataSize = Data.size();
|
||||
stream.read(Data.data(), std::streamsize(Data.size()));
|
||||
if (stream.eof() || stream.fail()) {
|
||||
RealDataSize = size_t(stream.gcount());
|
||||
}
|
||||
Data.resize(RealDataSize);
|
||||
if (RealDataSize == 0) {
|
||||
break;
|
||||
}
|
||||
if (RealDataSize > 0 && !EVP_DigestUpdate(mdctx, Data.data(), Data.size())) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestUpdate() failed");
|
||||
}
|
||||
Read += RealDataSize;
|
||||
}
|
||||
unsigned int sha256_len = 0;
|
||||
if (!EVP_DigestFinal_ex(mdctx, sha256_value, &sha256_len)) {
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
throw std::runtime_error("EVP_DigestFinal_ex() failed");
|
||||
}
|
||||
EVP_MD_CTX_free(mdctx);
|
||||
|
||||
std::string result;
|
||||
for (size_t i = 0; i < sha256_len; i++) {
|
||||
char buf[3];
|
||||
sprintf(buf, "%02x", sha256_value[i]);
|
||||
buf[2] = 0;
|
||||
result += buf;
|
||||
}
|
||||
return result;
|
||||
} catch (const std::exception& e) {
|
||||
error("Sha256 hashing of '" + filename + "' failed: " + e.what());
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
struct ModInfo {
|
||||
static std::pair<bool, std::vector<ModInfo>> ParseModInfosFromPacket(const std::string& packet) {
|
||||
bool success = false;
|
||||
@ -318,11 +377,6 @@ struct ModInfo {
|
||||
.Hash = entry["hash"],
|
||||
.HashAlgorithm = entry["hash_algorithm"],
|
||||
};
|
||||
|
||||
if (entry.contains("protected")) {
|
||||
modInfo.Protected = entry["protected"];
|
||||
}
|
||||
|
||||
modInfos.push_back(modInfo);
|
||||
success = true;
|
||||
}
|
||||
@ -336,14 +390,13 @@ struct ModInfo {
|
||||
size_t FileSize;
|
||||
std::string Hash;
|
||||
std::string HashAlgorithm;
|
||||
bool Protected = false;
|
||||
};
|
||||
|
||||
nlohmann::json modUsage = {};
|
||||
|
||||
void UpdateModUsage(const std::string& fileName) {
|
||||
try {
|
||||
fs::path usageFile = CachingDirectory / "mods.json";
|
||||
fs::path usageFile = fs::path(CachingDirectory) / "mods.json";
|
||||
|
||||
if (!fs::exists(usageFile)) {
|
||||
if (std::ofstream file(usageFile); !file.is_open()) {
|
||||
@ -361,7 +414,7 @@ void UpdateModUsage(const std::string& fileName) {
|
||||
}
|
||||
|
||||
if (modUsage.empty()) {
|
||||
auto Size = fs::file_size(CachingDirectory / "mods.json");
|
||||
auto Size = fs::file_size(fs::path(CachingDirectory) / "mods.json");
|
||||
std::string modsJson(Size, 0);
|
||||
file.read(&modsJson[0], Size);
|
||||
|
||||
@ -413,45 +466,22 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
|
||||
info("Syncing...");
|
||||
|
||||
std::vector<std::pair<std::string, std::filesystem::path>> CachedMods = {};
|
||||
if (deleteDuplicateMods) {
|
||||
for (const auto& entry : fs::directory_iterator(CachingDirectory)) {
|
||||
const std::string filename = entry.path().filename().string();
|
||||
if (entry.is_regular_file() && entry.path().extension() == ".zip" && filename.length() > 10) {
|
||||
CachedMods.push_back(std::make_pair(filename.substr(0, filename.length() - 13) + ".zip", entry.path()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int ModNo = 0;
|
||||
int ModNo = 1;
|
||||
int TotalMods = ModInfos.size();
|
||||
for (auto ModInfoIter = ModInfos.begin(), AlsoModInfoIter = ModInfos.begin(); ModInfoIter != ModInfos.end() && !Terminate; ++ModInfoIter, ++AlsoModInfoIter) {
|
||||
++ModNo;
|
||||
if (deleteDuplicateMods) {
|
||||
for (auto& CachedMod : CachedMods) {
|
||||
const bool cachedModExists = CachedMod.first == ModInfoIter->FileName;
|
||||
const bool cachedModIsNotNewestVersion = CachedMod.second.stem().string() + ".zip" != std::filesystem::path(ModInfoIter->FileName).stem().string() + "-" + ModInfoIter->Hash.substr(0, 8) + ".zip";
|
||||
if (cachedModExists && cachedModIsNotNewestVersion) {
|
||||
debug("Found duplicate mod '" + CachedMod.second.stem().string() + ".zip" + "' in cache, removing it");
|
||||
std::filesystem::remove(CachedMod.second);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ModInfoIter->Hash.length() < 8 || ModInfoIter->HashAlgorithm != "sha256") {
|
||||
error("Unsupported hash algorithm or invalid hash for '" + ModInfoIter->FileName + "'");
|
||||
Terminate = true;
|
||||
return;
|
||||
}
|
||||
auto FileName = std::filesystem::path(ModInfoIter->FileName).stem().string() + "-" + ModInfoIter->Hash.substr(0, 8) + std::filesystem::path(ModInfoIter->FileName).extension().string();
|
||||
auto PathToSaveTo = (CachingDirectory / FileName);
|
||||
if (fs::exists(PathToSaveTo) && Utils::GetSha256HashReallyFast(PathToSaveTo) == ModInfoIter->Hash) {
|
||||
auto PathToSaveTo = (fs::path(CachingDirectory) / FileName).string();
|
||||
if (fs::exists(PathToSaveTo) && GetSha256HashReallyFast(PathToSaveTo) == ModInfoIter->Hash) {
|
||||
debug("Mod '" + FileName + "' found in cache");
|
||||
UpdateUl(false, std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + ModInfoIter->FileName);
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
try {
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
auto modname = ModInfoIter->FileName;
|
||||
#if defined(__linux__)
|
||||
@ -475,16 +505,15 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
}
|
||||
WaitForConfirm();
|
||||
continue;
|
||||
} else if (auto OldCachedPath = CachingDirectory / std::filesystem::path(ModInfoIter->FileName).filename();
|
||||
fs::exists(OldCachedPath) && Utils::GetSha256HashReallyFast(OldCachedPath) == ModInfoIter->Hash) {
|
||||
} else if (auto OldCachedPath = fs::path(CachingDirectory) / std::filesystem::path(ModInfoIter->FileName).filename();
|
||||
fs::exists(OldCachedPath) && GetSha256HashReallyFast(OldCachedPath.string()) == ModInfoIter->Hash) {
|
||||
debug("Mod '" + FileName + "' found in old cache, copying it to the new cache");
|
||||
UpdateUl(false, std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + ModInfoIter->FileName);
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
try {
|
||||
fs::copy_file(OldCachedPath, PathToSaveTo, fs::copy_options::overwrite_existing);
|
||||
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
|
||||
auto modname = ModInfoIter->FileName;
|
||||
@ -512,20 +541,10 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
WaitForConfirm();
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ModInfoIter->Protected) {
|
||||
std::string message = "Mod '" + ModInfoIter->FileName + "' is protected and therefore must be placed in the Resources/Caching folder manually here: " + absolute(CachingDirectory).string();
|
||||
|
||||
error(message);
|
||||
UUl(message);
|
||||
Terminate = true;
|
||||
return;
|
||||
}
|
||||
|
||||
CheckForDir();
|
||||
std::string FName = ModInfoIter->FileName;
|
||||
do {
|
||||
debug(beammp_wide("Loading file '") + Utils::ToWString(FName) + beammp_wide("' to '") + beammp_fs_string(PathToSaveTo) + beammp_wide("'"));
|
||||
debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
|
||||
TCPSend("f" + ModInfoIter->FileName, Sock);
|
||||
|
||||
std::string Data = TCPRcv(Sock);
|
||||
@ -535,13 +554,6 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
break;
|
||||
}
|
||||
|
||||
if (Data != "AG") {
|
||||
UUl("Received corrupted download confirmation, aborting download.");
|
||||
debug("Corrupted download confirmation: " + Data);
|
||||
Terminate = true;
|
||||
break;
|
||||
}
|
||||
|
||||
std::string Name = std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + FName;
|
||||
|
||||
std::vector<char> DownloadedFile = SingleNormalDownload(Sock, ModInfoIter->FileSize, Name);
|
||||
@ -556,20 +568,15 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
OutFile.write(DownloadedFile.data(), DownloadedFile.size());
|
||||
OutFile.flush();
|
||||
}
|
||||
// 2. verify size and hash
|
||||
// 2. verify size
|
||||
if (std::filesystem::file_size(PathToSaveTo) != DownloadedFile.size()) {
|
||||
error(beammp_wide("Failed to write the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (file size mismatch)"));
|
||||
Terminate = true;
|
||||
}
|
||||
|
||||
if (Utils::GetSha256HashReallyFast(PathToSaveTo) != ModInfoIter->Hash) {
|
||||
error(beammp_wide("Failed to write or download the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (hash mismatch)"));
|
||||
error("Failed to write the entire file '" + PathToSaveTo + "' correctly (file size mismatch)");
|
||||
Terminate = true;
|
||||
}
|
||||
} while (fs::file_size(PathToSaveTo) != ModInfoIter->FileSize && !Terminate);
|
||||
if (!Terminate) {
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
|
||||
// Linux version of the game doesnt support uppercase letters in mod names
|
||||
@ -583,6 +590,7 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
|
||||
UpdateModUsage(FName);
|
||||
}
|
||||
WaitForConfirm();
|
||||
++ModNo;
|
||||
}
|
||||
|
||||
if (!Terminate) {
|
||||
@ -626,8 +634,7 @@ void SyncResources(SOCKET Sock) {
|
||||
Ret.clear();
|
||||
|
||||
int Amount = 0, Pos = 0;
|
||||
std::filesystem::path PathToSaveTo;
|
||||
std::string t;
|
||||
std::string PathToSaveTo, t;
|
||||
for (const std::string& name : FNames) {
|
||||
if (!name.empty()) {
|
||||
t += name.substr(name.find_last_of('/') + 1) + ";";
|
||||
@ -655,7 +662,7 @@ void SyncResources(SOCKET Sock) {
|
||||
for (auto FN = FNames.begin(), FS = FSizes.begin(); FN != FNames.end() && !Terminate; ++FN, ++FS) {
|
||||
auto pos = FN->find_last_of('/');
|
||||
if (pos != std::string::npos) {
|
||||
PathToSaveTo = CachingDirectory / std::filesystem::path(*FN).filename();
|
||||
PathToSaveTo = CachingDirectory + FN->substr(pos);
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
@ -665,22 +672,21 @@ void SyncResources(SOCKET Sock) {
|
||||
if (FS->find_first_not_of("0123456789") != std::string::npos)
|
||||
continue;
|
||||
if (fs::file_size(PathToSaveTo) == FileSize) {
|
||||
UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + PathToSaveTo.filename().string());
|
||||
UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + PathToSaveTo.substr(PathToSaveTo.find_last_of('/')));
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
try {
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
auto modname = PathToSaveTo.filename().string();
|
||||
auto modname = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
|
||||
#if defined(__linux__)
|
||||
// Linux version of the game doesnt support uppercase letters in mod names
|
||||
for (char& c : modname) {
|
||||
c = ::tolower(c);
|
||||
}
|
||||
#endif
|
||||
auto name = GetGamePath() / beammp_wide("mods/multiplayer") / Utils::ToWString(modname);
|
||||
auto tmp_name = name;
|
||||
tmp_name += L".tmp";
|
||||
auto name = GetGamePath() + "mods/multiplayer" + modname;
|
||||
auto tmp_name = name + ".tmp";
|
||||
fs::copy_file(PathToSaveTo, tmp_name, fs::copy_options::overwrite_existing);
|
||||
fs::rename(tmp_name, name);
|
||||
UpdateModUsage(modname);
|
||||
@ -692,12 +698,12 @@ void SyncResources(SOCKET Sock) {
|
||||
WaitForConfirm();
|
||||
continue;
|
||||
} else
|
||||
fs::remove(PathToSaveTo.wstring());
|
||||
remove(PathToSaveTo.c_str());
|
||||
}
|
||||
CheckForDir();
|
||||
std::string FName = PathToSaveTo.filename().string();
|
||||
std::string FName = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
|
||||
do {
|
||||
debug("Loading file '" + FName + "' to '" + PathToSaveTo.string() + "'");
|
||||
debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
|
||||
TCPSend("f" + *FN, Sock);
|
||||
|
||||
std::string Data = TCPRcv(Sock);
|
||||
@ -722,13 +728,13 @@ void SyncResources(SOCKET Sock) {
|
||||
}
|
||||
// 2. verify size
|
||||
if (std::filesystem::file_size(PathToSaveTo) != DownloadedFile.size()) {
|
||||
error(beammp_wide("Failed to write the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (file size mismatch)"));
|
||||
error("Failed to write the entire file '" + PathToSaveTo + "' correctly (file size mismatch)");
|
||||
Terminate = true;
|
||||
}
|
||||
} while (fs::file_size(PathToSaveTo) != std::stoull(*FS) && !Terminate);
|
||||
if (!Terminate) {
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
|
||||
// Linux version of the game doesnt support uppercase letters in mod names
|
||||
@ -738,7 +744,7 @@ void SyncResources(SOCKET Sock) {
|
||||
}
|
||||
#endif
|
||||
|
||||
fs::copy_file(PathToSaveTo, GetGamePath() / beammp_wide("mods/multiplayer") / Utils::ToWString(FName), fs::copy_options::overwrite_existing);
|
||||
fs::copy_file(PathToSaveTo, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
|
||||
UpdateModUsage(FN->substr(pos));
|
||||
}
|
||||
WaitForConfirm();
|
||||
|
||||
@ -81,8 +81,7 @@ std::string TCPRcv(SOCKET Sock) {
|
||||
UUl("Invalid Socket");
|
||||
return "";
|
||||
}
|
||||
int32_t Header;
|
||||
int Temp;
|
||||
int32_t Header, Temp;
|
||||
std::vector<char> Data(sizeof(Header));
|
||||
Temp = recv(Sock, Data.data(), sizeof(Header), MSG_WAITALL);
|
||||
if (!CheckBytes(Temp)) {
|
||||
|
||||
@ -86,12 +86,6 @@ void InitOptions(int argc, const char *argv[], Options &options) {
|
||||
options.no_download = true;
|
||||
options.no_launch = true;
|
||||
options.no_update = true;
|
||||
} else if (argument == "--user-path") {
|
||||
if (i + 1 >= argc) {
|
||||
error("You must specify a path after the `--user-path` argument");
|
||||
}
|
||||
options.user_path = argv[i + 1];
|
||||
i++;
|
||||
} else if (argument == "--" || argument == "--game") {
|
||||
options.game_arguments = &argv[i + 1];
|
||||
options.game_arguments_length = argc - i - 1;
|
||||
@ -107,7 +101,6 @@ void InitOptions(int argc, const char *argv[], Options &options) {
|
||||
"\t--no-update Skip applying launcher updates (you must update manually)\n"
|
||||
"\t--no-launch Skip launching the game (you must launch the game manually)\n"
|
||||
"\t--dev Developer mode, same as --verbose --no-download --no-launch --no-update\n"
|
||||
"\t--user-path <path> Path to BeamNG's User Path\n"
|
||||
"\t--game <args...> Passes ALL following arguments to the game, see also `--`\n"
|
||||
<< std::flush;
|
||||
exit(0);
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
|
||||
#include <filesystem>
|
||||
#if defined(_WIN32)
|
||||
#include <windows.h>
|
||||
#elif defined(__linux__)
|
||||
#include "vdf_parser.hpp"
|
||||
#include <pwd.h>
|
||||
@ -14,8 +15,6 @@
|
||||
#include <vector>
|
||||
#endif
|
||||
#include "Logger.h"
|
||||
#include "Utils.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
@ -24,7 +23,7 @@
|
||||
#define MAX_VALUE_NAME 16383
|
||||
|
||||
int TraceBack = 0;
|
||||
beammp_fs_string GameDir;
|
||||
std::string GameDir;
|
||||
|
||||
void lowExit(int code) {
|
||||
TraceBack = 0;
|
||||
@ -34,7 +33,7 @@ void lowExit(int code) {
|
||||
exit(2);
|
||||
}
|
||||
|
||||
beammp_fs_string GetGameDir() {
|
||||
std::string GetGameDir() {
|
||||
#if defined(_WIN32)
|
||||
return GameDir.substr(0, GameDir.find_last_of('\\'));
|
||||
#elif defined(__linux__)
|
||||
@ -45,8 +44,8 @@ beammp_fs_string GetGameDir() {
|
||||
LONG OpenKey(HKEY root, const char* path, PHKEY hKey) {
|
||||
return RegOpenKeyEx(root, reinterpret_cast<LPCSTR>(path), 0, KEY_READ, hKey);
|
||||
}
|
||||
std::wstring QueryKey(HKEY hKey, int ID) {
|
||||
wchar_t* achKey; // buffer for subkey name
|
||||
std::string QueryKey(HKEY hKey, int ID) {
|
||||
TCHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name
|
||||
DWORD cbName; // size of name string
|
||||
TCHAR achClass[MAX_PATH] = TEXT(""); // buffer for class name
|
||||
DWORD cchClassName = MAX_PATH; // size of class string
|
||||
@ -61,7 +60,7 @@ std::wstring QueryKey(HKEY hKey, int ID) {
|
||||
|
||||
DWORD i, retCode;
|
||||
|
||||
wchar_t* achValue = new wchar_t[MAX_VALUE_NAME];
|
||||
TCHAR achValue[MAX_VALUE_NAME];
|
||||
DWORD cchValue = MAX_VALUE_NAME;
|
||||
|
||||
retCode = RegQueryInfoKey(
|
||||
@ -83,9 +82,9 @@ std::wstring QueryKey(HKEY hKey, int ID) {
|
||||
if (cSubKeys) {
|
||||
for (i = 0; i < cSubKeys; i++) {
|
||||
cbName = MAX_KEY_LENGTH;
|
||||
retCode = RegEnumKeyExW(hKey, i, achKey, &cbName, nullptr, nullptr, nullptr, &ftLastWriteTime);
|
||||
retCode = RegEnumKeyEx(hKey, i, achKey, &cbName, nullptr, nullptr, nullptr, &ftLastWriteTime);
|
||||
if (retCode == ERROR_SUCCESS) {
|
||||
if (wcscmp(achKey, L"Steam App 284160") == 0) {
|
||||
if (strcmp(achKey, "Steam App 284160") == 0) {
|
||||
return achKey;
|
||||
}
|
||||
}
|
||||
@ -95,37 +94,36 @@ std::wstring QueryKey(HKEY hKey, int ID) {
|
||||
for (i = 0, retCode = ERROR_SUCCESS; i < cValues; i++) {
|
||||
cchValue = MAX_VALUE_NAME;
|
||||
achValue[0] = '\0';
|
||||
retCode = RegEnumValueW(hKey, i, achValue, &cchValue, nullptr, nullptr, nullptr, nullptr);
|
||||
retCode = RegEnumValue(hKey, i, achValue, &cchValue, nullptr, nullptr, nullptr, nullptr);
|
||||
if (retCode == ERROR_SUCCESS) {
|
||||
DWORD lpData = cbMaxValueData;
|
||||
buffer[0] = '\0';
|
||||
LONG dwRes = RegQueryValueExW(hKey, achValue, nullptr, nullptr, buffer, &lpData);
|
||||
std::wstring data = (wchar_t*)(buffer);
|
||||
std::wstring key = achValue;
|
||||
|
||||
LONG dwRes = RegQueryValueEx(hKey, achValue, nullptr, nullptr, buffer, &lpData);
|
||||
std::string data = (char*)(buffer);
|
||||
std::string key = achValue;
|
||||
|
||||
switch (ID) {
|
||||
case 1:
|
||||
if (key == L"SteamExe") {
|
||||
auto p = data.find_last_of(L"/\\");
|
||||
if (key == "SteamExe") {
|
||||
auto p = data.find_last_of("/\\");
|
||||
if (p != std::string::npos) {
|
||||
return data.substr(0, p);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (key == L"Name" && data == L"BeamNG.drive")
|
||||
if (key == "Name" && data == "BeamNG.drive")
|
||||
return data;
|
||||
break;
|
||||
case 3:
|
||||
if (key == L"rootpath")
|
||||
if (key == "rootpath")
|
||||
return data;
|
||||
break;
|
||||
case 4:
|
||||
if (key == L"userpath_override")
|
||||
if (key == "userpath_override")
|
||||
return data;
|
||||
case 5:
|
||||
if (key == L"Local AppData")
|
||||
if (key == "Local AppData")
|
||||
return data;
|
||||
default:
|
||||
break;
|
||||
@ -133,9 +131,8 @@ std::wstring QueryKey(HKEY hKey, int ID) {
|
||||
}
|
||||
}
|
||||
}
|
||||
delete[] achValue;
|
||||
delete[] buffer;
|
||||
return L"";
|
||||
return "";
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -162,7 +159,7 @@ void FileList(std::vector<std::string>& a, const std::string& Path) {
|
||||
}
|
||||
void LegitimacyCheck() {
|
||||
#if defined(_WIN32)
|
||||
std::wstring Result;
|
||||
std::string Result;
|
||||
std::string K3 = R"(Software\BeamNG\BeamNG.drive)";
|
||||
HKEY hKey;
|
||||
LONG dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K3.c_str(), &hKey);
|
||||
@ -232,9 +229,12 @@ void LegitimacyCheck() {
|
||||
}
|
||||
#endif
|
||||
}
|
||||
std::string CheckVer(const std::filesystem::path& dir) {
|
||||
std::string temp;
|
||||
std::filesystem::path Path = dir / beammp_wide("integrity.json");
|
||||
std::string CheckVer(const std::string& dir) {
|
||||
#if defined(_WIN32)
|
||||
std::string temp, Path = dir + "\\integrity.json";
|
||||
#elif defined(__linux__)
|
||||
std::string temp, Path = dir + "/integrity.json";
|
||||
#endif
|
||||
std::ifstream f(Path.c_str(), std::ios::binary);
|
||||
int Size = int(std::filesystem::file_size(Path));
|
||||
std::string vec(Size, 0);
|
||||
|
||||
@ -12,20 +12,20 @@
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <string>
|
||||
#if defined(_WIN32)
|
||||
#include <windows.h>
|
||||
#elif defined(__linux__)
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include "Http.h"
|
||||
#include "Logger.h"
|
||||
#include "Network/network.hpp"
|
||||
#include "Options.h"
|
||||
#include "Security/Init.h"
|
||||
#include "Startup.h"
|
||||
#include "Utils.h"
|
||||
#include "hashpp.h"
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <thread>
|
||||
#include "Options.h"
|
||||
|
||||
extern int TraceBack;
|
||||
int ProxyPort = 0;
|
||||
@ -72,49 +72,49 @@ Version::Version(const std::array<uint8_t, 3>& v)
|
||||
: Version(v[0], v[1], v[2]) {
|
||||
}
|
||||
|
||||
beammp_fs_string GetEN() {
|
||||
std::string GetEN() {
|
||||
#if defined(_WIN32)
|
||||
return L"BeamMP-Launcher.exe";
|
||||
return "BeamMP-Launcher.exe";
|
||||
#elif defined(__linux__)
|
||||
return "BeamMP-Launcher";
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string GetVer() {
|
||||
return "2.5";
|
||||
return "2.4";
|
||||
}
|
||||
std::string GetPatch() {
|
||||
return ".0";
|
||||
}
|
||||
|
||||
beammp_fs_string GetEP(const beammp_fs_char* P) {
|
||||
static beammp_fs_string Ret = [&]() {
|
||||
beammp_fs_string path(P);
|
||||
return path.substr(0, path.find_last_of(beammp_wide("\\/")) + 1);
|
||||
std::string GetEP(const char* P) {
|
||||
static std::string Ret = [&]() {
|
||||
std::string path(P);
|
||||
return path.substr(0, path.find_last_of("\\/") + 1);
|
||||
}();
|
||||
return Ret;
|
||||
}
|
||||
#if defined(_WIN32)
|
||||
void ReLaunch() {
|
||||
std::wstring Arg;
|
||||
std::string Arg;
|
||||
for (int c = 2; c <= options.argc; c++) {
|
||||
Arg += Utils::ToWString(options.argv[c - 1]);
|
||||
Arg += L" ";
|
||||
Arg += options.argv[c - 1];
|
||||
Arg += " ";
|
||||
}
|
||||
info("Relaunch!");
|
||||
system("cls");
|
||||
ShellExecuteW(nullptr, L"runas", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
ShellExecute(nullptr, "runas", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
ShowWindow(GetConsoleWindow(), 0);
|
||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||
exit(1);
|
||||
}
|
||||
void URelaunch() {
|
||||
std::wstring Arg;
|
||||
std::string Arg;
|
||||
for (int c = 2; c <= options.argc; c++) {
|
||||
Arg += Utils::ToWString(options.argv[c - 1]);
|
||||
Arg += L" ";
|
||||
Arg += options.argv[c - 1];
|
||||
Arg += " ";
|
||||
}
|
||||
ShellExecuteW(nullptr, L"open", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
ShellExecute(nullptr, "open", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
ShowWindow(GetConsoleWindow(), 0);
|
||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||
exit(1);
|
||||
@ -149,16 +149,16 @@ void URelaunch() {
|
||||
|
||||
void CheckName() {
|
||||
#if defined(_WIN32)
|
||||
std::wstring DN = GetEN(), CDir = Utils::ToWString(options.executable_name), FN = CDir.substr(CDir.find_last_of('\\') + 1);
|
||||
std::string DN = GetEN(), CDir = options.executable_name, FN = CDir.substr(CDir.find_last_of('\\') + 1);
|
||||
#elif defined(__linux__)
|
||||
std::string DN = GetEN(), CDir = options.executable_name, FN = CDir.substr(CDir.find_last_of('/') + 1);
|
||||
#endif
|
||||
if (FN != DN) {
|
||||
if (fs::exists(DN))
|
||||
fs::remove(DN.c_str());
|
||||
remove(DN.c_str());
|
||||
if (fs::exists(DN))
|
||||
ReLaunch();
|
||||
fs::rename(FN.c_str(), DN.c_str());
|
||||
std::rename(FN.c_str(), DN.c_str());
|
||||
URelaunch();
|
||||
}
|
||||
}
|
||||
@ -169,9 +169,9 @@ void CheckForUpdates(const std::string& CV) {
|
||||
"https://backend.beammp.com/version/launcher?branch=" + Branch + "&pk=" + PublicKey);
|
||||
|
||||
transform(LatestHash.begin(), LatestHash.end(), LatestHash.begin(), ::tolower);
|
||||
beammp_fs_string EP(GetEP() + GetEN()), Back(GetEP() + beammp_wide("BeamMP-Launcher.back"));
|
||||
std::string EP(GetEP() + GetEN()), Back(GetEP() + "BeamMP-Launcher.back");
|
||||
|
||||
std::string FileHash = Utils::GetSha256HashReallyFast(EP);
|
||||
std::string FileHash = hashpp::get::getFileHash(hashpp::ALGORITHMS::SHA2_256, EP);
|
||||
|
||||
if (FileHash != LatestHash && IsOutdated(Version(VersionStrToInts(GetVer() + GetPatch())), Version(VersionStrToInts(LatestVersion)))) {
|
||||
if (!options.no_update) {
|
||||
@ -251,7 +251,7 @@ size_t DirCount(const std::filesystem::path& path) {
|
||||
return (size_t)std::distance(std::filesystem::directory_iterator { path }, std::filesystem::directory_iterator {});
|
||||
}
|
||||
|
||||
void CheckMP(const beammp_fs_string& Path) {
|
||||
void CheckMP(const std::string& Path) {
|
||||
if (!fs::exists(Path))
|
||||
return;
|
||||
size_t c = DirCount(fs::path(Path));
|
||||
@ -271,7 +271,7 @@ void CheckMP(const beammp_fs_string& Path) {
|
||||
}
|
||||
|
||||
void EnableMP() {
|
||||
beammp_fs_string File(GetGamePath() / beammp_wide("mods/db.json"));
|
||||
std::string File(GetGamePath() + "mods/db.json");
|
||||
if (!fs::exists(File))
|
||||
return;
|
||||
auto Size = fs::file_size(File);
|
||||
@ -294,18 +294,18 @@ void EnableMP() {
|
||||
ofs << d.dump();
|
||||
ofs.close();
|
||||
} else {
|
||||
error(beammp_wide("Failed to write ") + File);
|
||||
error("Failed to write " + File);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PreGame(const beammp_fs_string& GamePath) {
|
||||
void PreGame(const std::string& GamePath) {
|
||||
std::string GameVer = CheckVer(GamePath);
|
||||
info("Game Version : " + GameVer);
|
||||
|
||||
CheckMP(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
info(beammp_wide("Game user path: ") + beammp_fs_string(GetGamePath()));
|
||||
CheckMP(GetGamePath() + "mods/multiplayer");
|
||||
info("Game user path: " + GetGamePath());
|
||||
|
||||
if (!options.no_download) {
|
||||
std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/mod?branch=" + Branch + "&pk=" + PublicKey);
|
||||
@ -315,21 +315,21 @@ void PreGame(const beammp_fs_string& GamePath) {
|
||||
LatestHash.end());
|
||||
|
||||
try {
|
||||
if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
|
||||
fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
|
||||
if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
|
||||
fs::create_directories(GetGamePath() + "mods/multiplayer");
|
||||
}
|
||||
EnableMP();
|
||||
} catch (std::exception& e) {
|
||||
fatal(e.what());
|
||||
}
|
||||
#if defined(_WIN32)
|
||||
std::wstring ZipPath(GetGamePath() / LR"(mods\multiplayer\BeamMP.zip)");
|
||||
std::string ZipPath(GetGamePath() + R"(mods\multiplayer\BeamMP.zip)");
|
||||
#elif defined(__linux__)
|
||||
// Linux version of the game cant handle mods with uppercase names
|
||||
std::string ZipPath(GetGamePath() / R"(mods/multiplayer/beammp.zip)");
|
||||
std::string ZipPath(GetGamePath() + R"(mods/multiplayer/beammp.zip)");
|
||||
#endif
|
||||
|
||||
std::string FileHash = fs::exists(ZipPath) ? Utils::GetSha256HashReallyFast(ZipPath) : "";
|
||||
std::string FileHash = hashpp::get::getFileHash(hashpp::ALGORITHMS::SHA2_256, ZipPath);
|
||||
|
||||
if (FileHash != LatestHash) {
|
||||
info("Downloading BeamMP Update " + LatestHash);
|
||||
@ -339,9 +339,9 @@ void PreGame(const beammp_fs_string& GamePath) {
|
||||
ZipPath);
|
||||
}
|
||||
|
||||
beammp_fs_string Target(GetGamePath() / beammp_wide("mods/unpacked/beammp"));
|
||||
std::string Target(GetGamePath() + "mods/unpacked/beammp");
|
||||
|
||||
if (fs::is_directory(Target) && !fs::is_directory(Target + beammp_wide("/.git"))) {
|
||||
if (fs::is_directory(Target)) {
|
||||
fs::remove_all(Target);
|
||||
}
|
||||
}
|
||||
|
||||
@ -9,7 +9,6 @@
|
||||
#include "Network/network.hpp"
|
||||
#include "Security/Init.h"
|
||||
#include "Startup.h"
|
||||
#include "Utils.h"
|
||||
#include <curl/curl.h>
|
||||
#include <iostream>
|
||||
#include <thread>
|
||||
@ -38,7 +37,7 @@ int main(int argc, const char** argv) try {
|
||||
|
||||
curl_global_init(CURL_GLOBAL_ALL);
|
||||
|
||||
GetEP(Utils::ToWString(std::string(argv[0])).c_str());
|
||||
GetEP(argv[0]);
|
||||
|
||||
InitLog();
|
||||
ConfigInit();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user