Static server build

Create LICENSE

.clang-format

@@ -0,0 +1,5 @@
+---
+BasedOnStyle: WebKit
+BreakBeforeBraces: Attach
+
+...

.gitignore

@@ -1,3 +1,5 @@
+boost_*
+Resources
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 ##
@@ -16,6 +18,20 @@
 # Mono auto generated files
 mono_crash.*
 
+#VS Files
+out/
+
+#Clion Files
+cmake-build-debug/CMakeFiles/
+cmake-build-release/CMakeFiles/
+cmake-build-debug/Resources/
+cmake-build-release/Resources/
+cmake-build-debug/*.*
+cmake-build-release/*.*
+cmake-build-debug/Makefile
+cmake-build-release/Makefile
+!cmake-build-debug/*.lib
+!cmake-build-release/*.lib
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
@@ -445,3 +461,4 @@ out/build/x86-Debug/.cmake/api/v1/reply/target-cmake-main-Debug-540e487569703b71
 out/build/x86-Debug/.cmake/api/v1/reply/index-2020-01-28T17-35-38-0764.json
 out/build/x86-Debug/.cmake/api/v1/reply/codemodel-v2-6a61e390ef8eaf17e9f8.json
 out/build/x86-Debug/Server.cfg
+*Server.cfg*

.idea/.name

@@ -0,0 +1 @@
+Server

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/BeamNG-MP-Server.iml" filepath="$PROJECT_DIR$/.idea/BeamNG-MP-Server.iml" />
-    </modules>
-  </component>
-</project>

CMakeLists.txt

@@ -1,11 +1,43 @@
-cmake_minimum_required(VERSION 3.15)
-project(BeamNG-MP-Server)
-
-set(CMAKE_CXX_STANDARD 14)
-
-add_executable(cmake-main src/main.cpp src/network.cpp src/logger.cpp src/config.cpp)
-ADD_LIBRARY(
-	enet STATIC
-	enet.lib
-)
-set_target_properties(enet PROPERTIES LINKER_LANGUAGE CXX)
+cmake_minimum_required(VERSION 3.13)
+project(Server)
+set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
+
+if (UNIX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -static-libstdc++")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -g")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2 -s -fno-builtin")
+elseif (WIN32)
+    # This might cause issues with old windows headers, but it's worth the trouble to keep the code
+    #   completely cross platform. For fixes to common issues arising from /permissive- visit:
+    #   https://docs.microsoft.com/en-us/cpp/build/reference/permissive-standards-conformance
+
+    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /permissive-")
+    message(STATUS "MSVC -> forcing use of statically-linked runtime.")
+    STRING(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
+    STRING(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+    #-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static
+endif ()
+
+#find_package(Boost 1.70.0 REQUIRED COMPONENTS system thread)
+
+file(GLOB source_files "src/*.cpp" "include/*.h" "include/*/*.h" "include/*/*/*.h" "include/*.hpp" "include/*/*.hpp" "src/*/*.cpp")
+add_executable(BeamMP-Server ${source_files})
+    
+target_include_directories(BeamMP-Server PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+
+find_package(Lua REQUIRED)
+target_include_directories(BeamMP-Server PUBLIC ${LUA_INCLUDE_DIR})
+
+if (UNIX)
+    target_link_libraries(BeamMP-Server z pthread stdc++fs ${Boost_LINK_DIRS} ${LUA_LIBRARIES} curl dl)
+elseif (WIN32)
+    include(FindLua)
+    find_package(ZLIB REQUIRED)
+    find_package(CURL CONFIG REQUIRED)
+    find_package(RapidJSON CONFIG REQUIRED)
+    target_include_directories(BeamMP-Server PRIVATE ${RAPIDJSON_INCLUDE_DIRS})
+    target_link_libraries(BeamMP-Server PRIVATE ws2_32 CURL::libcurl ZLIB::ZLIB ${LUA_LIBRARIES})
+    #${Boost_LINK_DIRS}
+endif ()

LICENSE

@@ -0,0 +1 @@
+Copyright (c) 2019-present Anonymous275. BeamMP Server 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.

README.md

@@ -1 +1,41 @@
-# BeamNG-MP-Server
+# BeamMP-Server
+
+The Server is the way we link client to each other and handle authentication, compression, and data management. It also allows lua plugins, that system is always being reviewed and improved with detailed instructions on wiki.beammp.com.
+
+## Supported Operating Systems
+
+The code itself supports (latest stable) Linux and Windows. In terms of actual build support, for now we only distribute windows binaries and instructions to build on Debian 10 (stable). For any other distro or OS, you just have to find the same libraries listed in the Linux Build [Prerequisites](#prerequisites) further down the page, and it should build fine. We don't currently support ARM or any big-endian architectures. 
+
+Recommended compilers: MSVC, GCC. 
+
+## Linux / POSIX specific build instructions
+
+Currently only linux and windows are supported (generally). On systems to which we do not provide binaries (so anything but windows), you are allowed to compile the program and use it. Other restrictions, such as not being allowed to distribute those binaries, still apply (see [copyright notice](#copyright)).
+
+### Prerequisites
+
+All package names are ones found in debian's (debian 10 stable) repositories, but will exist under similar names in other distros. Feel free to PR your own guide for a different distro.
+
+- `git`
+- `make`
+- `cmake`
+- `g++` (must support ISO C++17)
+- `liblua5.3`
+- `libz-dev`
+- `rapidjson-dev`
+- `libcurl4-openssl-dev` (or other `libcurl4-*-dev`)
+
+### How to build
+
+1. Make sure you have all [prerequisites](#prerequisites) installed
+2. Clone the repository in a location of your choice with `git clone --recursive https://github.com/BeamMP/BeamMP-Server`
+3. `cd` into it with `cd BeamMP-Server`
+4. Run `cmake .` (with `.`)
+5. Run `make`
+6. You will now have a `BeamMP-Server` file in your directory, which is executable with `./BeamMP-Server`. Follow the (windows or linux, doesnt matter) instructions on the [wiki](https://wiki.beammp.com/en/home/Server_Mod) for further setup after installation (which we just did), such as port-forwarding and getting a key to actually run the server.
+
+*tip: to run the server in the background, simply (in bash, zsh, etc) run:* `nohup ./BeamMP-Server &`*.*
+
+## Copyright
+
+Copyright (c) 2019-present Anonymous275. BeamMP Server 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/Client.hpp

@@ -0,0 +1,91 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/8/2020
+///
+
+#pragma once
+#ifdef WIN32
+#include <WS2tcpip.h>
+#else
+#include <arpa/inet.h>
+#define SOCKET int
+#endif
+#include "CustomAssert.h"
+#include <algorithm>
+#include <chrono>
+#include <set>
+#include <string>
+#include <vector>
+
+struct VData {
+    int ID = -1;
+    std::string Data;
+};
+
+class Client {
+private:
+    std::set<std::unique_ptr<VData>> VehicleData; //ID and Data;
+    std::string Name = "Unknown Client";
+    SOCKET SOCK[2] { SOCKET(-1) };
+    sockaddr_in UDPADDR;
+    std::string Role;
+    std::string DID;
+    int Status = 0;
+    int ID = -1;
+
+public:
+    bool isConnected = false;
+    bool isSynced = false;
+    bool isGuest = false;
+
+    void AddNewCar(int ident, const std::string& Data);
+    void SetCarData(int ident, const std::string& Data);
+    std::set<std::unique_ptr<VData>>& GetAllCars();
+    void SetName(const std::string& name) { Name = name; }
+    void SetRoles(const std::string& role) { Role = role; }
+    std::string GetCarData(int ident);
+    void SetUDPAddr(sockaddr_in Addr) { UDPADDR = Addr; }
+    void SetDownSock(SOCKET CSock) { SOCK[1] = CSock; }
+    void SetTCPSock(SOCKET CSock) { SOCK[0] = CSock; }
+    void SetStatus(int status) { Status = status; }
+    void DeleteCar(int ident);
+    sockaddr_in GetUDPAddr() { return UDPADDR; }
+    std::string GetRoles() { return Role; }
+    std::string GetName() { return Name; }
+    SOCKET GetDownSock() { return SOCK[1]; }
+    SOCKET GetTCPSock() { return SOCK[0]; }
+    void SetID(int ID) { this->ID = ID; }
+    int GetOpenCarID();
+    int GetCarCount();
+    void ClearCars();
+    int GetStatus() { return Status; }
+    int GetID() { return ID; }
+};
+struct ClientInterface {
+    std::set<std::unique_ptr<Client>> Clients;
+    void RemoveClient(Client*& c) {
+        Assert(c);
+        c->ClearCars();
+        auto Iter = std::find_if(Clients.begin(), Clients.end(), [&](auto& ptr) {
+            return c == ptr.get();
+        });
+        Assert(Iter != Clients.end());
+        if (Iter == Clients.end()) {
+            return;
+        }
+        Clients.erase(Iter);
+        c = nullptr;
+    }
+    void AddClient(Client*&& c) {
+        Assert(c);
+        Clients.insert(std::unique_ptr<Client>(c));
+    }
+    int Size() {
+        return int(Clients.size());
+    }
+};
+
+extern std::unique_ptr<ClientInterface> CI;

include/Compressor.h

@@ -0,0 +1,11 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/24/2020
+///
+#pragma once
+#include <string>
+std::string Comp(std::string Data);
+std::string DeComp(std::string Compressed);

include/Curl/Http.h

@@ -0,0 +1,11 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/18/2020
+///
+#pragma once
+#include <string>
+std::string HttpRequest(const std::string& IP, int port);
+std::string PostHTTP(const std::string& IP, const std::string& Fields, bool json);

include/CustomAssert.h

@@ -0,0 +1,67 @@
+// Author: lionkor
+
+/*
+ * Asserts are to be used anywhere where assumptions about state are made
+ * implicitly. AssertNotReachable is used where code should never go, like in
+ * default switch cases which shouldn't trigger. They make it explicit
+ * that a place cannot normally be reached and make it an error if they do.
+ */
+
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <thread>
+
+#include "Logger.h"
+
+static const char* const ANSI_RESET = "\u001b[0m";
+
+static const char* const ANSI_BLACK = "\u001b[30m";
+static const char* const ANSI_RED = "\u001b[31m";
+static const char* const ANSI_GREEN = "\u001b[32m";
+static const char* const ANSI_YELLOW = "\u001b[33m";
+static const char* const ANSI_BLUE = "\u001b[34m";
+static const char* const ANSI_MAGENTA = "\u001b[35m";
+static const char* const ANSI_CYAN = "\u001b[36m";
+static const char* const ANSI_WHITE = "\u001b[37m";
+
+static const char* const ANSI_BLACK_BOLD = "\u001b[30;1m";
+static const char* const ANSI_RED_BOLD = "\u001b[31;1m";
+static const char* const ANSI_GREEN_BOLD = "\u001b[32;1m";
+static const char* const ANSI_YELLOW_BOLD = "\u001b[33;1m";
+static const char* const ANSI_BLUE_BOLD = "\u001b[34;1m";
+static const char* const ANSI_MAGENTA_BOLD = "\u001b[35;1m";
+static const char* const ANSI_CYAN_BOLD = "\u001b[36;1m";
+static const char* const ANSI_WHITE_BOLD = "\u001b[37;1m";
+
+static const char* const ANSI_BOLD = "\u001b[1m";
+static const char* const ANSI_UNDERLINE = "\u001b[4m";
+
+#if DEBUG
+inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const char* function, [[maybe_unused]] unsigned line,
+    [[maybe_unused]] const char* condition_string, [[maybe_unused]] bool result) {
+    if (!result) {
+        std::cout << std::flush << "(debug build) TID "
+                  << std::this_thread::get_id() << ": ASSERTION FAILED: at "
+                  << file << ":" << line << " \n\t-> in "
+                  << function << ", Line " << line << ": \n\t\t-> "
+                  << "Failed Condition: " << condition_string << std::endl;
+        std::cout << "... terminating ..." << std::endl;
+        abort();
+    }
+}
+
+#define Assert(cond) _assert(__FILE__, __func__, __LINE__, #cond, (cond))
+#define AssertNotReachable() _assert(__FILE__, __func__, __LINE__, "reached unreachable code", false)
+#else
+// In release build, these macros turn into NOPs. The compiler will optimize these out.
+#define Assert(x) \
+    do {          \
+    } while (false)
+#define AssertNotReachable() \
+    do {                     \
+    } while (false)
+#endif // DEBUG

include/Json.h

@@ -0,0 +1,12 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 11/27/2020
+///
+#pragma once
+#include "rapidjson/document.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/writer.h"
+namespace json = rapidjson;

include/Logger.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 4/2/2020.
+///
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include <string>
+void InitLog();
+#define DebugPrintTID() DebugPrintTIDInternal(__func__, false)
+void DebugPrintTIDInternal(const std::string& func, bool overwrite = true); // prints the current thread id in debug mode, to make tracing of crashes and asserts easier
+void ConsoleOut(const std::string& msg);
+void except(const std::string& toPrint);
+void debug(const std::string& toPrint);
+void error(const std::string& toPrint);
+void info(const std::string& toPrint);
+void warn(const std::string& toPrint);

include/Lua/LuaSystem.hpp

@@ -0,0 +1,81 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/20/2020
+///
+
+#pragma once
+#include <any>
+#include <filesystem>
+#include <iostream>
+#include <lua.hpp>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <thread>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+struct LuaArg {
+    std::vector<std::any> args;
+    void PushArgs(lua_State* State) {
+        for (std::any arg : args) {
+            if (!arg.has_value())
+                return;
+            std::string Type = arg.type().name();
+            if (Type.find("bool") != std::string::npos) {
+                lua_pushboolean(State, std::any_cast<bool>(arg));
+            }
+            if (Type.find("basic_string") != std::string::npos || Type.find("char") != std::string::npos) {
+                lua_pushstring(State, std::any_cast<std::string>(arg).c_str());
+            }
+            if (Type.find("int") != std::string::npos) {
+                lua_pushinteger(State, std::any_cast<int>(arg));
+            }
+            if (Type.find("float") != std::string::npos) {
+                lua_pushnumber(State, std::any_cast<float>(arg));
+            }
+        }
+    }
+};
+
+class Lua {
+private:
+    std::set<std::pair<std::string, std::string>> _RegisteredEvents;
+    lua_State* luaState { nullptr };
+    fs::file_time_type _LastWrote;
+    std::string _PluginName {};
+    std::string _FileName {};
+    bool _StopThread = false;
+    bool _Console = false;
+
+public:
+    void Init();
+    void RegisterEvent(const std::string& Event, const std::string& FunctionName);
+    std::string GetRegistered(const std::string& Event) const;
+    void UnRegisterEvent(const std::string& Event);
+    void SetLastWrite(fs::file_time_type time);
+    bool IsRegistered(const std::string& Event);
+    void SetPluginName(const std::string& Name);
+    void Execute(const std::string& Command);
+    void SetFileName(const std::string& Name);
+    fs::file_time_type GetLastWrite();
+    std::string GetPluginName() const;
+    std::string GetFileName() const;
+    lua_State* GetState();
+    const lua_State* GetState() const;
+    std::string GetOrigin();
+    std::mutex Lock;
+    void Reload();
+    Lua(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote, bool Console = false);
+    Lua(bool Console = false);
+    ~Lua();
+    void SetStopThread(bool StopThread) { _StopThread = StopThread; }
+    bool GetStopThread() const { return _StopThread; }
+};
+std::any CallFunction(Lua* lua, const std::string& FuncName, std::shared_ptr<LuaArg> args);
+std::any TriggerLuaEvent(const std::string& Event, bool local, Lua* Caller, std::shared_ptr<LuaArg> arg, bool Wait);
+extern std::set<std::unique_ptr<Lua>> PluginEngine;

include/Network.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/31/2020
+///
+#pragma once
+#include "Client.hpp"
+#include <string>
+void TCPServerMain();
+void UpdatePlayers();
+void OnConnect(Client* c);
+void TCPClient(Client* c);
+std::string TCPRcv(Client* c);
+void SyncResources(Client* c);
+[[noreturn]] void UDPServerMain();
+void OnDisconnect(Client* c, bool kicked);
+void UDPSend(Client* c, std::string Data);
+void SendLarge(Client* c, std::string Data);
+bool TCPSend(Client* c, const std::string& Data);
+void GParser(Client* c, const std::string& Packet);
+std::string StaticReason(bool Set, const std::string& R);
+void Respond(Client* c, const std::string& MSG, bool Rel);
+void SendToAll(Client* c, const std::string& Data, bool Self, bool Rel);

include/RWMutex.h

@@ -0,0 +1,19 @@
+// Author: lionkor
+#pragma once
+
+/*
+ * An RWMutex allows multiple simultaneous readlocks but only one writelock at a time,
+ * and write locks and read locks are mutually exclusive.
+ */
+
+#include <shared_mutex>
+
+// Use ReadLock(m) and WriteLock(m) to lock it.
+using RWMutex = std::shared_mutex;
+// Construct with an RWMutex as a non-const reference.
+// locks the mutex in lock_shared mode (for reading). Locking in a thread that already owns a lock
+// i.e. locking multiple times successively is UB. Construction may be blocking. Destruction is guaranteed to release the lock.
+using ReadLock = std::shared_lock<RWMutex>;
+// Construct with an RWMutex as a non-const reference.
+// locks the mutex for writing. Construction may be blocking. Destruction is guaranteed to release the lock.
+using WriteLock = std::unique_lock<RWMutex>;

include/Security/Enc.h

@@ -0,0 +1,15 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#pragma once
+#ifdef __linux
+#define EXCEPTION_POINTERS void
+#else
+#include <WS2tcpip.h>
+#endif
+#include <string>
+int Handle(EXCEPTION_POINTERS* ep, char* Origin);

include/Settings.h

@@ -0,0 +1,28 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#pragma once
+#include <string>
+extern std::string ServerName;
+extern std::string ServerDesc;
+extern std::string StatReport;
+extern std::string FileSizes;
+extern std::string Resource;
+extern std::string FileList;
+extern std::string CustomIP;
+extern std::string MapName;
+extern uint64_t MaxModSize;
+extern std::string Key;
+std::string GetSVer();
+std::string GetCVer();
+extern int MaxPlayers;
+extern int ModsLoaded;
+extern bool Private;
+extern int MaxCars;
+extern bool Debug;
+extern int Port;
+extern int PPS;

include/Startup.h

@@ -0,0 +1,16 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#pragma once
+void InitServer(int argc, char* argv[]);
+void ConsoleInit();
+void InitConfig();
+void InitLua();
+void InitRes();
+void HBInit();
+void StatInit();
+void NetMain();

include/UnixCompat.h

@@ -0,0 +1,38 @@
+// Author: lionkor
+
+#pragma once
+
+// This header defines unix equivalents of common win32 functions.
+
+#ifndef WIN32
+
+#include "CustomAssert.h"
+#include <cstring>
+#include <sys/socket.h>
+#include <unistd.h>
+
+// ZeroMemory is just a {0} or a memset(addr, 0, len), and it's a macro on MSVC
+inline void ZeroMemory([[maybe_unused]] void* dst, [[maybe_unused]] size_t len) {
+    [[maybe_unused]] auto res = std::memset(dst, 0, len);
+    Assert(res != nullptr);
+}
+// provides unix equivalent of closesocket call in win32
+inline void CloseSocketProper(int socket) {
+    shutdown(socket, SHUT_RDWR);
+    close(socket);
+}
+
+#ifndef __try
+#define __try
+#endif
+
+#ifndef __except
+#define __except (x) /**/
+#endif
+
+#else // win32
+inline void CloseSocketProper(uint64_t socket) {
+    shutdown(socket, SD_BOTH);
+    closesocket(socket);
+}
+#endif // WIN32

src/Compressor.cpp

