Added IPv6 support

.github/pull_request_template.md

@@ -1,6 +0,0 @@
-Please replace this text <-> with your PR description and leave the below declarations intact.
-
----
-
-By creating this pull request, I understand that code that is AI generated or otherwise automatically generated may be rejected without further discussion.
-I declare that I fully understand all code I pushed into this PR, and wrote all this code myself and own the rights to this code.

.github/workflows/cmake-linux.yml

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

.github/workflows/release-build.yml

@@ -0,0 +1,104 @@
+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

.gitignore

@@ -12,4 +12,3 @@ Resources/
 bin/
 compile_commands.json
 key
-out/

CMakeLists.txt

@@ -17,7 +17,6 @@ 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)
-find_package(CURL REQUIRED)
 
 add_executable(${PROJECT_NAME} ${source_files})
 set_target_properties(${PROJECT_NAME} PROPERTIES OUTPUT_NAME "BeamMP-Launcher")
@@ -26,15 +25,15 @@ if (WIN32)
     find_package(ZLIB REQUIRED)
     find_package(OpenSSL REQUIRED)
     target_link_libraries(${PROJECT_NAME} PRIVATE
-            ZLIB::ZLIB OpenSSL::SSL OpenSSL::Crypto ws2_32 httplib::httplib nlohmann_json::nlohmann_json CURL::libcurl)
+            ZLIB::ZLIB OpenSSL::SSL OpenSSL::Crypto ws2_32 httplib::httplib nlohmann_json::nlohmann_json)
 elseif (LINUX)
     find_package(ZLIB REQUIRED)
     find_package(OpenSSL REQUIRED)
     target_link_libraries(${PROJECT_NAME} PRIVATE 
-            ZLIB::ZLIB OpenSSL::SSL OpenSSL::Crypto CURL::libcurl)
+            ZLIB::ZLIB OpenSSL::SSL OpenSSL::Crypto)
 else(WIN32) #MINGW
     add_definitions("-D_WIN32_WINNT=0x0600")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Os -s --static")
-    target_link_libraries(${PROJECT_NAME} ssl crypto ws2_32 ssp crypt32 z CURL::libcurl)
+    target_link_libraries(${PROJECT_NAME} ssl crypto ws2_32 ssp crypt32 z)
 endif(WIN32)
 target_include_directories(${PROJECT_NAME} PRIVATE "include")

README.md

@@ -2,20 +2,13 @@
 
 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.
 
-**To clone this repository**: `git clone --recurse-submodules https://github.com/BeamMP/BeamMP-Launcher.git`
+## How to build
 
-## 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,
+the only permission that has been granted is to use the software in its compiled form as distributed from the BeamMP.com website.
+Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.

include/Http.h

@@ -14,7 +14,7 @@ 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;
 };

include/Network/network.hpp

@@ -26,16 +26,17 @@ extern int ClientID;
 extern int LastPort;
 extern bool ModLoaded;
 extern bool Terminate;
+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);
@@ -51,5 +52,3 @@ 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/Options.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <string>
-
-struct Options {
-#if defined(_WIN32)
-    std::string executable_name = "BeamMP-Launcher.exe";
-#elif defined(__linux__)
-    std::string executable_name = "BeamMP-Launcher";
-#endif
-    unsigned int port = 4444;
-    bool verbose = false;
-    bool no_download = false;
-    bool no_update = false;
-    bool no_launch = false;
-    const char **game_arguments = nullptr;
-    int game_arguments_length = 0;
-    const char** argv = nullptr;
-    int argc = 0;
-};
-
-void InitOptions(int argc, const char *argv[], Options &options);
-
-extern Options options;

include/Startup.h

@@ -10,10 +10,12 @@
 #include <string>
 #include <vector>
 
-void InitLauncher();
+void InitLauncher(int argc, char* argv[]);
-std::string GetEP(const char* P = nullptr);
+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;
+

include/Utils.h

@@ -1,20 +0,0 @@
-#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;
-    };
-};

src/Compressor.cpp

@@ -25,7 +25,7 @@ std::vector<char> Comp(std::span<const char> input) {
         reinterpret_cast<const Bytef*>(input.data()),
         static_cast<uLongf>(input.size()));
     if (res != Z_OK) {
-        error("zlib compress() failed (code: " + std::to_string(res) + ", message: " + zError(res) + ")");
+        error("zlib compress() failed: " + std::to_string(res));
         throw std::runtime_error("zlib compress() failed");
     }
     debug("zlib compressed " + std::to_string(input.size()) + " B to " + std::to_string(output_size) + " B");
