Server.h

Go to the documentation of this file.

 
// cServer.h
 
// Interfaces to the cServer object representing the network server
 
 
 
 
 
#pragma once
 
#include "RCONServer.h"
#include "OSSupport/IsThread.h"
#include "OSSupport/Network.h"
 
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable:4127)
    #pragma warning(disable:4244)
    #pragma warning(disable:4231)
    #pragma warning(disable:4189)
    #pragma warning(disable:4702)
#endif
 
#include "mbedTLS++/RsaPrivateKey.h"
 
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
 
 
 
 
 
// fwd:
class cClientHandle;
typedef std::shared_ptr<cClientHandle> cClientHandlePtr;
typedef std::list<cClientHandlePtr> cClientHandlePtrs;
typedef std::list<cClientHandle *> cClientHandles;
class cCommandOutputCallback;
class cSettingsRepositoryInterface;
class cUUID;
 
 
namespace Json
{
    class Value;
}
 
 
 
 
 
// tolua_begin
class cServer
{
public:
    // tolua_end
 
    virtual ~cServer() {}
    bool InitServer(cSettingsRepositoryInterface & a_Settings, bool a_ShouldAuth);
 
    // tolua_begin
 
    const AString & GetDescription(void) const {return m_Description; }
 
    const AString & GetShutdownMessage(void) const { return m_ShutdownMessage; }
 
    // Player counts:
    size_t GetMaxPlayers(void) const { return m_MaxPlayers; }
    size_t GetNumPlayers(void) const { return m_PlayerCount; }
    void SetMaxPlayers(size_t a_MaxPlayers) { m_MaxPlayers = a_MaxPlayers; }
 
    // tolua_end
 
    bool RegisterForgeMod(const AString & a_ModName, const AString & a_ModVersion, UInt32 a_ProtocolVersionNumber);
 
    // tolua_begin
 
    void UnregisterForgeMod(const AString & a_ModName, UInt32 a_ProtocolVersionNumber);
 
    bool IsPlayerInQueue(const AString & a_Username);
 
    bool DoesAllowMultiLogin(void) { return m_bAllowMultiLogin; }
 
    // Hardcore mode or not:
    bool IsHardcore(void) const { return m_bIsHardcore; }
 
    // tolua_end
 
    bool ShouldRequireResourcePack(void) { return m_RequireResourcePack; }
 
    const AString & GetResourcePackUrl(void) { return m_ResourcePackUrl; }
 
    std::string_view GetCustomRedirectUrl(void) { return m_CustomRedirectUrl; }
 
    bool Start(void);
 
    bool Command(cClientHandle & a_Client, AString & a_Cmd);
 
    void QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
 
    void ScheduleTask(cTickTime a_DelayTicks, std::function<void(class cServer &)> a_Task);
 
    void PrintHelp(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
 
    static void BindBuiltInConsoleCommands(void);
 
    void Shutdown(void);
 
    void KickUser(int a_ClientID, const AString & a_Reason);
 
    void AuthenticateUser(int a_ClientID, AString && a_Username, const cUUID & a_UUID, Json::Value && a_Properties);
 
    const AString & GetServerID(void) const { return m_ServerID; }  // tolua_export
 
    void ClientMovedToWorld(const cClientHandle * a_Client);
 
    void PlayerCreated();
 
    void PlayerDestroyed();
 
    const AString & GetFaviconData(void) const { return m_FaviconData; }
 
    cRsaPrivateKey & GetPrivateKey(void) { return m_PrivateKey; }
    ContiguousByteBufferView GetPublicKeyDER(void) const { return m_PublicKeyDER; }
 
    bool ShouldAuthenticate(void) const { return m_ShouldAuthenticate; }  // tolua_export
 
    bool ShouldLimitPlayerBlockChanges(void) const { return m_ShouldLimitPlayerBlockChanges; }
 
    bool ShouldAllowBungeeCord(void) const { return m_ShouldAllowBungeeCord; }
 
    bool OnlyAllowBungeeCord(void) const { return m_OnlyAllowBungeeCord; }
 
    const AString & GetProxySharedSecret(void) const { return m_ProxySharedSecret; }
 
    bool ShouldAllowMultiWorldTabCompletion(void) const { return m_ShouldAllowMultiWorldTabCompletion; }
 
    const AStringMap & GetRegisteredForgeMods(const UInt32 a_Protocol);
 
private:
 
    friend class cRoot;  // so cRoot can create and destroy cServer
    friend class cServerListenCallbacks;  // Accessing OnConnectionAccepted()
 
 
 
    class cTickThread:
        public cIsThread
    {
        using Super = cIsThread;
 
    public:
 
        cTickThread(cServer & a_Server);
 
    protected:
        cServer & m_Server;
 
        // cIsThread overrides:
        virtual void Execute(void) override;
    } ;
 
 
 
    cServerHandlePtrs m_ServerHandles;
 
    cCriticalSection m_CSClients;
 
    cClientHandlePtrs m_Clients;
 
    cClientHandles m_ClientsToRemove;
 
    std::atomic_size_t m_PlayerCount;
 
    cCriticalSection m_CSPendingCommands;
    std::vector<std::pair<AString, cCommandOutputCallback *>> m_PendingCommands;
 
    int m_ClientViewDistance;  // The default view distance for clients; settable in Settings.ini
 
    bool m_bIsConnected;  // true - connected false - not connected
 
    cRsaPrivateKey m_PrivateKey;
 
    ContiguousByteBuffer m_PublicKeyDER;
 
    cRCONServer m_RCONServer;
 
    AString m_Description;
    AString m_ShutdownMessage;
    AString m_FaviconData;
    size_t m_MaxPlayers;
    bool m_bIsHardcore;
    bool m_RequireResourcePack;
    AString m_ResourcePackUrl;
    AString m_CustomRedirectUrl;
 
    std::map<UInt32, AStringMap> m_ForgeModsByVersion;
 
    bool m_bAllowMultiLogin;
 
    cTickThread m_TickThread;
 
    AString m_ServerID;
 
    bool m_ShouldAuthenticate;
 
    bool m_ShouldLimitPlayerBlockChanges;
 
    bool m_ShouldAllowBungeeCord;
 
    bool m_OnlyAllowBungeeCord;
 
    AString m_ProxySharedSecret;
 
    bool m_ShouldAllowMultiWorldTabCompletion;
 
    AStringVector m_Ports;
 
 
    cTickTimeLong m_UpTime;
 
    cCriticalSection m_CSTasks;
 
    std::vector<std::pair<std::chrono::milliseconds, std::function<void(class cServer &)>>> m_Tasks;
 
 
    cServer(void);
 
    void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
 
    AStringMap & RegisteredForgeMods(const UInt32 a_Protocol);
 
    void PrepareKeys(void);
 
    cTCPLink::cCallbacksPtr OnConnectionAccepted(const AString & a_RemoteIPAddress);
 
    void Tick(float a_Dt);
 
    void TickClients(float a_Dt);
 
    void TickCommands(void);
 
 
    void TickQueuedTasks(void);
 
 
};  // tolua_export