@@ -0,0 +1,56 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/15/2020
+///
+
+#include <algorithm>
+#include <array>
+#include <iostream>
+#include <zlib.h>
+
+#define Biggest 30000
+std::string Comp(std::string Data) {
+    std::array<char, Biggest> C {};
+    // obsolete
+    C.fill(0);
+    z_stream defstream;
+    defstream.zalloc = Z_NULL;
+    defstream.zfree = Z_NULL;
+    defstream.opaque = Z_NULL;
+    defstream.avail_in = (uInt)Data.length();
+    defstream.next_in = (Bytef*)&Data[0];
+    defstream.avail_out = Biggest;
+    defstream.next_out = reinterpret_cast<Bytef*>(C.data());
+    deflateInit(&defstream, Z_BEST_COMPRESSION);
+    deflate(&defstream, Z_SYNC_FLUSH);
+    deflate(&defstream, Z_FINISH);
+    deflateEnd(&defstream);
+    size_t TO = defstream.total_out;
+    std::string Ret(TO, 0);
+    std::copy_n(C.begin(), TO, Ret.begin());
+    return Ret;
+}
+std::string DeComp(std::string Compressed) {
+    std::array<char, Biggest> C {};
+    // not needed
+    C.fill(0);
+    z_stream infstream;
+    infstream.zalloc = Z_NULL;
+    infstream.zfree = Z_NULL;
+    infstream.opaque = Z_NULL;
+    infstream.avail_in = Biggest;
+    infstream.next_in = (Bytef*)(&Compressed[0]);
+    infstream.avail_out = Biggest;
+    infstream.next_out = (Bytef*)(C.data());
+    inflateInit(&infstream);
+    inflate(&infstream, Z_SYNC_FLUSH);
+    inflate(&infstream, Z_FINISH);
+    inflateEnd(&infstream);
+    size_t TO = infstream.total_out;
+    std::string Ret(TO, 0);
+    std::copy_n(C.begin(), TO, Ret.begin());
+    return Ret;
+}

src/Console.cpp

