Removal invalid comma causing the default config to be broken (#123)

also moved cls/clear to the beginning, idk wtf it was doing in there.

.github/workflows/cmake-linux.yml

@@ -36,7 +36,7 @@ jobs:
         run: cmake --build . --config $BUILD_TYPE
 
       - name: Archive artifacts
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: BeamMP-Launcher
           path: ${{github.workspace}}/build-linux/BeamMP-Launcher

.github/workflows/cmake-windows.yml

@@ -37,7 +37,7 @@ jobs:
         run: cmake --build . --config $BUILD_TYPE
 
       - name: Archive artifacts
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: BeamMP-Launcher.exe
           path: ${{github.workspace}}/build-windows/Release/BeamMP-Launcher.exe

.github/workflows/release-build.yml

@@ -1,104 +0,0 @@
-name: Release Create & Build
-on:
-  push:
-    # Sequence of patterns matched against refs/tags
-    tags:
-    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  create-release:
-    runs-on: ubuntu-latest
-    name: Create Release
-    outputs: 
-      upload_url: ${{ steps.create_release.outputs.upload_url }} 
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false 
-          body: |
-              Files included in this release:
-              - `BeamMP-Launcher.exe` windows build
-              - `BeamMP-Launcher` linux build
-
-  upload-release-files-windows:
-    name: Upload Windows Release Files
-    runs-on: windows-latest
-    needs: create-release
-    steps:
-      - uses: actions/checkout@v2
-        with:
-            submodules: 'true'
-      
-      - name: Restore artifacts, or run vcpkg, build and cache artifacts
-        uses: lukka/run-vcpkg@main
-        id: runvcpkg
-        with:
-            vcpkgArguments: 'discord-rpc zlib nlohmann-json openssl cpp-httplib[openssl]'
-            vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-            vcpkgGitCommitId: '16ee2ecb31788c336ace8bb14c21801efb6836e4'
-            vcpkgTriplet: 'x64-windows-static'
-
-      - name: Create Build Environment
-        run: cmake -E make_directory ${{github.workspace}}/build-windows
-
-      - name: Configure CMake
-        shell: bash
-        working-directory: ${{github.workspace}}/build-windows
-        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_TOOLCHAIN_FILE='${{ runner.workspace }}/b/vcpkg/scripts/buildsystems/vcpkg.cmake' -DVCPKG_TARGET_TRIPLET=x64-windows-static
-
-      - name: Build
-        working-directory: ${{github.workspace}}/build-windows
-        shell: bash
-        run: cmake --build . --config $BUILD_TYPE
-
-      - name: Upload Release Asset
-        id: upload-release-asset 
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.create-release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
-          asset_path: ${{github.workspace}}/build-windows/Release/BeamMP-Launcher.exe
-          asset_name: BeamMP-Launcher.exe
-          asset_content_type: application/vnd.microsoft.portable-executable
-
-  upload-release-files-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-            submodules: 'true'
-
-      - name: Create Build Environment
-        run: cmake -E make_directory ${{github.workspace}}/build-linux
-
-      - name: Configure CMake
-        shell: bash
-        working-directory: ${{github.workspace}}/build-linux
-        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
-
-      - name: Build
-        working-directory: ${{github.workspace}}/build-linux
-        shell: bash
-        run: cmake --build . --config $BUILD_TYPE
-        
-      - name: Upload Release Asset
-        id: upload-release-asset 
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.create-release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
-          asset_path: ${{github.workspace}}/build-linux/BeamMP-Launcher
-          asset_name: BeamMP-Launcher
-          asset_content_type: application/octet-stream

CMakeLists.txt

@@ -12,6 +12,8 @@ set(CMAKE_CXX_STANDARD 20)
 
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
 
+add_compile_definitions(CPPHTTPLIB_OPENSSL_SUPPORT)
+
 file(GLOB source_files "src/*.cpp" "src/*/*.cpp" "src/*/*.hpp" "include/*.h"  "include/*/*.h" "include/*/*/*.h" "include/*.hpp"  "include/*/*.hpp" "include/*/*/*.hpp")
 find_package(httplib CONFIG REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)

README.md

@@ -2,11 +2,24 @@
 
 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.
 
-## How to build
+**To clone this repository**: `git clone --recurse-submodules https://github.com/BeamMP/BeamMP-Launcher.git`
 
+## How to build - 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. 
+
+## How to build - 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. 
+
 Copyright (c) 2019-present Anonymous275.
 BeamMP Launcher code is not in the public domain and is not free software.
 One must be granted explicit permission by the copyright holder in order to modify or distribute any part of the source or binaries,

include/Http.h

@@ -14,7 +14,8 @@ public:
     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);
-
+    static void StartProxy();
 public:
     static bool isDownload;
-};
+    static inline bool SkipSslVerify = false;
+};

include/Network/network.hpp

@@ -30,25 +30,27 @@ extern int DEFAULT_PORT;
 extern uint64_t UDPSock;
 extern uint64_t TCPSock;
 extern std::string Branch;
+extern std::string CachingDirectory;
 extern bool TCPTerminate;
 extern std::string LastIP;
 extern std::string MStatus;
 extern std::string UlStatus;
 extern std::string PublicKey;
 extern std::string PrivateKey;
-extern std::string ListOfMods;
 int KillSocket(uint64_t Dead);
 void UUl(const std::string& R);
 void UDPSend(std::string Data);
 bool CheckBytes(int32_t Bytes);
-void GameSend(std::string Data);
+void GameSend(std::string_view Data);
 void SendLarge(std::string Data);
 std::string TCPRcv(uint64_t Sock);
 void SyncResources(uint64_t TCPSock);
 std::string GetAddr(const std::string& IP);
-void ServerParser(const std::string& Data);
+void ServerParser(std::string_view Data);
 std::string Login(const std::string& fields);
 void TCPSend(const std::string& Data, uint64_t Sock);
 void TCPClientMain(const std::string& IP, int Port);
 void UDPClientMain(const std::string& IP, int Port);
 void TCPGameServer(const std::string& IP, int Port);
+bool SecurityWarning();
+void CoreSend(std::string data);

include/Startup.h

@@ -14,15 +14,8 @@ void InitLauncher(int argc, char* argv[]);
 std::string GetEP(char* P = nullptr);
 std::string GetGamePath();
 std::string GetVer();
+std::string GetPatch();
 std::string GetEN();
-void StartProxy();
 void ConfigInit();
 extern bool Dev;
 
-struct VersionParser {
-    explicit VersionParser(const std::string& from_string);
-    std::strong_ordering operator<=>(VersionParser const& rhs) const noexcept;
-    bool operator==(VersionParser const& rhs) const noexcept;
-    std::vector<std::string> split;
-    std::vector<size_t> data;
-};

include/Utils.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <string>
+#include <vector>
+
+namespace Utils {
+    inline std::vector<std::string> Split(const std::string& String, const std::string& delimiter) {
+        std::vector<std::string> Val;
+        size_t pos;
+        std::string token, s = String;
+        while ((pos = s.find(delimiter)) != std::string::npos) {
+            token = s.substr(0, pos);
+            if (!token.empty())
+                Val.push_back(token);
+            s.erase(0, pos + delimiter.length());
+        }
+        if (!s.empty())
+            Val.push_back(s);
+        return Val;
+    };
+};

include/Zlib/Compressor.h

@@ -9,5 +9,5 @@
 #include <span>
 #include <vector>
 
-std::vector<char> Comp(std::span<char> input);
-std::vector<char> DeComp(std::span<char> input);
+std::vector<char> Comp(std::span<const char> input);
+std::vector<char> DeComp(std::span<const char> input);

src/Compressor.cpp

@@ -15,14 +15,14 @@
 #include <cstring>
 #endif
 
