Made regionhandler handled on http level

CMakeLists.txt

@@ -55,6 +55,7 @@ set(PRJ_HEADERS
     include/ChronoWrapper.h
     include/TConnectionLimiter.h
     include/TLuaResult.h
+    include/RegionHandler.h
 )
 # add all source files (.cpp) to this, except the one with main()
 set(PRJ_SOURCES
@@ -84,6 +85,7 @@ set(PRJ_SOURCES
     src/ChronoWrapper.cpp
     src/TConnectionLimiter.cpp
     src/TLuaResult.cpp
+    src/RegionHandler.cpp
 )
 
 find_package(Lua REQUIRED)

include/Common.h

@@ -80,16 +80,12 @@ public:
 
     static inline struct Settings Settings { };
 
-    static std::vector<std::string> GetBackendUrlsInOrder() {
+    static std::vector<std::string> GetBackendUrlsInOrder();
-        return {
-            "https://backend.beammp.com",
-        };
-    }
 
-    static std::string GetServerCheckUrl() { return "https://check.beammp.com"; }
+    static std::string GetServerCheckUrl();
 
-    static std::string GetBackendUrlForAuth() { return "https://auth.beammp.com"; }
+    static std::string GetBackendUrlForAuth();
-    static std::string GetBackendUrlForSocketIO() { return "https://backend.beammp.com"; }
+    static std::string GetBackendUrlForSocketIO();
     static void CheckForUpdates();
     static std::array<uint8_t, 3> VersionStrToInts(const std::string& str);
     static bool IsOutdated(const Version& Current, const Version& Newest);
@@ -128,6 +124,8 @@ private:
     static inline bool mShutdown { false };
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
+    static inline int mTLDIndex { 0 };
+    static inline std::vector<std::string> mValidTLDs {"beammp.com", "beammp.ru"};
 
     static inline Version mVersion { 3, 9, 3 };
 };

include/Http.h

