RcfSession.hpp

Go to the documentation of this file.

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2023, Delta V Software. All rights reserved.
// https://www.deltavsoft.com
//
// RCF is distributed under dual licenses - closed source or GPL.
// Consult your particular license for conditions of use.
//
// If you have not purchased a commercial license, you are using RCF under GPL terms.
//
// Version: 3.4
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************


#ifndef INCLUDE_RCF_RCFSESSION_HPP
#define INCLUDE_RCF_RCFSESSION_HPP

#include <vector>
#include <functional>
#include <memory>
#include <typeinfo>

#include <RCF/Any.hpp>
#include <RCF/Export.hpp>
#include <RCF/MethodInvocation.hpp>
#include <RCF/RcfFwd.hpp>
#include <RCF/SerializationProtocol.hpp>
#include <RCF/Tchar.hpp>

#if RCF_FEATURE_FILETRANSFER==1
#include <RCF/FileSystem.hpp>
#endif

#if RCF_FEATURE_SSPI==1
#include <wincred.h>
#endif

namespace RCF {


    struct TypeInfoCompare
    {
        bool operator()(
            const std::type_info* lhs,
            const std::type_info* rhs) const
        { 
            if (lhs->before(*rhs))
            {
                return true;
            }
            return false;
        }
    };

    RCF_EXPORT RcfSession &         getCurrentRcfSession();