@@ -0,0 +1,263 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 10/29/2020
+///
+
+#include "Lua/LuaSystem.hpp"
+#ifdef WIN32
+#include <conio.h>
+#include <windows.h>
+#else // *nix
+typedef unsigned long DWORD, *PDWORD, *LPDWORD;
+#include <termios.h>
+#include <unistd.h>
+#endif // WIN32
+#include "Logger.h"
+#include <array>
+#include <cstring>
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <thread>
+
+std::vector<std::string> QConsoleOut;
+std::string CInputBuff;
+std::mutex MLock;
+std::unique_ptr<Lua> LuaConsole;
+void HandleInput(const std::string& cmd) {
+    std::cout << std::endl;
+    if (cmd == ("exit")) {
+        _Exit(0);
+    } else if (cmd == ("clear") || cmd == ("cls")) {
+        // 2J is clearscreen, H is reset position to top-left
+        ConsoleOut(("\x1b[2J\x1b[H"));
+    } else {
+        LuaConsole->Execute(cmd);
+    }
+}
+
+void ProcessOut() {
+    printf("%c[2K\r", 27);
+    for (const std::string& msg : QConsoleOut)
+        if (!msg.empty())
+            std::cout << msg;
+    MLock.lock();
+    QConsoleOut.clear();
+    MLock.unlock();
+    std::cout << "> " << CInputBuff << std::flush;
+}
+
+void ConsoleOut(const std::string& msg) {
+    MLock.lock();
+    QConsoleOut.emplace_back(msg);
+    MLock.unlock();
+}
+
+[[noreturn]] void OutputRefresh() {
+    DebugPrintTID();
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        ProcessOut();
+    }
+}
+
+#ifndef WIN32
+
+static struct termios old, current;
+
+void initTermios(int echo) {
+    tcgetattr(0, &old); /* grab old terminal i/o settings */
+    current = old; /* make new settings same as old settings */
+    current.c_lflag &= ~ICANON; /* disable buffered i/o */
+    if (echo) {
+        current.c_lflag |= ECHO; /* set echo mode */
+    } else {
+        current.c_lflag &= ~ECHO; /* set no echo mode */
+    }
+    tcsetattr(0, TCSANOW, &current); /* use these new terminal i/o settings now */
+}
+
+void resetTermios(void) {
+    tcsetattr(0, TCSANOW, &old);
+}
+
+char getch_(int echo) {
+    char ch;
+    initTermios(echo);
+    read(STDIN_FILENO, &ch, 1);
+    resetTermios();
+    return ch;
+}
+
+char _getch(void) {
+    return getch_(0);
+}
+
+#endif // WIN32
+
+void SetupConsole() {
+#if defined(WIN32)
+    DWORD outMode = 0;
+    HANDLE stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (stdoutHandle == INVALID_HANDLE_VALUE) {
+        error("Invalid console handle! Inputs will not work properly");
+        return;
+    }
+    if (!GetConsoleMode(stdoutHandle, &outMode)) {
+        error("Invalid console mode! Inputs will not work properly");
+        return;
+    }
+    // Enable ANSI escape codes
+    outMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    if (!SetConsoleMode(stdoutHandle, outMode)) {
+        error("failed to set console mode! Inputs will not work properly");
+        return;
+    }
+#else
+#endif // WIN32
+}
+
+static std::vector<std::string> ConsoleHistory {};
+// buffer used to revert back to what we were writing when we go all the way forward in history
+static std::string LastInputBuffer {};
+static size_t ConsoleHistoryReadIndex { 0 };
+
+static inline void ConsoleHistoryAdd(const std::string& cmd) {
+    LastInputBuffer.clear();
+    ConsoleHistory.push_back(cmd);
+    ConsoleHistoryReadIndex = ConsoleHistory.size();
+}
+
+static inline void ConsoleHistoryEnsureBounds() {
+    if (ConsoleHistoryReadIndex >= ConsoleHistory.size()) {
+        ConsoleHistoryReadIndex = ConsoleHistory.size() - 1;
+    }
+}
+
+static inline void ConsoleHistoryGoBack() {
+    if (ConsoleHistoryReadIndex > 0) {
+        --ConsoleHistoryReadIndex;
+        ConsoleHistoryEnsureBounds();
+    }
+}
+
+static inline void ConsoleHistoryGoForward() {
+    ++ConsoleHistoryReadIndex;
+    ConsoleHistoryEnsureBounds();
+}
+
+static std::string CompositeInput;
+static bool CompositeInputExpected { false };
+
+static void ProcessCompositeInput() {
+#ifdef WIN32
+    if (CompositeInput.size() == 1 && memcmp(CompositeInput.data(), std::array<char, 1> { 72 }.data(), 1) == 0) {
+#else // unix
+    if (CompositeInput.size() == 2 && memcmp(CompositeInput.data(), std::array<char, 2> { 91, 65 }.data(), 2) == 0) {
+#endif // WIN32
+
+        // UP ARROW
+        if (!ConsoleHistory.empty()) {
+            ConsoleHistoryGoBack();
+            CInputBuff = ConsoleHistory.at(ConsoleHistoryReadIndex);
+        }
+#ifdef WIN32
+    } else if (CompositeInput.size() == 1 && memcmp(CompositeInput.data(), std::array<char, 1> { 80 }.data(), 1) == 0) {
+#else // unix
+    } else if (CompositeInput.size() == 2 && memcmp(CompositeInput.data(), std::array<char, 2> { 91, 66 }.data(), 2) == 0) {
+#endif // WIN32
+
+        // DOWN ARROW
+        if (!ConsoleHistory.empty()) {
+            if (ConsoleHistoryReadIndex == ConsoleHistory.size() - 1) {
+                CInputBuff = LastInputBuffer;
+            } else {
+                ConsoleHistoryGoForward();
+                CInputBuff = ConsoleHistory.at(ConsoleHistoryReadIndex);
+            }
+        }
+    } else {
+        // not composite input, we made a mistake, so lets just add it to the buffer like usual
+        CInputBuff += CompositeInput;
+    }
+    // ensure history doesnt grow too far beyond a max
+    static constexpr size_t MaxHistory = 10;
+    if (ConsoleHistory.size() > 2 * MaxHistory) {
+        decltype(ConsoleHistory) NewHistory(ConsoleHistory.begin() + ConsoleHistory.size() - MaxHistory, ConsoleHistory.end());
+        ConsoleHistory = std::move(NewHistory);
+        ConsoleHistoryReadIndex = ConsoleHistory.size();
+    }
+}
+
+void ReadCin() {
+    DebugPrintTID();
+    size_t null_byte_counter = 0;
+    while (true) {
+        int In = _getch();
+        //info(std::to_string(In));
+        if (In == 0) {
+            ++null_byte_counter;
+            if (null_byte_counter > 50) {
+                info(("too many null bytes in input, this is now assumed to be a background thread - console input is now disabled"));
+                break;
+            }
+        }
+        if (CompositeInputExpected) {
+            CompositeInput += char(In);
+#ifdef WIN32
+            if (CompositeInput.size() == 1) {
+#else // unix
+            if (CompositeInput.size() == 2) {
+#endif // WIN32
+                CompositeInputExpected = false;
+                ProcessCompositeInput();
+            }
+            continue;
+        }
+        if (In == 13 || In == '\n') {
+            if (!CInputBuff.empty()) {
+                HandleInput(CInputBuff);
+                ConsoleHistoryAdd(CInputBuff);
+                CInputBuff.clear();
+            }
+        } else if (In == 8 || In == 127) {
+            if (!CInputBuff.empty())
+                CInputBuff.pop_back();
+        } else if (In == 4) {
+            CInputBuff = "exit";
+            HandleInput(CInputBuff);
+            CInputBuff.clear();
+        } else if (In == 12) {
+            CInputBuff = "clear";
+            HandleInput(CInputBuff);
+            CInputBuff.clear();
+#ifdef WIN32
+        } else if (In == 224) {
+#else // unix
+        } else if (In == 27) {
+#endif // WIN32
+
+            // escape char, assume stuff follows
+            CompositeInputExpected = true;
+            CompositeInput.clear();
+        } else if (!isprint(In)) {
+            // ignore
+        } else {
+            CInputBuff += char(In);
+            LastInputBuffer = CInputBuff;
+        }
+    }
+}
+void ConsoleInit() {
+    SetupConsole();
+    LuaConsole = std::make_unique<Lua>(true);
+    LuaConsole->Init();
+    printf("> ");
+    std::thread In(ReadCin);
+    In.detach();
+    std::thread Out(OutputRefresh);
+    Out.detach();
+}

src/Enc.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#include "Security/Enc.h"
+#include "CustomAssert.h"
+#include "Logger.h"
+#include <sstream>
+
+#ifdef WIN32
+#include <WS2tcpip.h>
+int Handle(EXCEPTION_POINTERS* ep, char* Origin) {
+    Assert(false);
+    std::stringstream R;
+    R << ("Code : ") << std::hex
+      << ep->ExceptionRecord->ExceptionCode
+      << std::dec << (" Origin : ") << Origin;
+    except(R.str());
+    return 1;
+}
+#else
+// stub
+int Handle(EXCEPTION_POINTERS*, char*) { return 1; }
+#endif // WIN32

src/Init/Config.cpp

@@ -0,0 +1,167 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#include "CustomAssert.h"
+#include "Logger.h"
+#include "Security/Enc.h"
+#include <fstream>
+#include <string>
+#include <thread>
+std::string ServerName;
+std::string ServerDesc;
+std::string Resource;
+std::string MapName;
+std::string Key;
+int MaxPlayers;
+bool Private;
+int MaxCars;
+bool Debug;
+int Port;
+
+void SetValues(const std::string& Line, int Index) {
+    int state = 0;
+    std::string Data;
+    bool Switch = false;
+    if (Index > 5)
+        Switch = true;
+    for (char c : Line) {
+        if (Switch) {
+            if (c == '\"')
+                state++;
+            if (state > 0 && state < 2)
+                Data += c;
+        } else {
+            if (c == ' ')
+                state++;
+            if (state > 1)
+                Data += c;
+        }
+    }
+    Data = Data.substr(1);
+    std::string::size_type sz;
+    bool FoundTrue = std::string(Data).find("true") != std::string::npos; //searches for "true"
+    switch (Index) {
+    case 1:
+        Debug = FoundTrue; //checks and sets the Debug Value
+        break;
+    case 2:
+        Private = FoundTrue; //checks and sets the Private Value
+        break;
+    case 3:
+        Port = std::stoi(Data, &sz); //sets the Port
+        break;
+    case 4:
+        MaxCars = std::stoi(Data, &sz); //sets the Max Car amount
+        break;
+    case 5:
+        MaxPlayers = std::stoi(Data, &sz); //sets the Max Amount of player
+        break;
+    case 6:
+        MapName = Data; //Map
+        break;
+    case 7:
+        ServerName = Data; //Name
+        break;
+    case 8:
+        ServerDesc = Data; //desc
+        break;
+    case 9:
+        Resource = Data; //File name
+        break;
+    case 10:
+        Key = Data; //File name
+    default:
+        break;
+    }
+}
+std::string RemoveComments(const std::string& Line) {
+    std::string Return;
+    for (char c : Line) {
+        if (c == '#')
+            break;
+        Return += c;
+    }
+    return Return;
+}
+void LoadConfig(std::ifstream& IFS) {
+    Assert(IFS.is_open());
+    std::string line;
+    int index = 1;
+    while (getline(IFS, line)) {
+        index++;
+    }
+    if (index - 1 < 11) {
+        error(("Outdated/Incorrect config please remove it server will close in 5 secs"));
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+        _Exit(0);
+    }
+    IFS.close();
+    IFS.open(("Server.cfg"));
+    info(("Config found updating values"));
+    index = 1;
+    while (getline(IFS, line)) {
+        if (line.rfind('#', 0) != 0 && line.rfind(' ', 0) != 0) { //Checks if it starts as Comment
+            std::string CleanLine = RemoveComments(line); //Cleans it from the Comments
+            SetValues(CleanLine, index); //sets the values
+            index++;
+        }
+    }
+}
+void GenerateConfig() {
+    std::ofstream FileStream;
+    FileStream.open(("Server.cfg"));
+    FileStream << ("# This is the BeamMP Server Configuration File v0.60\n"
+                   "Debug = false # true or false to enable debug console output\n"
+                   "Private = true # Private?\n"
+                   "Port = 30814 # Port to run the server on UDP and TCP\n"
+                   "Cars = 1 # Max cars for every player\n"
+                   "MaxPlayers = 10 # Maximum Amount of Clients\n"
+                   "Map = \"/levels/gridmap/info.json\" # Default Map\n"
+                   "Name = \"BeamMP New Server\" # Server Name\n"
+                   "Desc = \"BeamMP Default Description\" # Server Description\n"
+                   "use = \"Resources\" # Resource file name\n"
+                   "AuthKey = \"\" # Auth Key");
+    FileStream.close();
+}
+void Default() {
+    info(("Config not found generating default"));
+    GenerateConfig();
+    error(("You are required to input the AuthKey"));
+    std::this_thread::sleep_for(std::chrono::seconds(3));
+    _Exit(0);
+}
+void DebugData() {
+    debug(std::string("Debug : ") + (Debug ? "true" : "false"));
+    debug(std::string("Private : ") + (Private ? "true" : "false"));
+    debug("Port : " + std::to_string(Port));
+    debug("Max Cars : " + std::to_string(MaxCars));
+    debug("MaxPlayers : " + std::to_string(MaxPlayers));
+    debug("MapName : " + MapName);
+    debug("ServerName : " + ServerName);
+    debug("ServerDesc : " + ServerDesc);
+    debug("File : " + Resource);
+    debug("Key length: " + std::to_string(Key.length()));
+}
+void InitConfig() {
+    ////TODO: Move to json after update 4
+
+    std::ifstream IFS;
+    IFS.open(("Server.cfg"));
+    if (IFS.good())
+        LoadConfig(IFS);
+    else
+        Default();
+    if (IFS.is_open())
+        IFS.close();
+    if (Key.empty()) {
+        error(("No AuthKey was found"));
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+        _Exit(0);
+    }
+    if (Debug)
+        DebugData();
+}

src/Init/Heartbeat.cpp

@@ -0,0 +1,84 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#include "Client.hpp"
+#include "Curl/Http.h"
+#include "Logger.h"
+#include "Settings.h"
+#include <chrono>
+#include <future>
+#include <sstream>
+#include <thread>
+
+void WebsocketInit();
+std::string GetPlayers() {
+    std::string Return;
+    for (auto& c : CI->Clients) {
+        if (c != nullptr) {
+            Return += c->GetName() + ";";
+        }
+    }
+    return Return;
+}
+std::string GenerateCall() {
+    std::stringstream Ret;
+    Ret << "uuid=" << Key << "&players=" << CI->Size()
+        << "&maxplayers=" << MaxPlayers << "&port=" << Port
+        << "&map=" << MapName << "&private=" << (Private ? "true" : "false")
+        << "&version=" << GetSVer() << "&clientversion=" << GetCVer()
+        << "&name=" << ServerName << "&pps=" << StatReport
+        << "&modlist=" << FileList << "&modstotalsize=" << MaxModSize
+        << "&modstotal=" << ModsLoaded << "&playerslist=" << GetPlayers()
+        << "&desc=" << ServerDesc;
+    return Ret.str();
+}
+std::string RunPromise(const std::string& IP, const std::string& R) {
+    std::packaged_task<std::string()> task([&] { return PostHTTP(IP, R, false); });
+    std::future<std::string> f1 = task.get_future();
+    std::thread t(std::move(task));
+    t.detach();
+    auto status = f1.wait_for(std::chrono::seconds(15));
+    if (status != std::future_status::timeout)
+        return f1.get();
+    error("Backend system Timeout please try again later");
+    return "";
+}
+
+[[noreturn]] void Heartbeat() {
+    DebugPrintTID();
+    std::string R, T;
+    bool isAuth = false;
+    while (true) {
+        R = GenerateCall();
+        if (!CustomIP.empty())
+            R += "&ip=" + CustomIP;
+        std::string link = "https://beammp.com/heartbeatv2";
+        T = RunPromise(link, R);
+
+        if (T.substr(0, 2) != "20") {
+            //Backend system refused server startup!
+            std::this_thread::sleep_for(std::chrono::seconds(10));
+            std::string Backup = "https://backup1.beammp.com/heartbeatv2";
+            T = RunPromise(Backup, R);
+            if (T.substr(0, 2) != "20") {
+                warn("Backend system refused server! Server might not show in the public list");
+            }
+        }
+        //Server Authenticated
+        if (!isAuth) {
+            WebsocketInit();
+            if (T.length() == 4)info(("Authenticated!"));
+            else info(("Resumed authenticated session!"));
+            isAuth = true;
+        }
+        //std::this_thread::sleep_for(std::chrono::seconds(5));
+    }
+}
+void HBInit() {
+    std::thread HB(Heartbeat);
+    HB.detach();
+}

src/Init/Resources.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#include "Logger.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include <algorithm>
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+uint64_t MaxModSize = 0;
+std::string FileSizes;
+std::string FileList;
+int ModsLoaded = 0;
+
+void InitRes() {
+    std::string Path = Resource + "/Client";
+    if (!fs::exists(Path))
+        fs::create_directory(Path);
+    for (const auto& entry : fs::directory_iterator(Path)) {
+        auto pos = entry.path().string().find(".zip");
+        if (pos != std::string::npos) {
+            if (entry.path().string().length() - pos == 4) {
+                FileList += entry.path().string() + ";";
+                FileSizes += std::to_string(uint64_t(fs::file_size(entry.path()))) + ";";
+                MaxModSize += uint64_t(fs::file_size(entry.path()));
+                ModsLoaded++;
+            }
+        }
+    }
+    std::replace(FileList.begin(), FileList.end(), '\\', '/');
+    if (ModsLoaded)
+        info("Loaded " + std::to_string(ModsLoaded) + " Mods");
+}

src/Init/Startup.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/28/2020
+///
+#include "Client.hpp"
+#include "Logger.h"
+#include "Security/Enc.h"
+#include <algorithm>
+#include <string>
+
+std::string CustomIP;
+std::string GetSVer() {
+    return "1.20";
+}
+std::string GetCVer() {
+    return "1.80";
+}
+void Args(int argc, char* argv[]) {
+    info("BeamMP Server Running version " + GetSVer());
+    if (argc > 1) {
+        CustomIP = argv[1];
+        size_t n = std::count(CustomIP.begin(), CustomIP.end(), '.');
+        auto p = CustomIP.find_first_not_of((".0123456789"));
+        if (p != std::string::npos || n != 3 || CustomIP.substr(0, 3) == ("127")) {
+            CustomIP.clear();
+            warn("IP Specified is invalid! Ignoring");
+        } else
+            info("Server started with custom IP");
+    }
+}
+void InitServer(int argc, char* argv[]) {
+    InitLog();
+    Args(argc, argv);
+    CI = std::make_unique<ClientInterface>();
+}

src/Lua/LuaMain.cpp

@@ -0,0 +1,92 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/20/2020
+///
+
+#include "Logger.h"
+#include "Lua/LuaSystem.hpp"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include <thread>
+
+#ifdef __linux
+// we need this for `struct stat`
+#include <sys/stat.h>
+#endif // __linux
+
+std::set<std::unique_ptr<Lua>> PluginEngine;
+bool NewFile(const std::string& Path) {
+    for (auto& Script : PluginEngine) {
+        if (Path == Script->GetFileName())
+            return false;
+    }
+    return true;
+}
+void RegisterFiles(const std::string& Path, bool HotSwap) {
+    std::string Name = Path.substr(Path.find_last_of('\\') + 1);
+    if (!HotSwap)
+        info(("Loading plugin : ") + Name);
+    for (const auto& entry : fs::directory_iterator(Path)) {
+        auto pos = entry.path().string().find((".lua"));
+        if (pos != std::string::npos && entry.path().string().length() - pos == 4) {
+            if (!HotSwap || NewFile(entry.path().string())) {
+                auto FileName = entry.path().string();
+                std::unique_ptr<Lua> ScriptToInsert(new Lua(Name, FileName, fs::last_write_time(FileName)));
+                auto& Script = *ScriptToInsert;
+                PluginEngine.insert(std::move(ScriptToInsert));
+                Script.Init();
+                if (HotSwap)
+                    info(("[HOTSWAP] Added : ") + Script.GetFileName().substr(Script.GetFileName().find('\\')));
+            }
+        }
+    }
+}
+void FolderList(const std::string& Path, bool HotSwap) {
+    for (const auto& entry : fs::directory_iterator(Path)) {
+        auto pos = entry.path().filename().string().find('.');
+        if (pos == std::string::npos) {
+            RegisterFiles(entry.path().string(), HotSwap);
+        }
+    }
+}
+[[noreturn]] void HotSwaps(const std::string& path) {
+    DebugPrintTID();
+    while (true) {
+        if (!PluginEngine.empty()) {
+            for (auto& Script : PluginEngine) {
+                struct stat Info { };
+                if (stat(Script->GetFileName().c_str(), &Info) != 0) {
+                    Script->SetStopThread(true);
+                    PluginEngine.erase(Script);
+                    info(("[HOTSWAP] Removed removed script due to delete"));
+                    break;
+                }
+                if (Script->GetLastWrite() != fs::last_write_time(Script->GetFileName())) {
+                    Script->SetStopThread(true);
+                    info(("[HOTSWAP] Updated Scripts due to edit"));
+                    Script->SetLastWrite(fs::last_write_time(Script->GetFileName()));
+                    Script->Reload();
+                }
+            }
+        }
+        FolderList(path, true);
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+    }
+}
+
+void InitLua() {
+    if (!fs::exists(Resource)) {
+        fs::create_directory(Resource);
+    }
+    std::string Path = Resource + ("/Server");
+    if (!fs::exists(Path)) {
+        fs::create_directory(Path);
+    }
+    FolderList(Path, false);
+    std::thread t1(HotSwaps, Path);
+    t1.detach();
+    info(("Lua system online"));
+}

src/Lua/LuaSystem.cpp

@@ -0,0 +1,705 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/19/2020
+///
+
+#include "Lua/LuaSystem.hpp"
+#include "Client.hpp"
+#include "Logger.h"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#include <future>
+#include <iostream>
+#include <optional>
+#include <utility>
+
+std::shared_ptr<LuaArg> CreateArg(lua_State* L, int T, int S) {
+    if (S > T)
+        return nullptr;
+    std::shared_ptr<LuaArg> temp(new LuaArg);
+    for (int C = S; C <= T; C++) {
+        if (lua_isstring(L, C)) {
+            temp->args.emplace_back(std::string(lua_tostring(L, C)));
+        } else if (lua_isinteger(L, C)) {
+            temp->args.emplace_back(int(lua_tointeger(L, C)));
+        } else if (lua_isboolean(L, C)) {
+            temp->args.emplace_back(bool(lua_toboolean(L, C)));
+        } else if (lua_isnumber(L, C)) {
+            temp->args.emplace_back(float(lua_tonumber(L, C)));
+        }
+    }
+    return temp;
+}
+void ClearStack(lua_State* L) {
+    lua_settop(L, 0);
+}
+std::optional<std::reference_wrapper<Lua>> GetScript(lua_State* L) {
+    for (auto& Script : PluginEngine) {
+        if (Script->GetState() == L)
+            return *Script;
+    }
+    return std::nullopt;
+}
+void SendError(lua_State* L, const std::string& msg) {
+    Assert(L);
+    auto MaybeS = GetScript(L);
+    std::string a;
+    if (!MaybeS.has_value()) {
+        a = ("_Console");
+    } else {
+        Lua& S = MaybeS.value();
+        a = fs::path(S.GetFileName()).filename().string();
+    }
+    warn(a + (" | Incorrect Call of ") + msg);
+}
+std::any Trigger(Lua* lua, const std::string& R, std::shared_ptr<LuaArg> arg) {
+    std::lock_guard<std::mutex> lockGuard(lua->Lock);
+    std::packaged_task<std::any(std::shared_ptr<LuaArg>)> task([lua, R](std::shared_ptr<LuaArg> arg) { return CallFunction(lua, R, arg); });
+    std::future<std::any> f1 = task.get_future();
+    std::thread t(std::move(task), arg);
+    t.detach();
+    auto status = f1.wait_for(std::chrono::seconds(5));
+    if (status != std::future_status::timeout)
+        return f1.get();
+    SendError(lua->GetState(), R + " took too long to respond");
+    return 0;
+}
+std::any FutureWait(Lua* lua, const std::string& R, std::shared_ptr<LuaArg> arg, bool Wait) {
+    Assert(lua);
+    std::packaged_task<std::any(std::shared_ptr<LuaArg>)> task([lua, R](std::shared_ptr<LuaArg> arg) { return Trigger(lua, R, arg); });
+    std::future<std::any> f1 = task.get_future();
+    std::thread t(std::move(task), arg);
+    t.detach();
+    int T = 0;
+    if (Wait)
+        T = 6;
+    auto status = f1.wait_for(std::chrono::seconds(T));
+    if (status != std::future_status::timeout)
+        return f1.get();
+    return 0;
+}
+std::any TriggerLuaEvent(const std::string& Event, bool local, Lua* Caller, std::shared_ptr<LuaArg> arg, bool Wait) {
+    std::any R;
+    std::string Type;
+    int Ret = 0;
+    for (auto& Script : PluginEngine) {
+        if (Script->IsRegistered(Event)) {
+            if (local) {
+                if (Script->GetPluginName() == Caller->GetPluginName()) {
+                    R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait);
+                    Type = R.type().name();
+                    if (Type.find("int") != std::string::npos) {
+                        if (std::any_cast<int>(R))
+                            Ret++;
+                    } else if (Event == "onPlayerAuth")
+                        return R;
+                }
+            } else {
+                R = FutureWait(Script.get(), Script->GetRegistered(Event), arg, Wait);
+                Type = R.type().name();
+                if (Type.find("int") != std::string::npos) {
+                    if (std::any_cast<int>(R))
+                        Ret++;
+                } else if (Event == "onPlayerAuth")
+                    return R;
+            }
+        }
+    }
+    return Ret;
+}
+bool ConsoleCheck(lua_State* L, int r) {
+    if (r != LUA_OK) {
+        std::string msg = lua_tostring(L, -1);
+        warn(("_Console | ") + msg);
+        return false;
+    }
+    return true;
+}
+bool CheckLua(lua_State* L, int r) {
+    if (r != LUA_OK) {
+        std::string msg = lua_tostring(L, -1);
+        auto MaybeS = GetScript(L);
+        if (MaybeS.has_value()) {
+            Lua& S = MaybeS.value();
+            std::string a = fs::path(S.GetFileName()).filename().string();
+            warn(a + " | " + msg);
+            return false;
+        }
+        // What the fuck, what do we do?!
+        AssertNotReachable();
+    }
+    return true;
+}
+
+int lua_RegisterEvent(lua_State* L) {
+    int Args = lua_gettop(L);
+    auto MaybeScript = GetScript(L);
+    Assert(MaybeScript.has_value());
+    Lua& Script = MaybeScript.value();
+    if (Args == 2 && lua_isstring(L, 1) && lua_isstring(L, 2)) {
+        Script.RegisterEvent(lua_tostring(L, 1), lua_tostring(L, 2));
+    } else
+        SendError(L, ("RegisterEvent invalid argument count expected 2 got ") + std::to_string(Args));
+    return 0;
+}
+int lua_TriggerEventL(lua_State* L) {
+    int Args = lua_gettop(L);
+    auto MaybeScript = GetScript(L);
+    Assert(MaybeScript.has_value());
+    Lua& Script = MaybeScript.value();
+    if (Args > 0) {
+        if (lua_isstring(L, 1)) {
+            TriggerLuaEvent(lua_tostring(L, 1), true, &Script, CreateArg(L, Args, 2), false);
+        } else
+            SendError(L, ("TriggerLocalEvent wrong argument [1] need string"));
+    } else {
+        SendError(L, ("TriggerLocalEvent not enough arguments expected 1 got 0"));
+    }
+    return 0;
+}
+
+int lua_TriggerEventG(lua_State* L) {
+    int Args = lua_gettop(L);
+    auto MaybeScript = GetScript(L);
+    Assert(MaybeScript.has_value());
+    Lua& Script = MaybeScript.value();
+    if (Args > 0) {
+        if (lua_isstring(L, 1)) {
+            TriggerLuaEvent(lua_tostring(L, 1), false, &Script, CreateArg(L, Args, 2), false);
+        } else
+            SendError(L, ("TriggerGlobalEvent wrong argument [1] need string"));
+    } else
+        SendError(L, ("TriggerGlobalEvent not enough arguments"));
+    return 0;
+}
+
+char* ThreadOrigin(Lua* lua) {
+    std::string T = "Thread in " + fs::path(lua->GetFileName()).filename().string();
+    char* Data = new char[T.size() + 1];
+    ZeroMemory(Data, T.size() + 1);
+    memcpy(Data, T.c_str(), T.size());
+    return Data;
+}
+void SafeExecution(Lua* lua, const std::string& FuncName) {
+    lua_State* luaState = lua->GetState();
+    lua_getglobal(luaState, FuncName.c_str());
+    if (lua_isfunction(luaState, -1)) {
+        char* Origin = ThreadOrigin(lua);
+#ifdef WIN32
+        __try {
+            int R = lua_pcall(luaState, 0, 0, 0);
+            CheckLua(luaState, R);
+        } __except (Handle(GetExceptionInformation(), Origin)) {
+        }
+#else // unix
+        int R = lua_pcall(luaState, 0, 0, 0);
+        CheckLua(luaState, R);
+#endif // WIN32
+        delete[] Origin;
+    }
+    ClearStack(luaState);
+}
+
+void ExecuteAsync(Lua* lua, const std::string& FuncName) {
+    std::lock_guard<std::mutex> lockGuard(lua->Lock);
+    SafeExecution(lua, FuncName);
+}
+void CallAsync(Lua* lua, const std::string& Func, int U) {
+    DebugPrintTID();
+    lua->SetStopThread(false);
+    int D = 1000 / U;
+    while (!lua->GetStopThread()) {
+        ExecuteAsync(lua, Func);
+        std::this_thread::sleep_for(std::chrono::milliseconds(D));
+    }
+}
+int lua_StopThread(lua_State* L) {
+    auto MaybeScript = GetScript(L);
+    Assert(MaybeScript.has_value());
+    // ugly, but whatever, this is safe as fuck
+    MaybeScript.value().get().SetStopThread(true);
+    return 0;
+}
+int lua_CreateThread(lua_State* L) {
+    int Args = lua_gettop(L);
+    if (Args > 1) {
+        if (lua_isstring(L, 1)) {
+            std::string STR = lua_tostring(L, 1);
+            if (lua_isinteger(L, 2) || lua_isnumber(L, 2)) {
+                int U = int(lua_tointeger(L, 2));
+                if (U > 0 && U < 501) {
+                    auto MaybeScript = GetScript(L);
+                    Assert(MaybeScript.has_value());
+                    Lua& Script = MaybeScript.value();
+                    std::thread t1(CallAsync, &Script, STR, U);
+                    t1.detach();
+                } else
+                    SendError(L, ("CreateThread wrong argument [2] number must be between 1 and 500"));
+            } else
+                SendError(L, ("CreateThread wrong argument [2] need number"));
+        } else
+            SendError(L, ("CreateThread wrong argument [1] need string"));
+    } else
+        SendError(L, ("CreateThread not enough arguments"));
+    return 0;
+}
+int lua_Sleep(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int t = int(lua_tonumber(L, 1));
+        std::this_thread::sleep_for(std::chrono::milliseconds(t));
+    } else {
+        SendError(L, ("Sleep not enough arguments"));
+        return 0;
+    }
+    return 1;
+}
+Client* GetClient(int ID) {
+    for (auto& c : CI->Clients) {
+        if (c != nullptr && c->GetID() == ID) {
+            return c.get();
+        }
+    }
+    return nullptr;
+}
+int lua_isConnected(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c != nullptr)
+            lua_pushboolean(L, c->isConnected);
+        else
+            return 0;
+    } else {
+        SendError(L, ("isConnected not enough arguments"));
+        return 0;
+    }
+    return 1;
+}
+int lua_GetPlayerName(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c != nullptr)
+            lua_pushstring(L, c->GetName().c_str());
+        else
+            return 0;
+    } else {
+        SendError(L, ("GetPlayerName not enough arguments"));
+        return 0;
+    }
+    return 1;
+}
+int lua_GetPlayerCount(lua_State* L) {
+    lua_pushinteger(L, CI->Size());
+    return 1;
+}
+int lua_GetGuest(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c != nullptr)
+            lua_pushboolean(L, c->isGuest);
+        else
+            return 0;
+    } else {
+        SendError(L, "GetGuest not enough arguments");
+        return 0;
+    }
+    return 1;
+}
+int lua_GetAllPlayers(lua_State* L) {
+    lua_newtable(L);
+    int i = 1;
+    for (auto& c : CI->Clients) {
+        if (c == nullptr)
+            continue;
+        lua_pushinteger(L, c->GetID());
+        lua_pushstring(L, c->GetName().c_str());
+        lua_settable(L, -3);
+        i++;
+    }
+    if (CI->Clients.empty())
+        return 0;
+    return 1;
+}
+int lua_GetCars(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c != nullptr) {
+            int i = 1;
+            for (auto& v : c->GetAllCars()) {
+                if (v != nullptr) {
+                    lua_pushinteger(L, v->ID);
+                    lua_pushstring(L, v->Data.substr(3).c_str());
+                    lua_settable(L, -3);
+                    i++;
+                }
+            }
+            if (c->GetAllCars().empty())
+                return 0;
+        } else
+            return 0;
+    } else {
+        SendError(L, ("GetPlayerVehicles not enough arguments"));
+        return 0;
+    }
+    return 1;
+}
+int lua_dropPlayer(lua_State* L) {
+    int Args = lua_gettop(L);
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c == nullptr)
+            return 0;
+        std::string Reason;
+        if (Args > 1 && lua_isstring(L, 2)) {
+            Reason = std::string((" Reason : ")) + lua_tostring(L, 2);
+        }
+        Respond(c, "C:Server:You have been Kicked from the server! " + Reason, true);
+        c->SetStatus(-2);
+        info(("Closing socket due to kick"));
+        CloseSocketProper(c->GetTCPSock());
+    } else
+        SendError(L, ("DropPlayer not enough arguments"));
+    return 0;
+}
+int lua_sendChat(lua_State* L) {
+    if (lua_isinteger(L, 1) || lua_isnumber(L, 1)) {
+        if (lua_isstring(L, 2)) {
+            int ID = int(lua_tointeger(L, 1));
+            if (ID == -1) {
+                std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
+                SendToAll(nullptr, Packet, true, true);
+            } else {
+                Client* c = GetClient(ID);
+                if (c != nullptr) {
+                    if (!c->isSynced)
+                        return 0;
+                    std::string Packet = "C:Server: " + std::string(lua_tostring(L, 2));
+                    Respond(c, Packet, true);
+                } else
+                    SendError(L, ("SendChatMessage invalid argument [1] invalid ID"));
+            }
+        } else
+            SendError(L, ("SendChatMessage invalid argument [2] expected string"));
+    } else
+        SendError(L, ("SendChatMessage invalid argument [1] expected number"));
+    return 0;
+}
+int lua_RemoveVehicle(lua_State* L) {
+    int Args = lua_gettop(L);
+    if (Args != 2) {
+        SendError(L, ("RemoveVehicle invalid argument count expected 2 got ") + std::to_string(Args));
+        return 0;
+    }
+    if ((lua_isinteger(L, 1) || lua_isnumber(L, 1)) && (lua_isinteger(L, 2) || lua_isnumber(L, 2))) {
+        int PID = int(lua_tointeger(L, 1));
+        int VID = int(lua_tointeger(L, 2));
+        Client* c = GetClient(PID);
+        if (c == nullptr) {
+            SendError(L, ("RemoveVehicle invalid Player ID"));
+            return 0;
+        }
+        if (!c->GetCarData(VID).empty()) {
+            std::string Destroy = "Od:" + std::to_string(PID) + "-" + std::to_string(VID);
+            SendToAll(nullptr, Destroy, true, true);
+            c->DeleteCar(VID);
+        }
+    } else
+        SendError(L, ("RemoveVehicle invalid argument expected number"));
+    return 0;
+}
+int lua_HWID(lua_State* L) {
+    lua_pushinteger(L, -1);
+    return 1;
+}
+int lua_RemoteEvent(lua_State* L) {
+    int Args = lua_gettop(L);
+    if (Args != 3) {
+        SendError(L, ("TriggerClientEvent invalid argument count expected 3 got ") + std::to_string(Args));
+        return 0;
+    }
+    if (!lua_isnumber(L, 1)) {
+        SendError(L, ("TriggerClientEvent invalid argument [1] expected number"));
+        return 0;
+    }
+    if (!lua_isstring(L, 2)) {
+        SendError(L, ("TriggerClientEvent invalid argument [2] expected string"));
+        return 0;
+    }
+    if (!lua_isstring(L, 3)) {
+        SendError(L, ("TriggerClientEvent invalid argument [3] expected string"));
+        return 0;
+    }
+    int ID = int(lua_tointeger(L, 1));
+    std::string Packet = "E:" + std::string(lua_tostring(L, 2)) + ":" + std::string(lua_tostring(L, 3));
+    if (ID == -1)
+        SendToAll(nullptr, Packet, true, true);
+    else {
+        Client* c = GetClient(ID);
+        if (c == nullptr) {
+            SendError(L, ("TriggerClientEvent invalid Player ID"));
+            return 0;
+        }
+        Respond(c, Packet, true);
+    }
+    return 0;
+}
+int lua_ServerExit(lua_State* L) {
+    if (lua_gettop(L) > 0) {
+        if (lua_isnumber(L, 1)) {
+            _Exit(int(lua_tointeger(L, 1)));
+        }
+    }
+    _Exit(0);
+}
+int lua_Set(lua_State* L) {
+    int Args = lua_gettop(L);
+    if (Args != 2) {
+        SendError(L, ("set invalid argument count expected 2 got ") + std::to_string(Args));
+        return 0;
+    }
+    if (!lua_isnumber(L, 1)) {
+        SendError(L, ("set invalid argument [1] expected number"));
+        return 0;
+    }
+    auto MaybeSrc = GetScript(L);
+    std::string Name;
+    if (!MaybeSrc.has_value()) {
+        Name = ("_Console");
+    } else {
+        Name = MaybeSrc.value().get().GetPluginName();
+    }
+    int C = int(lua_tointeger(L, 1));
+    switch (C) {
+    case 0: //debug
+        if (lua_isboolean(L, 2)) {
+            Debug = lua_toboolean(L, 2);
+            info(Name + (" | Debug -> ") + (Debug ? "true" : "false"));
+        } else
+            SendError(L, ("set invalid argument [2] expected boolean for ID : 0"));
+        break;
+    case 1: //private
+        if (lua_isboolean(L, 2)) {
+            Private = lua_toboolean(L, 2);
+            info(Name + (" | Private -> ") + (Private ? "true" : "false"));
+        } else
+            SendError(L, ("set invalid argument [2] expected boolean for ID : 1"));
+        break;
+    case 2: //max cars
+        if (lua_isnumber(L, 2)) {
+            MaxCars = int(lua_tointeger(L, 2));
+            info(Name + (" | MaxCars -> ") + std::to_string(MaxCars));
+        } else
+            SendError(L, ("set invalid argument [2] expected number for ID : 2"));
+        break;
+    case 3: //max players
+        if (lua_isnumber(L, 2)) {
+            MaxPlayers = int(lua_tointeger(L, 2));
+            info(Name + (" | MaxPlayers -> ") + std::to_string(MaxPlayers));
+        } else
+            SendError(L, ("set invalid argument [2] expected number for ID : 3"));
+        break;
+    case 4: //Map
+        if (lua_isstring(L, 2)) {
+            MapName = lua_tostring(L, 2);
+            info(Name + (" | MapName -> ") + MapName);
+        } else
+            SendError(L, ("set invalid argument [2] expected string for ID : 4"));
+        break;
+    case 5: //Name
+        if (lua_isstring(L, 2)) {
+            ServerName = lua_tostring(L, 2);
+            info(Name + (" | ServerName -> ") + ServerName);
+        } else
+            SendError(L, ("set invalid argument [2] expected string for ID : 5"));
+        break;
+    case 6: //Desc
+        if (lua_isstring(L, 2)) {
+            ServerDesc = lua_tostring(L, 2);
+            info(Name + (" | ServerDesc -> ") + ServerDesc);
+        } else
+            SendError(L, ("set invalid argument [2] expected string for ID : 6"));
+        break;
+    default:
+        warn(("Invalid config ID : ") + std::to_string(C));
+        break;
+    }
+
+    return 0;
+}
+extern "C" {
+int lua_Print(lua_State* L) {
+    int Arg = lua_gettop(L);
+    for (int i = 1; i <= Arg; i++) {
+        auto str = lua_tostring(L, i);
+        if (str != nullptr) {
+            ConsoleOut(str + std::string(("\n")));
+        } else {
+            ConsoleOut(("nil\n"));
+        }
+    }
+    return 0;
+}
+}
+
+Lua::Lua(const std::string& PluginName, const std::string& FileName, fs::file_time_type LastWrote, bool Console)
+    : luaState(luaL_newstate()) {
+    Assert(luaState);
+    if (!PluginName.empty()) {
+        SetPluginName(PluginName);
+    }
+    if (!FileName.empty()) {
+        SetFileName(FileName);
+    }
+    SetLastWrite(LastWrote);
+    _Console = Console;
+}
+
+Lua::Lua(bool Console)
+    : luaState(luaL_newstate()) {
+    _Console = Console;
+}
+
+void Lua::Execute(const std::string& Command) {
+    if (ConsoleCheck(luaState, luaL_dostring(luaState, Command.c_str()))) {
+        lua_settop(luaState, 0);
+    }
+}
+void Lua::Reload() {
+    if (CheckLua(luaState, luaL_dofile(luaState, _FileName.c_str()))) {
+        CallFunction(this, ("onInit"), nullptr);
+    }
+}
+std::string Lua::GetOrigin() {
+    return fs::path(GetFileName()).filename().string();
+}
+
+std::any CallFunction(Lua* lua, const std::string& FuncName, std::shared_ptr<LuaArg> Arg) {
+    lua_State* luaState = lua->GetState();
+    lua_getglobal(luaState, FuncName.c_str());
+    if (lua_isfunction(luaState, -1)) {
+        int Size = 0;
+        if (Arg != nullptr) {
+            Size = int(Arg->args.size());
+            Arg->PushArgs(luaState);
+        }
+        int R = lua_pcall(luaState, Size, 1, 0);
+        if (CheckLua(luaState, R)) {
+            if (lua_isnumber(luaState, -1)) {
+                return int(lua_tointeger(luaState, -1));
+            } else if (lua_isstring(luaState, -1)) {
+                return std::string(lua_tostring(luaState, -1));
+            }
+        }
+    }
+    ClearStack(luaState);
+    return 0;
+}
+void Lua::SetPluginName(const std::string& Name) {
+    _PluginName = Name;
+}
+void Lua::SetFileName(const std::string& Name) {
+    _FileName = Name;
+}
+int lua_TempFix(lua_State* L) {
+    if (lua_isnumber(L, 1)) {
+        int ID = int(lua_tonumber(L, 1));
+        Client* c = GetClient(ID);
+        if (c == nullptr)
+            return 0;
+        std::string Ret;
+        if (c->isGuest) {
+            Ret = "Guest-" + c->GetName();
+        } else
+            Ret = c->GetName();
+        lua_pushstring(L, Ret.c_str());
+    } else
+        SendError(L, "GetDID not enough arguments");
+    return 1;
+}
+void Lua::Init() {
+    Assert(luaState);
+    luaL_openlibs(luaState);
+    lua_register(luaState, "TriggerGlobalEvent", lua_TriggerEventG);
+    lua_register(luaState, "TriggerLocalEvent", lua_TriggerEventL);
+    lua_register(luaState, "TriggerClientEvent", lua_RemoteEvent);
+    lua_register(luaState, "GetPlayerCount", lua_GetPlayerCount);
+    lua_register(luaState, "isPlayerConnected", lua_isConnected);
+    lua_register(luaState, "RegisterEvent", lua_RegisterEvent);
+    lua_register(luaState, "GetPlayerName", lua_GetPlayerName);
+    lua_register(luaState, "RemoveVehicle", lua_RemoveVehicle);
+    lua_register(luaState, "GetPlayerDiscordID", lua_TempFix);
+    lua_register(luaState, "CreateThread", lua_CreateThread);
+    lua_register(luaState, "GetPlayerVehicles", lua_GetCars);
+    lua_register(luaState, "SendChatMessage", lua_sendChat);
+    lua_register(luaState, "GetPlayers", lua_GetAllPlayers);
+    lua_register(luaState, "GetPlayerGuest", lua_GetGuest);
+    lua_register(luaState, "StopThread", lua_StopThread);
+    lua_register(luaState, "DropPlayer", lua_dropPlayer);
+    lua_register(luaState, "GetPlayerHWID", lua_HWID);
+    lua_register(luaState, "exit", lua_ServerExit);
+    lua_register(luaState, "Sleep", lua_Sleep);
+    lua_register(luaState, "print", lua_Print);
+    lua_register(luaState, "Set", lua_Set);
+    if (!_Console)
+        Reload();
+}
+
+void Lua::RegisterEvent(const std::string& Event, const std::string& FunctionName) {
+    _RegisteredEvents.insert(std::make_pair(Event, FunctionName));
+}
+void Lua::UnRegisterEvent(const std::string& Event) {
+    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
+        if (a.first == Event) {
+            _RegisteredEvents.erase(a);
+            break;
+        }
+    }
+}
+bool Lua::IsRegistered(const std::string& Event) {
+    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
+        if (a.first == Event)
+            return true;
+    }
+    return false;
+}
+std::string Lua::GetRegistered(const std::string& Event) const {
+    for (const std::pair<std::string, std::string>& a : _RegisteredEvents) {
+        if (a.first == Event)
+            return a.second;
+    }
+    return "";
+}
+std::string Lua::GetFileName() const {
+    return _FileName;
+}
+std::string Lua::GetPluginName() const {
+    return _PluginName;
+}
+lua_State* Lua::GetState() {
+    return luaState;
+}
+
+const lua_State* Lua::GetState() const {
+    return luaState;
+}
+
+void Lua::SetLastWrite(fs::file_time_type time) {
+    _LastWrote = time;
+}
+fs::file_time_type Lua::GetLastWrite() {
+    return _LastWrote;
+}
+
+Lua::~Lua() {
+    info("closing lua state");
+    lua_close(luaState);
+}

