Added check for Stateview, added socket cancel to finish all connect, send and receive operations immediately

.github/workflows/linux.yml

@@ -84,7 +84,7 @@ jobs:
         run: ./bin/BeamMP-Server-tests
 
   arm64-matrix:
-    runs-on: ubuntu-22.04-arm
+    runs-on: [Linux, ARM64]
     env:
       VCPKG_DEFAULT_TRIPLET: "arm64-linux"
     strategy:

.github/workflows/release.yml

@@ -104,7 +104,7 @@ jobs:
           asset_content_type: application/x-elf
 
   arm64-matrix:
-    runs-on: ubuntu-22.04-arm
+    runs-on: [Linux, ARM64]
     needs: create-release
     strategy:
       matrix:

include/Common.h

@@ -127,11 +127,10 @@ private:
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 
-    static inline Version mVersion { 3, 8, 3 };
+    static inline Version mVersion { 3, 8, 1 };
 };
 
 void SplitString(std::string const& str, const char delim, std::vector<std::string>& out);
-std::string LowerString(std::string str);
 
 std::string ThreadName(bool DebugModeOverride = false);
 void RegisterThread(const std::string& str);

include/Settings.h

@@ -79,7 +79,6 @@ struct Settings {
         General_Map,
         General_AuthKey,
         General_Private,
-        General_IP,
         General_Port,
         General_MaxCars,
         General_LogChat,

src/Client.cpp

@@ -84,6 +84,7 @@ void TClient::Disconnect(std::string_view Reason) {
         if (ec) {
             beammp_debugf("Failed to shutdown client socket: {}", ec.message());
         }
+        mSocket.cancel();
         mSocket.close(ec);
         if (ec) {
             beammp_debugf("Failed to close client socket: {}", ec.message());

src/Common.cpp

@@ -384,13 +384,6 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
         out.push_back(str.substr(start, end - start));
     }
 }
-
-std::string LowerString(std::string str) {
-    std::ranges::transform(str, str.begin(), ::tolower);
-    return str;
-}
-
-
 static constexpr size_t STARTING_MAX_DECOMPRESSION_BUFFER_SIZE = 15 * 1024 * 1024;
 static constexpr size_t MAX_DECOMPRESSION_BUFFER_SIZE = 30 * 1024 * 1024;
 

src/LuaAPI.cpp

@@ -148,11 +148,6 @@ static inline std::pair<bool, std::string> InternalTriggerClientEvent(int Player
             return { false, "Invalid Player ID" };
         }
         auto c = MaybeClient.value().lock();
-
-        if (!c->IsSyncing() && !c->IsSynced()) {
-            return { false, "Player hasn't joined yet" };
-        }
-
         if (!LuaAPI::MP::Engine->Network().Respond(*c, StringToVector(Packet), true)) {
             beammp_lua_errorf("Respond failed, dropping client {}", PlayerID);
             LuaAPI::MP::Engine->Network().ClientKick(*c, "Disconnected after failing to receive packets");

src/Settings.cpp

@@ -28,7 +28,6 @@ Settings::Settings() {
         { General_Map, std::string("/levels/gridmap_v2/info.json") },
         { General_AuthKey, std::string("") },
         { General_Private, true },
-        { General_IP, "::"},
         { General_Port, 30814 },
         { General_MaxCars, 1 },
         { General_LogChat, true },
@@ -48,7 +47,6 @@ Settings::Settings() {
         { { "General", "Map" }, { General_Map, READ_WRITE } },
         { { "General", "AuthKey" }, { General_AuthKey, NO_ACCESS } },
         { { "General", "Private" }, { General_Private, READ_ONLY } },
-        { { "General", "IP" }, { General_IP, READ_ONLY } },
         { { "General", "Port" }, { General_Port, READ_ONLY } },
         { { "General", "MaxCars" }, { General_MaxCars, READ_WRITE } },
         { { "General", "LogChat" }, { General_LogChat, READ_ONLY } },

src/TConfig.cpp

@@ -34,8 +34,6 @@ static constexpr std::string_view StrDebug = "Debug";
 static constexpr std::string_view EnvStrDebug = "BEAMMP_DEBUG";
 static constexpr std::string_view StrPrivate = "Private";
 static constexpr std::string_view EnvStrPrivate = "BEAMMP_PRIVATE";
-static constexpr std::string_view StrIP = "IP";
-static constexpr std::string_view EnvStrIP = "BEAMMP_IP";
 static constexpr std::string_view StrPort = "Port";
 static constexpr std::string_view EnvStrPort = "BEAMMP_PORT";
 static constexpr std::string_view StrMaxCars = "MaxCars";
@@ -140,8 +138,6 @@ void TConfig::FlushToFile() {
     data["General"][StrInformationPacket.data()] = Application::Settings.getAsBool(Settings::Key::General_InformationPacket);
     data["General"][StrAllowGuests.data()] = Application::Settings.getAsBool(Settings::Key::General_AllowGuests);
     SetComment(data["General"][StrAllowGuests.data()].comments(), " Whether to allow guests");
-    data["General"][StrIP.data()] = Application::Settings.getAsString(Settings::Key::General_IP);
-    SetComment(data["General"][StrIP.data()].comments(), " The IP address to bind the server to, this is NOT related to your public IP. Can be used if your machine has multiple network interfaces");
     data["General"][StrPort.data()] = Application::Settings.getAsInt(Settings::Key::General_Port);
     data["General"][StrName.data()] = Application::Settings.getAsString(Settings::Key::General_Name);
     SetComment(data["General"][StrTags.data()].comments(), " Add custom identifying tags to your server to make it easier to find. Format should be TagA,TagB,TagC. Note the comma seperation.");
@@ -258,7 +254,6 @@ void TConfig::ParseFromFile(std::string_view name) {
         } else {
             TryReadValue(data, "General", StrPort, EnvStrPort, Settings::Key::General_Port);
         }
-        TryReadValue(data, "General", StrIP, EnvStrIP, Settings::Key::General_IP);
         TryReadValue(data, "General", StrMaxCars, EnvStrMaxCars, Settings::Key::General_MaxCars);
         TryReadValue(data, "General", StrMaxPlayers, EnvStrMaxPlayers, Settings::Key::General_MaxPlayers);
         TryReadValue(data, "General", StrMap, EnvStrMap, Settings::Key::General_Map);

src/TLuaEngine.cpp

@@ -40,6 +40,20 @@ TLuaEngine* LuaAPI::MP::Engine;
 
 static sol::protected_function AddTraceback(sol::state_view StateView, sol::protected_function RawFn);
 
+static std::optional<sol::function> GetLuaHandler(sol::state_view StateView, const std::string Handler, const std::string EventName);
+
+static std::optional<sol::function> GetLuaHandler(sol::state_view StateView, const std::string Handler, const std::string EventName) {
+    if (!StateView)
+        return std::nullopt;
+    auto Res = StateView.safe_script("return " + Handler, sol::script_pass_on_error);
+    if (!Res.valid()) {
+        beammp_errorf("invalid handler for event \"{}\". handler: \"{}\"", EventName, Handler);
+    } else if (Res.get_type() == sol::type::function) {
+        return Res.get<sol::function>();
+    }
+    return std::nullopt;
+}
+
 TLuaEngine::TLuaEngine()
     : mResourceServerPath(fs::path(Application::Settings.getAsString(Settings::Key::General_ResourceFolder)) / "Server") {
     Application::SetSubsystemStatus("LuaEngine", Application::Status::Starting);
@@ -68,11 +82,10 @@ TEST_CASE("TLuaEngine ctor & dtor") {
 
 void TLuaEngine::operator()() {
     RegisterThread("LuaEngine");
+    Application::SetSubsystemStatus("LuaEngine", Application::Status::Good);
     // lua engine main thread
     beammp_infof("Lua v{}.{}.{}", LUA_VERSION_MAJOR, LUA_VERSION_MINOR, LUA_VERSION_RELEASE);
     CollectAndInitPlugins();
-
-    Application::SetSubsystemStatus("LuaEngine", Application::Status::Good);
     // now call all onInit's
     auto Futures = TriggerEvent("onInit", "");
     WaitForAll(Futures, std::chrono::seconds(5));
@@ -495,9 +508,11 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerGlobalEvent(const std::string
 
     sol::variadic_results LocalArgs = JsonStringToArray(Str);
     for (const auto& Handler : MyHandlers) {
-        auto Fn = mStateView[Handler];
-        Fn = AddTraceback(mStateView, Fn);
-        if (Fn.valid()) {
+        auto Res = GetLuaHandler(mStateView, Handler, EventName);
+        if (Res.has_value()) {
+            sol::function Fn = Res.value();
+            Fn = AddTraceback(mStateView, Fn);
+
             auto LuaResult = Fn(LocalArgs);
             auto Result = std::make_shared<TLuaResult>();
             if (LuaResult.valid()) {
@@ -549,8 +564,9 @@ sol::table TLuaEngine::StateThreadData::Lua_TriggerLocalEvent(const std::string&
     sol::table Result = mStateView.create_table();
     int i = 1;
     for (const auto& Handler : mEngine->GetEventHandlersForState(EventName, mStateId)) {
-        auto Fn = mStateView[Handler];
-        if (Fn.valid() && Fn.get_type() == sol::type::function) {
+        auto Res = GetLuaHandler(mStateView, Handler, EventName);
+        if (Res.has_value()) {
+            sol::function Fn = Res.value();
             auto FnRet = Fn(EventArgs);
             if (FnRet.valid()) {
                 Result.set(i, FnRet);
@@ -1162,8 +1178,10 @@ void TLuaEngine::StateThreadData::operator()() {
                 // TODO: Use TheQueuedFunction.EventName for errors, warnings, etc
                 Result->StateId = mStateId;
                 sol::state_view StateView(mState);
-                auto RawFn = StateView[FnName];
-                if (RawFn.valid() && RawFn.get_type() == sol::type::function) {
+
+                auto Res = GetLuaHandler(StateView, FnName, TheQueuedFunction.EventName);
+                if (Res.has_value()) {
+                    sol::function Fn = Res.value();
                     std::vector<sol::object> LuaArgs;
                     for (const auto& Arg : Args) {
                         if (Arg.valueless_by_exception()) {
@@ -1198,7 +1216,7 @@ void TLuaEngine::StateThreadData::operator()() {
                             break;
                         }
                     }
-                    auto Fn = AddTraceback(StateView, RawFn);
+                    Fn = AddTraceback(StateView, Fn);
                     auto Res = Fn(sol::as_args(LuaArgs));
                     if (Res.valid()) {
                         Result->Error = false;

src/TNetwork.cpp

@@ -85,17 +85,9 @@ TNetwork::TNetwork(TServer& Server, TPPSMonitor& PPSMonitor, TResourceManager& R
 
 void TNetwork::UDPServerMain() {
     RegisterThread("UDPServer");
-
+    // listen on all ipv6 addresses
+    ip::udp::endpoint UdpListenEndpoint(ip::make_address("::"), Application::Settings.getAsInt(Settings::Key::General_Port));
     boost::system::error_code ec;
-    auto address = ip::make_address(Application::Settings.getAsString(Settings::Key::General_IP), ec);
-
-    if (ec) {
-        beammp_errorf("Failed to parse IP: {}", ec.message());
-        Application::GracefullyShutdown();
-    }
-
-    ip::udp::endpoint UdpListenEndpoint(address, Application::Settings.getAsInt(Settings::Key::General_Port));
-
     mUDPSock.open(UdpListenEndpoint.protocol(), ec);
     if (ec) {
         beammp_error("open() failed: " + ec.message());
@@ -115,7 +107,7 @@ void TNetwork::UDPServerMain() {
         Application::GracefullyShutdown();
     }
     Application::SetSubsystemStatus("UDPNetwork", Application::Status::Good);
-    beammp_info(("Vehicle data network online on port ") + std::to_string(UdpListenEndpoint.port()) + (" with a Max of ")
+    beammp_info(("Vehicle data network online on port ") + std::to_string(Application::Settings.getAsInt(Settings::Key::General_Port)) + (" with a Max of ")
         + std::to_string(Application::Settings.getAsInt(Settings::Key::General_MaxPlayers)) + (" Clients"));
     while (!Application::IsShuttingDown()) {
         try {
@@ -178,17 +170,12 @@ void TNetwork::UDPServerMain() {
 void TNetwork::TCPServerMain() {
     RegisterThread("TCPServer");
 
-    boost::system::error_code ec;
-    auto address = ip::make_address(Application::Settings.getAsString(Settings::Key::General_IP), ec);
-    if (ec) {
-        beammp_errorf("Failed to parse IP: {}", ec.message());
-        return;
-    }
-
-    ip::tcp::endpoint ListenEp(address,
-        uint16_t(Application::Settings.getAsInt(Settings::Key::General_Port)));
-
+    // listen on all ipv6 addresses
+    auto port = uint16_t(Application::Settings.getAsInt(Settings::Key::General_Port));
+    ip::tcp::endpoint ListenEp(ip::make_address("::"), port);
+    beammp_infof("Listening on 0.0.0.0:{0} and [::]:{0}", port);
     ip::tcp::socket Listener(mServer.IoCtx());
+    boost::system::error_code ec;
     Listener.open(ListenEp.protocol(), ec);
     if (ec) {
         beammp_errorf("Failed to open socket: {}", ec.message());
@@ -222,7 +209,6 @@ void TNetwork::TCPServerMain() {
         Application::GracefullyShutdown();
     }
     Application::SetSubsystemStatus("TCPNetwork", Application::Status::Good);
-    beammp_infof("Listening on {0} port {1}", ListenEp.address().to_string(), static_cast<uint16_t>(ListenEp.port()));
     beammp_info("Vehicle event network online");
     do {
         try {
@@ -321,11 +307,6 @@ std::shared_ptr<TClient> TNetwork::Authentication(TConnection&& RawConnection) {
     Client->SetIdentifier("ip", ip);
     beammp_tracef("This thread is ip {} ({})", ip, RawConnection.SockAddr.address().to_v6().is_v4_mapped() ? "IPv4 mapped IPv6" : "IPv6");
 
-    if (Application::GetSubsystemStatuses().at("Main") == Application::Status::Starting) {
-        ClientKick(*Client, "The server is still starting, please try joining again later.");
-        return nullptr;
-    }
-
     beammp_info("Identifying new ClientConnection...");
 
     auto Data = TCPRcv(*Client);

src/TPluginMonitor.cpp

@@ -57,26 +57,21 @@ void TPluginMonitor::operator()() {
                     mFileTimes[Pair.first] = CurrentTime;
                     // grandparent of the path should be Resources/Server
                     if (fs::equivalent(fs::path(Pair.first).parent_path().parent_path(), mPath)) {
-                        if (LowerString(fs::path(Pair.first).extension().string()) == ".lua") {
-                            beammp_infof("File \"{}\" changed, reloading", Pair.first);
-                            // is in root folder, so reload
-                            std::ifstream FileStream(Pair.first, std::ios::in | std::ios::binary);
-                            auto Size = std::filesystem::file_size(Pair.first);
-                            auto Contents = std::make_shared<std::string>();
-                            Contents->resize(Size);
-                            FileStream.read(Contents->data(), Contents->size());
-                            TLuaChunk Chunk(Contents, Pair.first, fs::path(Pair.first).parent_path().string());
-                            auto StateID = mEngine->GetStateIDForPlugin(fs::path(Pair.first).parent_path());
-                            auto Res = mEngine->EnqueueScript(StateID, Chunk);
-                            Res->WaitUntilReady();
-                            if (Res->Error) {
-                                beammp_lua_errorf("Error while hot-reloading \"{}\": {}", Pair.first, Res->ErrorMessage);
-                            } else {
-                                mEngine->ReportErrors(mEngine->TriggerLocalEvent(StateID, "onInit"));
-                                mEngine->ReportErrors(mEngine->TriggerEvent("onFileChanged", "", Pair.first));
-                            }
+                        beammp_infof("File \"{}\" changed, reloading", Pair.first);
+                        // is in root folder, so reload
+                        std::ifstream FileStream(Pair.first, std::ios::in | std::ios::binary);
+                        auto Size = std::filesystem::file_size(Pair.first);
+                        auto Contents = std::make_shared<std::string>();
+                        Contents->resize(Size);
+                        FileStream.read(Contents->data(), Contents->size());
+                        TLuaChunk Chunk(Contents, Pair.first, fs::path(Pair.first).parent_path().string());
+                        auto StateID = mEngine->GetStateIDForPlugin(fs::path(Pair.first).parent_path());
+                        auto Res = mEngine->EnqueueScript(StateID, Chunk);
+                        Res->WaitUntilReady();
+                        if (Res->Error) {
+                            beammp_lua_errorf("Error while hot-reloading \"{}\": {}", Pair.first, Res->ErrorMessage);
                         } else {
-                            beammp_debugf("File \"{}\" changed, not reloading because it's not a lua file. Triggering 'onFileChanged' event instead", Pair.first);
+                            mEngine->ReportErrors(mEngine->TriggerLocalEvent(StateID, "onInit"));
                             mEngine->ReportErrors(mEngine->TriggerEvent("onFileChanged", "", Pair.first));
                         }
                     } else {

src/main.cpp

@@ -182,6 +182,10 @@ int BeamMPServerMain(MainArguments Arguments) {
 
     TServer Server(Arguments.List);
 
+    auto LuaEngine = std::make_shared<TLuaEngine>();
+    LuaEngine->SetServer(&Server);
+    Application::Console().InitializeLuaConsole(*LuaEngine);
+
     RegisterThread("Main");
 
     beammp_trace("Running in debug mode on a debug build");
@@ -190,16 +194,13 @@ int BeamMPServerMain(MainArguments Arguments) {
     TPPSMonitor PPSMonitor(Server);
     THeartbeatThread Heartbeat(ResourceManager, Server);
     TNetwork Network(Server, PPSMonitor, ResourceManager);
-
-    auto LuaEngine = std::make_shared<TLuaEngine>();
-    LuaEngine->SetServer(&Server);
-    Application::Console().InitializeLuaConsole(*LuaEngine);
     LuaEngine->SetNetwork(&Network);
     PPSMonitor.SetNetwork(Network);
     Application::CheckForUpdates();
 
     TPluginMonitor PluginMonitor(fs::path(Application::Settings.getAsString(Settings::Key::General_ResourceFolder)) / "Server", LuaEngine);
 
+    Application::SetSubsystemStatus("Main", Application::Status::Good);
     RegisterThread("Main(Waiting)");
 
     std::set<std::string> IgnoreSubsystems {
@@ -214,10 +215,6 @@ int BeamMPServerMain(MainArguments Arguments) {
             std::string SystemsBadList {};
             auto Statuses = Application::GetSubsystemStatuses();
             for (const auto& NameStatusPair : Statuses) {
-                if (NameStatusPair.first == "Main") {
-                    continue;
-                }
-
                 if (IgnoreSubsystems.count(NameStatusPair.first) > 0) {
                     continue; // ignore
                 }
@@ -231,8 +228,6 @@ int BeamMPServerMain(MainArguments Arguments) {
             // remove ", "
             SystemsBadList = SystemsBadList.substr(0, SystemsBadList.size() - 2);
             if (FullyStarted) {
-                Application::SetSubsystemStatus("Main", Application::Status::Good);
-
                 if (!WithErrors) {
                     beammp_info("ALL SYSTEMS STARTED SUCCESSFULLY, EVERYTHING IS OKAY");
                 } else {