-std::vector<char> Comp(std::span<char> input) {
+std::vector<char> Comp(std::span<const char> input) {
     auto max_size = compressBound(input.size());
     std::vector<char> output(max_size);
     uLongf output_size = output.size();
     int res = compress(
         reinterpret_cast<Bytef*>(output.data()),
         &output_size,
-        reinterpret_cast<Bytef*>(input.data()),
+        reinterpret_cast<const Bytef*>(input.data()),
         static_cast<uLongf>(input.size()));
     if (res != Z_OK) {
         error("zlib compress() failed: " + std::to_string(res));
@@ -33,7 +33,7 @@ std::vector<char> Comp(std::span<char> input) {
     return output;
 }
 
-std::vector<char> DeComp(std::span<char> input) {
+std::vector<char> DeComp(std::span<const char> input) {
     std::vector<char> output_buffer(std::min<size_t>(input.size() * 5, 15 * 1024 * 1024));
 
     uLongf output_size = output_buffer.size();

src/Config.cpp

@@ -11,6 +11,8 @@
 namespace fs = std::filesystem;
 
 std::string Branch;
+std::string CachingDirectory = "./Resources";
+
 void ParseConfig(const nlohmann::json& d) {
     if (d["Port"].is_number()) {
         DEFAULT_PORT = d["Port"].get<int>();
@@ -20,12 +22,15 @@ void ParseConfig(const nlohmann::json& d) {
     // EA 2
     // Dev 3
     // Custom 3
-
     if (d["Build"].is_string()) {
         Branch = d["Build"].get<std::string>();
         for (char& c : Branch)
             c = char(tolower(c));
     }
+    if (d.contains("CachingDirectory") && d["CachingDirectory"].is_string()) {
+        CachingDirectory = d["CachingDirectory"].get<std::string>();
+        info("Mod caching directory: " + CachingDirectory);
+    }
 }
 
 void ConfigInit() {
@@ -48,8 +53,9 @@ void ConfigInit() {
         if (cfg.is_open()) {
             cfg <<
                 R"({
-"Port": 4444,
-"Build": "Default"
+    "Port": 4444,
+    "Build": "Default",
+    "CachingDirectory": "./Resources"
 })";
             cfg.close();
         } else {

src/GameStart.cpp

@@ -43,11 +43,17 @@ std::string GetGamePath() {
         sk = R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders)";
         openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
         if (openRes != ERROR_SUCCESS) {
-            fatal("Cannot get Local Appdata directory!");
+            sk = R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders)";
+            openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
         }
+        if (openRes != ERROR_SUCCESS) {
+            fatal("Cannot get Local Appdata directory");
+        }
+
         Path = QueryKey(hKey, 5);
         Path += "\\BeamNG.drive\\";
     }
+
     std::string Ver = CheckVer(GetGameDir());
     Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
     Path += Ver + "\\";
@@ -91,7 +97,7 @@ void StartGame(std::string Dir) {
 #elif defined(__linux__)
 void StartGame(std::string Dir) {
     int status;
-    std::string filename = (Dir + "/BinLinux/BeamNG.drive.x64");
+    std::string filename = (Dir + "/BinLinux/BeamNG.x64");
     char* argv[] = { filename.data(), NULL };
     pid_t pid;
     int result = posix_spawn(&pid, filename.c_str(), NULL, NULL, argv, environ);

src/Logger.cpp

@@ -54,10 +54,10 @@ void info(const std::string& toPrint) {
     addToLog(Print);
 }
 void debug(const std::string& toPrint) {
-    if (!Dev)
-        return;
     std::string Print = getDate() + "[DEBUG] " + toPrint + "\n";
-    std::cout << Print;
+    if (Dev) {
+        std::cout << Print;
+    }
     addToLog(Print);
 }
 void warn(const std::string& toPrint) {
@@ -75,7 +75,7 @@ void fatal(const std::string& toPrint) {
     std::cout << Print;
     addToLog(Print);
     std::this_thread::sleep_for(std::chrono::seconds(5));
-    _Exit(-1);
+    std::exit(1);
 }
 void except(const std::string& toPrint) {
     std::string Print = getDate() + "[EXCEP] " + toPrint + "\n";

src/Network/Core.cpp

@@ -39,10 +39,31 @@ bool Terminate = false;
 bool LoginAuth = false;
 std::string Username = "";
 std::string UserRole = "";
+int UserID = -1;
 std::string UlStatus;
 std::string MStatus;
 bool ModLoaded;
 int ping = -1;
+SOCKET CoreSocket = -1;
+signed char confirmed = -1;
+
+bool SecurityWarning() {
+    confirmed = -1;
+    CoreSend("WMODS_FOUND");
+
+    while (confirmed == -1)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    if (confirmed == 1)
+        return true;
+
+    NetReset();
+    Terminate = true;
+    TCPTerminate = true;
+    ping = -1;
+
+    return false;
+}
 
 void StartSync(const std::string& Data) {
     std::string IP = GetAddr(Data.substr(1, Data.find(':') - 1));
@@ -51,8 +72,8 @@ void StartSync(const std::string& Data) {
             UlStatus = "UlConnection Failed! (DNS Lookup Failed)";
         else
             UlStatus = "UlConnection Failed! (WSA failed to start)";
-        ListOfMods = "-";
         Terminate = true;
+        CoreSend("L");
         return;
     }
     CheckLocalKey();
@@ -66,8 +87,17 @@ void StartSync(const std::string& Data) {
     info("Connecting to server");
 }
 
+void CoreSend(std::string data) {
+    if (CoreSocket != -1) {
+        int res = send(CoreSocket, (data + "\n").c_str(), int(data.size()) + 1, 0);
+        if (res < 0) {
+            debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
+        }
+    }
+}
+
 bool IsAllowedLink(const std::string& Link) {
-    std::regex link_pattern(R"(https:\/\/(?:\w+)?(?:\.)?(?:beammp\.com|discord\.gg))");
+    std::regex link_pattern(R"(https:\/\/(?:\w+)?(?:\.)?(?:beammp\.com|discord\.gg|patreon\.com\/BeamMP))");
     std::smatch link_match;
     return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0;
 }
@@ -87,15 +117,8 @@ void Parse(std::string Data, SOCKET CSocket) {
         Data = Code + HTTP::Get("https://backend.beammp.com/servers-info");
         break;
     case 'C':
-        ListOfMods.clear();
         StartSync(Data);
-        while (ListOfMods.empty() && !Terminate) {
-            std::this_thread::sleep_for(std::chrono::seconds(1));
-        }
-        if (ListOfMods == "-")
-            Data = "L";
-        else
-            Data = "L" + ListOfMods;
+        Data.clear();
         break;
     case 'O': // open default browser with URL
         if (IsAllowedLink(Data.substr(1))) {
@@ -155,8 +178,10 @@ void Parse(std::string Data, SOCKET CSocket) {
             TCPTerminate = true;
             ping = -1;
         }
-        if (SubCode == 'G')
+        if (SubCode == 'G') {
+            debug("Closing via 'G' packet");
             exit(2);
+        }
         Data.clear();
         break;
     case 'R': // will send mod name
@@ -180,11 +205,23 @@ void Parse(std::string Data, SOCKET CSocket) {
             if (!UserRole.empty()) {
                 Auth["role"] = UserRole;
             }
+            if (UserID != -1) {
+                Auth["id"] = UserID;
+            }
             Data = "N" + Auth.dump();
         } else {
             Data = "N" + Login(Data.substr(Data.find(':') + 1));
         }
         break;
+    case 'W':
+        if (SubCode == 'Y') {
+            confirmed = 1;
+        } else if (SubCode == 'N') {
+            confirmed = 0;
+        }
+
+        Data.clear();
+        break;
     default:
         Data.clear();
         break;
@@ -197,7 +234,7 @@ void Parse(std::string Data, SOCKET CSocket) {
     }
 }
 void GameHandler(SOCKET Client) {
-
+    CoreSocket = Client;
     int32_t Size, Temp, Rcv;
     char Header[10] = { 0 };
     do {
@@ -230,8 +267,7 @@ void GameHandler(SOCKET Client) {
         if (Temp < 1)
             break;
 
-        std::thread Respond(Parse, Ret, Client);
-        Respond.detach();
+        Parse(Ret, Client);
     } while (Temp > 0);
     if (Temp == 0) {
         debug("(Core) Connection closing");

src/Network/GlobalHandler.cpp

@@ -6,6 +6,7 @@
 /// Created by Anonymous275 on 7/25/2020
 ///
 #include "Network/network.hpp"
+#include <memory>
 #include <zlib.h>
 #if defined(_WIN32)
 #include <winsock2.h>
@@ -56,13 +57,12 @@ bool CheckBytes(uint32_t Bytes) {
     return true;
 }
 
-void GameSend(std::string Data) {
+void GameSend(std::string_view Data) {
     static std::mutex Lock;
     std::scoped_lock Guard(Lock);
     if (TCPTerminate || !GConnected || CSocket == -1)
         return;
     int32_t Size, Temp, Sent;
-    Data += '\n';
     Size = int32_t(Data.size());
     Sent = 0;
 #ifdef DEBUG
@@ -78,6 +78,11 @@ void GameSend(std::string Data) {
             return;
         Sent += Temp;
     } while (Sent < Size);
+    // send separately to avoid an allocation for += "\n"
+    Temp = send(CSocket, "\n", 1, 0);
+    if (!CheckBytes(Temp)) {
+        return;
+    }
 }
 void ServerSend(std::string Data, bool Rel) {
     if (Terminate || Data.empty())
@@ -120,17 +125,17 @@ void NetReset() {
     UlStatus = "Ulstart";
     MStatus = " ";
     if (UDPSock != (SOCKET)(-1)) {
-        debug("Terminating UDP Socket : " + std::to_string(TCPSock));
+        debug("Terminating UDP Socket: " + std::to_string(TCPSock));
         KillSocket(UDPSock);
     }
     UDPSock = -1;
     if (TCPSock != (SOCKET)(-1)) {
-        debug("Terminating TCP Socket : " + std::to_string(TCPSock));
+        debug("Terminating TCP Socket: " + std::to_string(TCPSock));
         KillSocket(TCPSock);
     }
     TCPSock = -1;
     if (GSocket != (SOCKET)(-1)) {
-        debug("Terminating GTCP Socket : " + std::to_string(GSocket));
+        debug("Terminating GTCP Socket: " + std::to_string(GSocket));
         KillSocket(GSocket);
     }
     GSocket = -1;
@@ -194,7 +199,7 @@ void AutoPing() {
     }
 }
 int ClientID = -1;
-void ParserAsync(const std::string& Data) {
+void ParserAsync(std::string_view Data) {
     if (Data.empty())
         return;
     char Code = Data.at(0), SubCode = 0;
@@ -217,7 +222,7 @@ void ParserAsync(const std::string& Data) {
     }
     GameSend(Data);
 }
-void ServerParser(const std::string& Data) {
+void ServerParser(std::string_view Data) {
     ParserAsync(Data);
 }
 void NetMain(const std::string& IP, int Port) {
@@ -230,6 +235,8 @@ void NetMain(const std::string& IP, int Port) {
 }
 void TCPGameServer(const std::string& IP, int Port) {
     GSocket = SetupListener();
+    std::unique_ptr<std::thread> ClientThread {};
+    std::unique_ptr<std::thread> NetMainThread {};
     while (!TCPTerminate && GSocket != -1) {
         debug("MAIN LOOP OF GAME SERVER");
         GConnected = false;
@@ -241,8 +248,7 @@ void TCPGameServer(const std::string& IP, int Port) {
             break;
         }
         if (CServer) {
-            std::thread Client(TCPClientMain, IP, Port);
-            Client.detach();
+            ClientThread = std::make_unique<std::thread>(TCPClientMain, IP, Port);
         }
         CSocket = accept(GSocket, nullptr, nullptr);
         if (CSocket == -1) {
@@ -252,8 +258,7 @@ void TCPGameServer(const std::string& IP, int Port) {
         debug("(Proxy) Game Connected!");
         GConnected = true;
         if (CServer) {
-            std::thread t1(NetMain, IP, Port);
-            t1.detach();
+            NetMainThread = std::make_unique<std::thread>(NetMain, IP, Port);
             CServer = false;
         }
         int32_t Size, Temp, Rcv;
@@ -296,6 +301,16 @@ void TCPGameServer(const std::string& IP, int Port) {
     TCPTerminate = true;
     GConnected = false;
     Terminate = true;
+    if (ClientThread) {
+        debug("Waiting for client thread");
+        ClientThread->join();
+        debug("Client thread done");
+    }
+    if (NetMainThread) {
+        debug("Waiting for net main thread");
+        NetMainThread->join();
+        debug("Net main thread done");
+    }
     if (CSocket != SOCKET_ERROR)
         KillSocket(CSocket);
     debug("END OF GAME SERVER");

src/Network/Http.cpp

@@ -5,7 +5,6 @@
 ///
 /// Created by Anonymous275 on 7/18/2020
 ///
-#define CPPHTTPLIB_OPENSSL_SUPPORT
 
 #include "Http.h"
 #include <Logger.h>
@@ -16,6 +15,9 @@
 #include <iostream>
 #include <mutex>
 #include <nlohmann/json.hpp>
+#include <Startup.h>
+#include <Network/network.hpp>
+#include <Utils.h>
 
 void WriteHttpDebug(const httplib::Client& client, const std::string& method, const std::string& target, const httplib::Result& result) try {
     const std::filesystem::path folder = ".https_debug";
@@ -67,6 +69,10 @@ std::string HTTP::Get(const std::string& IP) {
     httplib::Client cli(IP.substr(0, pos).c_str());
     cli.set_connection_timeout(std::chrono::seconds(10));
     cli.set_follow_location(true);
+    if (SkipSslVerify) {
+        debug("Skipping SSL server validation via --skip-ssl-verify");
+        cli.enable_server_certificate_verification(false);
+    }
     auto res = cli.Get(IP.substr(pos).c_str(), ProgressBar);
     std::string Ret;
 
@@ -96,6 +102,10 @@ std::string HTTP::Post(const std::string& IP, const std::string& Fields) {
 
     httplib::Client cli(IP.substr(0, pos).c_str());
     cli.set_connection_timeout(std::chrono::seconds(10));
+    if (SkipSslVerify) {
+        debug("Skipping SSL server validation via --skip-ssl-verify");
+        cli.enable_server_certificate_verification(false);
+    }
     std::string Ret;
 
     if (!Fields.empty()) {
@@ -172,3 +182,127 @@ bool HTTP::Download(const std::string& IP, const std::string& Path) {
 
     return true;
 }
+
+void set_headers(httplib::Response& res) {
+    res.set_header("Access-Control-Allow-Origin", "*");
+    res.set_header("Access-Control-Request-Method", "POST, OPTIONS, GET");
+    res.set_header("Access-Control-Request-Headers", "X-API-Version");
+}
+
+
+void HTTP::StartProxy() {
+    std::thread proxy([&]() {
+        httplib::Server HTTPProxy;
+        httplib::Headers headers = {
+            { "User-Agent", "BeamMP-Launcher/" + GetVer() + GetPatch() },
+            { "Accept", "*/*" }
+        };
+        httplib::Client backend("https://backend.beammp.com");
+        httplib::Client forum("https://forum.beammp.com");
+
+        const std::string pattern = ".*";
+
+        auto handle_request = [&](const httplib::Request& req, httplib::Response& res) {
+            set_headers(res);
+            if (req.has_header("X-BMP-Authentication")) {
+                headers.emplace("X-BMP-Authentication", PrivateKey);
+            }
+            if (req.has_header("X-API-Version")) {
+                headers.emplace("X-API-Version", req.get_header_value("X-API-Version"));
+            }
+
+            const std::vector<std::string> path = Utils::Split(req.path, "/");
+
+            httplib::Result cli_res;
+            const std::string method = req.method;
+            std::string host = "";
+
+            if (!path.empty())
+                host = path[0];
+
+            if (host == "backend") {
+                std::string remaining_path = req.path.substr(std::strlen("/backend"));
+
+                if (method == "GET")
+                    cli_res = backend.Get(remaining_path, headers);
+                else if (method == "POST")
+                    cli_res = backend.Post(remaining_path, headers);
+
+            } else if (host == "avatar") {
+                bool error = false;
+                std::string username;
+                std::string avatar_size = "100";
+
+                if (path.size() > 1) {
+                    username = path[1];
+                } else {
+                    error = true;
+                }
+
+                if (path.size() > 2) {
+                    try {
+                        if (std::stoi(path[2]) > 0)
+                            avatar_size = path[2];
+
+                    } catch (std::exception&) {}
+                }
+
+                httplib::Result summary_res;
+
+                if (!error) {
+                    summary_res = forum.Get("/u/" + username + ".json", headers);
+
+                    if (!summary_res || summary_res->status != 200) {
+                        error = true;
+                    }
+                }
+
+                if (!error) {
+                    try {
+                        nlohmann::json d = nlohmann::json::parse(summary_res->body, nullptr, false); // can fail with parse_error
+
+                        auto user = d.at("user"); // can fail with out_of_range
+                        auto avatar_link_json = user.at("avatar_template"); // can fail with out_of_range
+
+                        auto avatar_link = avatar_link_json.get<std::string>();
+                        size_t start_pos = avatar_link.find("{size}");
+                        if (start_pos != std::string::npos)
+                            avatar_link.replace(start_pos, std::strlen("{size}"), avatar_size);
+
+                        cli_res = forum.Get(avatar_link, headers);
+
+                    } catch (std::exception&) {
+                        error = true;
+                    }
+                }
+
+                if (error) {
+                    cli_res = forum.Get("/user_avatar/forum.beammp.com/user/0/0.png", headers);
+                }
+
+            } else {
+                res.set_content("Host not found", "text/plain");
+                return;
+            }
+
+            if (cli_res) {
+                res.set_content(cli_res->body, cli_res->get_header_value("Content-Type"));
+            } else {
+                res.set_content(to_string(cli_res.error()), "text/plain");
+            }
+        };
+
+        HTTPProxy.Get(pattern, [&](const httplib::Request& req, httplib::Response& res) {
+            handle_request(req, res);
+        });
+
+        HTTPProxy.Post(pattern, [&](const httplib::Request& req, httplib::Response& res) {
+            handle_request(req, res);
+        });
+
+        ProxyPort = HTTPProxy.bind_to_any_port("0.0.0.0");
+        debug("HTTP Proxy listening on port " + std::to_string(ProxyPort));
+        HTTPProxy.listen_after_bind();
+    });
+    proxy.detach();
+}

src/Network/Resources.cpp

@@ -7,6 +7,8 @@
 ///
 
 #include "Network/network.hpp"
+#include <chrono>
+#include <mutex>
 
 #if defined(_WIN32)
 #include <ws2tcpip.h>
@@ -28,35 +30,20 @@
 #include <fstream>
 #include <future>
 #include <iostream>
-#include <string>
 #include <thread>
-#include <vector>
+#include <Utils.h>
 
 namespace fs = std::filesystem;
-std::string ListOfMods;
-std::vector<std::string> Split(const std::string& String, const std::string& delimiter) {
-    std::vector<std::string> Val;
-    size_t pos;
-    std::string token, s = String;
-    while ((pos = s.find(delimiter)) != std::string::npos) {
-        token = s.substr(0, pos);
-        if (!token.empty())
-            Val.push_back(token);
-        s.erase(0, pos + delimiter.length());
-    }
-    if (!s.empty())
-        Val.push_back(s);
-    return Val;
-}
 
 void CheckForDir() {
-    if (!fs::exists("Resources")) {
-// Could we just use fs::create_directory instead?
-#if defined(_WIN32)
-        _wmkdir(L"Resources");
-#elif defined(__linux__)
-        fs::create_directory(L"Resources");
-#endif
+    if (!fs::exists(CachingDirectory)) {
+        try {
+            fs::create_directories(CachingDirectory);
+        } catch (const std::exception& e) {
+            error(std::string("Failed to create caching directory: ") + e.what() + ". This is a fatal error. Please make sure to configure a directory which you have permission to create, read and write from/to.");
+            std::this_thread::sleep_for(std::chrono::seconds(3));
+            std::exit(1);
+        }
     }
 }
 void WaitForConfirm() {
@@ -79,16 +66,20 @@ std::string Auth(SOCKET Sock) {
 
     if (Res.empty() || Res[0] == 'E' || Res[0] == 'K') {
         Abord();
+        CoreSend("L");
         return "";
     }
 
     TCPSend(PublicKey, Sock);
-    if (Terminate)
+    if (Terminate) {
+        CoreSend("L");
         return "";
+    }
 
     Res = TCPRcv(Sock);
     if (Res.empty() || Res[0] != 'P') {
         Abord();
+        CoreSend("L");
         return "";
     }
 
@@ -97,23 +88,27 @@ std::string Auth(SOCKET Sock) {
         ClientID = std::stoi(Res);
     } else {
         Abord();
+        CoreSend("L");
         UUl("Authentication failed!");
         return "";
     }
     TCPSend("SR", Sock);
-    if (Terminate)
+    if (Terminate) {
+        CoreSend("L");
         return "";
+    }
 
     Res = TCPRcv(Sock);
 
     if (Res[0] == 'E' || Res[0] == 'K') {
         Abord();
+        CoreSend("L");
         return "";
     }
 
     if (Res.empty() || Res == "-") {
         info("Didn't Receive any mods...");
-        ListOfMods = "-";
+        CoreSend("L");
         TCPSend("Done", Sock);
         info("Done!");
         return "";
@@ -137,29 +132,44 @@ void AsyncUpdate(uint64_t& Rcv, uint64_t Size, const std::string& Name) {
     } while (!Terminate && Rcv < Size);
 }
 
-char* TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
+// MICROSOFT, I DONT CARE, WRITE BETTER CODE
+#undef min
+
+std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
     if (Sock == -1) {
         Terminate = true;
         UUl("Invalid Socket");
-        return nullptr;
+        return {};
     }
-    char* File = new char[Size];
+    std::vector<char> File(Size);
     uint64_t Rcv = 0;
+
+    int i = 0;
     do {
-        int Len = int(Size - Rcv);
-        if (Len > 1000000)
-            Len = 1000000;
+        auto start = std::chrono::high_resolution_clock::now();
+
+        // receive at most some MB at a time
+        int Len = std::min(int(Size - Rcv), 2 * 1024 * 1024);
         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;
-            delete[] File;
-            return nullptr;
+            return {};
         }
         Rcv += Temp;
         GRcv += Temp;
+
+        // every 8th iteration calculate download speed for that iteration
+        if (i % 8 == 0) {
+            auto end = std::chrono::high_resolution_clock::now();
+            auto difference = end - start;
+            float bits_per_s = float(Temp * 8) / float(std::chrono::duration_cast<std::chrono::milliseconds>(difference).count());
+            float megabits_per_s = bits_per_s / 1000;
+            debug("Download speed: " + std::to_string(uint32_t(megabits_per_s)) + "Mbit/s");
+        }
+        ++i;
     } while (Rcv < Size && !Terminate);
     return File;
 }
@@ -193,44 +203,47 @@ SOCKET InitDSock() {
     return DSock;
 }
 
-std::string MultiDownload(SOCKET MSock, SOCKET DSock, uint64_t Size, const std::string& Name) {
+std::vector<char> MultiDownload(SOCKET MSock, SOCKET DSock, uint64_t Size, const std::string& Name) {
+    uint64_t GRcv = 0;
 
-    uint64_t GRcv = 0, MSize = Size / 2, DSize = Size - MSize;
+    uint64_t MSize = Size / 2;
+    uint64_t DSize = Size - MSize;
 
-    std::thread Au(AsyncUpdate, std::ref(GRcv), Size, Name);
+    std::thread Au([&] { AsyncUpdate(GRcv, Size, Name); });
 
-    std::packaged_task<char*()> task([&] { return TCPRcvRaw(MSock, GRcv, MSize); });
-    std::future<char*> f1 = task.get_future();
-    std::thread Dt(std::move(task));
-    Dt.detach();
+    const std::vector<char> MData = TCPRcvRaw(MSock, GRcv, MSize);
 
-    char* DData = TCPRcvRaw(DSock, GRcv, DSize);
-
-    if (!DData) {
+    if (MData.empty()) {
         MultiKill(MSock, DSock);
-        return "";
-    }
-
-    f1.wait();
-    char* MData = f1.get();
-
-    if (!MData) {
-        MultiKill(MSock, DSock);
-        return "";
-    }
-
-    if (Au.joinable())
+        Terminate = true;
         Au.join();
+        return {};
+    }
 
-    /// omg yes very ugly my god but i was in a rush will revisit
-    std::string Ret(Size, 0);
-    memcpy(&Ret[0], MData, MSize);
-    delete[] MData;
+    const std::vector<char> DData = TCPRcvRaw(DSock, GRcv, DSize);
 
-    memcpy(&Ret[MSize], DData, DSize);
-    delete[] DData;
+    if (DData.empty()) {
+        MultiKill(MSock, DSock);
+        Terminate = true;
+        Au.join();
+        return {};
+    }
 
-    return Ret;
+    // ensure that GRcv is good before joining the async update thread
+    GRcv = MData.size() + DData.size();
+    if (GRcv != Size) {
+        error("Something went wrong during download; didn't get enough data. Expected " + std::to_string(Size) + " bytes, got " + std::to_string(GRcv) + " bytes instead");
+        Terminate = true;
+        Au.join();
+        return {};
+    }
+
+    Au.join();
+
+    std::vector<char> Result{};
+    Result.insert(Result.begin(), MData.begin(), MData.end());
+    Result.insert(Result.end(), DData.begin(), DData.end());
+    return Result;
 }
 
 void InvalidResource(const std::string& File) {
@@ -244,26 +257,29 @@ void SyncResources(SOCKET Sock) {
     if (Ret.empty())
         return;
 
+    if (!SecurityWarning())
+		return;
+
     info("Checking Resources...");
     CheckForDir();
 
-    std::vector<std::string> list = Split(Ret, ";");
+    std::vector<std::string> list = Utils::Split(Ret, ";");
     std::vector<std::string> FNames(list.begin(), list.begin() + (list.size() / 2));
     std::vector<std::string> FSizes(list.begin() + (list.size() / 2), list.end());
     list.clear();
     Ret.clear();
 
     int Amount = 0, Pos = 0;
-    std::string a, t;
+    std::string PathToSaveTo, t;
     for (const std::string& name : FNames) {
         if (!name.empty()) {
             t += name.substr(name.find_last_of('/') + 1) + ";";
         }
     }
     if (t.empty())
-        ListOfMods = "-";
+        CoreSend("L");
     else
-        ListOfMods = t;
+        CoreSend("L" + t);
     t.clear();
     for (auto FN = FNames.begin(), FS = FSizes.begin(); FN != FNames.end() && !Terminate; ++FN, ++FS) {
         auto pos = FN->find_last_of('/');
@@ -282,29 +298,32 @@ 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) {
-            a = "Resources" + FN->substr(pos);
-        } else
+            PathToSaveTo = CachingDirectory + FN->substr(pos);
+        } else {
             continue;
+        }
         Pos++;
-        if (fs::exists(a)) {
+        auto FileSize = std::stoull(*FS);
+        if (fs::exists(PathToSaveTo)) {
             if (FS->find_first_not_of("0123456789") != std::string::npos)
                 continue;
-            if (fs::file_size(a) == std::stoull(*FS)) {
-                UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + a.substr(a.find_last_of('/')));
+            if (fs::file_size(PathToSaveTo) == FileSize) {
+                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() + "mods/multiplayer")) {
                         fs::create_directories(GetGamePath() + "mods/multiplayer");
                     }
-                    auto name = GetGamePath() + "mods/multiplayer" + a.substr(a.find_last_of('/'));
+                    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 : name) {
+                    for (char& c : modname) {
                         c = ::tolower(c);
                     }
 #endif
+                    auto name = GetGamePath() + "mods/multiplayer" + modname;
                     auto tmp_name = name + ".tmp";
-                    fs::copy_file(a, tmp_name, fs::copy_options::overwrite_existing);
+                    fs::copy_file(PathToSaveTo, tmp_name, fs::copy_options::overwrite_existing);
                     fs::rename(tmp_name, name);
                 } catch (std::exception& e) {
                     error("Failed copy to the mods folder! " + std::string(e.what()));
@@ -314,11 +333,12 @@ void SyncResources(SOCKET Sock) {
                 WaitForConfirm();
                 continue;
             } else
-                remove(a.c_str());
+                remove(PathToSaveTo.c_str());
         }
         CheckForDir();
-        std::string FName = a.substr(a.find_last_of('/'));
+        std::string FName = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
         do {
+            debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
             TCPSend("f" + *FN, Sock);
 
             std::string Data = TCPRcv(Sock);
@@ -330,19 +350,23 @@ void SyncResources(SOCKET Sock) {
 
             std::string Name = std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + FName;
 
-            Data = MultiDownload(Sock, DSock, std::stoull(*FS), Name);
+            std::vector<char> DownloadedFile = MultiDownload(Sock, DSock, FileSize, Name);
 
             if (Terminate)
                 break;
             UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + FName);
-            std::ofstream LFS;
-            LFS.open(a.c_str(), std::ios_base::app | std::ios::binary);
-            if (LFS.is_open()) {
-                LFS.write(&Data[0], Data.size());
-                LFS.close();
-            }
 
-        } while (fs::file_size(a) != std::stoull(*FS) && !Terminate);
+            // 1. write downloaded file to disk
+            {
+                std::ofstream OutFile(PathToSaveTo, std::ios::binary | std::ios::trunc);
+                OutFile.write(DownloadedFile.data(), DownloadedFile.size());
+            }
+            // 2. verify size
+            if (std::filesystem::file_size(PathToSaveTo) != DownloadedFile.size()) {
+                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() + "mods/multiplayer")) {
                 fs::create_directories(GetGamePath() + "mods/multiplayer");
@@ -355,7 +379,7 @@ void SyncResources(SOCKET Sock) {
             }
 #endif
 
-            fs::copy_file(a, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
+            fs::copy_file(PathToSaveTo, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
         }
         WaitForConfirm();
     }

src/Network/VehicleData.cpp

@@ -7,6 +7,7 @@
 ///
 #include "Network/network.hpp"
 #include "Zlib/Compressor.h"
+#include <stdexcept>
 
 #if defined(_WIN32)
 #include <ws2tcpip.h>
@@ -14,14 +15,13 @@
 #include "linuxfixes.h"
 #include <arpa/inet.h>
 #include <cstring>
-#include <errno.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #endif
 
 #include "Logger.h"
-#include <set>
+#include <array>
 #include <string>
 
 SOCKET UDPSock = -1;
@@ -48,13 +48,19 @@ void SendLarge(std::string Data) {
     TCPSend(Data, TCPSock);
 }
 
-void UDPParser(std::string Packet) {
+void UDPParser(std::string_view Packet) {
     if (Packet.substr(0, 4) == "ABG:") {
         auto substr = Packet.substr(4);
-        auto res = DeComp(std::span<char>(substr.data(), substr.size()));
-        Packet = std::string(res.data(), res.size());
+        try {
+            auto res = DeComp(std::span<const char>(substr.data(), substr.size()));
+            std::string DeCompPacket = std::string(res.data(), res.size());
+            ServerParser(DeCompPacket);
+        } catch (const std::runtime_error& err) {
+            error("Error in decompression of UDP, ignoring");
+        }
+    } else {
+        ServerParser(Packet);
     }
-    ServerParser(Packet);
 }
 void UDPRcv() {
     sockaddr_in FromServer {};
@@ -64,13 +70,14 @@ void UDPRcv() {
     socklen_t clientLength = sizeof(FromServer);
 #endif
     ZeroMemory(&FromServer, clientLength);
-    std::string Ret(10240, 0);
+    static thread_local std::array<char, 10240> Ret {};
     if (UDPSock == -1)
         return;
-    int32_t Rcv = recvfrom(UDPSock, &Ret[0], 10240, 0, (sockaddr*)&FromServer, &clientLength);
+    int32_t Rcv = recvfrom(UDPSock, Ret.data(), Ret.size() - 1, 0, (sockaddr*)&FromServer, &clientLength);
     if (Rcv == SOCKET_ERROR)
         return;
-    UDPParser(Ret.substr(0, Rcv));
+    Ret[Rcv] = 0;
+    UDPParser(std::string_view(Ret.data(), Rcv));
 }
 void UDPClientMain(const std::string& IP, int Port) {
 #ifdef _WIN32
@@ -90,8 +97,11 @@ void UDPClientMain(const std::string& IP, int Port) {
     GameSend("P" + std::to_string(ClientID));
     TCPSend("H", TCPSock);
     UDPSend("p");
-    while (!Terminate)
+    debug("Starting UDP receive loop");
+    while (!Terminate) {
         UDPRcv();
+    }
+    debug("UDP receive loop done");
     KillSocket(UDPSock);
     WSACleanup();
 }

src/Network/VehicleEvent.cpp

@@ -82,39 +82,39 @@ std::string TCPRcv(SOCKET Sock) {
         UUl("Invalid Socket");
         return "";
     }
-    int32_t Header, BytesRcv = 0, Temp;
+    int32_t Header, Temp;
     std::vector<char> Data(sizeof(Header));
-    do {
-        Temp = recv(Sock, &Data[BytesRcv], 4 - BytesRcv, 0);
-        if (!CheckBytes(Temp)) {
-            UUl("Socket Closed Code 3");
-            return "";
-        }
-        BytesRcv += Temp;
-    } while (BytesRcv < 4);
-    memcpy(&Header, &Data[0], sizeof(Header));
+    Temp = recv(Sock, Data.data(), sizeof(Header), MSG_WAITALL);
+    if (!CheckBytes(Temp)) {
+        UUl("Socket Closed Code 3");
+        return "";
+    }
+    memcpy(&Header, Data.data(), sizeof(Header));
 
-    if (!CheckBytes(BytesRcv)) {
+    if (!CheckBytes(Temp)) {
         UUl("Socket Closed Code 4");
         return "";
     }
-    Data.resize(Header);
-    BytesRcv = 0;
-    do {
-        Temp = recv(Sock, &Data[BytesRcv], Header - BytesRcv, 0);
-        if (!CheckBytes(Temp)) {
-            UUl("Socket Closed Code 5");
-            return "";
-        }
-        BytesRcv += Temp;
-    } while (BytesRcv < Header);
+
+    Data.resize(Header, 0);
+    Temp = recv(Sock, Data.data(), Header, MSG_WAITALL);
+    if (!CheckBytes(Temp)) {
+        UUl("Socket Closed Code 5");
+        return "";
+    }
 
     std::string Ret(Data.data(), Header);
 
     if (Ret.substr(0, 4) == "ABG:") {
         auto substr = Ret.substr(4);
-        auto res = DeComp(std::span<char>(substr.data(), substr.size()));
-        Ret = std::string(res.data(), res.size());
+        try {
+            auto res = DeComp(std::span<char>(substr.data(), substr.size()));
+            Ret = std::string(res.data(), res.size());
+        } catch (const std::runtime_error& err) {
+            // this happens e.g. when we're out of memory, or when we get incomplete data
+            error("Decompression failed");
+            return "";
+        }
     }
 
 #ifdef DEBUG
@@ -152,6 +152,7 @@ void TCPClientMain(const std::string& IP, int Port) {
         KillSocket(TCPSock);
         WSACleanup();
         Terminate = true;
+        CoreSend("L");
         return;
     }
     info("Connected!");

src/Security/BeamNG.cpp

@@ -17,7 +17,6 @@
 #endif
 #include "Logger.h"
 #include <fstream>
-#include <sstream>
 #include <string>
 #include <thread>
 
@@ -34,24 +33,8 @@ void lowExit(int code) {
     std::this_thread::sleep_for(std::chrono::seconds(10));
     exit(2);
 }
-/*void Exit(int code){
-    TraceBack = 0;
-    std::string msg =
-    "Sorry. We do not support cracked copies report this if you believe this is a mistake code ";
-    error(msg+std::to_string(code));
-    std::this_thread::sleep_for(std::chrono::seconds(10));
-    exit(3);
-}
-void SteamExit(int code){
-    TraceBack = 0;
-    std::string msg =
-    "Illegal steam modifications detected report this if you believe this is a mistake code ";
-    error(msg+std::to_string(code));
-    std::this_thread::sleep_for(std::chrono::seconds(10));
-    exit(4);
-}*/
+
 std::string GetGameDir() {
-// if(TraceBack != 4)Exit(0);
 #if defined(_WIN32)
     return GameDir.substr(0, GameDir.find_last_of('\\'));
 #elif defined(__linux__)
@@ -175,151 +158,7 @@ void FileList(std::vector<std::string>& a, const std::string& Path) {
         }
     }
 }
-bool Find(const std::string& FName, const std::string& Path) {
-    std::vector<std::string> FS;
-    FileList(FS, Path + "\\userdata");
-    for (std::string& a : FS) {
-        if (a.find(FName) != std::string::npos) {
-            FS.clear();
-            return true;
-        }
-    }
-    FS.clear();
-    return false;
-}
-bool FindHack(const std::string& Path) {
-    bool s = true;
-    for (const auto& entry : fs::directory_iterator(Path)) {
-        std::string Name = entry.path().filename().string();
-        for (char& c : Name)
-            c = char(tolower(c));
-        if (Name == "steam.exe")
-            s = false;
-        if (Name.find("greenluma") != -1) {
-            error("Found malicious file/folder \"" + Name + "\"");
-            return true;
-        }
-        Name.clear();
-    }
-    return s;
-}
-std::vector<std::string> GetID(const std::string& log) {
-    std::string vec, t, r;
-    std::vector<std::string> Ret;
-    std::ifstream f(log.c_str(), std::ios::binary);
-    f.seekg(0, std::ios_base::end);
-    std::streampos fileSize = f.tellg();
-    vec.resize(size_t(fileSize) + 1);
-    f.seekg(0, std::ios_base::beg);
-    f.read(&vec[0], fileSize);
-    f.close();
-    std::stringstream ss(vec);
-    bool S = false;
-    while (std::getline(ss, t, '{')) {
-        if (!S)
-            S = true;
-        else {
-            for (char& c : t) {
-                if (isdigit(c))
-                    r += c;
-            }
-            break;
-        }
-    }
-    Ret.emplace_back(r);
-    r.clear();
-    S = false;
-    bool L = true;
-    while (std::getline(ss, t, '}')) {
-        if (L) {
-            L = false;
-            continue;
-        }
-        for (char& c : t) {
-            if (c == '"') {
-                if (!S)
-                    S = true;
-                else {
-                    if (r.length() > 10) {
-                        Ret.emplace_back(r);
-                    }
-                    r.clear();
-                    S = false;
-                    continue;
-                }
-            }
-            if (isdigit(c))
-                r += c;
-        }
-    }
-    vec.clear();
-    return Ret;
-}
-std::string GetManifest(const std::string& Man) {
-    std::string vec;
-    std::ifstream f(Man.c_str(), std::ios::binary);
-    f.seekg(0, std::ios_base::end);
-    std::streampos fileSize = f.tellg();
-    vec.resize(size_t(fileSize) + 1);
-    f.seekg(0, std::ios_base::beg);
-    f.read(&vec[0], fileSize);
-    f.close();
-    std::string ToFind = "\"LastOwner\"\t\t\"";
-    int pos = int(vec.find(ToFind));
-    if (pos != -1) {
-        pos += int(ToFind.length());
-        vec = vec.substr(pos);
-        return vec.substr(0, vec.find('\"'));
-    } else
-        return "";
-}
-bool IDCheck(std::string Man, std::string steam) {
-    bool a = false, b = true;
-    int pos = int(Man.rfind("steamapps"));
-    //  if(pos == -1)Exit(5);
-    Man = Man.substr(0, pos + 9) + "\\appmanifest_284160.acf";
-    steam += "\\config\\loginusers.vdf";
-    if (fs::exists(Man) && fs::exists(steam)) {
-        for (const std::string& ID : GetID(steam)) {
-            if (ID == GetManifest(Man))
-                b = false;
-        }
-        // if(b)Exit(6);
-    } else
-        a = true;
-    return a;
-}
 void LegitimacyCheck() {
-
-// std::string K1 = R"(Software\Valve\Steam)";
-// std::string K2 = R"(Software\Valve\Steam\Apps\284160)";
-
-/*LONG dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K1.c_str(), &hKey);
-
-if(dwRegOPenKey == ERROR_SUCCESS) {
-    Result = QueryKey(hKey, 1);
-    if(Result.empty())Exit(1);
-
-    if(fs::exists(Result)){
-        if(!Find("284160.json",Result))Exit(2);
-        if(FindHack(Result))SteamExit(1);
-    }else Exit(3);
-
-    T = Result;
-    Result.clear();
-    TraceBack++;
-}else Exit(4);
-
-K1.clear();
-RegCloseKey(hKey);
-dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K2.c_str(), &hKey);
-if(dwRegOPenKey == ERROR_SUCCESS) {
-    Result = QueryKey(hKey, 2);
-    if(Result.empty())lowExit(1);
-    TraceBack++;
-}else lowExit(2);
-K2.clear();
-RegCloseKey(hKey);*/
 #if defined(_WIN32)
     std::string Result;
     std::string K3 = R"(Software\BeamNG\BeamNG.drive)";
@@ -327,17 +166,18 @@ RegCloseKey(hKey);*/
     LONG dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K3.c_str(), &hKey);
     if (dwRegOPenKey == ERROR_SUCCESS) {
         Result = QueryKey(hKey, 3);
-        if (Result.empty())
+        if (Result.empty()) {
+            debug("Failed to QUERY key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
             lowExit(3);
-        // if(IDCheck(Result,T))lowExit(5);
+        }
         GameDir = Result;
-        // TraceBack++;
-    } else
+    } else {
+        debug("Failed to OPEN key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
         lowExit(4);
+    }
     K3.clear();
     Result.clear();
     RegCloseKey(hKey);
-// if(TraceBack < 3)exit(-1);
 #elif defined(__linux__)
     struct passwd* pw = getpwuid(getuid());
     std::string homeDir = pw->pw_dir;

src/Security/Login.cpp

@@ -18,6 +18,7 @@ std::string PrivateKey;
 extern bool LoginAuth;
 extern std::string Username;
 extern std::string UserRole;
+extern int UserID;
 
 void UpdateKey(const char* newKey) {
     if (newKey && std::isalnum(newKey[0])) {
@@ -48,6 +49,7 @@ std::string Login(const std::string& fields) {
     if (fields == "LO") {
         Username = "";
         UserRole = "";
+        UserID = -1;
         LoginAuth = false;
         UpdateKey(nullptr);
         return "";
@@ -74,6 +76,9 @@ std::string Login(const std::string& fields) {
             if (d.contains("role")) {
                 UserRole = d["role"].get<std::string>();
             }
+            if (d.contains("id")) {
+                UserID = d["id"].get<int>();
+            }
             if (d.contains("private_key")) {
                 UpdateKey(d["private_key"].get<std::string>().c_str());
             }
@@ -129,6 +134,9 @@ void CheckLocalKey() {
                 if (d.contains("role")) {
                     UserRole = d["role"].get<std::string>();
                 }
+                if (d.contains("id")) {
+                    UserID = d["id"].get<int>();
+                }
                 // info(Role);
             } else {
                 info("Auto-Authentication unsuccessful please re-login!");

src/Startup.cpp

@@ -7,6 +7,7 @@
 ///
 
 #include "zip_file.h"
+#include <charconv>
 #include <httplib.h>
 #include <nlohmann/json.hpp>
 #include <string>
@@ -31,36 +32,44 @@ int ProxyPort = 0;
 
 namespace fs = std::filesystem;
 
-VersionParser::VersionParser(const std::string& from_string) {
-    std::string token;
-    std::istringstream tokenStream(from_string);
-    while (std::getline(tokenStream, token, '.')) {
-        data.emplace_back(std::stol(token));
-        split.emplace_back(token);
+struct Version {
+    uint8_t major;
+    uint8_t minor;
+    uint8_t patch;
+    Version(uint8_t major, uint8_t minor, uint8_t patch);
+    Version(const std::array<uint8_t, 3>& v);
+};
+
+std::array<uint8_t, 3> VersionStrToInts(const std::string& str) {
+    std::array<uint8_t, 3> Version;
+    std::stringstream ss(str);
+    for (uint8_t& i : Version) {
+        std::string Part;
+        std::getline(ss, Part, '.');
+        std::from_chars(&*Part.begin(), &*Part.begin() + Part.size(), i);
+    }
+    return Version;
+}
+
+bool IsOutdated(const Version& Current, const Version& Newest) {
+    if (Newest.major > Current.major) {
+        return true;
+    } else if (Newest.major == Current.major && Newest.minor > Current.minor) {
+        return true;
+    } else if (Newest.major == Current.major && Newest.minor == Current.minor && Newest.patch > Current.patch) {
+        return true;
+    } else {
+        return false;
     }
 }
 
-std::strong_ordering VersionParser::operator<=>(
-    const VersionParser& rhs) const noexcept {
-    size_t const fields = std::min(data.size(), rhs.data.size());
-    for (size_t i = 0; i != fields; ++i) {
-        if (data[i] == rhs.data[i])
-            continue;
-        else if (data[i] < rhs.data[i])
-            return std::strong_ordering::less;
-        else
-            return std::strong_ordering::greater;
-    }
-    if (data.size() == rhs.data.size())
-        return std::strong_ordering::equal;
-    else if (data.size() > rhs.data.size())
-        return std::strong_ordering::greater;
-    else
-        return std::strong_ordering::less;
-}
+Version::Version(uint8_t major, uint8_t minor, uint8_t patch)
+    : major(major)
+    , minor(minor)
+    , patch(patch) { }
 
-bool VersionParser::operator==(const VersionParser& rhs) const noexcept {
-    return std::is_eq(*this <=> rhs);
+Version::Version(const std::array<uint8_t, 3>& v)
+    : Version(v[0], v[1], v[2]) {
 }
 
 std::string GetEN() {
@@ -72,10 +81,10 @@ std::string GetEN() {
 }
 
 std::string GetVer() {
-    return "2.0";
+    return "2.1";
 }
 std::string GetPatch() {
-    return ".85";
+    return ".3";
 }
 
 std::string GetEP(char* P) {
@@ -92,6 +101,7 @@ void ReLaunch(int argc, char* args[]) {
         Arg += " ";
         Arg += args[c - 1];
     }
+    info("Relaunch!");
     system("cls");
     ShellExecute(nullptr, "runas", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
     ShowWindow(GetConsoleWindow(), 0);
@@ -116,6 +126,7 @@ void ReLaunch(int argc, char* args[]) {
         Arg += " ";
         Arg += args[c - 1];
     }
+    info("Relaunch!");
     system("clear");
     execl((GetEP() + GetEN()).c_str(), Arg.c_str(), NULL);
     std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -158,12 +169,8 @@ void CheckForUpdates(int argc, char* args[], const std::string& CV) {
     std::string EP(GetEP() + GetEN()), Back(GetEP() + "BeamMP-Launcher.back");
 
     std::string FileHash = hashpp::get::getFileHash(hashpp::ALGORITHMS::SHA2_256, EP);
-#if defined(_WIN32)
-#elif defined(__linux__)
-    system("clear");
-#endif
 
-    if (FileHash != LatestHash && VersionParser(LatestVersion) > VersionParser(GetVer() + GetPatch())) {
+    if (FileHash != LatestHash && IsOutdated(Version(VersionStrToInts(GetVer() + GetPatch())), Version(VersionStrToInts(LatestVersion))) && !Dev) {
         info("Launcher update found!");
 #if defined(__linux__)
         error("Auto update is NOT implemented for the Linux version. Please update manually ASAP as updates contain security patches.");
@@ -177,7 +184,7 @@ void CheckForUpdates(int argc, char* args[], const std::string& CV) {
                 + PublicKey + "&branch=" + Branch,
             EP);
         URelaunch(argc, args);
-        #endif
+#endif
     } else
         info("Launcher version is up to date");
     TraceBack++;
@@ -228,7 +235,6 @@ void LinuxPatch() {
 
 #if defined(_WIN32)
 void InitLauncher(int argc, char* argv[]) {
-    system("cls");
     SetConsoleTitleA(("BeamMP Launcher v" + std::string(GetVer()) + GetPatch()).c_str());
     InitLog();
     CheckName(argc, argv);
@@ -240,8 +246,8 @@ void InitLauncher(int argc, char* argv[]) {
 }
 #elif defined(__linux__)
 void InitLauncher(int argc, char* argv[]) {
-    system("clear");
     InitLog();
+    info("BeamMP Launcher v" + GetVer() + GetPatch());
     CheckName(argc, argv);
     CheckLocalKey();
     ConfigInit();
@@ -308,6 +314,7 @@ void PreGame(const std::string& GamePath) {
     info("Game Version : " + GameVer);
 
     CheckMP(GetGamePath() + "mods/multiplayer");
+    info("Game user path: " + GetGamePath());
 
     if (!Dev) {
         std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/mod?branch=" + Branch + "&pk=" + PublicKey);
@@ -348,59 +355,3 @@ void PreGame(const std::string& GamePath) {
         }
     }
 }
-
-void set_headers(httplib::Response& res) {
-    res.set_header("Access-Control-Allow-Origin", "*");
-    res.set_header("Access-Control-Request-Method", "POST, OPTIONS, GET");
-    res.set_header("Access-Control-Request-Headers", "X-API-Version");
-}
-
-void StartProxy() {
-    std::thread proxy([&]() {
-        httplib::Server HTTPProxy;
-        httplib::Headers headers = {
-            { "User-Agent", "BeamMP-Launcher/" + GetVer() + GetPatch() },
-            { "Accept", "*/*" }
-        };
-        std::string pattern = "/:any1";
-        for (int i = 2; i <= 4; i++) {
-            HTTPProxy.Get(pattern, [&](const httplib::Request& req, httplib::Response& res) {
-                httplib::Client cli("https://backend.beammp.com");
-                set_headers(res);
-                if (req.has_header("X-BMP-Authentication")) {
-                    headers.emplace("X-BMP-Authentication", PrivateKey);
-                }
-                if (req.has_header("X-API-Version")) {
-                    headers.emplace("X-API-Version", req.get_header_value("X-API-Version"));
-                }
-                if (auto cli_res = cli.Get(req.path, headers); cli_res) {
-                    res.set_content(cli_res->body, cli_res->get_header_value("Content-Type"));
-                } else {
-                    res.set_content(to_string(cli_res.error()), "text/plain");
-                }
-            });
-
-            HTTPProxy.Post(pattern, [&](const httplib::Request& req, httplib::Response& res) {
-                httplib::Client cli("https://backend.beammp.com");
-                set_headers(res);
-                if (req.has_header("X-BMP-Authentication")) {
-                    headers.emplace("X-BMP-Authentication", PrivateKey);
-                }
-                if (req.has_header("X-API-Version")) {
-                    headers.emplace("X-API-Version", req.get_header_value("X-API-Version"));
-                }
-                if (auto cli_res = cli.Post(req.path, headers, req.body,
-                        req.get_header_value("Content-Type"));
-                    cli_res) {
-                    res.set_content(cli_res->body, cli_res->get_header_value("Content-Type"));
-                } else {
-                    res.set_content(to_string(cli_res.error()), "text/plain");
-                }
-            });
-            pattern += "/:any" + std::to_string(i);
-        }
-        ProxyPort = HTTPProxy.bind_to_any_port("0.0.0.0");
-        HTTPProxy.listen_after_bind();
-    });
-    proxy.detach();
-}

src/main.cpp

@@ -20,26 +20,51 @@
     }
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char** argv) try {
 #ifdef DEBUG
     std::thread th(flush);
     th.detach();
 #endif
 
+
+#if defined(_WIN32)
+    system("cls");
+#elif defined(__linux__)
+    system("clear");
+#endif
+
+
     GetEP(argv[0]);
 
+    for (int i = 0; i < argc; ++i) {
+        if (std::string_view(argv[i]) == "--skip-ssl-verify") {
+            info("SSL verification skip enabled");
+            HTTP::SkipSslVerify = true;
+        }
+    }
+
     InitLauncher(argc, argv);
 
+    info("IMPORTANT: You MUST keep this window open to play BeamMP!");
+
     try {
         LegitimacyCheck();
     } catch (std::exception& e) {
-        fatal("Main 1 : " + std::string(e.what()));
+        error("Failure in LegitimacyCheck: " + std::string(e.what()));
+        throw;
     }
 
-    StartProxy();
+    try {
+        HTTP::StartProxy();
+    } catch (const std::exception& e) {
+        error(std::string("Failed to start HTTP proxy: Some in-game functions may not work. Error: ") + e.what());
+    }
     PreGame(GetGameDir());
     InitGame(GetGameDir());
     CoreNetwork();
-
-    /// TODO: make sure to use argv[0] for everything that should be in the same dir (mod down ect...)
+} catch (const std::exception& e) {
+    error(std::string("Exception in main(): ") + e.what());
+    info("Closing in 5 seconds");
+    info("If this keeps happening, contact us on either: Forum: https://forum.beammp.com, Discord: https://discord.gg/beammp");
+    std::this_thread::sleep_for(std::chrono::seconds(5));
 }