src/Network/Auth.cpp

@@ -0,0 +1,228 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/31/2020
+///
+
+#include "Curl/Http.h"
+#include "Json.h"
+#include "Logger.h"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#include <Lua/LuaSystem.hpp>
+#include <cstring>
+#include <string>
+#include <thread>
+
+std::string GetClientInfo(const std::string& PK) {
+    if (!PK.empty()) {
+        return PostHTTP("https://auth.beammp.com/pkToUser", R"({"key":")" + PK + "\"}", true);
+        ;
+    }
+    return "";
+}
+
+Client* CreateClient(SOCKET TCPSock) {
+    auto* c = new Client;
+    c->SetTCPSock(TCPSock);
+    return c;
+}
+
+void ClientKick(Client* c, const std::string& R) {
+    info("Client kicked: " + R);
+    TCPSend(c, "E" + R);
+    CloseSocketProper(c->GetTCPSock());
+}
+
+void Authentication(SOCKET TCPSock) {
+    DebugPrintTID();
+    auto* c = CreateClient(TCPSock);
+
+    info("Identifying new client...");
+    std::string Rc = TCPRcv(c);
+
+    if (Rc.size() > 3 && Rc.substr(0, 2) == "VC") {
+        Rc = Rc.substr(2);
+        if (Rc.length() > 4 || Rc != GetCVer()) {
+            ClientKick(c, "Outdated Version!");
+            return;
+        }
+    } else {
+        ClientKick(c, "Invalid version header!");
+        return;
+    }
+    TCPSend(c, "S");
+
+    Rc = TCPRcv(c);
+
+    if (Rc.size() > 50) {
+        ClientKick(c, "Invalid Key!");
+        return;
+    }
+
+    Rc = GetClientInfo(Rc);
+    json::Document d;
+    d.Parse(Rc.c_str());
+    if (Rc == "-1" || d.HasParseError()) {
+        ClientKick(c, "Invalid key! Please restart your game.");
+        return;
+    }
+
+    if (d["username"].IsString() && d["roles"].IsString() && d["guest"].IsBool()) {
+        c->SetName(d["username"].GetString());
+        c->SetRoles(d["roles"].GetString());
+        c->isGuest = d["guest"].GetBool();
+    } else {
+        ClientKick(c, "Invalid authentication data!");
+        return;
+    }
+
+    debug("Name -> " + c->GetName() + ", Guest -> " + std::to_string(c->isGuest) + ", Roles -> " + c->GetRoles());
+    for (auto& Cl : CI->Clients) {
+        if (Cl != nullptr) {
+            if (Cl->GetName() == c->GetName() && Cl->isGuest == c->isGuest) {
+                info("Old client (" + Cl->GetName() + ") kicked: Reconnecting");
+                CloseSocketProper(Cl->GetTCPSock());
+                Cl->SetStatus(-2);
+                break;
+            }
+        }
+    }
+
+    auto arg = std::make_unique<LuaArg>(LuaArg { { c->GetName(), c->GetRoles(), c->isGuest } });
+    std::any Res = TriggerLuaEvent("onPlayerAuth", false, nullptr, std::move(arg), true);
+    std::string Type = Res.type().name();
+    if (Type.find("int") != std::string::npos && std::any_cast<int>(Res)) {
+        ClientKick(c, "you are not allowed on the server!");
+        return;
+    } else if (Type.find("string") != std::string::npos) {
+        ClientKick(c, std::any_cast<std::string>(Res));
+        return;
+    }
+    if (CI->Size() < MaxPlayers) {
+        info("Identification success");
+        Client& Client = *c;
+        CI->AddClient(std::move(c));
+        TCPClient(&Client);
+    } else
+        ClientKick(c, "Server full!");
+}
+
+void HandleDownload(SOCKET TCPSock) {
+    char D;
+    if (recv(TCPSock, &D, 1, 0) != 1) {
+        CloseSocketProper(TCPSock);
+        return;
+    }
+    auto ID = uint8_t(D);
+    for (auto& c : CI->Clients) {
+        if (c->GetID() == ID) {
+            c->SetDownSock(TCPSock);
+        }
+    }
+}
+
+void Identify(SOCKET TCPSock) {
+    char Code;
+    if (recv(TCPSock, &Code, 1, 0) != 1) {
+        CloseSocketProper(TCPSock);
+        return;
+    }
+    if (Code == 'C') {
+        Authentication(TCPSock);
+    } else if (Code == 'D') {
+        HandleDownload(TCPSock);
+    } else
+        CloseSocketProper(TCPSock);
+}
+
+void TCPServerMain() {
+    DebugPrintTID();
+#ifdef WIN32
+    WSADATA wsaData;
+    if (WSAStartup(514, &wsaData)) {
+        error("Can't start Winsock!");
+        return;
+    }
+    SOCKET client, Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    sockaddr_in addr {};
+    addr.sin_addr.S_un.S_addr = ADDR_ANY;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(Port);
+    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
+        error("Can't bind socket! " + std::to_string(WSAGetLastError()));
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        _Exit(-1);
+    }
+    if (Listener == -1) {
+        error("Invalid listening socket");
+        return;
+    }
+    if (listen(Listener, SOMAXCONN)) {
+        error("listener failed " + std::to_string(GetLastError()));
+        return;
+    }
+    info("Vehicle event network online");
+    do {
+        try {
+            client = accept(Listener, nullptr, nullptr);
+            if (client == -1) {
+                warn("Got an invalid client socket on connect! Skipping...");
+                continue;
+            }
+            std::thread ID(Identify, client);
+            ID.detach();
+        } catch (const std::exception& e) {
+            error("fatal: " + std::string(e.what()));
+        }
+    } while (client);
+
+    CloseSocketProper(client);
+    WSACleanup();
+#else // unix
+    // wondering why we need slightly different implementations of this?
+    // ask ms.
+    SOCKET client = -1, Listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    int optval = 1;
+    setsockopt(Listener, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
+    // TODO: check optval or return value idk
+    sockaddr_in addr {};
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(uint16_t(Port));
+    if (bind(Listener, (sockaddr*)&addr, sizeof(addr)) != 0) {
+        error(("Can't bind socket! ") + std::string(strerror(errno)));
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        _Exit(-1);
+    }
+    if (Listener == -1) {
+        error(("Invalid listening socket"));
+        return;
+    }
+    if (listen(Listener, SOMAXCONN)) {
+        error(("listener failed ") + std::string(strerror(errno)));
+        return;
+    }
+    info(("Vehicle event network online"));
+    do {
+        try {
+            client = accept(Listener, nullptr, nullptr);
+            if (client == -1) {
+                warn(("Got an invalid client socket on connect! Skipping..."));
+                continue;
+            }
+            std::thread ID(Identify, client);
+            ID.detach();
+        } catch (const std::exception& e) {
+            error(("fatal: ") + std::string(e.what()));
+        }
+    } while (client);
+
+    debug("all ok, arrived at " + std::string(__func__) + ":" + std::to_string(__LINE__));
+    CloseSocketProper(client);
+#endif // WIN32
+}

src/Network/Client.cpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/8/2020
+///
+#include "Client.hpp"
+
+#include <memory>
+
+void Client::DeleteCar(int ident) {
+    for (auto& v : VehicleData) {
+        if (v != nullptr && v->ID == ident) {
+            VehicleData.erase(v);
+            break;
+        }
+    }
+}
+void Client::ClearCars() {
+    VehicleData.clear();
+}
+int Client::GetOpenCarID() {
+    int OpenID = 0;
+    bool found;
+    do {
+        found = true;
+        for (auto& v : VehicleData) {
+            if (v != nullptr && v->ID == OpenID) {
+                OpenID++;
+                found = false;
+            }
+        }
+    } while (!found);
+    return OpenID;
+}
+void Client::AddNewCar(int ident, const std::string& Data) {
+    VehicleData.insert(std::make_unique<VData>(VData { ident, Data }));
+}
+
+std::set<std::unique_ptr<VData>>& Client::GetAllCars() {
+    return VehicleData;
+}
+
+std::string Client::GetCarData(int ident) {
+    for (auto& v : VehicleData) {
+        if (v != nullptr && v->ID == ident) {
+            return v->Data;
+        }
+    }
+    DeleteCar(ident);
+    return "";
+}
+
+void Client::SetCarData(int ident, const std::string& Data) {
+    for (auto& v : VehicleData) {
+        if (v != nullptr && v->ID == ident) {
+            v->Data = Data;
+            return;
+        }
+    }
+    DeleteCar(ident);
+}
+int Client::GetCarCount() {
+    return int(VehicleData.size());
+}

src/Network/GParser.cpp