@@ -39,8 +39,8 @@
 namespace fs = std::filesystem;
 
 namespace Http {
-std::string GET(const std::string& url, unsigned int* status = nullptr);
+std::string GET(std::string url, unsigned int* status = nullptr, const bool& redirect = true);
-std::string POST(const std::string& url, const std::string& body, const std::string& ContentType, unsigned int* status = nullptr, const std::map<std::string, std::string>& headers = {});
+std::string POST(std::string url, const std::string& body, const std::string& ContentType, unsigned int* status = nullptr, const std::map<std::string, std::string>& headers = {}, const bool& redirect = true);
 namespace Status {
     std::string ToString(int code);
 }

include/RegionHandler.h

@@ -0,0 +1,34 @@
+// BeamMP, the BeamNG.drive multiplayer mod.
+// Copyright (C) 2024 BeamMP Ltd., BeamMP team and contributors.
+//
+// BeamMP Ltd. can be contacted by electronic mail via contact@beammp.com.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <array>
+
+class RegionHandler final {
+public:
+    RegionHandler() = delete;
+    static void TopLevelDomainFailed();
+    static std::string RegionToTopLevelDomain();
+    static std::string RedirectURL(const std::string &URL);
+private:
+    static inline unsigned int mRegionIndex { 0 };
+    const static inline std::array<std::string, 2> mValidTLDs {"beammp.com", "beammp.ru"};
+};

include/Settings.h

@@ -87,6 +87,7 @@ struct Settings {
         General_Debug,
         General_AllowGuests,
         General_InformationPacket,
+        General_Region,
     };
 
     Sync<std::unordered_map<Key, SettingsTypeVariant>> SettingsMap;

src/Common.cpp

@@ -35,6 +35,7 @@
 #include "Compat.h"
 #include "CustomAssert.h"
 #include "Http.h"
+#include "RegionHandler.h"
 
 void Application::RegisterShutdownHandler(const TShutdownHandler& Handler) {
     std::unique_lock Lock(mShutdownHandlersMutex);
@@ -73,6 +74,27 @@ std::string Application::ServerVersionString() {
     return mVersion.AsString();
 }
 
+std::vector<std::string> Application::GetBackendUrlsInOrder() {
+    return {
+        "https://backend.beammp.com",
+    };
+}
+
+std::string Application::GetServerCheckUrl()
+{
+    return "https://check.beammp.com";
+}
+
+std::string Application::GetBackendUrlForAuth()
+{
+    return "https://auth.beammp.com";
+}
+
+std::string Application::GetBackendUrlForSocketIO()
+{
+    return "https://backend.beammp.com";
+}
+
 std::array<uint8_t, 3> Application::VersionStrToInts(const std::string& str) {
     std::array<uint8_t, 3> Version;
     std::stringstream ss(str);

src/Http.cpp

@@ -18,6 +18,7 @@
 
 #include "Http.h"
 
+#include "RegionHandler.h"
 #include "Common.h"
 #include "CustomAssert.h"
 
@@ -115,10 +116,13 @@ public:
     }
 };
 
-std::string Http::GET(const std::string& url, unsigned int* status) {
+std::string Http::GET(std::string url, unsigned int* status, const bool& redirect) {
     std::string Ret;
     CurlLease Lease{};
     CURL* curl = Lease.GetHandle();
+    if (redirect) {
+        url = RegionHandler::RedirectURL(url);
+    }
     if (curl) {
         CURLcode res;
         char errbuf[CURL_ERROR_SIZE];
@@ -142,6 +146,7 @@ std::string Http::GET(const std::string& url, unsigned int* status) {
         if (res != CURLE_OK) {
             beammp_error("GET to " + url + " failed: " + std::string(curl_easy_strerror(res)));
             beammp_error("Curl error: " + std::string(errbuf));
+            RegionHandler::TopLevelDomainFailed();
             return Http::ErrorString;
         }
 
@@ -156,10 +161,13 @@ std::string Http::GET(const std::string& url, unsigned int* status) {
     return Ret;
 }
 
-std::string Http::POST(const std::string& url, const std::string& body, const std::string& ContentType, unsigned int* status, const std::map<std::string, std::string>& headers) {
+std::string Http::POST(std::string url, const std::string& body, const std::string& ContentType, unsigned int* status, const std::map<std::string, std::string>& headers, const bool& redirect) {
     std::string Ret;
     CurlLease Lease{};
     CURL* curl = Lease.GetHandle();
+    if (redirect) {
+        url = RegionHandler::RedirectURL(url);
+    }
     if (curl) {
         CURLcode res;
         char errbuf[CURL_ERROR_SIZE];
@@ -195,6 +203,7 @@ std::string Http::POST(const std::string& url, const std::string& body, const st
         if (res != CURLE_OK) {
             beammp_error("POST to " + url + " failed: " + std::string(curl_easy_strerror(res)));
             beammp_error("Curl error: " + std::string(errbuf));
+            RegionHandler::TopLevelDomainFailed();
             return Http::ErrorString;
         }
 

src/RegionHandler.cpp

@@ -0,0 +1,53 @@
+// BeamMP, the BeamNG.drive multiplayer mod.
+// Copyright (C) 2024 BeamMP Ltd., BeamMP team and contributors.
+//
+// BeamMP Ltd. can be contacted by electronic mail via contact@beammp.com.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#include "RegionHandler.h"
+#include "Common.h"
+
+#include <regex>
+
+void RegionHandler::TopLevelDomainFailed()
+{
+    static bool isDeveloperRegion = Application::Settings.getAsString(Settings::Key::General_Region) == "Developer";
+    if (!isDeveloperRegion) {
+        beammp_info("Top level domain of " + mValidTLDs[mRegionIndex % mValidTLDs.size()] + " didn't respond correctly , changing domain to " + mValidTLDs[(mRegionIndex + 1) % mValidTLDs.size()]);
+    }
+    mRegionIndex++;
+}
+
+std::string RegionHandler::RegionToTopLevelDomain()
+{
+    static bool isDeveloperRegion = Application::Settings.getAsString(Settings::Key::General_Region) == "Developer";
+    if (isDeveloperRegion) {
+        return "beammp.dev";
+    }
+    return mValidTLDs[mRegionIndex % mValidTLDs.size()]; // Global
+}
+
+std::string RegionHandler::RedirectURL(const std::string &URL)
+{
+    std::regex link_pattern(R"(^(https:\/\/.*)beammp\.com(\/.*)?$)");
+    std::smatch link_match;
+    if (std::regex_search(URL, link_match, link_pattern) && link_match.position() == 0) {
+        //TLD matched beammp.com
+        std::string before = link_match[1].str();                     // "https://..." up to beammp
+        std::string after  = link_match[2].matched ? link_match[2].str() : ""; // "/path" or ""
+        return before + RegionToTopLevelDomain() + after;
+    }
+    return URL; //if it didn't match, just return the unmodified URL
+}

src/Settings.cpp

@@ -36,6 +36,7 @@ Settings::Settings() {
         { General_Debug, false },
         { General_AllowGuests, true },
         { General_InformationPacket, true },
+        { General_Region, std::string("")},
         { Misc_ImScaredOfUpdates, true },
         { Misc_UpdateReminderTime, "30s" }
     };
@@ -56,6 +57,7 @@ Settings::Settings() {
         { { "General", "Debug" }, { General_Debug, READ_WRITE } },
         { { "General", "AllowGuests" }, { General_AllowGuests, READ_WRITE } },
         { { "General", "InformationPacket" }, { General_InformationPacket, READ_WRITE } },
+        { { "General", "Region" }, { General_Region, READ_WRITE } },
         { { "Misc", "ImScaredOfUpdates" }, { Misc_ImScaredOfUpdates, READ_WRITE } },
         { { "Misc", "UpdateReminderTime" }, { Misc_UpdateReminderTime, READ_WRITE } }
     };

src/TConfig.cpp

@@ -52,6 +52,8 @@ static constexpr std::string_view StrTags = "Tags";
 static constexpr std::string_view EnvStrTags = "BEAMMP_TAGS";
 static constexpr std::string_view StrResourceFolder = "ResourceFolder";
 static constexpr std::string_view EnvStrResourceFolder = "BEAMMP_RESOURCE_FOLDER";
+static constexpr std::string_view StrRegion = "BackendRegion";
+static constexpr std::string_view EnvStrRegion = "BEAMMP_BACKEND_REGION";
 static constexpr std::string_view StrAuthKey = "AuthKey";
 static constexpr std::string_view EnvStrAuthKey = "BEAMMP_AUTH_KEY";
 static constexpr std::string_view StrLogChat = "LogChat";
@@ -151,6 +153,9 @@ void TConfig::FlushToFile() {
     data["General"][StrMap.data()] = Application::Settings.getAsString(Settings::Key::General_Map);
     data["General"][StrDescription.data()] = Application::Settings.getAsString(Settings::Key::General_Description);
     data["General"][StrResourceFolder.data()] = Application::Settings.getAsString(Settings::Key::General_ResourceFolder);
+    if (Application::Settings.getAsString(Settings::Key::General_Region) != "") {
+        data["General"][StrRegion.data()] = Application::Settings.getAsString(Settings::Key::General_Region);
+    }
     // data["General"][StrPassword.data()] = Application::Settings.Password;
     // SetComment(data["General"][StrPassword.data()].comments(), " Sets a password on this server, which restricts people from joining. To join, a player must enter this exact password. Leave empty ("") to disable the password.");
     // Misc
@@ -221,16 +226,22 @@ void TConfig::TryReadValue(toml::value& Table, const std::string& Category, cons
         if constexpr (std::is_same_v<T, std::string>) {
             if (Table[Category.c_str()][Key.data()].is_string())
                 Application::Settings.set(key, Table[Category.c_str()][Key.data()].as_string());
+            else if (Table[Category.c_str()][Key.data()].is_empty())
+                beammp_debugf("Value '{}.{}' is empty", Category, Key);
             else
                 beammp_warnf("Value '{}.{}' has unexpected type, expected type 'string'", Category, Key);
         } else if constexpr (std::is_same_v<T, int>) {
             if (Table[Category.c_str()][Key.data()].is_integer())
                 Application::Settings.set(key, int(Table[Category.c_str()][Key.data()].as_integer()));
+            else if (Table[Category.c_str()][Key.data()].is_empty())
+                beammp_debugf("Value '{}.{}' is empty", Category, Key);
             else
                 beammp_warnf("Value '{}.{}' has unexpected type, expected type 'integer'", Category, Key);
         } else if constexpr (std::is_same_v<T, bool>) {
             if (Table[Category.c_str()][Key.data()].is_boolean())
                 Application::Settings.set(key, Table[Category.c_str()][Key.data()].as_boolean());
+            else if (Table[Category.c_str()][Key.data()].is_empty())
+                beammp_debugf("Value '{}.{}' is empty", Category, Key);
             else
                 beammp_warnf("Value '{}.{}' has unexpected type, expected type 'boolean'", Category, Key);
         } else {
@@ -270,6 +281,7 @@ void TConfig::ParseFromFile(std::string_view name) {
         TryReadValue(data, "General", StrDescription, EnvStrDescription, Settings::Key::General_Description);
         TryReadValue(data, "General", StrTags, EnvStrTags, Settings::Key::General_Tags);
         TryReadValue(data, "General", StrResourceFolder, EnvStrResourceFolder, Settings::Key::General_ResourceFolder);
+        TryReadValue(data, "General", StrRegion, EnvStrRegion, Settings::Key::General_Region);
         TryReadValue(data, "General", StrAuthKey, EnvStrAuthKey, Settings::Key::General_AuthKey);
         TryReadValue(data, "General", StrLogChat, EnvStrLogChat, Settings::Key::General_LogChat);
         TryReadValue(data, "General", StrAllowGuests, EnvStrAllowGuests, Settings::Key::General_AllowGuests);
@@ -322,6 +334,7 @@ void TConfig::PrintDebug() {
     beammp_debug(std::string(StrTags) + ": " + TagsAsPrettyArray());
     beammp_debug(std::string(StrLogChat) + ": \"" + (Application::Settings.getAsBool(Settings::Key::General_LogChat) ? "true" : "false") + "\"");
     beammp_debug(std::string(StrResourceFolder) + ": \"" + Application::Settings.getAsString(Settings::Key::General_ResourceFolder) + "\"");
+    beammp_debug(std::string(StrRegion) + ": \"" + Application::Settings.getAsString(Settings::Key::General_Region) + "\"");
     beammp_debug(std::string(StrAllowGuests) + ": \"" + (Application::Settings.getAsBool(Settings::Key::General_AllowGuests) ? "true" : "false") + "\"");
     // special!
     beammp_debug("Key Length: " + std::to_string(Application::Settings.getAsString(Settings::Key::General_AuthKey).length()) + "");

src/TConsole.cpp

@@ -25,6 +25,7 @@
 #include "Http.h"
 #include "LuaAPI.h"
 #include "TLuaEngine.h"
+#include "RegionHandler.h"
 
 #include <ctime>
 #include <lua.hpp>
@@ -297,6 +298,10 @@ void TConsole::Command_NetTest(const std::string& cmd, const std::vector<std::st
 
     std::string T = Http::GET(
         Application::GetServerCheckUrl() + "/api/v2/beammp/" + std::to_string(Application::Settings.getAsInt(Settings::Key::General_Port)), &status);
+    if (T == Http::ErrorString || status != 200) {
+        RegionHandler::TopLevelDomainFailed();
+        T = Http::GET(Application::GetServerCheckUrl() + "/api/v2/beammp/" + std::to_string(Application::Settings.getAsInt(Settings::Key::General_Port)), &status);
+    }
 
     beammp_debugf("Status and response from Server Check API: {0}, {1}", status, T);
 

src/THeartbeatThread.cpp

@@ -22,9 +22,9 @@
 #include "Client.h"
 #include "Common.h"
 #include "Http.h"
+#include "RegionHandler.h"
 // #include "SocketIO.h"
 #include <nlohmann/json.hpp>
-#include <sstream>
 
 void THeartbeatThread::operator()() {
     RegisterThread("Heartbeat");
@@ -63,6 +63,10 @@ void THeartbeatThread::operator()() {
         bool Ok = false;
         for (const auto& Url : Application::GetBackendUrlsInOrder()) {
             T = Http::POST(Url + Target, Body, "application/json", &ResponseCode, { { "api-v", "2" } });
+            if (T == Http::ErrorString || ResponseCode != 200) {
+                RegionHandler::TopLevelDomainFailed();
+                T = Http::POST(Url + Target, Body, "application/json", &ResponseCode, { { "api-v", "2" } });
+            }
 
             if (!Application::Settings.getAsBool(Settings::Key::General_Private)) {
                 beammp_debug("Backend response was: `" + T + "`");

src/TNetwork.cpp

@@ -20,6 +20,7 @@
 #include "Client.h"
 #include "Common.h"
 #include "LuaAPI.h"
+#include "RegionHandler.h"
 #include "TConnectionLimiter.h"
 #include "THeartbeatThread.h"
 #include "TLuaEngine.h"
@@ -440,6 +441,10 @@ std::shared_ptr<TClient> TNetwork::Authentication(TConnection&& RawConnection) {
 
         unsigned int ResponseCode = 0;
         AuthResStr = Http::POST(Application::GetBackendUrlForAuth() + Target, AuthReq.dump(), "application/json", &ResponseCode);
+        if (AuthResStr == Http::ErrorString || ResponseCode != 200) {
+            RegionHandler::TopLevelDomainFailed();
+            AuthResStr = Http::POST(Application::GetBackendUrlForAuth() + Target, AuthReq.dump(), "application/json", &ResponseCode);
+        }
 
     } catch (const std::exception& e) {
         beammp_debugf("Invalid json sent by client, kicking: {}", e.what());