Change and debug CreateProcessW params

.github/workflows/cmake-linux.yml

@@ -20,7 +20,7 @@ jobs:
         with:
             vcpkgArguments: 'zlib nlohmann-json openssl cpp-httplib[openssl]'
             vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-            vcpkgGitCommitId: 'b5d1a94fb7f88fd835e360fd23a45a09ceedbf48'
+            vcpkgGitCommitId: '40616a5e954f7be1077ef37db3fbddbd5dcd1ca6'
 
       - name: Create Build Environment
         run: cmake -E make_directory ${{github.workspace}}/build-linux

.github/workflows/cmake-windows.yml

@@ -20,7 +20,7 @@ jobs:
         with:
             vcpkgArguments: 'discord-rpc zlib nlohmann-json openssl cpp-httplib[openssl]'
             vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-            vcpkgGitCommitId: 'b5d1a94fb7f88fd835e360fd23a45a09ceedbf48'
+            vcpkgGitCommitId: '40616a5e954f7be1077ef37db3fbddbd5dcd1ca6'
             vcpkgTriplet: 'x64-windows-static'
 
       - name: Create Build Environment

include/Network/network.hpp

@@ -38,11 +38,10 @@ extern std::string MStatus;
 extern std::string UlStatus;
 extern std::string PublicKey;
 extern std::string PrivateKey;
-extern std::string magic;
 int KillSocket(uint64_t Dead);
 void UUl(const std::string& R);
 void UDPSend(std::string Data);
-bool CheckBytes(int32_t Bytes, int32_t Expected = -1);
+bool CheckBytes(int32_t Bytes);
 void GameSend(std::string_view Data);
 void SendLarge(std::string Data);
 std::string TCPRcv(uint64_t Sock);
@@ -56,4 +55,3 @@ void UDPClientMain(const std::string& IP, int Port);
 void TCPGameServer(const std::string& IP, int Port);
 bool SecurityWarning();
 void CoreSend(std::string data);
-int RecvWaitAll(int sockfd, char *buf, int len);

include/Options.h