@@ -0,0 +1,268 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 8/1/2020
+///
+
+#include "Client.hpp"
+#include "Logger.h"
+#include "Lua/LuaSystem.hpp"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#undef GetObject //to fix microsoft bs
+#include "Json.h"
+
+void Apply(Client* c, int VID, const std::string& pckt) {
+    Assert(c);
+    std::string Packet = pckt.substr(pckt.find('{')), VD = c->GetCarData(VID);
+    std::string Header = VD.substr(0, VD.find('{'));
+    VD = VD.substr(VD.find('{'));
+    rapidjson::Document Veh, Pack;
+    Veh.Parse(VD.c_str());
+    if (Veh.HasParseError()) {
+        error("Could not get vehicle config!");
+        return;
+    }
+    Pack.Parse(Packet.c_str());
+    if (Pack.HasParseError() || Pack.IsNull()) {
+        error("Could not get active vehicle config!");
+        return;
+    }
+
+    for (auto& M : Pack.GetObject()) {
+        if (Veh[M.name].IsNull()) {
+            Veh.AddMember(M.name, M.value, Veh.GetAllocator());
+        } else {
+            Veh[M.name] = Pack[M.name];
+        }
+    }
+    rapidjson::StringBuffer Buffer;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(Buffer);
+    Veh.Accept(writer);
+    c->SetCarData(VID, Header + Buffer.GetString());
+}
+
+void VehicleParser(Client* c, const std::string& Pckt) {
+    Assert(c);
+    if (c == nullptr || Pckt.length() < 4)
+        return;
+    std::string Packet = Pckt;
+    char Code = Packet.at(1);
+    int PID = -1;
+    int VID = -1;
+    std::string Data = Packet.substr(3), pid, vid;
+    switch (Code) { //Spawned Destroyed Switched/Moved NotFound Reset
+    case 's':
+#ifdef DEBUG
+        debug(std::string(("got 'Os' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        if (Data.at(0) == '0') {
+            int CarID = c->GetOpenCarID();
+            debug(c->GetName() + (" created a car with ID ") + std::to_string(CarID));
+            Packet = "Os:" + c->GetRoles() + ":" + c->GetName() + ":" + std::to_string(c->GetID()) + "-" + std::to_string(CarID) + Packet.substr(4);
+            auto Res = TriggerLuaEvent(("onVehicleSpawn"), false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID(), CarID, Packet.substr(3) } }), true);
+            if (c->GetCarCount() >= MaxCars || std::any_cast<int>(Res)) {
+                Respond(c, Packet, true);
+                std::string Destroy = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(CarID);
+                Respond(c, Destroy, true);
+                debug(c->GetName() + (" (force : car limit/lua) removed ID ") + std::to_string(CarID));
+            } else {
+                c->AddNewCar(CarID, Packet);
+                SendToAll(nullptr, Packet, true, true);
+            }
+        }
+        return;
+    case 'c':
+#ifdef DEBUG
+        debug(std::string(("got 'Oc' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        pid = Data.substr(0, Data.find('-'));
+        vid = Data.substr(Data.find('-') + 1, Data.find(':', 1) - Data.find('-') - 1);
+        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
+            PID = stoi(pid);
+            VID = stoi(vid);
+        }
+        if (PID != -1 && VID != -1 && PID == c->GetID()) {
+            auto Res = TriggerLuaEvent(("onVehicleEdited"), false, nullptr,
+                std::make_unique<LuaArg>(LuaArg { { c->GetID(), VID, Packet.substr(3) } }),
+                true);
+            if (!std::any_cast<int>(Res)) {
+                SendToAll(c, Packet, false, true);
+                Apply(c, VID, Packet);
+            } else {
+                std::string Destroy = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(VID);
+                Respond(c, Destroy, true);
+                c->DeleteCar(VID);
+            }
+        }
+        return;
+    case 'd':
+#ifdef DEBUG
+        debug(std::string(("got 'Od' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        pid = Data.substr(0, Data.find('-'));
+        vid = Data.substr(Data.find('-') + 1);
+        if (pid.find_first_not_of("0123456789") == std::string::npos && vid.find_first_not_of("0123456789") == std::string::npos) {
+            PID = stoi(pid);
+            VID = stoi(vid);
+        }
+        if (PID != -1 && VID != -1 && PID == c->GetID()) {
+            SendToAll(nullptr, Packet, true, true);
+            TriggerLuaEvent(("onVehicleDeleted"), false, nullptr,
+                std::make_unique<LuaArg>(LuaArg { { c->GetID(), VID } }), false);
+            c->DeleteCar(VID);
+            debug(c->GetName() + (" deleted car with ID ") + std::to_string(VID));
+        }
+        return;
+    case 'r':
+#ifdef DEBUG
+        debug(std::string(("got 'Or' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        SendToAll(c, Packet, false, true);
+        return;
+    case 't':
+#ifdef DEBUG
+        debug(std::string(("got 'Ot' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        SendToAll(c, Packet, false, true);
+        return;
+    default:
+#ifdef DEBUG
+        warn(std::string(("possibly not implemented: '") + Packet + ("' (") + std::to_string(Packet.size()) + (")")));
+#endif // DEBUG
+        return;
+    }
+}
+void SyncClient(Client* c) {
+    Assert(c);
+    if (c->isSynced)
+        return;
+    c->isSynced = true;
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    Respond(c, ("Sn") + c->GetName(), true);
+    SendToAll(c, ("JWelcome ") + c->GetName() + "!", false, true);
+    TriggerLuaEvent(("onPlayerJoin"), false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID() } }), false);
+    for (auto& client : CI->Clients) {
+        if (client != nullptr) {
+            if (client.get() != c) {
+                for (auto& v : client->GetAllCars()) {
+                    if (v != nullptr) {
+                        if (c->GetStatus() < 0)
+                            return;
+                        Respond(c, v->Data, true);
+                        std::this_thread::sleep_for(std::chrono::seconds(2));
+                    }
+                }
+            }
+        }
+    }
+    info(c->GetName() + (" is now synced!"));
+}
+void ParseVeh(Client* c, const std::string& Packet) {
+    Assert(c);
+#ifdef WIN32
+    __try {
+        VehicleParser(c, Packet);
+    } __except (Handle(GetExceptionInformation(), ("Vehicle Handler"))) { }
+#else // unix
+    VehicleParser(c, Packet);
+#endif // WIN32
+}
+
+void HandleEvent(Client* c, const std::string& Data) {
+    Assert(c);
+    std::stringstream ss(Data);
+    std::string t, Name;
+    int a = 0;
+    while (std::getline(ss, t, ':')) {
+        switch (a) {
+        case 1:
+            Name = t;
+            break;
+        case 2:
+            TriggerLuaEvent(Name, false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID(), t } }), false);
+            break;
+        default:
+            break;
+        }
+        if (a == 2)
+            break;
+        a++;
+    }
+}
+
+void GlobalParser(Client* c, const std::string& Packet) {
+    Assert(c);
+    if (Packet.empty() || c == nullptr)
+        return;
+    std::any Res;
+    char Code = Packet.at(0);
+
+    //V to Z
+    if (Code <= 90 && Code >= 86) {
+        PPS++;
+        SendToAll(c, Packet, false, false);
+        return;
+    }
+    switch (Code) {
+    case 'H': // initial connection
+#ifdef DEBUG
+        debug(std::string("got 'H' packet: '") + Packet + "' (" + std::to_string(Packet.size()) + ")");
+#endif
+        SyncClient(c);
+        return;
+    case 'p':
+        Respond(c, ("p"), false);
+        UpdatePlayers();
+        return;
+    case 'O':
+        if (Packet.length() > 1000) {
+            debug(("Received data from: ") + c->GetName() + (" Size: ") + std::to_string(Packet.length()));
+        }
+        ParseVeh(c, Packet);
+        return;
+    case 'J':
+#ifdef DEBUG
+        debug(std::string(("got 'J' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        SendToAll(c, Packet, false, true);
+        return;
+    case 'C':
+#ifdef DEBUG
+        debug(std::string(("got 'C' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        if (Packet.length() < 4 || Packet.find(':', 3) == std::string::npos)
+            break;
+        Res = TriggerLuaEvent("onChatMessage", false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID(), c->GetName(), Packet.substr(Packet.find(':', 3) + 1) } }), true);
+        if (std::any_cast<int>(Res))
+            break;
+        SendToAll(nullptr, Packet, true, true);
+        return;
+    case 'E':
+#ifdef DEBUG
+        debug(std::string(("got 'E' packet: '")) + Packet + ("' (") + std::to_string(Packet.size()) + (")"));
+#endif
+        HandleEvent(c, Packet);
+        return;
+    default:
+        return;
+    }
+}
+
+void GParser(Client* c, const std::string& Packet) {
+    Assert(c);
+    if (Packet.find("Zp") != std::string::npos && Packet.size() > 500) {
+        abort();
+    }
+#ifdef WIN32
+    __try {
+        GlobalParser(c, Packet);
+    } __except (Handle(GetExceptionInformation(), ("Global Handler"))) { }
+#else
+    GlobalParser(c, Packet);
+#endif // WIN32
+}

src/Network/Http.cpp

@@ -0,0 +1,75 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 4/9/2020
+///
+
+#include "CustomAssert.h"
+#include <curl/curl.h>
+#include <iostream>
+
+class CurlManager{
+public:
+    CurlManager(){
+        curl = curl_easy_init();
+    }
+    ~CurlManager(){
+        curl_easy_cleanup(curl);
+    }
+    inline CURL* Get(){
+        return curl;
+    }
+private:
+    CURL *curl;
+};
+
+static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
+    ((std::string*)userp)->append((char*)contents, size * nmemb);
+    return size * nmemb;
+}
+std::string HttpRequest(const std::string& IP, int port) {
+    static thread_local CurlManager M;
+    std::string readBuffer;
+    CURL* curl = M.Get();
+    CURLcode res;
+    Assert(curl);
+    if (curl) {
+        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
+        curl_easy_setopt(curl, CURLOPT_PORT, port);
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
+        res = curl_easy_perform(curl);
+        if (res != CURLE_OK)
+            return "-1";
+    }
+    return readBuffer;
+}
+
+std::string PostHTTP(const std::string& IP, const std::string& Fields, bool json) {
+    auto header = curl_slist { (char*)"Content-Type: application/json" };
+    static thread_local CurlManager M;
+    static std::mutex Lock;
+    std::scoped_lock Guard(Lock);
+    CURL* curl = M.Get();
+    CURLcode res;
+    std::string readBuffer;
+
+    Assert(curl);
+    if (curl) {
+        curl_easy_setopt(curl, CURLOPT_URL, IP.c_str());
+        if (json)
+            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, Fields.size());
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, Fields.c_str());
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
+        curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5);
+        res = curl_easy_perform(curl);
+        if (res != CURLE_OK)
+            return "-1";
+    }
+    return readBuffer;
+}

src/Network/InitClient.cpp

@@ -0,0 +1,109 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 8/1/2020
+///
+#include "Client.hpp"
+#include "Logger.h"
+#include "Lua/LuaSystem.hpp"
+#include "Network.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#include <memory>
+
+int OpenID() {
+    int ID = 0;
+    bool found;
+    do {
+        found = true;
+        for (auto& c : CI->Clients) {
+            if (c != nullptr) {
+                if (c->GetID() == ID) {
+                    found = false;
+                    ID++;
+                }
+            }
+        }
+    } while (!found);
+    return ID;
+}
+void Respond(Client* c, const std::string& MSG, bool Rel) {
+    Assert(c);
+    char C = MSG.at(0);
+    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
+        if (C == 'O' || C == 'T' || MSG.length() > 1000) {
+            SendLarge(c, MSG);
+        } else {
+            TCPSend(c, MSG);
+        }
+    } else {
+        UDPSend(c, MSG);
+    }
+}
+void SendToAll(Client* c, const std::string& Data, bool Self, bool Rel) {
+    if (!Self)
+        Assert(c);
+    char C = Data.at(0);
+    for (auto& client : CI->Clients) {
+        if (client != nullptr) {
+            if (Self || client.get() != c) {
+                if (client->isSynced) {
+                    if (Rel || C == 'W' || C == 'Y' || C == 'V' || C == 'E') {
+                        if (C == 'O' || C == 'T' || Data.length() > 1000)
+                            SendLarge(client.get(), Data);
+                        else
+                            TCPSend(client.get(), Data);
+                    } else
+                        UDPSend(client.get(), Data);
+                }
+            }
+        }
+    }
+}
+void UpdatePlayers() {
+    std::string Packet = ("Ss") + std::to_string(CI->Size()) + "/" + std::to_string(MaxPlayers) + ":";
+    for (auto& c : CI->Clients) {
+        if (c != nullptr)
+            Packet += c->GetName() + ",";
+    }
+    Packet = Packet.substr(0, Packet.length() - 1);
+    SendToAll(nullptr, Packet, true, true);
+}
+void OnDisconnect(Client* c, bool kicked) {
+    Assert(c);
+    info(c->GetName() + (" Connection Terminated"));
+    std::string Packet;
+    for (auto& v : c->GetAllCars()) {
+        if (v != nullptr) {
+            Packet = "Od:" + std::to_string(c->GetID()) + "-" + std::to_string(v->ID);
+            SendToAll(c, Packet, false, true);
+        }
+    }
+    if (kicked)
+        Packet = ("L") + c->GetName() + (" was kicked!");
+    else
+        Packet = ("L") + c->GetName() + (" left the server!");
+    SendToAll(c, Packet, false, true);
+    Packet.clear();
+    TriggerLuaEvent(("onPlayerDisconnect"), false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID() } }), false);
+    if (c->GetTCPSock())
+        CloseSocketProper(c->GetTCPSock());
+    if (c->GetDownSock())
+        CloseSocketProper(c->GetDownSock());
+    CI->RemoveClient(c);
+}
+void OnConnect(Client* c) {
+    Assert(c);
+    info("Client connected");
+    c->SetID(OpenID());
+    info("Assigned ID " + std::to_string(c->GetID()) + " to " + c->GetName());
+    TriggerLuaEvent("onPlayerConnecting", false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID() } }), false);
+    SyncResources(c);
+    if (c->GetStatus() < 0)
+        return;
+    Respond(c, "M" + MapName, true); //Send the Map on connect
+    info(c->GetName() + " : Connected");
+    TriggerLuaEvent("onPlayerJoining", false, nullptr, std::make_unique<LuaArg>(LuaArg { { c->GetID() } }), false);
+}

src/Network/NetMain.cpp

@@ -0,0 +1,9 @@
+#include "Network.h"
+#include <memory>
+#include <thread>
+std::unique_ptr<ClientInterface> CI;
+void NetMain() {
+    std::thread TCP(TCPServerMain);
+    TCP.detach();
+    UDPServerMain();
+}

src/Network/StatMonitor.cpp

@@ -0,0 +1,48 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 6/18/2020
+///
+#include "Client.hpp"
+#include "Security/Enc.h"
+#include <iostream>
+#include <string>
+#include <thread>
+std::string StatReport;
+int PPS = 0;
+void Monitor() {
+    int C = 0, V = 0;
+    if (CI->Clients.empty()) {
+        StatReport = "-";
+        return;
+    }
+    for (auto& c : CI->Clients) {
+        if (c != nullptr && c->GetCarCount() > 0) {
+            C++;
+            V += c->GetCarCount();
+        }
+    }
+    if (C == 0 || PPS == 0) {
+        StatReport = "-";
+    } else {
+        int R = (PPS / C) / V;
+        StatReport = std::to_string(R);
+    }
+    PPS = 0;
+}
+
+[[noreturn]] void Stat() {
+    DebugPrintTID();
+    while (true) {
+        Monitor();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+}
+
+void StatInit() {
+    StatReport = "-";
+    std::thread Init(Stat);
+    Init.detach();
+}

src/Network/Sync.cpp

@@ -0,0 +1,154 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 8/1/2020
+///
+
+#include "Client.hpp"
+#include "Logger.h"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#include <filesystem>
+#include <fstream>
+
+bool TCPSendRaw(SOCKET C, char* Data, int32_t Size) {
+    int64_t Sent = 0;
+    do {
+        int64_t Temp = send(C, &Data[Sent], int(Size - Sent), 0);
+        if (Temp < 1) {
+            info("Socket Closed! " + std::to_string(C));
+            CloseSocketProper(C);
+            return false;
+        }
+        Sent += Temp;
+    } while (Sent < Size);
+    return true;
+}
+
+void SplitLoad(Client* c, int64_t Sent, int64_t Size, bool D, const std::string& Name) {
+    std::ifstream f(Name.c_str(), std::ios::binary);
+    int32_t Split = 0x7735940; //125MB
+    char* Data;
+    if (Size > Split)
+        Data = new char[Split];
+    else
+        Data = new char[Size];
+    SOCKET TCPSock;
+    if (D)
+        TCPSock = c->GetDownSock();
+    else
+        TCPSock = c->GetTCPSock();
+    info("Split load Socket " + std::to_string(TCPSock));
+    while (c->GetStatus() > -1 && Sent < Size) {
+        int64_t Diff = Size - Sent;
+        if (Diff > Split) {
+            f.seekg(Sent, std::ios_base::beg);
+            f.read(Data, Split);
+            if (!TCPSendRaw(TCPSock, Data, Split)) {
+                if (c->GetStatus() > -1)
+                    c->SetStatus(-1);
+                break;
+            }
+            Sent += Split;
+        } else {
+            f.seekg(Sent, std::ios_base::beg);
+            f.read(Data, Diff);
+            if (!TCPSendRaw(TCPSock, Data, int32_t(Diff))) {
+                if (c->GetStatus() > -1)
+                    c->SetStatus(-1);
+                break;
+            }
+            Sent += Diff;
+        }
+    }
+    delete[] Data;
+    f.close();
+}
+
+void SendFile(Client* c, const std::string& Name) {
+    Assert(c);
+    info(c->GetName() + " requesting : " + Name.substr(Name.find_last_of('/')));
+
+    if (!std::filesystem::exists(Name)) {
+        TCPSend(c, "CO");
+        warn("File " + Name + " could not be accessed!");
+        return;
+    } else
+        TCPSend(c, "AG");
+
+    ///Wait for connections
+    int T = 0;
+    while (c->GetDownSock() < 1 && T < 50) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        T++;
+    }
+
+    if (c->GetDownSock() < 1) {
+        error("Client doesn't have a download socket!");
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+        return;
+    }
+
+    int64_t Size = std::filesystem::file_size(Name), MSize = Size / 2;
+
+    std::thread Dt(SplitLoad, c, 0, MSize, false, Name);
+    Dt.detach();
+
+    SplitLoad(c, MSize, Size, true, Name);
+
+    if (Dt.joinable())
+        Dt.join();
+}
+
+void Parse(Client* c, const std::string& Packet) {
+    Assert(c);
+    if (c == nullptr || Packet.empty())
+        return;
+    char Code = Packet.at(0), SubCode = 0;
+    if (Packet.length() > 1)
+        SubCode = Packet.at(1);
+    switch (Code) {
+    case 'f':
+        SendFile(c, Packet.substr(1));
+        return;
+    case 'S':
+        if (SubCode == 'R') {
+            debug("Sending Mod Info");
+            std::string ToSend = FileList + FileSizes;
+            if (ToSend.empty())
+                ToSend = "-";
+            TCPSend(c, ToSend);
+        }
+        return;
+    default:
+        return;
+    }
+}
+
+void SyncResources(Client* c) {
+    Assert(c);
+    if (c == nullptr)
+        return;
+#ifndef DEBUG
+    try {
+#endif
+        TCPSend(c, "P" + std::to_string(c->GetID()));
+        std::string Data;
+        while (c->GetStatus() > -1) {
+            Data = TCPRcv(c);
+            if (Data == "Done")
+                break;
+            Parse(c, Data);
+        }
+#ifndef DEBUG
+    } catch (std::exception& e) {
+        except("Exception! : " + std::string(e.what()));
+        c->SetStatus(-1);
+    }
+#endif
+}

src/Network/TCPHandler.cpp

