cNetServer.h

Go to the documentation of this file.

//
//
#ifndef _INC_cNetServer_H
#define _INC_cNetServer_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetStream.h"
#include "cProtocol.h"
#include "../Thread/cThread.h"
#include "../Math/cValueStats.h"
#include "GrayCore/include/cThreadArray.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetServer);
 
        class cNetServer;
        class cNetServerGroup;
        class cNetSocketSet;
 
        class GRAYLIB_LINK cNetServerPort : public cRefBase
        {
 
        public:
                cNetAddress m_SockAddr;                         
                cProtocolFactories m_Factories;         
                cNetSocket m_Socket;                            
 
        public:
                cNetServerPort();
                cNetServerPort(const cNetAddress& rSockAddr);
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        return m_Socket.get_HashCode();
                }
 
                HRESULT SetAddress(const cNetAddress& rSockAddr);
                HRESULT CreateBindAndListen();
        };
        typedef cRefPtr<cNetServerPort> cNetServerPortPtr;
 
        class GRAYLIB_LINK cNetServerConnection : public cRefBase, public cNetStream, public IUnkObject
        {
 
                typedef cNetStream SUPER_t;
 
        public:
                cNetServerGroup* m_pServerGroup;                
                cNetServerPortPtr m_pListenPort;                
 
                const cNetAddress m_addrPeer;                   
                // cNetAddrTrackPtr m_pAddrTracker;             //!< Track m_addrPeer across all sessions. Watch out for DoS attacks.
 
                cProtocolStreamPtr m_pProtocol;                 
 
        public:
                cNetServerConnection(cNetServerGroup* pServerGroup, cNetServerPort* pListenPort, SOCKET hSocket, const cNetAddress& addrPeer, cProtocolStream* pProtocol = nullptr);
                virtual ~cNetServerConnection();
 
                const char* get_ServerName() const;
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        return cNetStream::get_HashCode();
                }
                STDMETHOD_(HASHCODE_t, get_HashCodeX)() const noexcept override
                {
                        return cNetStream::get_HashCode();
                }
                STDMETHOD_(cString, get_Name)() const override;
                STDMETHOD_(cStringA, get_SymName)() const
                {
                        return StrArg<char>(get_HashCode(), (RADIX_t)0x10);
                }
 
                HRESULT ProcessStreamInp();
 
                // cNetStream
                virtual HRESULT onEventRead() override;
                virtual HRESULT OnTickStream();
#ifdef _WIN32
                virtual void OnClose() override;
#endif
                virtual void Close() override;
 
                IUNKNOWN_DISAMBIG(cRefBase);
        };
        typedef cRefPtr<cNetServerConnection> cNetServerConnectionPtr;
 
        class GRAYLIB_LINK cNetServerGroup : public cStreamStats
        {
 
        public:
                cNetServer& m_server;                                   
                cValueStatsRate<float> m_TickLatency;   
 
        protected:
                cThreadLockArrayHash<cNetServerConnection> m_aConnections;                      
 
        protected:
                HRESULT OnClientWrite(cNetServerConnection* pClient);
                virtual HRESULT OnClientRead(cNetServerConnection* pClient);
                HRESULT OnTickSelect(TIMESYSD_t tWaitMax, cNetSocketSet& readfds, cNetSocketSet& writefds);
                virtual void OnTickClients();
 
        public:
                cNetServerGroup(cNetServer& server);
                virtual ~cNetServerGroup();
 
                const char* get_ServerName() const;
 
                ITERATE_t get_ClientQty() const
                {
                        return m_aConnections.GetSize();
                }
 
                bool RemoveClient(cNetServerConnection* pClient);
                void MoveClientToGroup(cNetServerConnection* pClient);
                void MoveClientToClose(cNetServerConnection* pClient);
        };
 
        class GRAYLIB_LINK cNetServerThread : public cNetServerGroup, public cThreadNamed<cNetServerThread>
        {
                typedef cThreadNamed<cNetServerThread> SUPER_t;
        protected:
                virtual bool ThreadTick() override;
        public:
                cNetServerThread(cNetServer& server);
                UINT get_LoadScore() const;
        };
        typedef cRefPtr<cNetServerThread> cNetServerThreadPtr;
 
        class GRAYLIB_LINK cNetServer : public cProtocolFactories, public cNetServerGroup
        {
 
                typedef cProtocolFactories SUPER_t;
                friend class cNetServerGroup;
 
        public:
                const char* m_pszServerName;            
                const bool m_bAsyncEvents;                      
 
                int m_nMaxConnections;                  
                int m_nMaxPerAddr;                              
                int m_nMaxPerAddrUnresolved;    
 
        protected:
                cNetSystemPtr m_NetSystem;              
 
                cArrayRef<cNetServerThread> m_aThreads;                         
                cArraySortHash<cNetServerConnection> m_aConnecting;             
                cThreadLockArrayHash<cNetServerConnection> m_aClosing;  
                cArraySortHash<cNetServerPort> m_aListenPorts;                  
 
        protected:
                void OnClientCloseComplete();
 
                HRESULT TestProtocolClient(cNetServerConnection* pClient);
                HRESULT OnEventAccept(cNetServerPort* pListenPort, LSTATUS wError);
 
                HRESULT OnClientConnect(cNetServerConnection* pClient);
                virtual HRESULT OnClientReady(cNetServerConnection* pClient);
                virtual void OnClientClose(cNetServerConnection* pClient);
 
                virtual HRESULT OnClientRead(cNetServerConnection* pClient) override;
 
        public:
                cNetServer(const char* pszName = "NetServer", bool bAsyncEvents = false);
                virtual ~cNetServer();
 
                const char* get_ServerName() const noexcept
                {
                        return m_pszServerName;
                }
 
                ITERATE_t get_ConnectionQty() const noexcept
                {
                        return m_aListenPorts.GetSize() + m_aConnections.GetSize() + m_aConnecting.GetSize();
                }
 
                HRESULT AddListenPort(cNetServerPort* pServerPort);
                HRESULT AddListenPort(const cNetAddress& SockAddr);
                HRESULT AddListenPort2(const cNetAddress& SockAddr, OUT cNetServerPortPtr* ppServerPort = nullptr);
                bool RemoveListenPort(cNetServerPort* pServerPort);
 
                ITERATE_t get_ListenPortQty() const noexcept
                {
                        return m_aListenPorts.GetSize();
                }
                cNetServerPortPtr EnumListenPort(ITERATE_t i) const
                {
                        ASSERT(m_aListenPorts.IsValidIndex(i));
                        return m_aListenPorts[i];
                }
 
                HRESULT CreateServerStream(const cNetAddress& addr, IProtocolFactory& pf, cNetServerConnectionPtr& rpStream);
                virtual HRESULT CheckAddressBeforeAccept(const cNetAddress& Addr) const;
 
#ifdef _WIN32
                bool OnEvent(SOCKET hSocket, WORD wEvent, LSTATUS wError);              // called from HWND notifications. FD_READ FD_WRITE
#endif
 
                bool InitServer();
                void CloseServer();
 
                virtual void OnTickClients() override;
                void OnTickServer(TIMESYSD_t tWaitMax = 0);
 
                UNITTEST_FRIEND(cNetServer);
        };
 
}
#endif