@@ -20,7 +20,6 @@ struct Options {
     bool no_update = false;
     bool no_launch = false;
     const char* user_path = nullptr;
-    std::string region;
     const char **game_arguments = nullptr;
     int game_arguments_length = 0;
     const char** argv = nullptr;

include/Utils.h

@@ -13,39 +13,22 @@
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <regex>
-#include <cstdint>
-#include <cstring>
 #include <string>
 #include <variant>
 #include <vector>
-#include <array>
-#include <cerrno>
-#include <cstring>
-#include <stdexcept>
-#if defined(__linux__)
-#include <sys/socket.h>
-#include "linuxfixes.h"
-#else
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#endif
 
 #ifdef _WIN32
 #define beammp_fs_string std::wstring
 #define beammp_fs_char wchar_t
 #define beammp_wide(str) L##str
-#define beammp_stdout std::wcout
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #else
 #define beammp_fs_string std::string
 #define beammp_fs_char char
 #define beammp_wide(str) str
-#define beammp_stdout std::cout
 #endif
 
-#include "Logger.h"
-
 namespace Utils {
     inline std::vector<std::string> Split(const std::string& String, const std::string& delimiter) {
         std::vector<std::string> Val;
@@ -60,7 +43,7 @@ namespace Utils {
         if (!s.empty())
             Val.push_back(s);
         return Val;
-    }
+    };
     inline std::string ExpandEnvVars(const std::string& input) {
         std::string result;
         std::regex envPattern(R"(%([^%]+)%|\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([^}]+)\})");
@@ -137,6 +120,13 @@ namespace Utils {
             if (line.empty() || line[0] == ';' || line[0] == '#')
                 continue;
 
+            for (auto& c : line) {
+                if (c == '#' || c == ';') {
+                    line = line.substr(0, &c - &line[0]);
+                    break;
+                }
+            }
+
             auto invalidLineLog = [&]{
                 debug("Invalid INI line: " + line);
                 debug("Surrounding lines: \n" +
@@ -301,49 +291,4 @@ namespace Utils {
             return "";
         }
     }
-
-    template<typename T>
-    inline std::vector<char> PrependHeader(const T& data) {
-        std::vector<char> size_buffer(4);
-        uint32_t len = data.size();
-        std::memcpy(size_buffer.data(), &len, 4);
-        std::vector<char> buffer;
-        buffer.reserve(size_buffer.size() + data.size());
-        buffer.insert(buffer.begin(), size_buffer.begin(), size_buffer.end());
-        buffer.insert(buffer.end(), data.begin(), data.end());
-        return buffer;
-    }
-
-    inline uint32_t RecvHeader(SOCKET socket) {
-        std::array<uint8_t, sizeof(uint32_t)> header_buffer {};
-        auto n = recv(socket, reinterpret_cast<char*>(header_buffer.data()), header_buffer.size(), MSG_WAITALL);
-        if (n < 0) {
-            throw std::runtime_error(std::string("recv() of header failed: ") + std::strerror(errno));
-        } else if (n == 0) {
-            throw std::runtime_error("Game disconnected");
-        }
-        return *reinterpret_cast<uint32_t*>(header_buffer.data());
-    }
-
-    /// Throws!!!
-    inline void ReceiveFromGame(SOCKET socket, std::vector<char>& out_data) {
-        auto header = RecvHeader(socket);
-        out_data.resize(header);
-        auto n = recv(socket, reinterpret_cast<char*>(out_data.data()), out_data.size(), MSG_WAITALL);
-        if (n < 0) {
-            throw std::runtime_error(std::string("recv() of data failed: ") + std::strerror(errno));
-        } else if (n == 0) {
-            throw std::runtime_error("Game disconnected");
-        }
-    }
-
-    inline std::string RegionToTopLevelDomain(const std::string region) {
-        if (region == "Restricted") {
-            return "beammp.ru";
-        }
-        else if (region == "Developer") {
-            return "beammp.dev";
-        }
-        return "beammp.com"; // Global
-    }
 };

src/Config.cpp

@@ -36,10 +36,6 @@ void ParseConfig(const nlohmann::json& d) {
         CachingDirectory = std::filesystem::path(d["CachingDirectory"].get<std::string>());
         info(beammp_wide("Mod caching directory: ") + beammp_fs_string(CachingDirectory.relative_path()));
     }
-    if (d.contains("Region") && d["Region"].is_string()) {
-        options.region = d["Region"].get<std::string>();
-        info("Set the region to: " + options.region);
-    }
 
     if (d.contains("Dev") && d["Dev"].is_boolean()) {
         bool dev = d["Dev"].get<bool>();
@@ -71,18 +67,14 @@ void ConfigInit() {
         } else
             fatal("Failed to open Launcher.cfg!");
     } else {
-        if (options.region.empty())
-        {
-            options.region = "Global";
-        }
         std::ofstream cfg("Launcher.cfg");
         if (cfg.is_open()) {
             cfg <<
                 R"({
     "Port": 4444,
     "Build": "Default",
-    "CachingDirectory": "./Resources",
-    "Region": ")" << options.region << "\"\n}";
+    "CachingDirectory": "./Resources"
+})";
             cfg.close();
         } else {
             fatal("Failed to write config on disk!");

src/GameStart.cpp

@@ -4,8 +4,6 @@
  SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
-#include <cstring>
-#include "Utils.h"
 #if defined(_WIN32)
 #include <shlobj.h>
 #elif defined(__linux__)
@@ -20,6 +18,7 @@
 #include "Logger.h"
 #include "Options.h"
 #include "Startup.h"
+#include "Utils.h"
 #include <Security/Init.h>
 #include <filesystem>
 #include <thread>
@@ -58,6 +57,7 @@ std::filesystem::path GetGamePath() {
             if (ini.contains("filesystem") && std::get<std::map<std::string, std::string>>(ini["filesystem"]).contains("UserPath"))
                 userPath = Utils::ToWString(std::get<std::map<std::string, std::string>>(ini["filesystem"])["UserPath"]);
 
+            if (!userPath.empty() && Path.empty())
                 if (userPath = Utils::ExpandEnvVars(userPath); std::filesystem::exists(userPath)) {
                     Path = userPath;
                     debug(L"Using custom user folder path from startup.ini: " + Path.wstring());
@@ -94,6 +94,7 @@ std::filesystem::path GetGamePath() {
 
                     }
 
+                    if (!userPath.empty() && Path.empty())
                         if (userPath = std::filesystem::path(Utils::ExpandEnvVars(userPath)); std::filesystem::exists(userPath)) {
                             Path = userPath;
                             debug(L"Using custom user folder path from BeamNG.Drive.ini: " + Path.wstring());
@@ -147,7 +148,13 @@ void StartGame(std::wstring Dir) {
 
     debug(L"BeamNG executable path: " + Dir);
 
-    bSuccess = CreateProcessW(nullptr, (wchar_t*)(Dir + gameArgs).c_str(), nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
+    wchar_t* lpApplicationName = Dir.data();
+    wchar_t* lpCommandLine = (Dir + gameArgs).data();
+
+    debug(L"lpApplicationName: " + std::wstring(lpApplicationName));
+    debug(L"lpCommandLine: " + std::wstring(lpCommandLine));
+
+    bSuccess = CreateProcessW(lpApplicationName, lpCommandLine, nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
     if (bSuccess) {
         info("Game Launched!");
         GamePID = pi.dwProcessId;
@@ -174,6 +181,7 @@ void StartGame(std::wstring Dir) {
 }
 #elif defined(__linux__)
 void StartGame(std::string Dir) {
+    int status;
     std::string filename = (Dir + "/BinLinux/BeamNG.drive.x64");
     std::vector<const char*> argv;
     argv.push_back(filename.data());
@@ -183,24 +191,11 @@ void StartGame(std::string Dir) {
 
     argv.push_back(nullptr);
     pid_t pid;
-
-    posix_spawn_file_actions_t file_actions;
-    auto status = posix_spawn_file_actions_init(&file_actions);
-    // disable stdout
-    if (status != 0) {
-        error(std::string("posix_spawn_file_actions_init failed: ") + std::strerror(errno));
-    }
-    status = posix_spawn_file_actions_addclose(&file_actions, STDOUT_FILENO);
-    if (status != 0) {
-        error(std::string("posix_spawn_file_actions_addclose for STDOUT failed: ") + std::strerror(errno));
-    }
-    status = posix_spawn_file_actions_addclose(&file_actions, STDERR_FILENO);
-    if (status != 0) {
-        error(std::string("posix_spawn_file_actions_addclose for STDERR failed: ") + std::strerror(errno));
-    }
-
-    // launch the game
-    int result = posix_spawn(&pid, filename.c_str(), &file_actions, NULL, const_cast<char**>(argv.data()), environ);
+    posix_spawn_file_actions_t spawn_actions;
+    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");

src/Logger.cpp

@@ -57,36 +57,36 @@ void addToLog(const std::wstring& Line) {
 }
 void info(const std::string& toPrint) {
     std::string Print = getDate() + "[INFO] " + toPrint + "\n";
-    beammp_stdout << Utils::ToWString(Print);
+    std::cout << Print;
     addToLog(Print);
 }
 void debug(const std::string& toPrint) {
     std::string Print = getDate() + "[DEBUG] " + toPrint + "\n";
     if (options.verbose) {
-        beammp_stdout << Utils::ToWString(Print);
+        std::cout << Print;
     }
     addToLog(Print);
 }
 void warn(const std::string& toPrint) {
     std::string Print = getDate() + "[WARN] " + toPrint + "\n";
-    beammp_stdout << Utils::ToWString(Print);
+    std::cout << Print;
     addToLog(Print);
 }
 void error(const std::string& toPrint) {
     std::string Print = getDate() + "[ERROR] " + toPrint + "\n";
-    beammp_stdout << Utils::ToWString(Print);
+    std::cout << Print;
     addToLog(Print);
 }
 void fatal(const std::string& toPrint) {
     std::string Print = getDate() + "[FATAL] " + toPrint + "\n";
-    beammp_stdout << Utils::ToWString(Print);
+    std::cout << Print;
     addToLog(Print);
     std::this_thread::sleep_for(std::chrono::seconds(5));
     std::exit(1);
 }
 void except(const std::string& toPrint) {
     std::string Print = getDate() + "[EXCEP] " + toPrint + "\n";
-    beammp_stdout << Utils::ToWString(Print);
+    std::cout << Print;
     addToLog(Print);
 }
 

src/Network/Core.cpp

@@ -7,7 +7,6 @@
 #include "Http.h"
 #include "Network/network.hpp"
 #include "Security/Init.h"
-#include "Utils.h"
 #include <cstdlib>
 #include <regex>
 #if defined(_WIN32)
@@ -143,28 +142,29 @@ void GetServerInfo(std::string Data) {
     const std::string buffer = ([&]() -> std::string {
         int32_t Header;
         std::vector<char> data(sizeof(Header));
-        int Temp = RecvWaitAll(ISock, data.data(), sizeof(Header));
+        int Temp = recv(ISock, data.data(), sizeof(Header), MSG_WAITALL);
 
-        auto checkBytes = ([&](const int32_t bytes, const int32_t expected = -1) -> bool {
+        auto checkBytes = ([&](const int32_t bytes) -> bool {
             if (bytes == 0) {
                 return false;
             } else if (bytes < 0) {
                 return false;
             }
-            if (expected != -1 && bytes != expected) {
-                return false;
-            }
             return true;
         });
 
-        if (!checkBytes(Temp, sizeof(Header))) {
+        if (!checkBytes(Temp)) {
             return "";
         }
         memcpy(&Header, data.data(), sizeof(Header));
 
+        if (!checkBytes(Temp)) {
+            return "";
+        }
+
         data.resize(Header, 0);
-        Temp = RecvWaitAll(ISock, data.data(), Header);
-        if (!checkBytes(Temp, Header)) {
+        Temp = recv(ISock, data.data(), Header, MSG_WAITALL);
+        if (!checkBytes(Temp)) {
             return "";
         }
         return std::string(data.data(), Header);
@@ -188,8 +188,7 @@ void CoreSend(std::string data) {
     std::lock_guard lock(sendMutex);
     
     if (CoreSocket != -1) {
-        auto ToSend = Utils::PrependHeader(data);
-        int res = send(CoreSocket, ToSend.data(), ToSend.size(), 0);
+        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()));
         }
@@ -226,7 +225,7 @@ void Parse(std::string Data, SOCKET CSocket) {
             TCPTerminate = true;
             Data.clear();
             futures.push_back(std::async(std::launch::async, []() {
-                CoreSend("B" + HTTP::Get("https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/servers-info"));
+                CoreSend("B" + HTTP::Get("https://backend.beammp.com/servers-info"));
             }));
         }
         break;
@@ -279,7 +278,7 @@ void Parse(std::string Data, SOCKET CSocket) {
                 Ping = "-2";
             else
                 Ping = std::to_string(ping);
-            Data = "Up" + Ping;
+            Data = std::string(UlStatus) + "\n" + "Up" + Ping;
         }
         break;
     case 'M':
@@ -349,29 +348,51 @@ void Parse(std::string Data, SOCKET CSocket) {
         Data.clear();
         break;
     }
-    if (!Data.empty() && CSocket != -1) {
-        auto ToSend = Utils::PrependHeader(Data);
-        int res = send(CSocket, ToSend.data(), ToSend.size(), 0);
-        if (res < 0) {
-            debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
-        }
-    }
+    if (!Data.empty())
+        CoreSend(Data);
 }
 void GameHandler(SOCKET Client) {
     CoreSocket = Client;
-    std::vector<char> data{};
+    int32_t Size, Rcv;
     int Temp;
     char Header[10] = { 0 };
     do {
-        try {
-            Utils::ReceiveFromGame(Client, data);
-            Parse(std::string(data.data(), data.size()), Client);
-        } catch (const std::exception& e) {
-            error(std::string("Error while receiving from game on core: ") + e.what());
+        Rcv = 0;
+        do {
+            Temp = recv(Client, &Header[Rcv], 1, 0);
+            if (Temp < 1)
+                break;
+            if (!isdigit(Header[Rcv]) && Header[Rcv] != '>') {
+                error("(Core) Invalid lua communication");
+                KillSocket(Client);
+                return;
+            }
+        } while (Header[Rcv++] != '>');
+        if (Temp < 1)
+            break;
+        if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
+            debug("(Core) Invalid lua Header -> " + std::string(Header, Rcv));
             break;
         }
-    } while (true);
+        std::string Ret(Size, 0);
+        Rcv = 0;
+
+        do {
+            Temp = recv(Client, &Ret[Rcv], Size - Rcv, 0);
+            if (Temp < 1)
+                break;
+            Rcv += Temp;
+        } while (Rcv < Size);
+        if (Temp < 1)
+            break;
+
+        Parse(Ret, Client);
+    } while (Temp > 0);
+    if (Temp == 0) {
         debug("(Core) Connection closing");
+    } else {
+        debug("(Core) recv failed with error: " + std::to_string(WSAGetLastError()));
+    }
     NetReset();
     KillSocket(Client);
 }

src/Network/GlobalHandler.cpp

@@ -5,7 +5,6 @@
 */
 
 #include "Network/network.hpp"
-#include "Utils.h"
 #include <memory>
 #include <zlib.h>
 #if defined(_WIN32)
@@ -22,7 +21,6 @@
 #endif
 
 #include "Logger.h"
-#include "Options.h"
 #include <charconv>
 #include <mutex>
 #include <string>
@@ -35,7 +33,6 @@ bool GConnected = false;
 bool CServer = true;
 SOCKET CSocket = -1;
 SOCKET GSocket = -1;
-std::string magic;
 
 int KillSocket(uint64_t Dead) {
     if (Dead == (SOCKET)-1) {
@@ -50,16 +47,44 @@ int KillSocket(uint64_t Dead) {
     return a;
 }
 
+bool CheckBytes(uint32_t Bytes) {
+    if (Bytes == 0) {
+        debug("(Proxy) Connection closing");
+        return false;
+    } else if (Bytes < 0) {
+        debug("(Proxy) send failed with error: " + std::to_string(WSAGetLastError()));
+        return false;
+    }
+    return true;
+}
+
 void GameSend(std::string_view Data) {
     static std::mutex Lock;
     std::scoped_lock Guard(Lock);
-    auto ToSend = Utils::PrependHeader<std::string_view>(Data);
-    auto Result = send(CSocket, ToSend.data(), ToSend.size(), 0);
-    if (Result < 0) {
-        error("(Game) send failed with error: " + std::to_string(WSAGetLastError()));
+    if (TCPTerminate || !GConnected || CSocket == -1)
+        return;
+    int32_t Size, Temp, Sent;
+    Size = int32_t(Data.size());
+    Sent = 0;
+#ifdef DEBUG
+    if (Size > 1000) {
+        debug("Launcher -> game (" + std::to_string(Size) + ")");
+    }
+#endif
+    do {
+        if (Sent > -1) {
+            Temp = send(CSocket, &Data[Sent], Size - Sent, 0);
+        }
+        if (!CheckBytes(Temp))
+            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())
         return;
@@ -193,8 +218,6 @@ void ParserAsync(std::string_view Data) {
         MStatus = Data;
         UlStatus = "Uldone";
         return;
-    case 'U':
-        magic = Data.substr(1);
     default:
         break;
     }
@@ -242,19 +265,40 @@ void TCPGameServer(const std::string& IP, int Port) {
         int32_t Size, Rcv;
         int Temp;
         char Header[10] = { 0 };
-        std::vector<char> data {};
 
         // Read byte by byte until '>' is rcved then get the size and read based on it
         do {
-            try {
-                Utils::ReceiveFromGame(CSocket, data);
-                ServerSend(std::string(data.data(), data.size()), false);
-            } catch (const std::exception& e) {
-                error(std::string("Error while receiving from game on proxy: ") + e.what());
+            Rcv = 0;
+
+            do {
+                Temp = recv(CSocket, &Header[Rcv], 1, 0);
+                if (Temp < 1 || TCPTerminate)
+                    break;
+            } while (Header[Rcv++] != '>');
+            if (Temp < 1 || TCPTerminate)
+                break;
+            if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
+                debug("(Game) Invalid lua Header -> " + std::string(Header, Rcv));
                 break;
             }
-        } while (!TCPTerminate);
+            std::string Ret(Size, 0);
+            Rcv = 0;
+            do {
+                Temp = recv(CSocket, &Ret[Rcv], Size - Rcv, 0);
+                if (Temp < 1)
+                    break;
+                Rcv += Temp;
+            } while (Rcv < Size && !TCPTerminate);
+            if (Temp < 1 || TCPTerminate)
+                break;
+
+            ServerSend(Ret, false);
+
+        } while (Temp > 0 && !TCPTerminate);
+        if (Temp == 0)
             debug("(Proxy) Connection closing");
+        else
+            debug("(Proxy) recv failed error : " + std::to_string(WSAGetLastError()));
     }
     TCPTerminate = true;
     GConnected = false;

src/Network/Http.cpp

@@ -6,7 +6,6 @@
 
 
 #include "Http.h"
-#include "Options.h"
 #include <Logger.h>
 #include <Network/network.hpp>
 #include <Startup.h>
@@ -21,6 +20,45 @@
 #include <mutex>
 #include <nlohmann/json.hpp>
 
+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";
+    std::filesystem::create_directories(folder);
+    if (!std::filesystem::exists(folder / "WHAT IS THIS FOLDER.txt")) {
+        std::ofstream ignore { folder / "WHAT IS THIS FOLDER.txt" };
+        ignore << "This folder exists to help debug current issues with the backend. Do not share this folder with anyone but BeamMP staff. It contains detailed logs of any failed http requests." << std::endl;
+    }
+    const auto file = folder / (method + ".json");
+    // 1 MB limit
+    if (std::filesystem::exists(file) && std::filesystem::file_size(file) > 1'000'000) {
+        std::filesystem::rename(file, file.generic_string() + ".bak");
+    }
+
+    std::ofstream of { file, std::ios::app };
+    nlohmann::json js {
+        { "utc", std::chrono::system_clock::now().time_since_epoch().count() },
+        { "target", target },
+        { "client_info", {
+                             { "openssl_verify_result", client.get_openssl_verify_result() },
+                             { "host", client.host() },
+                             { "port", client.port() },
+                             { "socket_open", client.is_socket_open() },
+                             { "valid", client.is_valid() },
+                         } },
+    };
+    if (result) {
+        auto value = result.value();
+        js["result"] = {};
+        js["result"]["body"] = value.body;
+        js["result"]["status"] = value.status;
+        js["result"]["headers"] = value.headers;
+        js["result"]["version"] = value.version;
+        js["result"]["location"] = value.location;
+        js["result"]["reason"] = value.reason;
+    }
+    of << js.dump();
+} catch (const std::exception& e) {
+    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);
@@ -137,8 +175,8 @@ void HTTP::StartProxy() {
             { "User-Agent", "BeamMP-Launcher/" + GetVer() + GetPatch() },
             { "Accept", "*/*" }
         };
-        httplib::Client backend("https://backend." + Utils::RegionToTopLevelDomain(options.region));
-        httplib::Client forum("https://forum." + Utils::RegionToTopLevelDomain(options.region));
+        httplib::Client backend("https://backend.beammp.com");
+        httplib::Client forum("https://forum.beammp.com");
 
         const std::string pattern = ".*";
 
@@ -217,7 +255,7 @@ void HTTP::StartProxy() {
                 }
 
                 if (error) {
-                    cli_res = forum.Get("/user_avatar/forum." + Utils::RegionToTopLevelDomain(options.region) + "/user/0/0.png", headers);
+                    cli_res = forum.Get("/user_avatar/forum.beammp.com/user/0/0.png", headers);
                 }
 
             } else {

src/Network/Resources.cpp

@@ -164,7 +164,7 @@ std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
     do {
         // receive at most some MB at a time
         int Len = std::min(int(Size - Rcv), 1 * 1024 * 1024);
-        int Temp = RecvWaitAll(Sock, &File[Rcv], Len);
+        int Temp = recv(Sock, &File[Rcv], Len, MSG_WAITALL);
         if (Temp == -1 || Temp == 0) {
             debug("Recv returned: " + std::to_string(Temp));
             if (Temp == -1) {

src/Network/VehicleData.cpp

@@ -93,9 +93,6 @@ void UDPClientMain(const std::string& IP, int Port) {
     ToServer->sin_port = htons(Port);
     inet_pton(AF_INET, IP.c_str(), &ToServer->sin_addr);
     UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
-    if (!magic.empty())
-        for (int i = 0; i < 10; i++)
-            UDPSend(magic);
     GameSend("P" + std::to_string(ClientID));
     TCPSend("H", TCPSock);
     UDPSend("p");

src/Network/VehicleEvent.cpp

@@ -28,9 +28,9 @@ int LastPort;
 std::string LastIP;
 SOCKET TCPSock = -1;
 
-bool CheckBytes(int32_t Bytes, int32_t Expected) {
+bool CheckBytes(int32_t Bytes) {
     if (Bytes == 0) {
-        debug("(TCP) Connection closing...");
+        debug("(TCP) Connection closing... CheckBytes(16)");
         Terminate = true;
         return false;
     } else if (Bytes < 0) {
@@ -39,11 +39,6 @@ bool CheckBytes(int32_t Bytes, int32_t Expected) {
         Terminate = true;
         return false;
     }
-    if (Expected != -1 && Bytes != Expected) {
-        debug(std::format("(TCP) Short recv detected, expected {} bytes, got {} bytes", Expected, Bytes));
-        Terminate = true;
-        return false;
-    }
     return true;
 }
 void UUl(const std::string& R) {
@@ -80,24 +75,6 @@ void TCPSend(const std::string& Data, uint64_t Sock) {
     } while (Sent < Size);
 }
 
-int RecvWaitAll(int sockfd, char *buf, int len) {
-    // handle MSG_WAITALL not actually filling the whole buffer
-    // happens frequently in wine, and can also happen natively when the OS pauses the execution for various reasons
-    int offset = 0;
-    while (offset < len) {
-        int recv_status = recv(sockfd, &buf[offset], len - offset, MSG_WAITALL);
-        if (recv_status == 0) {
-            // do not discard received data when the other side closes the socket cleanly
-            return offset;
-        }
-        if (recv_status == -1) {
-            return -1;
-        }
-        offset += recv_status;
-    }
-    return offset;
-}
-
 std::string TCPRcv(SOCKET Sock) {
     if (Sock == -1) {
         Terminate = true;
@@ -107,8 +84,8 @@ std::string TCPRcv(SOCKET Sock) {
     int32_t Header;
     int Temp;
     std::vector<char> Data(sizeof(Header));
-    Temp = RecvWaitAll(Sock, Data.data(), sizeof(Header));
-    if (!CheckBytes(Temp, sizeof(Header))) {
+    Temp = recv(Sock, Data.data(), sizeof(Header), MSG_WAITALL);
+    if (!CheckBytes(Temp)) {
         UUl("Socket Closed Code 3");
         return "";
     }
@@ -120,8 +97,8 @@ std::string TCPRcv(SOCKET Sock) {
     }
 
     Data.resize(Header, 0);
-    Temp = RecvWaitAll(Sock, Data.data(), Header);
-    if (!CheckBytes(Temp, Header)) {
+    Temp = recv(Sock, Data.data(), Header, MSG_WAITALL);
+    if (!CheckBytes(Temp)) {
         UUl("Socket Closed Code 5");
         return "";
     }

src/Options.cpp

@@ -92,13 +92,6 @@ void InitOptions(int argc, const char *argv[], Options &options) {
             }
             options.user_path = argv[i + 1];
             i++;
-        } else if (argument == "--region") {
-            if (i + 1 >= argc) {
-                error("You must specify a region after the `--region` argument");
-            }
-            options.region = argv[i + 1];
-            info("Set the region to: " + options.region);
-            i++;
         } else if (argument == "--" || argument == "--game") {
             options.game_arguments = &argv[i + 1];
             options.game_arguments_length = argc - i - 1;
@@ -115,7 +108,6 @@ void InitOptions(int argc, const char *argv[], Options &options) {
                 "\t--no-launch          Skip launching the game (you must launch the game manually)\n"
                 "\t--dev                Developer mode, same as --verbose --no-download --no-launch --no-update\n"
                 "\t--user-path <path>   Path to BeamNG's User Path\n"
-                "\t--region <region>    Sets a custom region, options are 'Global', and 'Restricted'\n"
                 "\t--game <args...>     Passes ALL following arguments to the game, see also `--`\n"
                 << std::flush;
             exit(0);

src/Security/BeamNG.cpp

@@ -6,7 +6,6 @@
 
 
 #include <filesystem>
-#include "Utils.h"
 #if defined(_WIN32)
 #include <shlobj_core.h>
 #elif defined(__linux__)
@@ -16,6 +15,8 @@
 #include <vector>
 #endif
 #include "Logger.h"
+#include "Utils.h"
+
 #include <fstream>
 #include <string>
 #include <thread>
@@ -176,10 +177,6 @@ void LegitimacyCheck() {
             std::string contents((std::istreambuf_iterator(beamngIni)), std::istreambuf_iterator<char>());
             beamngIni.close();
 
-            if (contents.size() >= 3 && (unsigned char)contents[0] == 0xEF && (unsigned char)contents[1] == 0xBB && (unsigned char)contents[2] == 0xBF) {
-                contents = contents.substr(3);
-            }
-
             auto ini = Utils::ParseINI(contents);
             if (ini.empty())
                 lowExit(3);
@@ -268,7 +265,7 @@ void LegitimacyCheck() {
     std::ifstream libraryFolders(libraryFoldersPath);
     auto root = tyti::vdf::read(libraryFolders);
     for (auto folderInfo : root.childs) {
-        if ((folderInfo.second->childs["apps"]->attribs).contains("284160") && std::filesystem::exists(folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/integrity.json")){
+        if (std::filesystem::exists(folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/integrity.json")){
             GameDir = folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/";
             break;
         }

src/Security/Login.cpp

@@ -6,7 +6,6 @@
 
 
 #include "Http.h"
-#include "Options.h"
 #include "Logger.h"
 #include <filesystem>
 #include <fstream>
@@ -56,7 +55,7 @@ std::string Login(const std::string& fields) {
     }
     info("Attempting to authenticate...");
     try {
-        std::string Buffer = HTTP::Post("https://auth." + Utils::RegionToTopLevelDomain(options.region) + "/userlogin", fields);
+        std::string Buffer = HTTP::Post("https://auth.beammp.com/userlogin", fields);
 
         if (Buffer.empty()) {
             return GetFail("Failed to communicate with the auth system!");
@@ -116,7 +115,7 @@ void CheckLocalKey() {
                 }
             }
 
-            Buffer = HTTP::Post("https://auth." + Utils::RegionToTopLevelDomain(options.region) + "/userlogin", R"({"pk":")" + Buffer + "\"}");
+            Buffer = HTTP::Post("https://auth.beammp.com/userlogin", R"({"pk":")" + Buffer + "\"}");
 
             nlohmann::json d = nlohmann::json::parse(Buffer, nullptr, false);
 

src/Startup.cpp

@@ -4,6 +4,7 @@
  SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
+
 #include "zip_file.h"
 #include <charconv>
 #include <cstring>
@@ -14,8 +15,8 @@
 #elif defined(__linux__)
 #include <unistd.h>
 #elif defined (__APPLE__)
-#include <libproc.h>
 #include <unistd.h>
+#include <libproc.h>
 #endif // __APPLE__
 #include "Http.h"
 #include "Logger.h"
@@ -83,10 +84,10 @@ beammp_fs_string GetEN() {
 }
 
 std::string GetVer() {
-    return "2.8";
+    return "2.6";
 }
 std::string GetPatch() {
-    return ".0";
+    return ".3";
 }
 
 beammp_fs_string GetEP(const beammp_fs_char* P) {
@@ -193,156 +194,10 @@ void CheckName() {
     }
 }
 
-#if defined(_WIN32)
-#include <wincrypt.h>
-#include <wintrust.h>
-#include <softpub.h>
-#include <iostream>
-
-#pragma comment(lib, "wintrust.lib")
-#pragma comment(lib, "crypt32.lib")
-
-bool CheckThumbprint(std::filesystem::path filepath)
-{
-    HCERTSTORE hStore = NULL;
-    HCRYPTMSG hMsg = NULL;
-
-    if (!CryptQueryObject(
-        CERT_QUERY_OBJECT_FILE,
-        filepath.wstring().c_str(),
-        CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
-        CERT_QUERY_FORMAT_FLAG_BINARY,
-        0,
-        NULL, NULL, NULL,
-        &hStore,
-        &hMsg,
-        NULL))
-    {
-        return false;
-    }
-
-    DWORD dwSignerInfo = 0;
-    if (!CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &dwSignerInfo) || dwSignerInfo == 0)
-        return false;
-
-    PCMSG_SIGNER_INFO pSignerInfo = (PCMSG_SIGNER_INFO)LocalAlloc(LPTR, dwSignerInfo);
-    if (!CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, pSignerInfo, &dwSignerInfo))
-    {
-        LocalFree(pSignerInfo);
-        return false;
-    }
-
-    CERT_INFO certInfo = {};
-    certInfo.Issuer = pSignerInfo->Issuer;
-    certInfo.SerialNumber = pSignerInfo->SerialNumber;
-
-    PCCERT_CONTEXT pCertContext = CertFindCertificateInStore(
-        hStore,
-        X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
-        0,
-        CERT_FIND_SUBJECT_CERT,
-        &certInfo,
-        NULL);
-
-    if (!pCertContext)
-    {
-        LocalFree(pSignerInfo);
-        return false;
-    }
-
-    BYTE hash[64];
-    DWORD hashSize = sizeof(hash);
-
-    bool match = false;
-    if (CertGetCertificateContextProperty(pCertContext, CERT_SHA256_HASH_PROP_ID, hash, &hashSize))
-    {
-        std::string pubKeyData(
-            reinterpret_cast<const char*>(pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData),
-            pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData
-        );
-
-        std::string pubKeyHash = Utils::GetSha256HashReallyFast(pubKeyData, L"PubKey");
-        debug("pub key hash: " + pubKeyHash);
-
-        std::string fileThumbprint;
-        for (DWORD i = 0; i < hashSize; i++)
-        {
-            char buf[3];
-            sprintf_s(buf, "%02x", hash[i]);
-            fileThumbprint += buf;
-        }
-
-        debug("File thumbprint: " +fileThumbprint);
-        debug(filepath);
-
-        if (fileThumbprint == "937f055b713de69416926ed4651d65219a0a0e77d7a78c1932c007e14326da33" && pubKeyHash == "2afad4a5773b0ac449f48350ce0d09c372be0d5bcbaa6d01332ce000baffde99"){
-            match = true;
-        }
-    }
-
-    CertFreeCertificateContext(pCertContext);
-    CertCloseStore(hStore, 0);
-    LocalFree(pSignerInfo);
-
-    return match;
-}
-#include <windows.h>
-#include <wintrust.h>
-#include <Softpub.h>
-#include <filesystem>
-#include <string>
-
-#pragma comment(lib, "wintrust")
-
-bool VerifySignature(const std::filesystem::path& filePath)
-{
-    std::wstring path = filePath.wstring();
-
-    WINTRUST_FILE_INFO fileInfo = {};
-    fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
-    fileInfo.pcwszFilePath = path.c_str();
-    fileInfo.hFile = NULL;
-    fileInfo.pgKnownSubject = NULL;
-
-    WINTRUST_DATA winTrustData = {};
-    winTrustData.cbStruct = sizeof(WINTRUST_DATA);
-    winTrustData.dwUIChoice = WTD_UI_NONE;
-    winTrustData.dwUnionChoice = WTD_CHOICE_FILE;
-    winTrustData.pFile = &fileInfo;
-
-    winTrustData.dwStateAction = WTD_STATEACTION_VERIFY;
-
-    GUID policyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
-
-    LONG status = WinVerifyTrust(
-        NULL,
-        &policyGUID,
-        &winTrustData
-    );
-
-    debug(filePath);
-    debug("Signature check code: " + std::to_string(status));
-
-    winTrustData.dwStateAction = WTD_STATEACTION_CLOSE;
-    WinVerifyTrust(NULL, &policyGUID, &winTrustData);
-
-    return (status == CERT_E_UNTRUSTEDROOT);
-}
-#endif
-
 void CheckForUpdates(const std::string& CV) {
-    std::string LatestHash = HTTP::Get("https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/sha/launcher?branch=" + Branch + "&pk=" + PublicKey);
+    std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/launcher?branch=" + Branch + "&pk=" + PublicKey);
     std::string LatestVersion = HTTP::Get(
-        "https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/version/launcher?branch=" + Branch + "&pk=" + PublicKey);
-
-    std::regex sha256_pattern(R"(^[a-fA-F0-9]{64}$)");
-    std::smatch match;
-
-    if (LatestHash.length() != 64 || !std::regex_match(LatestHash, match, sha256_pattern)) {
-        error("Invalid hash from backend, skipping update check.");
-        debug("Launcher hash in question: " + LatestHash);
-        return;
-    }
+        "https://backend.beammp.com/version/launcher?branch=" + Branch + "&pk=" + PublicKey);
 
     transform(LatestHash.begin(), LatestHash.end(), LatestHash.begin(), ::tolower);
     beammp_fs_string BP(GetBP() / GetEN()), Back(GetBP() / beammp_wide("BeamMP-Launcher.back"));
@@ -356,23 +211,11 @@ void CheckForUpdates(const std::string& CV) {
             error("Auto update is NOT implemented for the Linux version. Please update manually ASAP as updates contain security patches.");
 #else
             info("Downloading Launcher update " + LatestHash);
-            std::wstring DownloadLocation = GetBP() / (beammp_wide("new_") + GetEN());
-            if (HTTP::Download(
-                    "https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/builds/launcher?download=true"
+            HTTP::Download(
+                "https://backend.beammp.com/builds/launcher?download=true"
                 "&pk="
                     + PublicKey + "&branch=" + Branch,
-                    DownloadLocation, LatestHash)) {
-                if (!VerifySignature(DownloadLocation) || !CheckThumbprint(DownloadLocation)) {
-                    std::error_code ec;
-                    fs::remove(DownloadLocation, ec);
-                    if (ec) {
-                        error("Failed to remove broken launcher update");
-                    }
-                    throw std::runtime_error("The authenticity of the updated launcher could not be verified, it was corrupted or tampered with.");
-                }
-
-                info("Update signature is valid");
-
+                GetBP() / (beammp_wide("new_") + GetEN()), LatestHash);
             std::error_code ec;
             fs::remove(Back, ec);
             if (ec == std::errc::permission_denied) {
@@ -383,16 +226,6 @@ void CheckForUpdates(const std::string& CV) {
             }
             fs::rename(GetBP() / (beammp_wide("new_") + GetEN()), BP);
             URelaunch();
-            } else {
-                if (fs::exists(DownloadLocation)) {
-                    std::error_code error_code;
-                    fs::remove(DownloadLocation, error_code);
-                    if (error_code) {
-                        error("Failed to remove broken launcher update");
-                    }
-                }
-                throw std::runtime_error("Failed to download the launcher update! Please try manually updating it, https://docs.beammp.com/FAQ/Update-launcher/");
-            }
 #endif
         } else {
             warn("Launcher update was found, but not updating because --no-update or --dev was specified.");
@@ -402,6 +235,7 @@ void CheckForUpdates(const std::string& CV) {
     TraceBack++;
 }
 
+
 #ifdef _WIN32
 void LinuxPatch() {
     HKEY hKey = nullptr;
@@ -435,8 +269,6 @@ void LinuxPatch() {
 
 void InitLauncher() {
     SetConsoleTitleA(("BeamMP Launcher v" + std::string(GetVer()) + GetPatch()).c_str());
-    SetConsoleOutputCP(CP_UTF8);
-    _setmode(_fileno(stdout), _O_U8TEXT);
     debug("Launcher Version : " + GetVer() + GetPatch());
     CheckName();
     LinuxPatch();
@@ -514,21 +346,12 @@ void PreGame(const beammp_fs_string& GamePath) {
     info(beammp_wide("Game user path: ") + beammp_fs_string(GetGamePath()));
 
     if (!options.no_download) {
-        std::string LatestHash = HTTP::Get("https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/sha/mod?branch=" + Branch + "&pk=" + PublicKey);
+        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(),
                              [](auto const& c) -> bool { return !std::isalnum(c); }),
             LatestHash.end());
 
-        std::regex sha256_pattern(R"(^[a-fA-F0-9]{64}$)");
-        std::smatch match;
-
-        if (LatestHash.length() != 64 || !std::regex_match(LatestHash, match, sha256_pattern)) {
-            error("Invalid hash from backend, skipping mod update check.");
-            debug("Mod hash in question: " + LatestHash);
-            return;
-        }
-
         try {
             if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
                 fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
@@ -548,7 +371,7 @@ void PreGame(const beammp_fs_string& GamePath) {
 
         if (FileHash != LatestHash) {
             info("Downloading BeamMP Update " + LatestHash);
-            HTTP::Download("https://backend." + Utils::RegionToTopLevelDomain(options.region) + "/builds/client?download=true"
+            HTTP::Download("https://backend.beammp.com/builds/client?download=true"
                            "&pk="
                     + PublicKey + "&branch=" + Branch,
                 ZipPath, LatestHash);