@@ -0,0 +1,137 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 8/1/2020
+///
+#include "Compressor.h"
+#include "Logger.h"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "UnixCompat.h"
+#include <thread>
+
+bool TCPSend(Client* c, const std::string& Data) {
+    Assert(c);
+    if (c == nullptr)
+        return false;
+
+    int32_t Size, Sent;
+    std::string Send(4, 0);
+    Size = int32_t(Data.size());
+    memcpy(&Send[0], &Size, sizeof(Size));
+    Send += Data;
+    Sent = 0;
+    Size += 4;
+    do {
+        int32_t Temp = send(c->GetTCPSock(), &Send[Sent], Size - Sent, 0);
+        if (Temp == 0) {
+            if (c->GetStatus() > -1)
+                c->SetStatus(-1);
+            return false;
+        } else if (Temp < 0) {
+            if (c->GetStatus() > -1)
+                c->SetStatus(-1);
+            CloseSocketProper(c->GetTCPSock());
+            return false;
+        }
+        Sent += Temp;
+    } while (Sent < Size);
+    return true;
+}
+
+bool CheckBytes(Client* c, int32_t BytesRcv) {
+    Assert(c);
+    if (BytesRcv == 0) {
+        debug("(TCP) Connection closing...");
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+        return false;
+    } else if (BytesRcv < 0) {
+#ifdef WIN32
+        debug(("(TCP) recv failed with error: ") + std::to_string(WSAGetLastError()));
+#else // unix
+        debug(("(TCP) recv failed with error: ") + std::string(strerror(errno)));
+#endif // WIN32
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+        info(("Closing socket in CheckBytes, BytesRcv < 0"));
+        CloseSocketProper(c->GetTCPSock());
+        return false;
+    }
+    return true;
+}
+
+std::string TCPRcv(Client* c) {
+    Assert(c);
+    int32_t Header, BytesRcv = 0, Temp;
+    if (c == nullptr || c->GetStatus() < 0)
+        return "";
+
+    std::vector<char> Data(sizeof(Header));
+    do {
+        Temp = recv(c->GetTCPSock(), &Data[BytesRcv], 4 - BytesRcv, 0);
+        if (!CheckBytes(c, Temp)) {
+#ifdef DEBUG
+            error(std::string(__func__) + (": failed on CheckBytes in while(BytesRcv < 4)"));
+#endif // DEBUG
+            return "";
+        }
+        BytesRcv += Temp;
+    } while (size_t(BytesRcv) < sizeof(Header));
+    memcpy(&Header, &Data[0], sizeof(Header));
+
+#ifdef DEBUG
+    //debug(std::string(__func__) + (": expecting ") + std::to_string(Header) + (" bytes."));
+#endif // DEBUG
+    if (!CheckBytes(c, BytesRcv)) {
+#ifdef DEBUG
+        error(std::string(__func__) + (": failed on CheckBytes"));
+#endif // DEBUG
+        return "";
+    }
+    Data.resize(Header);
+    BytesRcv = 0;
+    do {
+        Temp = recv(c->GetTCPSock(), &Data[BytesRcv], Header - BytesRcv, 0);
+        if (!CheckBytes(c, Temp)) {
+#ifdef DEBUG
+            error(std::string(__func__) + (": failed on CheckBytes in while(BytesRcv < Header)"));
+#endif // DEBUG
+
+            return "";
+        }
+#ifdef DEBUG
+        //debug(std::string(__func__) + (": Temp: ") + std::to_string(Temp) + (", BytesRcv: ") + std::to_string(BytesRcv));
+#endif // DEBUG
+        BytesRcv += Temp;
+    } while (BytesRcv < Header);
+#ifdef DEBUG
+    //debug(std::string(__func__) + (": finished recv with Temp: ") + std::to_string(Temp) + (", BytesRcv: ") + std::to_string(BytesRcv));
+#endif // DEBUG
+    std::string Ret(Data.data(), Header);
+
+    if (Ret.substr(0, 4) == "ABG:") {
+        Ret = DeComp(Ret.substr(4));
+    }
+#ifdef DEBUG
+    //debug("Parsing from " + c->GetName() + " -> " +std::to_string(Ret.size()));
+#endif
+
+    return Ret;
+}
+
+void TCPClient(Client* c) {
+    DebugPrintTIDInternal("Client(" + c->GetName() + ")", true);
+    Assert(c);
+    if (c->GetTCPSock() == -1) {
+        CI->RemoveClient(c);
+        return;
+    }
+    OnConnect(c);
+    while (c->GetStatus() > -1) {
+        GParser(c, TCPRcv(c));
+    }
+    OnDisconnect(c, c->GetStatus() == -2);
+}

src/Network/VehicleData.cpp

@@ -0,0 +1,193 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 5/8/2020
+///
+
+#include "Client.hpp"
+#include "Compressor.h"
+#include "Logger.h"
+#include "Network.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include "UnixCompat.h"
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <thread>
+#include <vector>
+#include <array>
+
+SOCKET UDPSock;
+void UDPSend(Client* c, std::string Data) {
+    Assert(c);
+    if (c == nullptr || !c->isConnected || c->GetStatus() < 0)
+        return;
+    sockaddr_in Addr = c->GetUDPAddr();
+    socklen_t AddrSize = sizeof(c->GetUDPAddr());
+    if (Data.length() > 400) {
+        std::string CMP(Comp(Data));
+        Data = "ABG:" + CMP;
+    }
+#ifdef WIN32
+    int sendOk;
+    int len = static_cast<int>(Data.size());
+#else
+    int64_t sendOk;
+    size_t len = Data.size();
+#endif // WIN32
+
+    sendOk = sendto(UDPSock, Data.c_str(), len, 0, (sockaddr*)&Addr, AddrSize);
+#ifdef WIN32
+    if (sendOk == -1) {
+        debug(("(UDP) Send Failed Code : ") + std::to_string(WSAGetLastError()));
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+    } else if (sendOk == 0) {
+        debug(("(UDP) sendto returned 0"));
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+    }
+#else // unix
+    if (sendOk == -1) {
+        debug(("(UDP) Send Failed Code : ") + std::string(strerror(errno)));
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+    } else if (sendOk == 0) {
+        debug(("(UDP) sendto returned 0"));
+        if (c->GetStatus() > -1)
+            c->SetStatus(-1);
+    }
+#endif // WIN32
+}
+
+void SendLarge(Client* c, std::string Data) {
+    Assert(c);
+    if (Data.length() > 400) {
+        std::string CMP(Comp(Data));
+        Data = "ABG:" + CMP;
+    }
+    TCPSend(c, Data);
+}
+
+std::string UDPRcvFromClient(sockaddr_in& client) {
+    size_t clientLength = sizeof(client);
+    std::array<char, 1024> Ret{};
+    int64_t Rcv = recvfrom(UDPSock, Ret.data(), Ret.size(), 0, (sockaddr*)&client, (socklen_t*)&clientLength);
+    if (Rcv == -1) {
+#ifdef WIN32
+        error(("(UDP) Error receiving from Client! Code : ") + std::to_string(WSAGetLastError()));
+#else // unix
+        error(("(UDP) Error receiving from Client! Code : ") + std::string(strerror(errno)));
+#endif // WIN32
+        return "";
+    }
+    return std::string(Ret.begin(), Ret.begin() + Rcv);
+}
+
+void UDPParser(Client* c, std::string Packet) {
+    if (Packet.find("Zp") != std::string::npos && Packet.size() > 500) {
+        abort();
+    }
+    Assert(c);
+    if (Packet.substr(0, 4) == "ABG:") {
+        Packet = DeComp(Packet.substr(4));
+    }
+    GParser(c, Packet);
+}
+
+[[noreturn]] void UDPServerMain() {
+#ifdef WIN32
+    WSADATA data;
+    if (WSAStartup(514, &data)) {
+        error(("Can't start Winsock!"));
+        //return;
+    }
+
+    UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
+    // Create a server hint structure for the server
+    sockaddr_in serverAddr {};
+    serverAddr.sin_addr.S_un.S_addr = ADDR_ANY; //Any Local
+    serverAddr.sin_family = AF_INET; // Address format is IPv4
+    serverAddr.sin_port = htons(Port); // Convert from little to big endian
+
+    // Try and bind the socket to the IP and port
+    if (bind(UDPSock, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
+        error(("Can't bind socket!") + std::to_string(WSAGetLastError()));
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        _Exit(-1);
+        //return;
+    }
+
+    info(("Vehicle data network online on port ") + std::to_string(Port) + (" with a Max of ") + std::to_string(MaxPlayers) + (" Clients"));
+    while (true) {
+        try {
+            sockaddr_in client {};
+            std::string Data = UDPRcvFromClient(client); //Receives any data from Socket
+            auto Pos = Data.find(':');
+            if (Data.empty() || Pos == std::string::npos || Pos > 2)
+                continue;
+            /*char clientIp[256];
+            ZeroMemory(clientIp, 256); ///Code to get IP we don't need that yet
+            inet_ntop(AF_INET, &client.sin_addr, clientIp, 256);*/
+            uint8_t ID = Data.at(0) - 1;
+            for (auto& c : CI->Clients) {
+                if (c != nullptr && c->GetID() == ID) {
+                    c->SetUDPAddr(client);
+                    c->isConnected = true;
+                    UDPParser(c.get(), Data.substr(2));
+                }
+            }
+        } catch (const std::exception& e) {
+            error(("fatal: ") + std::string(e.what()));
+        }
+    }
+    /*CloseSocketProper(UDPSock);
+    WSACleanup();
+    return;*/
+#else // unix
+    UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
+    // Create a server hint structure for the server
+    sockaddr_in serverAddr {};
+    serverAddr.sin_addr.s_addr = INADDR_ANY; //Any Local
+    serverAddr.sin_family = AF_INET; // Address format is IPv4
+    serverAddr.sin_port = htons(uint16_t(Port)); // Convert from little to big endian
+
+    // Try and bind the socket to the IP and port
+    if (bind(UDPSock, (sockaddr*)&serverAddr, sizeof(serverAddr)) != 0) {
+        error(("Can't bind socket!") + std::string(strerror(errno)));
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        _Exit(-1);
+        //return;
+    }
+
+    info(("Vehicle data network online on port ") + std::to_string(Port) + (" with a Max of ") + std::to_string(MaxPlayers) + (" Clients"));
+    while (true) {
+        try {
+            sockaddr_in client {};
+            std::string Data = UDPRcvFromClient(client); //Receives any data from Socket
+            size_t Pos = Data.find(':');
+            if (Data.empty() || Pos > 2)
+                continue;
+            /*char clientIp[256];
+            ZeroMemory(clientIp, 256); ///Code to get IP we don't need that yet
+            inet_ntop(AF_INET, &client.sin_addr, clientIp, 256);*/
+            uint8_t ID = uint8_t(Data.at(0)) - 1;
+            for (auto& c : CI->Clients) {
+                if (c != nullptr && c->GetID() == ID) {
+                    c->SetUDPAddr(client);
+                    c->isConnected = true;
+                    UDPParser(c.get(), Data.substr(2));
+                }
+            }
+        } catch (const std::exception& e) {
+            error(("fatal: ") + std::string(e.what()));
+        }
+    }
+    /*CloseSocketProper(UDPSock); // TODO: Why not this? We did this in TCPServerMain?
+    return;
+     */
+#endif // WIN32
+}

src/Network/Websocket.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 11/6/2020
+///
+/*#include <boost/beast/core.hpp>
+#include "Logger.h"
+#include "Security/Enc.h"
+#include <boost/asio/connect.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/beast/websocket.hpp>
+#include <iostream>
+#include <string>
+#include <thread>*/
+
+/*namespace beast = boost::beast;
+namespace http = beast::http;
+namespace websocket = beast::websocket;
+namespace net = boost::asio;
+using tcp = boost::asio::ip::tcp;
+
+std::string GetRes(const beast::flat_buffer& buff) {
+    return (char*)buff.data().data();
+}*/
+
+void SyncData() {
+    /*DebugPrintTID();
+    try {
+        std::string const host = ("95.216.35.232");
+
+        net::io_context ioc;
+        tcp::resolver r(ioc);
+
+        websocket::stream<tcp::socket> ws(ioc);
+        auto const results = r.resolve(host, ("3600"));
+        net::connect(ws.next_layer(), results.begin(), results.end());
+
+
+        ws.handshake(host, "/");
+        beast::flat_buffer buffer;
+        ws.write(boost::asio::buffer("Hello, world!"));
+        ws.read(buffer);
+
+        std::cout << GetRes(buffer) << std::endl;
+
+        ws.close(websocket::close_code::normal);
+
+    }catch(std::exception const& e){
+        error(e.what());
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+        _Exit(0);
+    }*/
+}
+
+void WebsocketInit() {
+    /*std::thread t1(SyncData);
+    t1.detach();*/
+}

src/config.cpp

@@ -1,119 +0,0 @@
-//
-// Created by Anonymous275 on 1/28/2020.
-//
-
-#include "main.h"
-#include <iostream>
-#include <fstream>
-#include <string>
-#include "logger.h"
-using namespace std; //nameSpace STD
-void GenerateConfig();
-string RemoveComments(string Line);
-string convertToString(char* a, int size);
-void SetValues(string Line, int Index);
-void SetMainValues(bool D,int P,string Name,string serverName);
-bool D;
-int P;
-string M;
-string S;
-
-
-//Generates or Reads Config
-void ParseConfig(){
-    ifstream InFileStream;
-    InFileStream.open("Server.cfg");
-    if(InFileStream.good()){ //Checks if Config Exists
-        info("Config Found Updating Values");
-        string line;
-        int index = 1;
-        while (getline(InFileStream, line)) {
-            if(line.rfind('#', 0) != 0){ //Checks if it starts as Comment
-                string CleanLine = RemoveComments(line); //Cleans it from the Comments
-                SetValues(CleanLine,index); //sets the values
-                index++;
-            }
-        }
-        SetMainValues(D,P,M,S); //gives the values to Main
-    }else{
-        info("Config Not Found Generating A new One");
-        GenerateConfig();
-    }
-    InFileStream.close();
-}
-
-
-
-void SetValues(string Line, int Index) {
-    int i = 0, state = 0;
-    char Data[50] = "";
-    bool Switch = false;
-    if (Index > 2) { Switch = true; }
-    for (char &c : Line) {
-        if (Switch) {
-            if (c == '\"') { state++; }
-            if (state > 0 && state < 2) {
-                Data[i] = c;
-                i++;
-            }
-        } else {
-            if (c == ' ') { state++; }
-            if (state > 1) {
-                Data[i] = c;
-                i++;
-            }
-        }
-    }
-    for (int C = 1; C <= i; C++){
-        Data[C-1] = Data[C];
-    }
-    string::size_type sz;
-    bool Boolean = (convertToString(Data,i-1).find("true") != string::npos);//searches for "true"
-    switch (Index){
-        case 1 :
-            if(Boolean){D = true;}else{D = false;}//checks and sets the Debug Value
-            break;
-        case 2 : P = stoi(Data, &sz);//sets the Port
-            break;
-        case 3 : M = Data; //Map
-            break;
-        case 4 : S = Data; //Name
-    }
-}
-
-
-
-//generates default Config
-void GenerateConfig(){
-    ofstream FileStream;
-    FileStream.open ("Server.cfg");
-    FileStream << "# This is the BeamNG-MP Server Configuration File\n"
-                  "Debug = false # true or false to enable debug console output\n"
-                  "Port = 30813 # Port to run the server on\n"
-                  "Map = \"levels/gridmap/level.json\"\n"
-                  "Name = \"BeamNG-MP FTW\"";
-    FileStream.close();
-}
-
-
-string RemoveComments(string Line){
-    int i = 0;
-    char Data[50] = "";
-    for(char& c : Line) {
-        if(c == '#'){break;} //when it finds the # it will stop
-        Data[i] = c;
-        i++;
-    }
-    return convertToString(Data,i); //Converts it from a char array to string and returns it
-}
-
-//Converts a char array or pointer to string
-string convertToString(char* a, int size)
-{
-    int i;
-    string s = "";
-    for (i = 0; i < size; i++) {
-        s = s + a[i];
-    }
-    return s;
-}

src/enet/callbacks.h

@@ -1,27 +0,0 @@
-/** 
- @file  callbacks.h
- @brief ENet callbacks
-*/
-#ifndef __ENET_CALLBACKS_H__
-#define __ENET_CALLBACKS_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetCallbacks
-{
-    void * (ENET_CALLBACK * malloc) (size_t size);
-    void (ENET_CALLBACK * free) (void * memory);
-    void (ENET_CALLBACK * no_memory) (void);
-} ENetCallbacks;
-
-/** @defgroup callbacks ENet internal callbacks
-    @{
-    @ingroup private
-*/
-extern void * enet_malloc (size_t);
-extern void   enet_free (void *);
-
-/** @} */
-
-#endif /* __ENET_CALLBACKS_H__ */
-

src/enet/enet.h

@@ -1,607 +0,0 @@
-/** 
- @file  enet.h
- @brief ENet public header file
-*/
-#ifndef __ENET_ENET_H__
-#define __ENET_ENET_H__
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include "enet/win32.h"
-#else
-#include "enet/unix.h"
-#endif
-
-#include "enet/types.h"
-#include "enet/protocol.h"
-#include "enet/list.h"
-#include "enet/callbacks.h"
-
-#define ENET_VERSION_MAJOR 1
-#define ENET_VERSION_MINOR 3
-#define ENET_VERSION_PATCH 14
-#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
-#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
-#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
-#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
-#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-typedef enet_uint32 ENetVersion;
-
-struct _ENetHost;
-struct _ENetEvent;
-struct _ENetPacket;
-
-typedef enum _ENetSocketType
-{
-   ENET_SOCKET_TYPE_STREAM   = 1,
-   ENET_SOCKET_TYPE_DATAGRAM = 2
-} ENetSocketType;
-
-typedef enum _ENetSocketWait
-{
-   ENET_SOCKET_WAIT_NONE      = 0,
-   ENET_SOCKET_WAIT_SEND      = (1 << 0),
-   ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-   ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-} ENetSocketWait;
-
-typedef enum _ENetSocketOption
-{
-   ENET_SOCKOPT_NONBLOCK  = 1,
-   ENET_SOCKOPT_BROADCAST = 2,
-   ENET_SOCKOPT_RCVBUF    = 3,
-   ENET_SOCKOPT_SNDBUF    = 4,
-   ENET_SOCKOPT_REUSEADDR = 5,
-   ENET_SOCKOPT_RCVTIMEO  = 6,
-   ENET_SOCKOPT_SNDTIMEO  = 7,
-   ENET_SOCKOPT_ERROR     = 8,
-   ENET_SOCKOPT_NODELAY   = 9
-} ENetSocketOption;
-
-typedef enum _ENetSocketShutdown
-{
-    ENET_SOCKET_SHUTDOWN_READ       = 0,
-    ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-} ENetSocketShutdown;
-
-#define ENET_HOST_ANY       0
-#define ENET_HOST_BROADCAST 0xFFFFFFFFU
-#define ENET_PORT_ANY       0
-
-/**
- * Portable internet address structure. 
- *
- * The host must be specified in network byte-order, and the port must be in host 
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default 
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
- */
-typedef struct _ENetAddress
-{
-   enet_uint32 host;
-   enet_uint16 port;
-} ENetAddress;
-
-/**
- * Packet flag bit constants.
- *
- * The host must be specified in network byte-order, and the port must be in
- * host byte-order. The constant ENET_HOST_ANY may be used to specify the
- * default server host.
- 
-   @sa ENetPacket
-*/
-typedef enum _ENetPacketFlag
-{
-   /** packet must be received by the target peer and resend attempts should be
-     * made until the packet is delivered */
-   ENET_PACKET_FLAG_RELIABLE    = (1 << 0),
-   /** packet will not be sequenced with other packets
-     * not supported for reliable packets
-     */
-   ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
-   /** packet will not allocate data, and user must supply it instead */
-   ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2),
-   /** packet will be fragmented using unreliable (instead of reliable) sends
-     * if it exceeds the MTU */
-   ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-
-   /** whether the packet has been sent from all queues it has been entered into */
-   ENET_PACKET_FLAG_SENT = (1<<8)
-} ENetPacketFlag;
-
-typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
-
-/**
- * ENet packet structure.
- *
- * An ENet data packet that may be sent to or received from a peer. The shown 
- * fields should only be read and never modified. The data field contains the 
- * allocated data for the packet. The dataLength fields specifies the length 
- * of the allocated data.  The flags field is either 0 (specifying no flags), 
- * or a bitwise-or of any combination of the following flags:
- *
- *    ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
- *    and resend attempts should be made until the packet is delivered
- *
- *    ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 
- *    (not supported for reliable packets)
- *
- *    ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
- *
- *    ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable
- *    (instead of reliable) sends if it exceeds the MTU
- *
- *    ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into
-   @sa ENetPacketFlag
- */
-typedef struct _ENetPacket
-{
-   size_t                   referenceCount;  /**< internal use only */
-   enet_uint32              flags;           /**< bitwise-or of ENetPacketFlag constants */
-   enet_uint8 *             data;            /**< allocated data for packet */
-   size_t                   dataLength;      /**< length of data */
-   ENetPacketFreeCallback   freeCallback;    /**< function to be called when the packet is no longer in use */
-   void *                   userData;        /**< application private data, may be freely modified */
-} ENetPacket;
-
-typedef struct _ENetAcknowledgement
-{
-   ENetListNode acknowledgementList;
-   enet_uint32  sentTime;
-   ENetProtocol command;
-} ENetAcknowledgement;
-
-typedef struct _ENetOutgoingCommand
-{
-   ENetListNode outgoingCommandList;
-   enet_uint16  reliableSequenceNumber;
-   enet_uint16  unreliableSequenceNumber;
-   enet_uint32  sentTime;
-   enet_uint32  roundTripTimeout;
-   enet_uint32  roundTripTimeoutLimit;
-   enet_uint32  fragmentOffset;
-   enet_uint16  fragmentLength;
-   enet_uint16  sendAttempts;
-   ENetProtocol command;
-   ENetPacket * packet;
-} ENetOutgoingCommand;
-
-typedef struct _ENetIncomingCommand
-{  
-   ENetListNode     incomingCommandList;
-   enet_uint16      reliableSequenceNumber;
-   enet_uint16      unreliableSequenceNumber;
-   ENetProtocol     command;
-   enet_uint32      fragmentCount;
-   enet_uint32      fragmentsRemaining;
-   enet_uint32 *    fragments;
-   ENetPacket *     packet;
-} ENetIncomingCommand;
-
-typedef enum _ENetPeerState
-{
-   ENET_PEER_STATE_DISCONNECTED                = 0,
-   ENET_PEER_STATE_CONNECTING                  = 1,
-   ENET_PEER_STATE_ACKNOWLEDGING_CONNECT       = 2,
-   ENET_PEER_STATE_CONNECTION_PENDING          = 3,
-   ENET_PEER_STATE_CONNECTION_SUCCEEDED        = 4,
-   ENET_PEER_STATE_CONNECTED                   = 5,
-   ENET_PEER_STATE_DISCONNECT_LATER            = 6,
-   ENET_PEER_STATE_DISCONNECTING               = 7,
-   ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT    = 8,
-   ENET_PEER_STATE_ZOMBIE                      = 9 
-} ENetPeerState;
-
-#ifndef ENET_BUFFER_MAXIMUM
-#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-#endif
-
-enum
-{
-   ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-   ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-   ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-   ENET_HOST_DEFAULT_MTU                  = 1400,
-   ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-   ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-
-   ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-   ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-   ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-   ENET_PEER_PACKET_THROTTLE_COUNTER      = 7, 
-   ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-   ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-   ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-   ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-   ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-   ENET_PEER_TIMEOUT_LIMIT                = 32,
-   ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-   ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-   ENET_PEER_PING_INTERVAL                = 500,
-   ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-   ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-   ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-   ENET_PEER_RELIABLE_WINDOWS             = 16,
-   ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-   ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-};
-
-typedef struct _ENetChannel
-{
-   enet_uint16  outgoingReliableSequenceNumber;
-   enet_uint16  outgoingUnreliableSequenceNumber;
-   enet_uint16  usedReliableWindows;
-   enet_uint16  reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
-   enet_uint16  incomingReliableSequenceNumber;
-   enet_uint16  incomingUnreliableSequenceNumber;
-   ENetList     incomingReliableCommands;
-   ENetList     incomingUnreliableCommands;
-} ENetChannel;
-
-/**
- * An ENet peer which data packets may be sent or received from. 
- *
- * No fields should be modified unless otherwise specified. 
- */
-typedef struct _ENetPeer
-{ 
-   ENetListNode  dispatchList;
-   struct _ENetHost * host;
-   enet_uint16   outgoingPeerID;
-   enet_uint16   incomingPeerID;
-   enet_uint32   connectID;
-   enet_uint8    outgoingSessionID;
-   enet_uint8    incomingSessionID;
-   ENetAddress   address;            /**< Internet address of the peer */
-   void *        data;               /**< Application private data, may be freely modified */
-   ENetPeerState state;
-   ENetChannel * channels;
-   size_t        channelCount;       /**< Number of channels allocated for communication with peer */
-   enet_uint32   incomingBandwidth;  /**< Downstream bandwidth of the client in bytes/second */
-   enet_uint32   outgoingBandwidth;  /**< Upstream bandwidth of the client in bytes/second */
-   enet_uint32   incomingBandwidthThrottleEpoch;
-   enet_uint32   outgoingBandwidthThrottleEpoch;
-   enet_uint32   incomingDataTotal;
-   enet_uint32   outgoingDataTotal;
-   enet_uint32   lastSendTime;
-   enet_uint32   lastReceiveTime;
-   enet_uint32   nextTimeout;
-   enet_uint32   earliestTimeout;
-   enet_uint32   packetLossEpoch;
-   enet_uint32   packetsSent;
-   enet_uint32   packetsLost;
-   enet_uint32   packetLoss;          /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
-   enet_uint32   packetLossVariance;
-   enet_uint32   packetThrottle;
-   enet_uint32   packetThrottleLimit;
-   enet_uint32   packetThrottleCounter;
-   enet_uint32   packetThrottleEpoch;
-   enet_uint32   packetThrottleAcceleration;
-   enet_uint32   packetThrottleDeceleration;
-   enet_uint32   packetThrottleInterval;
-   enet_uint32   pingInterval;
-   enet_uint32   timeoutLimit;
-   enet_uint32   timeoutMinimum;
-   enet_uint32   timeoutMaximum;
-   enet_uint32   lastRoundTripTime;
-   enet_uint32   lowestRoundTripTime;
-   enet_uint32   lastRoundTripTimeVariance;
-   enet_uint32   highestRoundTripTimeVariance;
-   enet_uint32   roundTripTime;            /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
-   enet_uint32   roundTripTimeVariance;
-   enet_uint32   mtu;
-   enet_uint32   windowSize;
-   enet_uint32   reliableDataInTransit;
-   enet_uint16   outgoingReliableSequenceNumber;
-   ENetList      acknowledgements;
-   ENetList      sentReliableCommands;
-   ENetList      sentUnreliableCommands;
-   ENetList      outgoingReliableCommands;
-   ENetList      outgoingUnreliableCommands;
-   ENetList      dispatchedCommands;
-   int           needsDispatch;
-   enet_uint16   incomingUnsequencedGroup;
-   enet_uint16   outgoingUnsequencedGroup;
-   enet_uint32   unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 
-   enet_uint32   eventData;
-   size_t        totalWaitingData;
-} ENetPeer;
-
-/** An ENet packet compressor for compressing UDP packets before socket sends or receives.
- */
-typedef struct _ENetCompressor
-{
-   /** Context data for the compressor. Must be non-NULL. */
-   void * context;
-   /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */
-   size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-   /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */
-   void (ENET_CALLBACK * destroy) (void * context);
-} ENetCompressor;
-
-/** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */
-typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount);
-
-/** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */
-typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event);
- 
-/** An ENet host for communicating with peers.
-  *
-  * No fields should be modified unless otherwise stated.
-
-    @sa enet_host_create()
-    @sa enet_host_destroy()
-    @sa enet_host_connect()
-    @sa enet_host_service()
-    @sa enet_host_flush()
-    @sa enet_host_broadcast()
-    @sa enet_host_compress()
-    @sa enet_host_compress_with_range_coder()
-    @sa enet_host_channel_limit()
-    @sa enet_host_bandwidth_limit()
-    @sa enet_host_bandwidth_throttle()
-  */
-typedef struct _ENetHost
-{
-   ENetSocket           socket;
-   ENetAddress          address;                     /**< Internet address of the host */
-   enet_uint32          incomingBandwidth;           /**< downstream bandwidth of the host */
-   enet_uint32          outgoingBandwidth;           /**< upstream bandwidth of the host */
-   enet_uint32          bandwidthThrottleEpoch;
-   enet_uint32          mtu;
-   enet_uint32          randomSeed;
-   int                  recalculateBandwidthLimits;
-   ENetPeer *           peers;                       /**< array of peers allocated for this host */
-   size_t               peerCount;                   /**< number of peers allocated for this host */
-   size_t               channelLimit;                /**< maximum number of channels allowed for connected peers */
-   enet_uint32          serviceTime;
-   ENetList             dispatchQueue;
-   int                  continueSending;
-   size_t               packetSize;
-   enet_uint16          headerFlags;
-   ENetProtocol         commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-   size_t               commandCount;
-   ENetBuffer           buffers [ENET_BUFFER_MAXIMUM];
-   size_t               bufferCount;
-   ENetChecksumCallback checksum;                    /**< callback the user can set to enable packet checksums for this host */
-   ENetCompressor       compressor;
-   enet_uint8           packetData [2][ENET_PROTOCOL_MAXIMUM_MTU];
-   ENetAddress          receivedAddress;
-   enet_uint8 *         receivedData;
-   size_t               receivedDataLength;
-   enet_uint32          totalSentData;               /**< total data sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalSentPackets;            /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedData;           /**< total data received, user should reset to 0 as needed to prevent overflow */
-   enet_uint32          totalReceivedPackets;        /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */
-   ENetInterceptCallback intercept;                  /**< callback the user can set to intercept received raw UDP packets */
-   size_t               connectedPeers;
-   size_t               bandwidthLimitedPeers;
-   size_t               duplicatePeers;              /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */
-   size_t               maximumPacketSize;           /**< the maximum allowable packet size that may be sent or received on a peer */
-   size_t               maximumWaitingData;          /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */
-} ENetHost;
-
-/**
- * An ENet event type, as specified in @ref ENetEvent.
- */
-typedef enum _ENetEventType
-{
-   /** no event occurred within the specified time limit */
-   ENET_EVENT_TYPE_NONE       = 0,  
-
-   /** a connection request initiated by enet_host_connect has completed.  
-     * The peer field contains the peer which successfully connected. 
-     */
-   ENET_EVENT_TYPE_CONNECT    = 1,  
-
-   /** a peer has disconnected.  This event is generated on a successful 
-     * completion of a disconnect initiated by enet_peer_disconnect, if 
-     * a peer has timed out, or if a connection request intialized by 
-     * enet_host_connect has timed out.  The peer field contains the peer 
-     * which disconnected. The data field contains user supplied data 
-     * describing the disconnection, or 0, if none is available.
-     */
-   ENET_EVENT_TYPE_DISCONNECT = 2,  
-
-   /** a packet has been received from a peer.  The peer field specifies the
-     * peer which sent the packet.  The channelID field specifies the channel
-     * number upon which the packet was received.  The packet field contains
-     * the packet that was received; this packet must be destroyed with
-     * enet_packet_destroy after use.
-     */
-   ENET_EVENT_TYPE_RECEIVE    = 3
-} ENetEventType;
-
-/**
- * An ENet event as returned by enet_host_service().
-   
-   @sa enet_host_service
- */
-typedef struct _ENetEvent 
-{
-   ENetEventType        type;      /**< type of the event */
-   ENetPeer *           peer;      /**< peer that generated a connect, disconnect or receive event */
-   enet_uint8           channelID; /**< channel on the peer that generated the event, if appropriate */
-   enet_uint32          data;      /**< data associated with the event, if appropriate */
-   ENetPacket *         packet;    /**< packet associated with the event, if appropriate */
-} ENetEvent;
-
-/** @defgroup global ENet global functions
-    @{ 
-*/
-
-/** 
-  Initializes ENet globally.  Must be called prior to using any functions in
-  ENet.
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize (void);
-
-/** 
-  Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored.
-
-  @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
-  @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults
-  @returns 0 on success, < 0 on failure
-*/
-ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
-
-/** 
-  Shuts down ENet globally.  Should be called when a program that has
-  initialized ENet exits.
-*/
-ENET_API void enet_deinitialize (void);
-
-/**
-  Gives the linked version of the ENet library.
-  @returns the version number 
-*/
-ENET_API ENetVersion enet_linked_version (void);
-
-/** @} */
-
-/** @defgroup private ENet private implementation functions */
-
-/**
-  Returns the wall-time in milliseconds.  Its initial value is unspecified
-  unless otherwise set.
-  */
-ENET_API enet_uint32 enet_time_get (void);
-/**
-  Sets the current wall-time in milliseconds.
-  */
-ENET_API void enet_time_set (enet_uint32);
-
-/** @defgroup socket ENet socket functions
-    @{
-*/
-ENET_API ENetSocket enet_socket_create (ENetSocketType);
-ENET_API int        enet_socket_bind (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_get_address (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_listen (ENetSocket, int);
-ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
-ENET_API int        enet_socket_connect (ENetSocket, const ENetAddress *);
-ENET_API int        enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-ENET_API int        enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-ENET_API int        enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
-ENET_API int        enet_socket_set_option (ENetSocket, ENetSocketOption, int);
-ENET_API int        enet_socket_get_option (ENetSocket, ENetSocketOption, int *);
-ENET_API int        enet_socket_shutdown (ENetSocket, ENetSocketShutdown);
-ENET_API void       enet_socket_destroy (ENetSocket);
-ENET_API int        enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-/** @} */
-
-/** @defgroup Address ENet address functions
-    @{
-*/
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
-    and sets the host field in the address parameter if successful.
-    @param address destination to store the parsed IP address
-    @param hostName IP address to parse
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostName);
-
-/** Attempts to resolve the host named by the parameter hostName and sets
-    the host field in the address parameter if successful.
-    @param address destination to store resolved address
-    @param hostName host name to lookup
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
-    @param address    address printed
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
-    @param address    address used for reverse lookup
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** @} */
-
-ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
-ENET_API void         enet_packet_destroy (ENetPacket *);
-ENET_API int          enet_packet_resize  (ENetPacket *, size_t);
-ENET_API enet_uint32  enet_crc32 (const ENetBuffer *, size_t);
-                
-ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-ENET_API void       enet_host_destroy (ENetHost *);
-ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
-ENET_API int        enet_host_check_events (ENetHost *, ENetEvent *);
-ENET_API int        enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
-ENET_API void       enet_host_flush (ENetHost *);
-ENET_API void       enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
-ENET_API void       enet_host_compress (ENetHost *, const ENetCompressor *);
-ENET_API int        enet_host_compress_with_range_coder (ENetHost * host);
-ENET_API void       enet_host_channel_limit (ENetHost *, size_t);
-ENET_API void       enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
-extern   void       enet_host_bandwidth_throttle (ENetHost *);
-extern  enet_uint32 enet_host_random_seed (void);
-
-ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
-ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
-ENET_API void                enet_peer_ping (ENetPeer *);
-ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-ENET_API void                enet_peer_reset (ENetPeer *);
-ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
-ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
-extern void                  enet_peer_reset_queues (ENetPeer *);
-extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
-extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
-extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
-extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
-extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
-extern void                  enet_peer_on_connect (ENetPeer *);
-extern void                  enet_peer_on_disconnect (ENetPeer *);
-
-ENET_API void * enet_range_coder_create (void);
-ENET_API void   enet_range_coder_destroy (void *);
-ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t);
-ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t);
-   
-extern size_t enet_protocol_command_size (enet_uint8);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __ENET_ENET_H__ */
-