@@ -52,7 +52,7 @@ std::vector<char> DeComp(std::span<const char> input) {
             output_buffer.resize(output_buffer.size() * 2);
             output_size = output_buffer.size();
         } else if (res != Z_OK) {
-            error("zlib uncompress() failed (code: " + std::to_string(res) + ", message: " + zError(res) + ")");
+            error("zlib uncompress() failed: " + std::to_string(res));
             throw std::runtime_error("zlib uncompress() failed");
         } else if (res == Z_OK) {
             break;

src/Config.cpp

@@ -8,37 +8,24 @@
 #include <filesystem>
 #include <fstream>
 #include <nlohmann/json.hpp>
-#include "Options.h"
 namespace fs = std::filesystem;
 
 std::string Branch;
-std::string CachingDirectory = "./Resources";
-
 void ParseConfig(const nlohmann::json& d) {
     if (d["Port"].is_number()) {
-        options.port = d["Port"].get<int>();
+        DEFAULT_PORT = d["Port"].get<int>();
     }
     // Default -1
     // Release 1
     // 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>();
-    }
-
-    if (d.contains("Dev") && d["Dev"].is_boolean()) {
-        bool dev = d["Dev"].get<bool>();
-        options.verbose = dev;
-        options.no_download = dev;
-        options.no_launch = dev;
-        options.no_update = dev;
-    }
 }
 
 void ConfigInit() {
@@ -62,8 +49,7 @@ void ConfigInit() {
             cfg <<
                 R"({
     "Port": 4444,
-    "Build": "Default",
+    "Build": "Default"
-    "CachingDirectory": "./Resources"
 })";
             cfg.close();
         } else {

src/GameStart.cpp

@@ -8,7 +8,6 @@
 
 #if defined(_WIN32)
 #include <windows.h>
-#include <shlobj.h>
 #elif defined(__linux__)
 #include "vdf_parser.hpp"
 #include <pwd.h>
@@ -23,7 +22,6 @@
 #include <Security/Init.h>
 #include <filesystem>
 #include <thread>
-#include "Options.h"
 
 unsigned long GamePID = 0;
 #if defined(_WIN32)
@@ -42,23 +40,18 @@ std::string GetGamePath() {
     Path = QueryKey(hKey, 4);
 
     if (Path.empty()) {
-        Path = "";
+        sk = R"(SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders)";
-        char appDataPath[MAX_PATH];
+        openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
-        HRESULT result = SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);
+        if (openRes != ERROR_SUCCESS) {
-        if (SUCCEEDED(result)) {
+            fatal("Cannot get Local Appdata directory!");
-            Path = appDataPath;
         }
-
+        Path = QueryKey(hKey, 5);
-        if (Path.empty()) {
-            fatal("Cannot get Local Appdata directory");
-        }
-
         Path += "\\BeamNG.drive\\";
     }
-
     std::string Ver = CheckVer(GetGameDir());
     Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
     Path += Ver + "\\";
+    info("Game user path: '" + Path + "'");
     return Path;
 }
 #elif defined(__linux__)
@@ -71,6 +64,7 @@ std::string GetGamePath() {
     std::string Ver = CheckVer(GetGameDir());
     Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
     Path += Ver + "/";
+    info("Game user path: '" + Path + "'");
     return Path;
 }
 #endif
@@ -84,14 +78,7 @@ void StartGame(std::string Dir) {
     std::string BaseDir = Dir; //+"\\Bin64";
     // Dir += R"(\Bin64\BeamNG.drive.x64.exe)";
     Dir += "\\BeamNG.drive.exe";
-    std::string gameArgs = "";
+    bSuccess = CreateProcessA(Dir.c_str(), nullptr, nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
-
-    for (int i = 0; i < options.game_arguments_length; i++) {
-        gameArgs += " ";
-        gameArgs += options.game_arguments[i];
-    }
-
-    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;
@@ -107,19 +94,9 @@ void StartGame(std::string Dir) {
 void StartGame(std::string Dir) {
     int status;
     std::string filename = (Dir + "/BinLinux/BeamNG.drive.x64");
-    std::vector<const char*> argv;
+    char* argv[] = { filename.data(), NULL };
-    argv.push_back(filename.data());
-    for (int i = 0; i < options.game_arguments_length; i++) {
-        argv.push_back(options.game_arguments[i]);
-    }
-
-    argv.push_back(nullptr);
     pid_t pid;
-    posix_spawn_file_actions_t spawn_actions;
+    int result = posix_spawn(&pid, filename.c_str(), NULL, NULL, argv, environ);
-    posix_spawn_file_actions_init(&spawn_actions);
-    posix_spawn_file_actions_addclose(&spawn_actions, STDOUT_FILENO);
-    posix_spawn_file_actions_addclose(&spawn_actions, STDERR_FILENO);
-    int result = posix_spawn(&pid, filename.c_str(), &spawn_actions, nullptr, const_cast<char**>(argv.data()), environ);
 
     if (result != 0) {
         error("Failed to Launch the game! launcher closing soon");
@@ -135,7 +112,7 @@ void StartGame(std::string Dir) {
 #endif
 
 void InitGame(const std::string& Dir) {
-    if (!options.no_launch) {
+    if (!Dev) {
         std::thread Game(StartGame, Dir);
         Game.detach();
     }

src/Logger.cpp

@@ -12,7 +12,6 @@
 #include <fstream>
 #include <sstream>
 #include <thread>
-#include "Options.h"
 
 std::string getDate() {
     time_t tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
@@ -55,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";
-    if (options.verbose) {
+    std::cout << Print;
-        std::cout << Print;
-    }
     addToLog(Print);
 }
 void warn(const std::string& toPrint) {
@@ -76,7 +75,7 @@ void fatal(const std::string& toPrint) {
     std::cout << Print;
     addToLog(Print);
     std::this_thread::sleep_for(std::chrono::seconds(5));
-    std::exit(1);
+    _Exit(-1);
 }
 void except(const std::string& toPrint) {
     std::string Print = getDate() + "[EXCEP] " + toPrint + "\n";

src/Network/Core.cpp

@@ -30,14 +30,11 @@
 #include <nlohmann/json.hpp>
 #include <set>
 #include <thread>
-#include <mutex>
-#include "Options.h"
-
-#include <future>
 
 extern int TraceBack;
 std::set<std::string>* ConfList = nullptr;
 bool TCPTerminate = false;
+int DEFAULT_PORT = 4444;
 bool Terminate = false;
 bool LoginAuth = false;
 std::string Username = "";
@@ -47,26 +44,6 @@ 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));
@@ -75,8 +52,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();
@@ -90,21 +67,8 @@ void StartSync(const std::string& Data) {
     info("Connecting to server");
 }
 
-std::mutex sendMutex;
-
-void CoreSend(std::string data) {
-    std::lock_guard lock(sendMutex);
-    
-    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|beammp\.gg|github\.com\/BeamMP\/|discord\.gg|patreon\.com\/BeamMP))");
+    std::regex link_pattern(R"(https:\/\/(?:\w+)?(?:\.)?(?:beammp\.com|discord\.gg))");
     std::smatch link_match;
     return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0;
 }
@@ -117,19 +81,22 @@ void Parse(std::string Data, SOCKET CSocket) {
     case 'A':
         Data = Data.substr(0, 1);
         break;
-    case 'B': {
+    case 'B':
-            NetReset();
+        NetReset();
-            Terminate = true;
+        Terminate = true;
-            TCPTerminate = true;
+        TCPTerminate = true;
-            Data.clear();
+        Data = Code + HTTP::Get("https://backend.beammp.com/servers-info");
-            auto future = std::async(std::launch::async, []() {
-                CoreSend("B" + HTTP::Get("https://backend.beammp.com/servers-info"));
-            });
-        }
         break;
     case 'C':
+        ListOfMods.clear();
         StartSync(Data);
-        Data.clear();
+        while (ListOfMods.empty() && !Terminate) {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+        if (ListOfMods == "-")
+            Data = "L";
+        else
+            Data = "L" + ListOfMods;
         break;
     case 'O': // open default browser with URL
         if (IsAllowedLink(Data.substr(1))) {
@@ -189,10 +156,8 @@ 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
@@ -221,30 +186,22 @@ void Parse(std::string Data, SOCKET CSocket) {
             }
             Data = "N" + Auth.dump();
         } else {
-            auto future = std::async(std::launch::async, [data = std::move(Data)]() {
+            Data = "N" + Login(Data.substr(Data.find(':') + 1));
-                CoreSend("N" + Login(data.substr(data.find(':') + 1)));
-            });
-            Data.clear();
         }
         break;
-    case 'W':
-        if (SubCode == 'Y') {
-            confirmed = 1;
-        } else if (SubCode == 'N') {
-            confirmed = 0;
-        }
-
-        Data.clear();
-        break;
     default:
         Data.clear();
         break;
     }
-    if (!Data.empty())
+    if (!Data.empty() && CSocket != -1) {
-        CoreSend(Data);
+        int res = send(CSocket, (Data + "\n").c_str(), int(Data.size()) + 1, 0);
+        if (res < 0) {
+            debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
+        }
+    }
 }
 void GameHandler(SOCKET Client) {
-    CoreSocket = Client;
+
     int32_t Size, Temp, Rcv;
     char Header[10] = { 0 };
     do {
@@ -298,7 +255,7 @@ void localRes() {
     ConfList = new std::set<std::string>;
 }
 void CoreMain() {
-    debug("Core Network on start! port: " + std::to_string(options.port));
+    debug("Core Network on start!");
     SOCKET LSocket, CSocket;
     struct addrinfo* res = nullptr;
     struct addrinfo hints { };
@@ -312,11 +269,11 @@ void CoreMain() {
 
     ZeroMemory(&hints, sizeof(hints));
 
-    hints.ai_family = AF_INET;
+    hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_flags = AI_PASSIVE;
-    iRes = getaddrinfo("127.0.0.1", std::to_string(options.port).c_str(), &hints, &res);
+    iRes = getaddrinfo(nullptr, std::to_string(DEFAULT_PORT).c_str(), &hints, &res);
     if (iRes) {
         debug("(Core) addr info failed with error: " + std::to_string(iRes));
         WSACleanup();

src/Network/DNS.cpp

@@ -7,6 +7,7 @@
 ///
 
 #include <string>
+#include "IPRegex.h"
 
 #if defined(_WIN32)
 #include <winsock2.h>
@@ -19,8 +20,9 @@
 #include "Logger.h"
 
 std::string GetAddr(const std::string& IP) {
-    if (IP.find_first_not_of("0123456789.") == -1)
+    if (!std::regex_match(IP, IP_REGEX)) {
         return IP;
+    }
     hostent* host;
 #ifdef _WIN32
     WSADATA wsaData;

src/Network/GlobalHandler.cpp

@@ -6,7 +6,6 @@
 /// Created by Anonymous275 on 7/25/2020
 ///
 #include "Network/network.hpp"
-#include <memory>
 #include <zlib.h>
 #if defined(_WIN32)
 #include <winsock2.h>
@@ -26,7 +25,6 @@
 #include <mutex>
 #include <string>
 #include <thread>
-#include "Options.h"
 
 std::chrono::time_point<std::chrono::high_resolution_clock> PingStart, PingEnd;
 bool GConnected = false;
@@ -126,17 +124,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;
@@ -158,11 +156,11 @@ SOCKET SetupListener() {
 #endif
 
     ZeroMemory(&hints, sizeof(hints));
-    hints.ai_family = AF_INET;
+    hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_flags = AI_PASSIVE;
-    iRes = getaddrinfo(nullptr, std::to_string(options.port + 1).c_str(), &hints, &result);
+    iRes = getaddrinfo(nullptr, std::to_string(DEFAULT_PORT + 1).c_str(), &hints, &result);
     if (iRes != 0) {
         error("(Proxy) info failed with error: " + std::to_string(iRes));
         WSACleanup();
@@ -236,8 +234,6 @@ 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;
@@ -249,7 +245,8 @@ void TCPGameServer(const std::string& IP, int Port) {
             break;
         }
         if (CServer) {
-            ClientThread = std::make_unique<std::thread>(TCPClientMain, IP, Port);
+            std::thread Client(TCPClientMain, IP, Port);
+            Client.detach();
         }
         CSocket = accept(GSocket, nullptr, nullptr);
         if (CSocket == -1) {
@@ -259,7 +256,8 @@ void TCPGameServer(const std::string& IP, int Port) {
         debug("(Proxy) Game Connected!");
         GConnected = true;
         if (CServer) {
-            NetMainThread = std::make_unique<std::thread>(NetMain, IP, Port);
+            std::thread t1(NetMain, IP, Port);
+            t1.detach();
             CServer = false;
         }
         int32_t Size, Temp, Rcv;
@@ -302,16 +300,6 @@ 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

@@ -8,12 +8,7 @@
 
 #include "Http.h"
 #include <Logger.h>
-#include <Network/network.hpp>
-#include <Startup.h>
-#include <Utils.h>
 #include <cmath>
-#include <curl/curl.h>
-#include <curl/easy.h>
 #include <filesystem>
 #include <fstream>
 #include <httplib.h>
@@ -61,81 +56,113 @@ void WriteHttpDebug(const httplib::Client& client, const std::string& method, co
     error(e.what());
 }
 
-static size_t CurlWriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
-    std::string* Result = reinterpret_cast<std::string*>(userp);
-    std::string NewContents(reinterpret_cast<char*>(contents), size * nmemb);
-    *Result += NewContents;
-    return size * nmemb;
-}
-
 bool HTTP::isDownload = false;
 std::string HTTP::Get(const std::string& IP) {
+    static std::mutex Lock;
+    std::scoped_lock Guard(Lock);
+
+    auto pos = IP.find('/', 10);
+
+    httplib::Client cli(IP.substr(0, pos).c_str());
+    cli.set_connection_timeout(std::chrono::seconds(10));
+    cli.set_follow_location(true);
+    auto res = cli.Get(IP.substr(pos).c_str(), ProgressBar);
     std::string Ret;
-    static thread_local CURL* curl = curl_easy_init();
+
-    if (curl) {
+    if (res) {
-        CURLcode res;
+        if (res->status == 200) {
-        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
+            Ret = res->body;
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWriteCallback);
+        } else {
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&Ret);
+            WriteHttpDebug(cli, "GET", IP, res);
-        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10); // seconds
+            error("Failed to GET '" + IP + "': " + res->reason + ", ssl verify = " + std::to_string(cli.get_openssl_verify_result()));
-        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
-        res = curl_easy_perform(curl);
-        if (res != CURLE_OK) {
-            error("GET to " + IP + " failed: " + std::string(curl_easy_strerror(res)));
-            return "";
         }
     } else {
-        error("Curl easy init failed");
+        if (isDownload) {
-        return "";
+            std::cout << "\n";
+        }
+        WriteHttpDebug(cli, "GET", IP, res);
+        error("HTTP Get failed on " + to_string(res.error()) + ", ssl verify = " + std::to_string(cli.get_openssl_verify_result()));
     }
+
     return Ret;
 }
 
 std::string HTTP::Post(const std::string& IP, const std::string& Fields) {
+    static std::mutex Lock;
+    std::scoped_lock Guard(Lock);
+
+    auto pos = IP.find('/', 10);
+
+    httplib::Client cli(IP.substr(0, pos).c_str());
+    cli.set_connection_timeout(std::chrono::seconds(10));
     std::string Ret;
-    static thread_local CURL* curl = curl_easy_init();
+
-    if (curl) {
+    if (!Fields.empty()) {
-        CURLcode res;
+        httplib::Result res = cli.Post(IP.substr(pos).c_str(), Fields, "application/json");
-        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
+
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWriteCallback);
+        if (res) {
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&Ret);
+            if (res->status != 200) {
-        curl_easy_setopt(curl, CURLOPT_POST, 1);
+                error(res->reason);
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, Fields.c_str());
+            }
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, Fields.size());
+            Ret = res->body;
-        struct curl_slist* list = nullptr;
+        } else {
-        list = curl_slist_append(list, "Content-Type: application/json");
+            WriteHttpDebug(cli, "POST", IP, res);
-        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+            error("HTTP Post failed on " + to_string(res.error()) + ", ssl verify = " + std::to_string(cli.get_openssl_verify_result()));
-        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10); // seconds
-        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
-        res = curl_easy_perform(curl);
-        curl_slist_free_all(list);
-        if (res != CURLE_OK) {
-            error("POST to " + IP + " failed: " + std::string(curl_easy_strerror(res)));
-            return "";
         }
     } else {
-        error("Curl easy init failed");
+        httplib::Result res = cli.Post(IP.substr(pos).c_str());
-        return "";
+        if (res) {
+            if (res->status != 200) {
+                error(res->reason);
+            }
+            Ret = res->body;
+        } else {
+            WriteHttpDebug(cli, "POST", IP, res);
+            error("HTTP Post failed on " + to_string(res.error()) + ", ssl verify = " + std::to_string(cli.get_openssl_verify_result()));
+        }
     }
-    return Ret;
+
+    if (Ret.empty())
+        return "-1";
+    else
+        return Ret;
+}
+
+bool HTTP::ProgressBar(size_t c, size_t t) {
+    if (isDownload) {
+        static double last_progress, progress_bar_adv;
+        progress_bar_adv = round(c / double(t) * 25);
+        std::cout << "\r";
+        std::cout << "Progress : [ ";
+        std::cout << round(c / double(t) * 100);
+        std::cout << "% ] [";
+        int i;
+        for (i = 0; i <= progress_bar_adv; i++)
+            std::cout << "#";
+        for (i = 0; i < 25 - progress_bar_adv; i++)
+            std::cout << ".";
+        std::cout << "]";
+        last_progress = round(c / double(t) * 100);
+    }
+    return true;
 }
 
 bool HTTP::Download(const std::string& IP, const std::string& Path) {
     static std::mutex Lock;
     std::scoped_lock Guard(Lock);
 
-    info("Downloading an update (this may take a while)");
+    isDownload = true;
     std::string Ret = Get(IP);
+    isDownload = false;
 
-    if (Ret.empty()) {
+    if (Ret.empty())
-        error("Download failed");
         return false;
-    }
 
     std::ofstream File(Path, std::ios::binary);
     if (File.is_open()) {
         File << Ret;
         File.close();
+        std::cout << "\n";
         info("Download Complete!");
     } else {
         error("Failed to open file directory: " + Path);
@@ -144,126 +171,3 @@ 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("127.0.0.1");
-        debug("HTTP Proxy listening on port " + std::to_string(ProxyPort));
-        HTTPProxy.listen_after_bind();
-    });
-    proxy.detach();
-}

src/Network/Resources.cpp

@@ -7,13 +7,6 @@
 ///
 
 #include "Network/network.hpp"
-#include <chrono>
-#include <iomanip>
-#include <ios>
-#include <mutex>
-#include <nlohmann/json.hpp>
-#include <openssl/err.h>
-#include <openssl/evp.h>
 
 #if defined(_WIN32)
 #include <ws2tcpip.h>
@@ -28,7 +21,6 @@
 
 #include "Logger.h"
 #include "Startup.h"
-#include <Utils.h>
 #include <atomic>
 #include <cmath>
 #include <cstring>
@@ -36,21 +28,35 @@
 #include <fstream>
 #include <future>
 #include <iostream>
+#include <string>
 #include <thread>
-
+#include <vector>
-#include "hashpp.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(CachingDirectory)) {
+    if (!fs::exists("Resources")) {
-        try {
+// Could we just use fs::create_directory instead?
-            fs::create_directories(CachingDirectory);
+#if defined(_WIN32)
-        } catch (const std::exception& e) {
+        _wmkdir(L"Resources");
-            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.");
+#elif defined(__linux__)
-            std::this_thread::sleep_for(std::chrono::seconds(3));
+        fs::create_directory(L"Resources");
-            std::exit(1);
+#endif
-        }
     }
 }
 void WaitForConfirm() {
@@ -73,20 +79,16 @@ 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 "";
     }
 
@@ -95,27 +97,23 @@ 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...");
-        CoreSend("L");
+        ListOfMods = "-";
         TCPSend("Done", Sock);
         info("Done!");
         return "";
@@ -130,62 +128,38 @@ void UpdateUl(bool D, const std::string& msg) {
         UlStatus = "UlLoading Resource " + msg;
 }
 
-float DownloadSpeed = 0;
-
 void AsyncUpdate(uint64_t& Rcv, uint64_t Size, const std::string& Name) {
     do {
         double pr = double(Rcv) / double(Size) * 100;
         std::string Per = std::to_string(trunc(pr * 10) / 10);
-        std::string SpeedString = "";
+        UpdateUl(true, Name + " (" + Per.substr(0, Per.find('.') + 2) + "%)");
-        if (DownloadSpeed > 0.01) {
-            std::stringstream ss;
-            ss << " at " << std::setprecision(1) << std::fixed << DownloadSpeed << " Mbit/s";
-            SpeedString = ss.str();
-        }
-        UpdateUl(true, Name + " (" + Per.substr(0, Per.find('.') + 2) + "%)" + SpeedString);
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
     } while (!Terminate && Rcv < Size);
 }
 
-// MICROSOFT, I DONT CARE, WRITE BETTER CODE
+char* TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
-#undef min
-
-std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
     if (Sock == -1) {
         Terminate = true;
         UUl("Invalid Socket");
-        return {};
+        return nullptr;
     }
-    std::vector<char> File(Size);
+    char* File = new char[Size];
     uint64_t Rcv = 0;
-
-    auto start = std::chrono::high_resolution_clock::now();
-
-    int i = 0;
     do {
-        // receive at most some MB at a time
+        int Len = int(Size - Rcv);
-        int Len = std::min(int(Size - Rcv), 1 * 1024 * 1024);
+        if (Len > 1000000)
+            Len = 1000000;
         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;
-            return {};
+            delete[] File;
+            return nullptr;
         }
         Rcv += Temp;
         GRcv += Temp;
-
-        auto end = std::chrono::high_resolution_clock::now();
-        auto difference = end - start;
-        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) {
-            debug("Download speed: " + std::to_string(uint32_t(megabits_per_s)) + "Mbit/s");
-        }
-        ++i;
     } while (Rcv < Size && !Terminate);
     return File;
 }
@@ -195,16 +169,16 @@ void MultiKill(SOCKET Sock, SOCKET Sock1) {
     Terminate = true;
 }
 SOCKET InitDSock() {
-    SOCKET DSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    SOCKET DSock = socket(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
     SOCKADDR_IN ServerAddr;
     if (DSock < 1) {
         KillSocket(DSock);
         Terminate = true;
         return 0;
     }
-    ServerAddr.sin_family = AF_INET;
+    ServerAddr.sin_family = AF_UNSPEC;
     ServerAddr.sin_port = htons(LastPort);
-    inet_pton(AF_INET, LastIP.c_str(), &ServerAddr.sin_addr);
+    inet_pton(AF_UNSPEC, LastIP.c_str(), &ServerAddr.sin_addr);
     if (connect(DSock, (SOCKADDR*)&ServerAddr, sizeof(ServerAddr)) != 0) {
         KillSocket(DSock);
         Terminate = true;
@@ -219,78 +193,44 @@ SOCKET InitDSock() {
     return DSock;
 }
 
-std::vector<char> SingleNormalDownload(SOCKET MSock, uint64_t Size, const std::string& Name) {
+std::string MultiDownload(SOCKET MSock, SOCKET DSock, uint64_t Size, const std::string& Name) {
-    DownloadSpeed = 0;
 
-    uint64_t GRcv = 0;
+    uint64_t GRcv = 0, MSize = Size / 2, DSize = Size - MSize;
 
-    std::thread Au([&] { AsyncUpdate(GRcv, Size, Name); });
+    std::thread Au(AsyncUpdate, std::ref(GRcv), Size, Name);
 
-    const std::vector<char> MData = TCPRcvRaw(MSock, GRcv, Size);
+    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();
 
-    if (MData.empty()) {
+    char* DData = TCPRcvRaw(DSock, GRcv, DSize);
-        KillSocket(MSock);
-        Terminate = true;
-        Au.join();
-        return {};
-    }
 
-    // ensure that GRcv is good before joining the async update thread
+    if (!DData) {
-    GRcv = MData.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();
-    return MData;
-}
-
-std::vector<char> MultiDownload(SOCKET MSock, SOCKET DSock, uint64_t Size, const std::string& Name) {
-    DownloadSpeed = 0;
-
-    uint64_t GRcv = 0;
-
-    uint64_t MSize = Size / 2;
-    uint64_t DSize = Size - MSize;
-
-    std::thread Au([&] { AsyncUpdate(GRcv, Size, Name); });
-
-    const std::vector<char> MData = TCPRcvRaw(MSock, GRcv, MSize);
-
-    if (MData.empty()) {
         MultiKill(MSock, DSock);
-        Terminate = true;
+        return "";
-        Au.join();
-        return {};
     }
 
-    const std::vector<char> DData = TCPRcvRaw(DSock, GRcv, DSize);
+    f1.wait();
+    char* MData = f1.get();
 
-    if (DData.empty()) {
+    if (!MData) {
         MultiKill(MSock, DSock);
-        Terminate = true;
+        return "";
-        Au.join();
-        return {};
     }
 
-    // ensure that GRcv is good before joining the async update thread
+    if (Au.joinable())
-    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();
+    /// 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;
 
-    std::vector<char> Result {};
+    memcpy(&Ret[MSize], DData, DSize);
-    Result.insert(Result.begin(), MData.begin(), MData.end());
+    delete[] DData;
-    Result.insert(Result.end(), DData.begin(), DData.end());
+
-    return Result;
+    return Ret;
 }
 
 void InvalidResource(const std::string& File) {
@@ -299,269 +239,31 @@ 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;
-        std::vector<ModInfo> modInfos;
-        try {
-            auto json = nlohmann::json::parse(packet);
-            if (json.empty()) {
-                return std::make_pair(true, modInfos);
-            }
-
-            for (const auto& entry : json) {
-                ModInfo modInfo {
-                    .FileName = entry["file_name"],
-                    .FileSize = entry["file_size"],
-                    .Hash = entry["hash"],
-                    .HashAlgorithm = entry["hash_algorithm"],
-                };
-                modInfos.push_back(modInfo);
-                success = true;
-            }
-        } catch (const std::exception& e) {
-            debug(std::string("Failed to receive mod list: ") + e.what());
-            warn("Failed to receive new mod list format! This server may be outdated, but everything should still work as expected.");
-        }
-        return std::make_pair(success, modInfos);
-    }
-    std::string FileName;
-    size_t FileSize;
-    std::string Hash;
-    std::string HashAlgorithm;
-};
-
-void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<ModInfo> ModInfos) {
-    if (ModInfos.empty()) {
-        CoreSend("L");
-        TCPSend("Done", Sock);
-        info("Done!");
-        return;
-    }
-
-    if (!SecurityWarning())
-        return;
-
-    info("Checking Resources...");
-
-    CheckForDir();
-
-    std::string t;
-    for (const auto& mod : ModInfos) {
-        t += mod.FileName + ";";
-    }
-
-    if (t.empty())
-        CoreSend("L");
-    else
-        CoreSend("L" + t);
-    t.clear();
-
-    info("Syncing...");
-
-    int ModNo = 1;
-    int TotalMods = ModInfos.size();
-    for (auto ModInfoIter = ModInfos.begin(), AlsoModInfoIter = ModInfos.begin(); ModInfoIter != ModInfos.end() && !Terminate; ++ModInfoIter, ++AlsoModInfoIter) {
-        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 = (fs::path(CachingDirectory) / FileName).string();
-        if (fs::exists(PathToSaveTo) && GetSha256HashReallyFast(PathToSaveTo) == ModInfoIter->Hash) {
-            debug("Mod '" + FileName + "' found in cache");
-            std::this_thread::sleep_for(std::chrono::milliseconds(50));
-            try {
-                if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                    fs::create_directories(GetGamePath() + "mods/multiplayer");
-                }
-                auto modname = ModInfoIter->FileName;
-#if defined(__linux__)
-                // Linux version of the game doesnt support uppercase letters in mod names
-                for (char& c : modname) {
-                    c = ::tolower(c);
-                }
-#endif
-                debug("Mod name: " + modname);
-                auto name = std::filesystem::path(GetGamePath()) / "mods/multiplayer" / modname;
-                std::string tmp_name = name.string();
-                tmp_name += ".tmp";
-
-                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()));
-                Terminate = true;
-                continue;
-            }
-            WaitForConfirm();
-            continue;
-        }
-        CheckForDir();
-        std::string FName = ModInfoIter->FileName;
-        do {
-            debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
-            TCPSend("f" + ModInfoIter->FileName, Sock);
-
-            std::string Data = TCPRcv(Sock);
-            if (Data == "CO" || Terminate) {
-                Terminate = true;
-                UUl("Server cannot find " + FName);
-                break;
-            }
-
-            std::string Name = std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + FName;
-
-            std::vector<char> DownloadedFile = SingleNormalDownload(Sock, ModInfoIter->FileSize, Name);
-
-            if (Terminate)
-                break;
-            UpdateUl(false, std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + FName);
-
-            // 1. write downloaded file to disk
-            {
-                std::ofstream OutFile(PathToSaveTo, std::ios::binary | std::ios::trunc);
-                OutFile.write(DownloadedFile.data(), DownloadedFile.size());
-                OutFile.flush();
-            }
-            // 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) != ModInfoIter->FileSize && !Terminate);
-        if (!Terminate) {
-            if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                fs::create_directories(GetGamePath() + "mods/multiplayer");
-            }
-
-// Linux version of the game doesnt support uppercase letters in mod names
-#if defined(__linux__)
-            for (char& c : FName) {
-                c = ::tolower(c);
-            }
-#endif
-
-            fs::copy_file(PathToSaveTo, std::filesystem::path(GetGamePath()) / "mods/multiplayer" / FName, fs::copy_options::overwrite_existing);
-        }
-        WaitForConfirm();
-        ++ModNo;
-    }
-
-    if (!Terminate) {
-        TCPSend("Done", Sock);
-        info("Done!");
-    } else {
-        UlStatus = "Ulstart";
-        info("Connection Terminated!");
-    }
-}
-
 void SyncResources(SOCKET Sock) {
     std::string Ret = Auth(Sock);
-
-    debug("Mod info: " + Ret);
-
-    if (Ret.starts_with("R")) {
-        debug("This server is likely outdated, not trying to parse new mod info format");
-    } else {
-        auto [success, modInfo] = ModInfo::ParseModInfosFromPacket(Ret);
-
-        if (success) {
-            NewSyncResources(Sock, Ret, modInfo);
-            return;
-        }
-    }
-
     if (Ret.empty())
         return;
 
-    if (!SecurityWarning())
-        return;
-
     info("Checking Resources...");
     CheckForDir();
 
-    std::vector<std::string> list = Utils::Split(Ret, ";");
+    std::vector<std::string> list = 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 PathToSaveTo, t;
+    std::string a, t;
     for (const std::string& name : FNames) {
         if (!name.empty()) {
             t += name.substr(name.find_last_of('/') + 1) + ";";
         }
     }
     if (t.empty())
-        CoreSend("L");
+        ListOfMods = "-";
     else
-        CoreSend("L" + t);
+        ListOfMods = t;
     t.clear();
     for (auto FN = FNames.begin(), FS = FSizes.begin(); FN != FNames.end() && !Terminate; ++FN, ++FS) {
         auto pos = FN->find_last_of('/');
@@ -580,23 +282,21 @@ 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 + FN->substr(pos);
+            a = "Resources" + FN->substr(pos);
-        } else {
+        } else
             continue;
-        }
         Pos++;
-        auto FileSize = std::stoull(*FS);
+        if (fs::exists(a)) {
-        if (fs::exists(PathToSaveTo)) {
             if (FS->find_first_not_of("0123456789") != std::string::npos)
                 continue;
-            if (fs::file_size(PathToSaveTo) == FileSize) {
+            if (fs::file_size(a) == std::stoull(*FS)) {
-                UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + PathToSaveTo.substr(PathToSaveTo.find_last_of('/')));
+                UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + a.substr(a.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 modname = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
+                    auto modname = a.substr(a.find_last_of('/'));
 #if defined(__linux__)
                     // Linux version of the game doesnt support uppercase letters in mod names
                     for (char& c : modname) {
@@ -605,7 +305,7 @@ void SyncResources(SOCKET Sock) {
 #endif
                     auto name = GetGamePath() + "mods/multiplayer" + modname;
                     auto tmp_name = name + ".tmp";
-                    fs::copy_file(PathToSaveTo, tmp_name, fs::copy_options::overwrite_existing);
+                    fs::copy_file(a, 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()));
@@ -615,12 +315,11 @@ void SyncResources(SOCKET Sock) {
                 WaitForConfirm();
                 continue;
             } else
-                remove(PathToSaveTo.c_str());
+                remove(a.c_str());
         }
         CheckForDir();
-        std::string FName = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
+        std::string FName = a.substr(a.find_last_of('/'));
         do {
-            debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
             TCPSend("f" + *FN, Sock);
 
             std::string Data = TCPRcv(Sock);
@@ -632,23 +331,19 @@ void SyncResources(SOCKET Sock) {
 
             std::string Name = std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + FName;
 
-            std::vector<char> DownloadedFile = MultiDownload(Sock, DSock, FileSize, Name);
+            Data = MultiDownload(Sock, DSock, std::stoull(*FS), 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();
+            }
 
-            // 1. write downloaded file to disk
+        } while (fs::file_size(a) != std::stoull(*FS) && !Terminate);
-            {
-                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");
@@ -661,11 +356,10 @@ void SyncResources(SOCKET Sock) {
             }
 #endif
 
-            fs::copy_file(PathToSaveTo, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
+            fs::copy_file(a, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
         }
         WaitForConfirm();
     }
-
     KillSocket(DSock);
     if (!Terminate) {
         TCPSend("Done", Sock);

src/Network/VehicleData.cpp

@@ -7,7 +7,6 @@
 ///
 #include "Network/network.hpp"
 #include "Zlib/Compressor.h"
-#include <stdexcept>
 
 #if defined(_WIN32)
 #include <ws2tcpip.h>
@@ -51,13 +50,9 @@ void SendLarge(std::string Data) {
 void UDPParser(std::string_view Packet) {
     if (Packet.substr(0, 4) == "ABG:") {
         auto substr = Packet.substr(4);
-        try {
+        auto res = DeComp(std::span<const char>(substr.data(), substr.size()));
-            auto res = DeComp(std::span<const char>(substr.data(), substr.size()));
+        std::string DeCompPacket = std::string(res.data(), res.size());
-            std::string DeCompPacket = std::string(res.data(), res.size());
+        ServerParser(DeCompPacket);
-            ServerParser(DeCompPacket);
-        } catch (const std::runtime_error& err) {
-            error("Error in decompression of UDP, ignoring");
-        }
     } else {
         ServerParser(Packet);
     }
@@ -90,18 +85,15 @@ void UDPClientMain(const std::string& IP, int Port) {
 
     delete ToServer;
     ToServer = new sockaddr_in;
-    ToServer->sin_family = AF_INET;
+    ToServer->sin_family = AF_UNSPEC;
     ToServer->sin_port = htons(Port);
-    inet_pton(AF_INET, IP.c_str(), &ToServer->sin_addr);
+    inet_pton(AF_UNSPEC, IP.c_str(), &ToServer->sin_addr);
-    UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
+    UDPSock = socket(AF_UNSPEC, SOCK_DGRAM, 0);
     GameSend("P" + std::to_string(ClientID));
     TCPSend("H", TCPSock);
     UDPSend("p");
-    debug("Starting UDP receive loop");
+    while (!Terminate)
-    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, Temp;
+    int32_t Header, BytesRcv = 0, Temp;
     std::vector<char> Data(sizeof(Header));
-    Temp = recv(Sock, Data.data(), sizeof(Header), MSG_WAITALL);
+    do {
-    if (!CheckBytes(Temp)) {
+        Temp = recv(Sock, &Data[BytesRcv], 4 - BytesRcv, 0);
-        UUl("Socket Closed Code 3");
+        if (!CheckBytes(Temp)) {
-        return "";
+            UUl("Socket Closed Code 3");
-    }
+            return "";
-    memcpy(&Header, Data.data(), sizeof(Header));
+        }
+        BytesRcv += Temp;
+    } while (BytesRcv < 4);
+    memcpy(&Header, &Data[0], sizeof(Header));
 
-    if (!CheckBytes(Temp)) {
+    if (!CheckBytes(BytesRcv)) {
         UUl("Socket Closed Code 4");
         return "";
     }
-
+    Data.resize(Header);
-    Data.resize(Header, 0);
+    BytesRcv = 0;
-    Temp = recv(Sock, Data.data(), Header, MSG_WAITALL);
+    do {
-    if (!CheckBytes(Temp)) {
+        Temp = recv(Sock, &Data[BytesRcv], Header - BytesRcv, 0);
-        UUl("Socket Closed Code 5");
+        if (!CheckBytes(Temp)) {
-        return "";
+            UUl("Socket Closed Code 5");
-    }
+            return "";
+        }
+        BytesRcv += Temp;
+    } while (BytesRcv < Header);
 
     std::string Ret(Data.data(), Header);
 
     if (Ret.substr(0, 4) == "ABG:") {
         auto substr = Ret.substr(4);
-        try {
+        auto res = DeComp(std::span<char>(substr.data(), substr.size()));
-            auto res = DeComp(std::span<char>(substr.data(), substr.size()));
+        Ret = std::string(res.data(), res.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
@@ -134,7 +134,7 @@ void TCPClientMain(const std::string& IP, int Port) {
     WSADATA wsaData;
     WSAStartup(514, &wsaData); // 2.2
 #endif
-    TCPSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    TCPSock = socket(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
 
     if (TCPSock == -1) {
         printf("Client: socket failed! Error code: %d\n", WSAGetLastError());
@@ -142,9 +142,9 @@ void TCPClientMain(const std::string& IP, int Port) {
         return;
     }
 
-    ServerAddr.sin_family = AF_INET;
+    ServerAddr.sin_family = AF_UNSPEC;
     ServerAddr.sin_port = htons(Port);
-    inet_pton(AF_INET, IP.c_str(), &ServerAddr.sin_addr);
+    inet_pton(AF_UNSPEC, IP.c_str(), &ServerAddr.sin_addr);
     RetCode = connect(TCPSock, (SOCKADDR*)&ServerAddr, sizeof(ServerAddr));
     if (RetCode != 0) {
         UlStatus = "UlConnection Failed!";
@@ -152,7 +152,6 @@ void TCPClientMain(const std::string& IP, int Port) {
         KillSocket(TCPSock);
         WSACleanup();
         Terminate = true;
-        CoreSend("L");
         return;
     }
     info("Connected!");

src/Options.cpp

@@ -1,107 +0,0 @@
-#include "Options.h"
-
-#include "Logger.h"
-#include <cstdlib>
-#include <filesystem>
-
-void InitOptions(int argc, const char *argv[], Options &options) {
-    int i = 1;
-
-    options.argc = argc;
-    options.argv = argv;
-
-    std::string AllOptions;
-    for (int i = 0; i < argc; ++i) {
-        AllOptions += std::string(argv[i]);
-        if (i + 1 < argc) {
-            AllOptions += " ";
-        }
-    }
-    debug("Launcher was invoked as: '" + AllOptions + "'");
-
-
-    if (argc > 2) {
-        if (std::string(argv[1]) == "0" && std::string(argv[2]) == "0") {
-            options.verbose = true;
-            options.no_download = true;
-            options.no_launch = true;
-            options.no_update = true;
-            warn("You are using deprecated commandline arguments, please use --dev instead");
-            return;
-        }
-    }
-
-    options.executable_name = std::string(argv[0]);
-
-    while (i < argc) {
-        std::string argument(argv[i]);
-        if (argument == "-p" || argument == "--port") {
-            if (i + 1 >= argc) {
-                std::string error_message =
-                    "No port specified, resorting to default (";
-                error_message += std::to_string(options.port);
-                error_message += ")";
-                error(error_message);
-                i++;
-                continue;
-            }
-
-            int port = options.port;
-
-            try {
-                port = std::stoi(argv[i + 1]);
-            } catch (std::exception& e) {
-                error("Invalid port specified: " + std::string(argv[i + 1]) + " " + std::string(e.what()));
-            }
-
-            if (port <= 0) {
-                std::string error_message =
-                    "Port invalid, must be a non-zero positive "
-                    "integer, resorting to default (";
-                error_message += options.port;
-                error_message += ")";
-                error(error_message);
-                i++;
-                continue;
-            }
-
-            options.port = port;
-            i++;
-        } else if (argument == "-v" || argument == "--verbose") {
-            options.verbose = true;
-        } else if (argument == "--no-download") {
-            options.no_download = true;
-        } else if (argument == "--no-update") {
-            options.no_update = true;
-        } else if (argument == "--no-launch") {
-            options.no_launch = true;
-        } else if (argument == "--dev") {
-            options.verbose = true;
-            options.no_download = true;
-            options.no_launch = true;
-            options.no_update = true;
-        } else if (argument == "--" || argument == "--game") {
-            options.game_arguments = &argv[i + 1];
-            options.game_arguments_length = argc - i - 1;
-            break;
-        } else if (argument == "--help" || argument == "-h" || argument == "/?") {
-            std::cout << "USAGE:\n"
-                "\t" + std::filesystem::path(options.executable_name).filename().string() + " [OPTIONS] [-- <GAME ARGS>...]\n"
-                "\n"
-                "OPTIONS:\n"
-                "\t--port <port>    -p  Change the default listen port to <port>. This must be configured ingame, too\n"
-                "\t--verbose        -v  Verbose mode, prints debug messages\n"
-                "\t--no-download        Skip downloading and installing the BeamMP Lua mod\n"
-                "\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--game <args...>     Passes ALL following arguments to the game, see also `--`\n"
-                << std::flush;
-            exit(0);
-        } else {
-            warn("Unknown option: " + argument);
-        }
-
-        i++;
-    }
-}

src/Security/BeamNG.cpp

@@ -17,6 +17,7 @@
 #endif
 #include "Logger.h"
 #include <fstream>
+#include <sstream>
 #include <string>
 #include <thread>
 
@@ -33,8 +34,24 @@ 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__)
@@ -158,7 +175,151 @@ 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)";
@@ -166,18 +327,17 @@ void LegitimacyCheck() {
     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;
-    } else {
+        // TraceBack++;
-        debug("Failed to OPEN key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
+    } else
         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

@@ -58,7 +58,7 @@ std::string Login(const std::string& fields) {
     try {
         std::string Buffer = HTTP::Post("https://auth.beammp.com/userlogin", fields);
 
-        if (Buffer.empty()) {
+        if (Buffer == "-1") {
             return GetFail("Failed to communicate with the auth system!");
         }
 
@@ -91,7 +91,6 @@ std::string Login(const std::string& fields) {
         if (d.contains("message")) {
             d.erase("private_key");
             d.erase("public_key");
-            debug("Authentication result: " + d["message"].get<std::string>());
             return d.dump();
         }
         return GetFail("Invalid message parsing!");
@@ -120,7 +119,7 @@ void CheckLocalKey() {
 
             nlohmann::json d = nlohmann::json::parse(Buffer, nullptr, false);
 
-            if (Buffer.empty() || Buffer.at(0) != '{' || d.is_discarded()) {
+            if (Buffer == "-1" || Buffer.at(0) != '{' || d.is_discarded()) {
                 error(Buffer);
                 info("Invalid answer from authentication servers.");
                 UpdateKey(nullptr);
@@ -138,6 +137,7 @@ void CheckLocalKey() {
                 if (d.contains("id")) {
                     UserID = d["id"].get<int>();
                 }
+                // info(Role);
             } else {
                 info("Auto-Authentication unsuccessful please re-login!");
                 UpdateKey(nullptr);

src/Startup.cpp

@@ -8,7 +8,6 @@
 
 #include "zip_file.h"
 #include <charconv>
-#include <cstring>
 #include <httplib.h>
 #include <nlohmann/json.hpp>
 #include <string>
@@ -26,9 +25,9 @@
 #include <filesystem>
 #include <fstream>
 #include <thread>
-#include "Options.h"
 
 extern int TraceBack;
+bool Dev = false;
 int ProxyPort = 0;
 
 namespace fs = std::filesystem;
@@ -82,13 +81,13 @@ std::string GetEN() {
 }
 
 std::string GetVer() {
-    return "2.3";
+    return "2.0";
 }
 std::string GetPatch() {
-    return ".2";
+    return ".99";
 }
 
-std::string GetEP(const char* P) {
+std::string GetEP(char* P) {
     static std::string Ret = [&]() {
         std::string path(P);
         return path.substr(0, path.find_last_of("\\/") + 1);
@@ -96,24 +95,23 @@ std::string GetEP(const char* P) {
     return Ret;
 }
 #if defined(_WIN32)
-void ReLaunch() {
+void ReLaunch(int argc, char* args[]) {
     std::string Arg;
-    for (int c = 2; c <= options.argc; c++) {
+    for (int c = 2; c <= argc; c++) {
-        Arg += options.argv[c - 1];
         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);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     exit(1);
 }
-void URelaunch() {
+void URelaunch(int argc, char* args[]) {
     std::string Arg;
-    for (int c = 2; c <= options.argc; c++) {
+    for (int c = 2; c <= argc; c++) {
-        Arg += options.argv[c - 1];
         Arg += " ";
+        Arg += args[c - 1];
     }
     ShellExecute(nullptr, "open", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
     ShowWindow(GetConsoleWindow(), 0);
@@ -121,50 +119,46 @@ void URelaunch() {
     exit(1);
 }
 #elif defined(__linux__)
-void ReLaunch() {
+void ReLaunch(int argc, char* args[]) {
     std::string Arg;
-    for (int c = 2; c <= options.argc; c++) {
+    for (int c = 2; c <= argc; c++) {
-        Arg += options.argv[c - 1];
         Arg += " ";
+        Arg += args[c - 1];
     }
-    info("Relaunch!");
     system("clear");
-    int ret = execv(options.executable_name.c_str(), const_cast<char**>(options.argv));
+    execl((GetEP() + GetEN()).c_str(), Arg.c_str(), NULL);
-    if (ret < 0) {
-        error(std::string("execv() failed with: ") + strerror(errno) + ". Failed to relaunch");
-        exit(1);
-    }
     std::this_thread::sleep_for(std::chrono::seconds(1));
     exit(1);
 }
-void URelaunch() {
+void URelaunch(int argc, char* args[]) {
-    int ret = execv(options.executable_name.c_str(), const_cast<char**>(options.argv));
+    std::string Arg;
-    if (ret < 0) {
+    for (int c = 2; c <= argc; c++) {
-        error(std::string("execv() failed with: ") + strerror(errno) + ". Failed to relaunch");
+        Arg += " ";
-        exit(1);
+        Arg += args[c - 1];
     }
+    execl((GetEP() + GetEN()).c_str(), Arg.c_str(), NULL);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     exit(1);
 }
 #endif
 
-void CheckName() {
+void CheckName(int argc, char* args[]) {
 #if defined(_WIN32)
-    std::string DN = GetEN(), CDir = options.executable_name, FN = CDir.substr(CDir.find_last_of('\\') + 1);
+    std::string DN = GetEN(), CDir = args[0], 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);
+    std::string DN = GetEN(), CDir = args[0], FN = CDir.substr(CDir.find_last_of('/') + 1);
 #endif
     if (FN != DN) {
         if (fs::exists(DN))
             remove(DN.c_str());
         if (fs::exists(DN))
-            ReLaunch();
+            ReLaunch(argc, args);
         std::rename(FN.c_str(), DN.c_str());
-        URelaunch();
+        URelaunch(argc, args);
     }
 }
 
-void CheckForUpdates(const std::string& CV) {
+void CheckForUpdates(int argc, char* args[], const std::string& CV) {
     std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/launcher?branch=" + Branch + "&pk=" + PublicKey);
     std::string LatestVersion = HTTP::Get(
         "https://backend.beammp.com/version/launcher?branch=" + Branch + "&pk=" + PublicKey);
@@ -173,31 +167,44 @@ void CheckForUpdates(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)
-    if (FileHash != LatestHash && IsOutdated(Version(VersionStrToInts(GetVer() + GetPatch())), Version(VersionStrToInts(LatestVersion)))) {
+#elif defined(__linux__)
-        if (!options.no_update) {
+    system("clear");
-            info("Launcher update found!");
+#endif
-#if defined(__linux__)
+
-            error("Auto update is NOT implemented for the Linux version. Please update manually ASAP as updates contain security patches.");
+    if (FileHash != LatestHash && IsOutdated(Version(VersionStrToInts(GetVer() + GetPatch())), Version(VersionStrToInts(LatestVersion))) && !Dev) {
-#else
+        info("Launcher update found!");
-            fs::remove(Back);
+#if defined(__linux__)
-            fs::rename(EP, Back);
+        error("Auto update is NOT implemented for the Linux version. Please update manually ASAP as updates contain security patches.");
-            info("Downloading Launcher update " + LatestHash);
+#else
-            HTTP::Download(
+        fs::remove(Back);
-                "https://backend.beammp.com/builds/launcher?download=true"
+        fs::rename(EP, Back);
-                "&pk="
+        info("Downloading Launcher update " + LatestHash);
-                    + PublicKey + "&branch=" + Branch,
+        HTTP::Download(
-                EP);
+            "https://backend.beammp.com/builds/launcher?download=true"
-            URelaunch();
+            "&pk="
+                + PublicKey + "&branch=" + Branch,
+            EP);
+        URelaunch(argc, args);
 #endif
-        } else {
-            warn("Launcher update was found, but not updating because --no-update or --dev was specified.");
-        }
     } else
         info("Launcher version is up to date");
     TraceBack++;
 }
 
+void CustomPort(int argc, char* argv[]) {
+    if (argc > 1) {
+        std::string Port = argv[1];
+        if (Port.find_first_not_of("0123456789") == std::string::npos) {
+            if (std::stoi(Port) > 1000) {
+                DEFAULT_PORT = std::stoi(Port);
+                warn("Running on custom port : " + std::to_string(DEFAULT_PORT));
+            }
+        }
+        if (argc > 2)
+            Dev = true;
+    }
+}
 
 #ifdef _WIN32
 void LinuxPatch() {
@@ -229,21 +236,26 @@ void LinuxPatch() {
 #endif
 
 #if defined(_WIN32)
-
+void InitLauncher(int argc, char* argv[]) {
-void InitLauncher() {
+    system("cls");
     SetConsoleTitleA(("BeamMP Launcher v" + std::string(GetVer()) + GetPatch()).c_str());
-    CheckName();
+    InitLog();
+    CheckName(argc, argv);
     LinuxPatch();
     CheckLocalKey();
-    CheckForUpdates(std::string(GetVer()) + GetPatch());
+    ConfigInit();
+    CustomPort(argc, argv);
+    CheckForUpdates(argc, argv, std::string(GetVer()) + GetPatch());
 }
 #elif defined(__linux__)
-
+void InitLauncher(int argc, char* argv[]) {
-void InitLauncher() {
+    system("clear");
-    info("BeamMP Launcher v" + GetVer() + GetPatch());
+    InitLog();
-    CheckName();
+    CheckName(argc, argv);
     CheckLocalKey();
-    CheckForUpdates(std::string(GetVer()) + GetPatch());
+    ConfigInit();
+    CustomPort(argc, argv);
+    CheckForUpdates(argc, argv, std::string(GetVer()) + GetPatch());
 }
 #endif
 
@@ -305,9 +317,8 @@ void PreGame(const std::string& GamePath) {
     info("Game Version : " + GameVer);
 
     CheckMP(GetGamePath() + "mods/multiplayer");
-    info("Game user path: " + GetGamePath());
 
-    if (!options.no_download) {
+    if (!Dev) {
         std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/mod?branch=" + Branch + "&pk=" + PublicKey);
         transform(LatestHash.begin(), LatestHash.end(), LatestHash.begin(), ::tolower);
         LatestHash.erase(std::remove_if(LatestHash.begin(), LatestHash.end(),
@@ -346,3 +357,59 @@ 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

@@ -10,12 +10,8 @@
 #include "Network/network.hpp"
 #include "Security/Init.h"
 #include "Startup.h"
-#include <curl/curl.h>
 #include <iostream>
 #include <thread>
-#include "Options.h"
-
-Options options;
 
 [[noreturn]] void flush() {
     while (true) {
@@ -24,48 +20,26 @@ Options options;
     }
 }
 
-int main(int argc, const char** argv) try {
+int main(int argc, char* argv[]) {
-#if defined(_WIN32)
-    system("cls");
-#elif defined(__linux__)
-    system("clear");
-#endif
-
 #ifdef DEBUG
     std::thread th(flush);
     th.detach();
 #endif
 
-    curl_global_init(CURL_GLOBAL_ALL);
-
     GetEP(argv[0]);
 
-    InitLog();
+    InitLauncher(argc, argv);
-    ConfigInit();
-    InitOptions(argc, argv, options);
-    info("Mod caching directory: " + CachingDirectory);
-    InitLauncher();
-
-    info("IMPORTANT: You MUST keep this window open to play BeamMP!");
 
     try {
         LegitimacyCheck();
     } catch (std::exception& e) {
-        error("Failure in LegitimacyCheck: " + std::string(e.what()));
+        fatal("Main 1 : " + std::string(e.what()));
-        throw;
     }
 
-    try {
+    StartProxy();
-        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();
-} catch (const std::exception& e) {
+
-    error(std::string("Exception in main(): ") + e.what());
+    /// TODO: make sure to use argv[0] for everything that should be in the same dir (mod down ect...)
-    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));
 }

vcpkg.json

@@ -3,7 +3,6 @@
     "cpp-httplib",
     "nlohmann-json",
     "zlib",
-    "openssl",
+    "openssl"
-    "curl"
   ]
 }