cXProtocolServer.h

Go to the documentation of this file.

//
//
#ifndef _INC_cXProtocolServer_H
#define _INC_cXProtocolServer_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cXProtocol.h"
#include "../Net/cProtocol.h"
#include "../Auth/IAuthUser.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cXProtocolServerTx
        : public cXProtocolTx
        {
        public:
                cXProtocolServerTx(cXProtocolBase& rBase, cStreamOutput* pOut);
                virtual ~cXProtocolServerTx();
 
                // Send the definitions of the cXObject i support.
                HRESULT Send_Interfaces(cXObject* pObj);
                HRESULT Send_InterfaceDef(const cScriptableInterfaceDef* pInterfaceDef);
                HRESULT Send_InterfaceDef(SCRIPTINTERFACEID_t bInterfaceID);
                HRESULT Send_InterfaceDefs(cXObject* pObj);
                HRESULT Send_InterfaceDefs(UID_t uid);
                HRESULT Send_TagDef(cAtomRef atomref);
 
                // Send actual object state data.
                HRESULT Send_PropsI(cXObject* pObj, const cScriptableInterfaceDef* pInterfaceDef);
                HRESULT Send_Props(cXObject* pObj, const cScriptableInterfaceDef* pInterfaceDef);
                HRESULT Send_Props(cXObject* pObj, SCRIPTINTERFACEID_t bInterfaceID);
                HRESULT Send_Prop(UID_t uid, SCRIPTINTERFACEID_t bInterfaceID, SCRIPTPROPID_t bPropIndex, const cVariant& vVal);
                HRESULT Send_Prop(cXObject* pObj, const cScriptableProp* pProp, const cVariant& vVal);
                HRESULT Send_PropGet(cXObject* pObj, const cScriptableProp* pProp);
                HRESULT Send_InvokeResponse(UID_t uid, SCRIPTINTERFACEID_t bInterfaceID, SCRIPTPROPID_t bMethodIndex, const cVariant& vValRet);
                HRESULT Send_InvokeResponse(cXObject* pObj, const cScriptableMethod* pMethod, const cVariant& vValRet);
                HRESULT Send_Tags(cXObject* pObj, bool bSendIfEmpty);
 
                HRESULT Send_InvokeResponseV(const cVariant& vValRet);
        };
 
        class cXProtocolFactory;
 
        class GRAYLIB_LINK cXProtocolServerStream
        : public cProtocolStream        // IUnkObject
        , public cXProtocolBase
        , public cXProtocolRx
        , public cXProtocolServerTx
        , public IAuthUser
        , public cStreamOutput
        {
 
        public:
                cTimeSys m_timePing;    
 
        protected:
                HRESULT onReq_Error();
                HRESULT onReq_Interfaces();                                     
                HRESULT onReq_InterfaceDef();                           
                HRESULT onReq_Prop();                                           
                HRESULT onReq_Props();                                          
                HRESULT onReq_Invoke();                                         
                HRESULT onReq_Tags();
                HRESULT onReq_TagDef();
                HRESULT onReq_File();
                virtual HRESULT onReq_File(const FILECHAR_t* pszReqName, size_t nFilePos);
                HRESULT onReq_Ping();
 
                virtual HRESULT onX_Error(HRESULT hResRet, const cVariant& vVal) override;
                HRESULT onSet_Prop();                   
                HRESULT onSet_Tag();                    
                HRESULT onSet_TagDef();
                HRESULT onSet_File();
 
                virtual HRESULT ProcessStreamRxMsg() override;
 
        public:
                cXProtocolServerStream(cXProtocolFactory* pProtocolFactory, IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut);
                virtual ~cXProtocolServerStream();
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        return cProtocolStream::get_HashCode();
                }
 
                // overrides
                virtual bool isClientSide() const override
                {
                        // cXProtocolBase
                        return false;
                }
                STDMETHOD_(cString, get_Name)() const override
                {
                        return cProtocolStream::get_Name();
                }
                STDMETHOD_(PLEVEL_TYPE, get_PrivLevel)() const override
                {
                        return PLEVEL_Admin;
                }
                STDMETHOD_(bool, CanBeDetectedBy)(const IAuthUser* pViewer) const override
                {
                        UNREFERENCED_PARAMETER(pViewer);
                        return true;
                }
 
                virtual HRESULT DisposeThis() override;
                virtual HRESULT ProcessStreamPacket() override;
                virtual HRESULT WriteString(const char* pszStr) override;
                virtual HRESULT OnTickStream() override;
        };
 
        class GRAYLIB_LINK cXProtocolServerStreamImpl : public cXProtocolServerStream, public cRefBase
        {
        public:
                cXProtocolServerStreamImpl(cXProtocolFactory* pProtocolFactory, IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut)
                : cXProtocolServerStream(pProtocolFactory, pServerConnection, pStreamInp, pStreamOut)
                {
                }
                IUNKNOWN_DISAMBIG(cRefBase);
        };
 
        class GRAYLIB_LINK cXProtocolFactory
        : public IProtocolFactory
        , public cXProtocolDataMgr
        {
        public:
                cXProtocolFactory();
                virtual ~cXProtocolFactory();
 
                virtual const char* get_ProtocolName() const override
                {
                        return "XProtocol";
                }
                virtual size_t get_ProtocolMaxMessageSize() const override
                {
                        return cStream::k_FILE_BLOCK_SIZE + 1024;       // k_Packet_Size_Max
                }
                virtual HRESULT TestProtocol(const BYTE* pszPrefixData, size_t iPrefixLen) const override;
                virtual cProtocolStreamPtr CreateProtocolStream(IUnkObject* pServerConnection, cStreamInput* pStreamInp, cStreamOutput* pStreamOut) override
                {
                        return new cXProtocolServerStreamImpl(this, pServerConnection, pStreamInp, pStreamOut);
                }
        };
};
#endif