src/enet/list.h

@@ -1,43 +0,0 @@
-/** 
- @file  list.h
- @brief ENet list management 
-*/
-#ifndef __ENET_LIST_H__
-#define __ENET_LIST_H__
-
-#include <stdlib.h>
-
-typedef struct _ENetListNode
-{
-   struct _ENetListNode * next;
-   struct _ENetListNode * previous;
-} ENetListNode;
-
-typedef ENetListNode * ENetListIterator;
-
-typedef struct _ENetList
-{
-   ENetListNode sentinel;
-} ENetList;
-
-extern void enet_list_clear (ENetList *);
-
-extern ENetListIterator enet_list_insert (ENetListIterator, void *);
-extern void * enet_list_remove (ENetListIterator);
-extern ENetListIterator enet_list_move (ENetListIterator, void *, void *);
-
-extern size_t enet_list_size (ENetList *);
-
-#define enet_list_begin(list) ((list) -> sentinel.next)
-#define enet_list_end(list) (& (list) -> sentinel)
-
-#define enet_list_empty(list) (enet_list_begin (list) == enet_list_end (list))
-
-#define enet_list_next(iterator) ((iterator) -> next)
-#define enet_list_previous(iterator) ((iterator) -> previous)
-
-#define enet_list_front(list) ((void *) (list) -> sentinel.next)
-#define enet_list_back(list) ((void *) (list) -> sentinel.previous)
-
-#endif /* __ENET_LIST_H__ */
-

src/enet/protocol.h

@@ -1,198 +0,0 @@
-/** 
- @file  protocol.h
- @brief ENet protocol
-*/
-#ifndef __ENET_PROTOCOL_H__
-#define __ENET_PROTOCOL_H__
-
-#include "enet/types.h"
-
-enum
-{
-   ENET_PROTOCOL_MINIMUM_MTU             = 576,
-   ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-   ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-   ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-   ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-   ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-   ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-   ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-   ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-};
-
-typedef enum _ENetProtocolCommand
-{
-   ENET_PROTOCOL_COMMAND_NONE               = 0,
-   ENET_PROTOCOL_COMMAND_ACKNOWLEDGE        = 1,
-   ENET_PROTOCOL_COMMAND_CONNECT            = 2,
-   ENET_PROTOCOL_COMMAND_VERIFY_CONNECT     = 3,
-   ENET_PROTOCOL_COMMAND_DISCONNECT         = 4,
-   ENET_PROTOCOL_COMMAND_PING               = 5,
-   ENET_PROTOCOL_COMMAND_SEND_RELIABLE      = 6,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE    = 7,
-   ENET_PROTOCOL_COMMAND_SEND_FRAGMENT      = 8,
-   ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED   = 9,
-   ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT    = 10,
-   ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
-   ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-   ENET_PROTOCOL_COMMAND_COUNT              = 13,
-
-   ENET_PROTOCOL_COMMAND_MASK               = 0x0F
-} ENetProtocolCommand;
-
-typedef enum _ENetProtocolFlag
-{
-   ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-   ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-
-   ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14),
-   ENET_PROTOCOL_HEADER_FLAG_SENT_TIME  = (1 << 15),
-   ENET_PROTOCOL_HEADER_FLAG_MASK       = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-
-   ENET_PROTOCOL_HEADER_SESSION_MASK    = (3 << 12),
-   ENET_PROTOCOL_HEADER_SESSION_SHIFT   = 12
-} ENetProtocolFlag;
-
-#ifdef _MSC_VER
-#pragma pack(push, 1)
-#define ENET_PACKED
-#elif defined(__GNUC__) || defined(__clang__)
-#define ENET_PACKED __attribute__ ((packed))
-#else
-#define ENET_PACKED
-#endif
-
-typedef struct _ENetProtocolHeader
-{
-   enet_uint16 peerID;
-   enet_uint16 sentTime;
-} ENET_PACKED ENetProtocolHeader;
-
-typedef struct _ENetProtocolCommandHeader
-{
-   enet_uint8 command;
-   enet_uint8 channelID;
-   enet_uint16 reliableSequenceNumber;
-} ENET_PACKED ENetProtocolCommandHeader;
-
-typedef struct _ENetProtocolAcknowledge
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 receivedReliableSequenceNumber;
-   enet_uint16 receivedSentTime;
-} ENET_PACKED ENetProtocolAcknowledge;
-
-typedef struct _ENetProtocolConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolConnect;
-
-typedef struct _ENetProtocolVerifyConnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 outgoingPeerID;
-   enet_uint8  incomingSessionID;
-   enet_uint8  outgoingSessionID;
-   enet_uint32 mtu;
-   enet_uint32 windowSize;
-   enet_uint32 channelCount;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-   enet_uint32 connectID;
-} ENET_PACKED ENetProtocolVerifyConnect;
-
-typedef struct _ENetProtocolBandwidthLimit
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 incomingBandwidth;
-   enet_uint32 outgoingBandwidth;
-} ENET_PACKED ENetProtocolBandwidthLimit;
-
-typedef struct _ENetProtocolThrottleConfigure
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 packetThrottleInterval;
-   enet_uint32 packetThrottleAcceleration;
-   enet_uint32 packetThrottleDeceleration;
-} ENET_PACKED ENetProtocolThrottleConfigure;
-
-typedef struct _ENetProtocolDisconnect
-{
-   ENetProtocolCommandHeader header;
-   enet_uint32 data;
-} ENET_PACKED ENetProtocolDisconnect;
-
-typedef struct _ENetProtocolPing
-{
-   ENetProtocolCommandHeader header;
-} ENET_PACKED ENetProtocolPing;
-
-typedef struct _ENetProtocolSendReliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendReliable;
-
-typedef struct _ENetProtocolSendUnreliable
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unreliableSequenceNumber;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnreliable;
-
-typedef struct _ENetProtocolSendUnsequenced
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 unsequencedGroup;
-   enet_uint16 dataLength;
-} ENET_PACKED ENetProtocolSendUnsequenced;
-
-typedef struct _ENetProtocolSendFragment
-{
-   ENetProtocolCommandHeader header;
-   enet_uint16 startSequenceNumber;
-   enet_uint16 dataLength;
-   enet_uint32 fragmentCount;
-   enet_uint32 fragmentNumber;
-   enet_uint32 totalLength;
-   enet_uint32 fragmentOffset;
-} ENET_PACKED ENetProtocolSendFragment;
-
-typedef union _ENetProtocol
-{
-   ENetProtocolCommandHeader header;
-   ENetProtocolAcknowledge acknowledge;
-   ENetProtocolConnect connect;
-   ENetProtocolVerifyConnect verifyConnect;
-   ENetProtocolDisconnect disconnect;
-   ENetProtocolPing ping;
-   ENetProtocolSendReliable sendReliable;
-   ENetProtocolSendUnreliable sendUnreliable;
-   ENetProtocolSendUnsequenced sendUnsequenced;
-   ENetProtocolSendFragment sendFragment;
-   ENetProtocolBandwidthLimit bandwidthLimit;
-   ENetProtocolThrottleConfigure throttleConfigure;
-} ENET_PACKED ENetProtocol;
-
-#ifdef _MSC_VER
-#pragma pack(pop)
-#endif
-
-#endif /* __ENET_PROTOCOL_H__ */
-