    class RCF_EXPORT RcfSession : 
        public std::enable_shared_from_this<RcfSession>
    {
    public:

        RcfSession(RcfServer &server);
        ~RcfSession();

        typedef std::function<void(RcfSession&)> OnWriteCompletedCallback;
        typedef std::function<void(RcfSession&)> OnWriteInitiatedCallback;
        typedef std::function<void(RcfSession&)> OnDestroyCallback;

        typedef std::map<const std::type_info *, Any, TypeInfoCompare> SessionObjectMap;
        SessionObjectMap mSessionObjects;

    private:

        template<typename T>
        T * getSessionObjectImpl(bool createIfDoesntExist)
        {
            typedef std::shared_ptr<T> TPtr;

            const std::type_info & whichType = typeid(T);
            const std::type_info * pWhichType = &whichType;

            SessionObjectMap::iterator iter = mSessionObjects.find(pWhichType);
            if (iter != mSessionObjects.end())
            {
                Any & a = iter->second;
                TPtr & tPtr = a.get<TPtr>();
                RCF_ASSERT(tPtr.get());
                return tPtr.get();
            }
            else if (createIfDoesntExist)
            {
                TPtr tPtr( new T() );
                mSessionObjects[pWhichType] = tPtr;
                return tPtr.get();
            }
            else
            {
                return NULL;
            }
        }

    public:



        template<typename T>
        void deleteSessionObject()
        {
            typedef std::shared_ptr<T> TPtr;

            const std::type_info & whichType = typeid(T);
            const std::type_info * pWhichType = &whichType;

            SessionObjectMap::iterator iter = mSessionObjects.find(pWhichType);
            if (iter != mSessionObjects.end())
            {
                mSessionObjects.erase(iter);
            }
        }

        template<typename T>
        T & createSessionObject()
        {
            deleteSessionObject<T>();
            T * pt = getSessionObjectImpl<T>(true);
            RCF_ASSERT(pt);
            if ( !pt )
            {
                RCF_THROW(Exception(RcfError_SessionObjectNotCreated, typeid(T).name()));
            }
            return *pt; 
        }

        template<typename T>
        T & getSessionObject(bool createIfDoesntExist = false)
        {
            T * pt = getSessionObjectImpl<T>(createIfDoesntExist);
            if (!pt)
            {
                RCF_THROW(Exception(RcfError_SessionObjectDoesNotExist, typeid(T).name()));
            }
            return *pt; 
        }

        template<typename T>
        T * querySessionObject()
        {
            T * pt = getSessionObjectImpl<T>(false);
            return pt;
        }


        RcfServer &     getRcfServer();

        void            disconnect();

        RcfClientPtr    getDefaultStubEntryPtr();
        void            setDefaultStubEntryPtr(RcfClientPtr stubEntryPtr);
        void            setCachedStubEntryPtr(RcfClientPtr stubEntryPtr);

        
        void            setRequestUserData(const std::string & userData);

        std::string     getRequestUserData();

        void            setResponseUserData(const std::string & userData);

        std::string     getResponseUserData();



        std::uint32_t   getRuntimeVersion();

        void            setRuntimeVersion(std::uint32_t version);

        std::uint32_t   getArchiveVersion();

        void            setArchiveVersion(std::uint32_t version);

        const RemoteAddress &
                        getClientAddress();

        bool            isOneway();

        std::uint32_t   getPingBackIntervalMs();

        tstring         getClientUserName();

        TransportProtocol 
                        getTransportProtocol();

        TransportType   getTransportType();

#if RCF_FEATURE_SSPI==1

        PCtxtHandle     getTransportSecurityContext() const;

        PCtxtHandle     getTransportProtocolSecurityContext() const;

#endif

        bool            getEnableCompression();

        CertificatePtr  getClientCertificatePtr();

        RemoteCallInfo  getRemoteCallRequest() const;

        time_t          getConnectedAtTime() const;

        std::size_t     getConnectionDuration() const;

        std::size_t     getRemoteCallCount() const;

        std::uint64_t   getTotalBytesReceived() const;

        std::uint64_t   getTotalBytesSent() const;

        void            setEnableSfPointerTracking(bool enable);

        bool            getEnableSfPointerTracking() const;



#if RCF_FEATURE_FILETRANSFER==1

        // RCF3 file API


        std::string         configureDownload(const Path& downloadPath, BandwidthQuotaPtr quotaPtr = nullptr);

        void                setAllowUploads(bool allowUploads);

        bool                getAllowUploads() const;

        void                setUploadBandwidthQuota(BandwidthQuotaPtr quotaPtr);

        BandwidthQuotaPtr   getUploadBandwidthQuota() const;

        Path                getUploadPath(const std::string& uploadId);
        

#endif

        //*******************************
        // callback tables - synchronized

        // may well be called on a different thread than the one that executed the remote call
        void addOnWriteCompletedCallback(
            const OnWriteCompletedCallback &        onWriteCompletedCallback);

        void extractOnWriteCompletedCallbacks(
            std::vector<OnWriteCompletedCallback> & onWriteCompletedCallbacks);

        void setOnDestroyCallback(
            OnDestroyCallback                       onDestroyCallback);

        //*******************************

        void            setEnableNativeWstringSerialization(bool enable);
        bool            getEnableNativeWstringSerialization() const;

        void            getMessageFilters(std::vector<FilterPtr> &filters) const;
        void            getTransportFilters(std::vector<FilterPtr> &filters) const;

        void            lockTransportFilters();
        void            unlockTransportFilters();
        bool            transportFiltersLocked();

        SerializationProtocolIn &   getSpIn();
        SerializationProtocolOut &  getSpOut();

        bool                        getFiltered();
        void                        setFiltered(bool filtered);

        std::vector<FilterPtr> &    getFilters();

        void            setCloseSessionAfterWrite(bool close);



        std::uint32_t   getPingTimestamp();
        void            setPingTimestamp();

        std::uint32_t   getPingIntervalMs();
        void            setPingIntervalMs(std::uint32_t pingIntervalMs);

        std::uint32_t   getTouchTimestamp();
        bool            getCallInProgress();

        void            touch();
        void            setCallInProgress(bool callInProgress);

        void            sendPingBack();
        bool            getAutoSend();

        void            setWeakThisPtr();

        void            cancelDownload();

#if RCF_FEATURE_FILETRANSFER==1

        void            addDownloadStream(
                            std::uint32_t sessionLocalId, 
                            FileStream fileStream);

#endif

        Mutex                                   mStopCallInProgressMutex;
        bool                                    mStopCallInProgress;
        
    private:

        template<
            typename R, 
            typename A1, 
            typename A2, 
            typename A3, 
            typename A4, 
            typename A5, 
            typename A6, 
            typename A7, 
            typename A8, 
            typename A9, 
            typename A10, 
            typename A11, 
            typename A12, 
            typename A13, 
            typename A14, 
            typename A15>
        friend class AllocateServerParameters;

        template<
            typename R, 
            typename A1, 
            typename A2, 
            typename A3,
            typename A4,
            typename A5, 
            typename A6, 
            typename A7, 
            typename A8, 
            typename A9, 
            typename A10, 
            typename A11, 
            typename A12, 
            typename A13, 
            typename A14, 
            typename A15>
        friend class ServerParameters;

        friend class PingBackService;
        friend class FilterService;

        friend class StubAccess;

        RcfServer &                             mRcfServer;

        Mutex                                   mMutex;
        std::vector<OnWriteCompletedCallback>   mOnWriteCompletedCallbacks;
        std::vector<OnWriteInitiatedCallback>   mOnWriteInitiatedCallbacks;
        OnDestroyCallback                       mOnDestroyCallback;

        std::uint32_t                           mRuntimeVersion;
        std::uint32_t                           mArchiveVersion;

        bool                                    mEnableSfPointerTracking;
        
        bool                                    mTransportFiltersLocked;

        bool                                    mEnableNativeWstringSerialization = false;

        SerializationProtocolIn                 mIn;
        SerializationProtocolOut                mOut;

        // message filters
        std::vector<FilterPtr>                  mFilters;
        bool                                    mFiltered;

        MethodInvocationRequest                 mRequest;

        bool                                    mCallInProgress = false;
        bool                                    mCloseSessionAfterWrite;
        std::uint32_t                           mPingTimestamp;
        std::uint32_t                           mPingIntervalMs;
        std::uint32_t                           mTouchTimestamp;
        ByteBuffer                              mPingBackByteBuffer;
        PingBackTimerEntry                      mPingBackTimerEntry;

        Mutex                                   mIoStateMutex;
        bool                                    mWritingPingBack;
        std::vector<ByteBuffer>                 mQueuedSendBuffers;

        void clearParameters();

        void onReadCompleted();
        void onWriteCompleted();

        void processRequest();

        void processOob_RequestTransportFilters(OobMessage& msg);
        void processOob_CreateCallbackConnection(OobMessage& msg);
        void processOob_RequestSubscription(OobMessage& msg);
        void processOob_RequestProxyConnection(OobMessage& msg);
        void processOobMessages();
        
        void callServant();
        
        void sendResponse();
        void sendResponseException(const std::exception &e);
        void sendResponseUncaughtException();

        void encodeRemoteException(
            SerializationProtocolOut & out, 
            const RemoteException & e);

        void sendSessionResponse(); 

        void registerForPingBacks();
        void unregisterForPingBacks();

        void verifyTransportProtocol(RCF::TransportProtocol protocol);

        friend class RcfServer;
        friend class RemoteCallContextImpl;

        I_Parameters *                          mpParameters;
        std::vector<char>                       mParametersVec;

        // For individual parameters.
        std::vector< std::vector<char> >        mParmsVec;

        bool                                    mAutoSend;

        RcfSessionWeakPtr                       mWeakThisPtr;

    private:

        // UdpServerTransport needs to explicitly set mIoState to Reading,
        // since it doesn't use async I/O with callbacks to RcfServer.
        friend class UdpServerTransport;
        friend class UdpNetworkSession;
        friend class FileStreamImpl;

        friend class AsioNetworkSession;
        void runOnDestroyCallbacks();

#if RCF_FEATURE_FILETRANSFER==1

    private:

        friend class FileTransferService;

        FileDownloadInfoPtr                     mDownloadInfoPtr;
        FileUploadInfoPtr                       mUploadInfoPtr;

        typedef std::map<std::uint32_t, FileUploadInfoPtr> SessionUploads;
        typedef std::map<std::uint32_t, FileDownload> SessionDownloads;

        SessionUploads                          mSessionUploads;
        SessionDownloads                        mSessionDownloads;

#endif

    private:

        RcfClientPtr                            mDefaultStubEntryPtr;
        RcfClientPtr                            mCachedStubEntryPtr;

    public:
        NetworkSession & getNetworkSession() const;
        void setNetworkSession(NetworkSession & networkSession);

#if RCF_FEATURE_HTTP==1

        void getHttpFrameInfo(
            std::string&                                            requestLine, 
            std::vector< std::pair<std::string, std::string> >&     headers);

#endif

    private:
        friend class HttpSessionFilter;
        NetworkSession * mpNetworkSession;

    public:
        std::string mCurrentCallDesc;

    public:

        bool getIsCallbackSession() const;
        void setIsCallbackSession(bool isCallbackSession);

        bool isConnected() const;

    private:

        void setConnectedAtTime(time_t connectedAtTime);

        friend class SspiServerFilter;
        friend class Win32NamedPipeNetworkSession;

        tstring                 mClientUsername;
        TransportProtocol       mTransportProtocol;
        bool                    mEnableCompression;

        bool                    mTransportProtocolVerified;
        bool                    mIsCallbackSession;

        time_t                  mConnectedAtTime;

        std::size_t             mRemoteCallCount;        
    };       

} // namespace RCF

#endif // ! INCLUDE_RCF_RCFSESSION_HPP