src/enet/time.h

@@ -1,18 +0,0 @@
-/** 
- @file  time.h
- @brief ENet time constants and macros
-*/
-#ifndef __ENET_TIME_H__
-#define __ENET_TIME_H__
-
-#define ENET_TIME_OVERFLOW 86400000
-
-#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
-#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
-
-#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
-
-#endif /* __ENET_TIME_H__ */
-

src/enet/types.h

@@ -1,13 +0,0 @@
-/** 
- @file  types.h
- @brief type definitions for ENet
-*/
-#ifndef __ENET_TYPES_H__
-#define __ENET_TYPES_H__
-
-typedef unsigned char enet_uint8;       /**< unsigned 8-bit type  */
-typedef unsigned short enet_uint16;     /**< unsigned 16-bit type */
-typedef unsigned int enet_uint32;      /**< unsigned 32-bit type */
-
-#endif /* __ENET_TYPES_H__ */
-

src/enet/unix.h

@@ -1,48 +0,0 @@
-/** 
- @file  unix.h
- @brief ENet Unix header
-*/
-#ifndef __ENET_UNIX_H__
-#define __ENET_UNIX_H__
-
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <unistd.h>
-
-#ifdef MSG_MAXIOVLEN
-#define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
-#endif
-
-typedef int ENetSocket;
-
-#define ENET_SOCKET_NULL -1
-
-#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
-#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value)) /**< macro that converts net to host byte-order of a 16-bit value */
-#define ENET_NET_TO_HOST_32(value) (ntohl (value)) /**< macro that converts net to host byte-order of a 32-bit value */
-
-typedef struct
-{
-    void * data;
-    size_t dataLength;
-} ENetBuffer;
-
-#define ENET_CALLBACK
-
-#define ENET_API extern
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-    
-#endif /* __ENET_UNIX_H__ */
-

src/enet/utility.h

@@ -1,12 +0,0 @@
-/** 
- @file  utility.h
- @brief ENet utility header
-*/
-#ifndef __ENET_UTILITY_H__
-#define __ENET_UTILITY_H__
-
-#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
-#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-
-#endif /* __ENET_UTILITY_H__ */
-

src/enet/win32.h

@@ -1,57 +0,0 @@
-/** 
- @file  win32.h
- @brief ENet Win32 header
-*/
-#ifndef __ENET_WIN32_H__
-#define __ENET_WIN32_H__
-
-#ifdef _MSC_VER
-#ifdef ENET_BUILDING_LIB
-#pragma warning (disable: 4267) // size_t to int conversion
-#pragma warning (disable: 4244) // 64bit to 32bit int
-#pragma warning (disable: 4018) // signed/unsigned mismatch
-#pragma warning (disable: 4146) // unary minus operator applied to unsigned type
-#endif
-#endif
-
-#include <stdlib.h>
-#include <winsock2.h>
-
-typedef SOCKET ENetSocket;
-
-#define ENET_SOCKET_NULL INVALID_SOCKET
-
-#define ENET_HOST_TO_NET_16(value) (htons (value))
-#define ENET_HOST_TO_NET_32(value) (htonl (value))
-
-#define ENET_NET_TO_HOST_16(value) (ntohs (value))
-#define ENET_NET_TO_HOST_32(value) (ntohl (value))
-
-typedef struct
-{
-    size_t dataLength;
-    void * data;
-} ENetBuffer;
-
-#define ENET_CALLBACK __cdecl
-
-#ifdef ENET_DLL
-#ifdef ENET_BUILDING_LIB
-#define ENET_API __declspec( dllexport )
-#else
-#define ENET_API __declspec( dllimport )
-#endif /* ENET_BUILDING_LIB */
-#else /* !ENET_DLL */
-#define ENET_API extern
-#endif /* ENET_DLL */
-
-typedef fd_set ENetSocketSet;
-
-#define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO (& (sockset))
-#define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET (socket, & (sockset))
-#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset))
-#define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET (socket, & (sockset))
-
-#endif /* __ENET_WIN32_H__ */
-
-

src/logger.cpp

@@ -1,94 +1,133 @@
-//
-// Created by jojos38 on 28.01.2020.
-//
-
-
-#include "logger.h"
-using namespace std;
-
-int loggerlevel;
-
-void setLoggerLevel(char level_string[]) {
-    if (!strcmp(level_string, "ALL"))
-        loggerlevel = 0;
-
-    if (!strcmp(level_string, "DEBUG"))
-        loggerlevel = 1;
-
-    if (!strcmp(level_string, "INFO"))
-        loggerlevel = 2;
-
-    if (!strcmp(level_string, "WARN"))
-        loggerlevel = 3;
-
-    if (!strcmp(level_string, "ERROR"))
-        loggerlevel = 4;
-
-    if (!strcmp(level_string, "OFF"))
-        loggerlevel = 5;
-}
-
-stringstream getDate() {
-    // current date/time based on current system
-    time_t now = time(0);
-    tm* ltm = localtime(&now);
-    
-    int month = 1 + ltm->tm_mon;
-    int day = ltm->tm_mday;
-    int hours = 1 + ltm->tm_hour;
-    int minutes = 1 + ltm->tm_min;
-    int seconds = 1 + ltm->tm_sec;
-
-    string month_string;
-    if (month < 10) month_string = "0" + to_string(month);
-    else month_string = to_string(month);
-
-    string day_string;
-    if (day < 10) day_string = "0" + to_string(day);
-    else day_string = to_string(day);
-
-    string hours_string;
-    if (hours < 10) hours_string = "0" + to_string(hours);
-    else hours_string = to_string(hours);
-
-    string minutes_string;
-    if (minutes < 10) minutes_string = "0" + to_string(minutes);
-    else minutes_string = to_string(minutes);
-
-    string seconds_string;
-    if (seconds < 10) seconds_string = "0" + to_string(seconds);
-    else seconds_string = to_string(seconds);
-
-    std::stringstream date;
-    date
-        << "["
-        << day_string << "/"
-        << month_string << "/"
-        << 1900 + ltm->tm_year << " "
-        << hours_string << ":"
-        << minutes_string << ":"
-        << seconds_string
-        << "] ";
-    return date;
-}
-
-/*
-void info(char obj[]) {
-    if (level <= 2)
-        cout << getDate().str() << "\u001b[36m" << "[INFO]" << "\u001b[0m" << " " << obj << endl;
-}
-
-void error(char obj[]) {
-    if (level <= 4)
-        cout << getDate().str() << "\x1B[31m" << "[ERRO]" << "\u001b[0m" << " " << obj << endl;
-}
-
-void warn(char obj[]) {
-    if (level <= 3)
-        cout << getDate().str() << "\u001b[33m" << "[WARN]" << "\u001b[0m" << " " << obj << endl;
-}
-
-void debug(char obj[]) {
-    if (level <= 1)
-        cout << getDate().str() << "\u001b[35m" << "[DBUG]" << "\u001b[0m" << " " << obj << endl;
-}*/
+// Copyright (c) 2019-present Anonymous275.
+// BeamMP Server 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.
+// Anything else is prohibited. Modified works may not be published and have be upstreamed to the official repository.
+///
+/// Created by Anonymous275 on 7/17/2020
+///
+#include "Logger.h"
+#include "RWMutex.h"
+#include "Security/Enc.h"
+#include "Settings.h"
+#include <chrono>
+#include <fstream>
+#include <mutex>
+#include <sstream>
+#include <thread>
+#include <unordered_map>
+
+static RWMutex ThreadNameMapMutex;
+static std::unordered_map<std::thread::id, std::string> ThreadNameMap;
+
+std::string ThreadName() {
+    ReadLock lock(ThreadNameMapMutex);
+    std::string Name;
+    if (ThreadNameMap.find(std::this_thread::get_id()) != ThreadNameMap.end()) {
+        Name = ThreadNameMap.at(std::this_thread::get_id());
+    } else {
+        std::stringstream ss;
+        ss << std::this_thread::get_id();
+        Name = ss.str();
+    }
+    return Name;
+}
+
+void SetThreadName(const std::string& Name, bool overwrite) {
+    WriteLock lock(ThreadNameMapMutex);
+    if (overwrite || ThreadNameMap.find(std::this_thread::get_id()) == ThreadNameMap.end()) {
+        ThreadNameMap[std::this_thread::get_id()] = Name;
+    }
+}
+
+std::string getDate() {
+    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+    time_t tt = std::chrono::system_clock::to_time_t(now);
+    tm local_tm {};
+#ifdef WIN32
+    localtime_s(&local_tm, &tt);
+#else // unix
+    localtime_r(&tt, &local_tm);
+#endif // WIN32
+    std::stringstream date;
+    int S = local_tm.tm_sec;
+    int M = local_tm.tm_min;
+    int H = local_tm.tm_hour;
+    std::string Secs = (S > 9 ? std::to_string(S) : "0" + std::to_string(S));
+    std::string Min = (M > 9 ? std::to_string(M) : "0" + std::to_string(M));
+    std::string Hour = (H > 9 ? std::to_string(H) : "0" + std::to_string(H));
+    date
+        << "["
+        << local_tm.tm_mday << "/"
+        << local_tm.tm_mon + 1 << "/"
+        << local_tm.tm_year + 1900 << " "
+        << Hour << ":"
+        << Min << ":"
+        << Secs
+        << "] ";
+    if (Debug) {
+        date << ThreadName()
+             << " ";
+    }
+    return date.str();
+}
+
+void InitLog() {
+    std::ofstream LFS;
+    LFS.open(("Server.log"));
+    if (!LFS.is_open()) {
+        error(("logger file init failed!"));
+    } else
+        LFS.close();
+}
+std::mutex LogLock;
+
+void DebugPrintTIDInternal(const std::string& func, bool overwrite) {
+    // we need to print to cout here as we might crash before all console output is handled,
+    // due to segfaults or asserts.
+    SetThreadName(func, overwrite);
+#ifdef DEBUG
+    std::scoped_lock Guard(LogLock);
+    std::stringstream Print;
+    Print << "(debug build) Thread '" << std::this_thread::get_id() << "' is " << func << "\n";
+    ConsoleOut(Print.str());
+#endif // DEBUG
+}
+
+void addToLog(const std::string& Line) {
+    std::ofstream LFS;
+    LFS.open(("Server.log"), std::ios_base::app);
+    LFS << Line.c_str();
+    LFS.close();
+}
+void info(const std::string& toPrint) {
+    std::scoped_lock Guard(LogLock);
+    std::string Print = getDate() + ("[INFO] ") + toPrint + "\n";
+    ConsoleOut(Print);
+    addToLog(Print);
+}
+void debug(const std::string& toPrint) {
+    if (!Debug)
+        return;
+    std::scoped_lock Guard(LogLock);
+    std::string Print = getDate() + ("[DEBUG] ") + toPrint + "\n";
+    ConsoleOut(Print);
+    addToLog(Print);
+}
+void warn(const std::string& toPrint) {
+    std::scoped_lock Guard(LogLock);
+    std::string Print = getDate() + ("[WARN] ") + toPrint + "\n";
+    ConsoleOut(Print);
+    addToLog(Print);
+}
+void error(const std::string& toPrint) {
+    std::scoped_lock Guard(LogLock);
+    std::string Print = getDate() + ("[ERROR] ") + toPrint + "\n";
+    ConsoleOut(Print);
+    addToLog(Print);
+}
+void except(const std::string& toPrint) {
+    std::scoped_lock Guard(LogLock);
+    std::string Print = getDate() + ("[EXCEP] ") + toPrint + "\n";
+    ConsoleOut(Print);
+    addToLog(Print);
+}

src/logger.h

@@ -1,41 +0,0 @@
-//
-// Created by jojos38 on 28.01.2020.
-//
-
-#ifndef LOGGER_H
-#define LOGGER_H
-
-#include <iostream>
-#include <ctime>
-#include <sstream>
-#include <string.h>
-using namespace std;
-
-extern int loggerlevel;
-stringstream getDate();
-void setLoggerLevel(char level_string[]);
-
-template<typename T>
-void info(const T& toPrint) {
-	if (loggerlevel <= 2)
-		cout << getDate().str() << "[INFO] " << toPrint << endl;
-}
-template<typename T>
-void error(const T& toPrint) {
-    if (loggerlevel <= 4)
-        cout << getDate().str() "[ERRO] " << toPrint << endl;
-}
-
-template<typename T>
-void warn(const T& toPrint) {
-    if (loggerlevel <= 3)
-        cout << getDate().str() << "[WARN] " << toPrint << endl;
-}
-
-template<typename T>
-void debug(const T& toPrint) {
-    if (loggerlevel <= 1)
-        cout << getDate().str() << "[DBUG] " << toPrint << endl;
-}
-
-#endif // LOGGER_H

src/main.cpp

@@ -1,46 +1,54 @@
-//
-// Created by Anonymous275 on 28.01.2020.
-//
-
-#include "main.h"
-#include <iostream>
-#include <string>
-#include "enet/enet.h"
-#include "network.h"
-#include "logger.h"
-
-using namespace std; //nameSpace STD
-
-void DebugData();
-void ParseConfig();
-
-bool Debug = false;
-int Port = 30813;
-string MapName = "levels/gridmap/level.json";
-string ServerName = "BeamNG-MP FTW";
-
-//Entry
-int main() {
-    ParseConfig();
-    if(Debug){ //checks if debug is on
-        DebugData(); //Prints Debug Data
-    }
-    setLoggerLevel("ALL");
-    startRUDP("localhost", 30814);
-}
-
-
-void DebugData(){
-    cout << "Debug : true" << "\n";
-    cout << "Port : " << Port << "\n";
-    cout << "MapName : " << MapName << "\n";
-    cout << "ServerName : " << ServerName << "\n";
-}
-
-void SetMainValues(bool D, int P,string Name,string serverName){
-    Debug = D;
-    Port = P;
-    MapName = Name;
-    ServerName = serverName;
-}
-
+#include "CustomAssert.h"
+
+#include "Startup.h"
+#include <curl/curl.h>
+#include <iostream>
+#include <thread>
+#ifndef WIN32
+#include <csignal>
+void UnixSignalHandler(int sig) {
+    switch (sig) {
+    case SIGPIPE:
+        warn(("ignored signal SIGPIPE: Pipe broken"));
+        break;
+    default:
+        error(("Signal arrived in handler but was not handled: ") + std::to_string(sig));
+        break;
+    }
+}
+#endif // WIN32
+
+[[noreturn]] void loop() {
+    DebugPrintTID();
+    while (true) {
+        std::cout.flush();
+        std::this_thread::sleep_for(std::chrono::milliseconds(600));
+    }
+}
+
+int main(int argc, char* argv[]) {
+#ifndef WIN32
+    // ignore SIGPIPE, the signal that is sent for example when a client
+    // disconnects while data is being sent to him ("broken pipe").
+    signal(SIGPIPE, UnixSignalHandler);
+#endif // WIN32
+    DebugPrintTID();
+    // curl needs to be initialized to properly deallocate its resources later
+    [[maybe_unused]] auto ret = curl_global_init(CURL_GLOBAL_DEFAULT);
+    Assert(ret == CURLE_OK);
+#ifdef DEBUG
+    std::thread t1(loop);
+    t1.detach();
+#endif
+    ConsoleInit();
+    InitServer(argc, argv);
+    InitConfig();
+    InitLua();
+    InitRes();
+    HBInit();
+    StatInit();
+    NetMain();
+    // clean up curl at the end to be sure
+    curl_global_cleanup();
+    return 0;
+}

src/main.h

@@ -1,12 +0,0 @@
-//
-// Created by Антон on 28.01.2020.
-//
-
-#ifndef BEAMNG_MP_SERVER_MAIN_H
-#define BEAMNG_MP_SERVER_MAIN_H
-
-class main {
-
-};
-
-#endif //BEAMNG_MP_SERVER_MAIN_H

src/network.cpp

@@ -1,68 +0,0 @@
-//
-// Created by jojos38 on 28.01.2020.
-//
-
-#include <iostream>
-#include "network.h"
-#include "logger.h"
-using namespace std;
-#define EXIT_SUCCESS /*implementation defined*/
-#define EXIT_FAILURE /*implementation defined*/
-
-void listen();
-
-ENetAddress address;
-ENetHost* server;
-ENetEvent event;
-
-void startRUDP(char host[], int port) {
-    // ---------- Initializing ENet ---------- //
-    if (enet_initialize() != 0) {
-        fprintf(stderr, "An error occurred while initializing ENet.\n");
-        return EXIT_FAILURE;
-    }
-    atexit(enet_deinitialize);
-    info("ENet initialized");
-
-    // ---------- Starting server ---------- //
-    enet_address_set_host(&address, host); // Set host
-    address.port = port; // Set port
-    server = enet_host_create(
-        &address /* the address to bind the server host to */,
-        32      /* allow up to 32 clients and/or outgoing connections */,
-        2      /* allow up to 2 channels to be used, 0 and 1 */,
-        0      /* assume any amount of incoming bandwidth */,
-        0      /* assume any amount of outgoing bandwidth */);
-    if (server == NULL) {
-        fprintf(stderr, "An error occurred while trying to create an ENet server host.\n");
-        return EXIT_FAILURE;
-    }
-    info("Server started");
-    listen();
-}
-
-void listen() {
-    info("Listening for packets...");
-    while (true) {
-        switch (event.type) {
-            case ENET_EVENT_TYPE_CONNECT:
-                printf("A new client connected from %x:%u.\n", event.peer->address.host, event.peer->address.port);
-                /* Store any relevant client information here. */
-                event.peer->data = "Client information";
-                break;
-            case ENET_EVENT_TYPE_RECEIVE:
-                printf("A packet of length %u containing %s was received from %s on channel %u.\n",
-                    event.packet->dataLength,
-                    event.packet->data,
-                    event.peer->data,
-                    event.channelID);
-                /* Clean up the packet now that we're done using it. */
-                enet_packet_destroy(event.packet);
-                break;
-            case ENET_EVENT_TYPE_DISCONNECT:
-                printf("%s disconnected.\n", event.peer->data);
-                /* Reset the peer's client information. */
-                event.peer->data = NULL;
-        }
-    }
-}

src/network.h

@@ -1,15 +0,0 @@
-//
-// Created by jojos38 on 28.01.2020.
-//
-
-#ifndef NETWORK_H
-#define NETWORK_H
-
-#include "enet/enet.h"
-#pragma comment(lib,"ws2_32.lib")
-#pragma comment(lib,"winmm.lib")
-#pragma comment(lib,"enet.lib")
-
-void startRUDP(char host[], int port);
-
-#endif // NETWORK_H