RCFProto.hpp

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2013, Delta V Software. All rights reserved.
// http://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: 2.0
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************

#pragma once

#include <RCF/GoogleProtobufs.hpp>

#include <RCF/RCF.hpp>
#include <RCF/ClientStub.hpp>
#include <RCF/Exception.hpp>
#include <RCF/Export.hpp>
#include <RCF/RemoteCallContext.hpp>

#if RCF_FEATURE_OPENSSL==1
#include <RCF/OpenSslEncryptionFilter.hpp>
#else
namespace RCF {
    class RCF_EXPORT PemCertificate : public Certificate
    {
    public:
        PemCertificate(const std::string & pathToCert, const std::string & password = "")
        {
            RCF_THROW(Exception(_RcfError_NotSupportedInThisBuild("PemCertificate")));
        }
    };
    class RCF_EXPORT X509Certificate : public Certificate
    {
    public:
        X509Certificate()
        {
            RCF_THROW(Exception(_RcfError_NotSupportedInThisBuild("X509Certificate")));
        }
        std::string getCertificateName()        { return "";}
        std::string getIssuerName()             { return ""; }

    };
} // namespace RCF
#endif

#if RCF_FEATURE_SSPI==1
#include <RCF/Schannel.hpp>
#endif

#if RCF_FEATURE_NAMEDPIPE==1
#include <RCF/Win32NamedPipeEndpoint.hpp>
#endif

#if RCF_FEATURE_LOCALSOCKET==1
#include <RCF/UnixLocalEndpoint.hpp>
#endif

#ifdef BOOST_WINDOWS

// On Windows, stub out some Unix-only functionality.
namespace RCF {

    class RCF_EXPORT UnixLocalEndpoint : public Endpoint
    {
    public:
        UnixLocalEndpoint(const std::string & socketName)                       { RCF_THROW(Exception(_RcfError_NotSupportedOnWindows("UnixLocalEndpoint"))); }

        virtual std::auto_ptr<ServerTransport>  createServerTransport() const   { return std::auto_ptr<ServerTransport>(); }
        virtual std::auto_ptr<ClientTransport>  createClientTransport() const   { return std::auto_ptr<ClientTransport>(); }
        virtual EndpointPtr                     clone() const                   { return EndpointPtr(); }
        virtual std::string                     asString() const                { return std::string(); }
    };

} // namespace RCF

#else

// On Unix, stub out some Windows-only functionality.
namespace RCF {

    class RCF_EXPORT LogToDebugWindow : public LogTarget
    {
    public:
        LogToDebugWindow()
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("LogToDebugWindow"));
            RCF_THROW(e);
        }
        virtual LogTarget * clone() const { return NULL; }
        virtual void write(const RCF::ByteBuffer & output) {}
    };

    class RCF_EXPORT LogToEventLog : public LogTarget
    {
    public:
        LogToEventLog(const std::string & appName, int eventLogLevel)
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("LogToEventLog"));
            RCF_THROW(e);
        }
        virtual LogTarget * clone() const { return NULL; }
        virtual void write(const RCF::ByteBuffer & output) {}
    };

    class RCF_EXPORT Win32NamedPipeEndpoint : public Endpoint
    {
    public:
        Win32NamedPipeEndpoint(const tstring & pipeName)                        { RCF_THROW(Exception(_RcfError_SupportedOnWindowsOnly("Win32NamedPipeEndpoint"))); }

        virtual std::auto_ptr<ServerTransport>  createServerTransport() const   { return std::auto_ptr<ServerTransport>(); }
        virtual std::auto_ptr<ClientTransport>  createClientTransport() const   { return std::auto_ptr<ClientTransport>(); }
        virtual EndpointPtr                     clone() const                   { return EndpointPtr(); }
        virtual std::string                     asString() const                { return std::string(); }
    };

    class RCF_EXPORT Win32Certificate : public Certificate
    {
    public:
        Win32Certificate()
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("Win32Certificate"));
            RCF_THROW(e);
        }

        virtual CertificateImplementationType _getType()
        {
            return Cit_Win32;
        }

        tstring getCertificateName()                            { return tstring(); }
        tstring getIssuerName()                                 { return tstring(); }
        void exportToPfx(const std::string & pfxFilePath)       {}

        Win32CertificatePtr findRootCertificate(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore)                    { return Win32CertificatePtr(); }

        // *** SWIG END ***
    };

    class RCF_EXPORT PfxCertificate : public Win32Certificate
    {
    public:

        PfxCertificate(
            const std::string & pathToCert, 
            const tstring & password,
            const tstring & certName)
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("PfxCertificate"));
            RCF_THROW(e);
        }

        void addToStore(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore)                    {}
    };

    class RCF_EXPORT StoreCertificate  : public Win32Certificate
    {
    public:

        StoreCertificate(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore,
            const tstring & certName)
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("StoreCertificate"));
            RCF_THROW(e);
        }

        void removeFromStore()                                  {}

    };

    class RCF_EXPORT StoreCertificateIterator
    {
    public:

        StoreCertificateIterator(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore)
        {
            Exception e(_RcfError_SupportedOnWindowsOnly("StoreCertificateIterator"));
            RCF_THROW(e);
        }

        bool moveNext()                                         { return false; }
        void reset()                                            {}
        Win32CertificatePtr current()                           { return Win32CertificatePtr(); }
    };

} // namespace RCF

#endif // ! BOOST_WINDOWS

using namespace google::protobuf;
using namespace RCF;

namespace RCF {

class RcfProtoChannel;
class RcfProtoSession;

class RCF_EXPORT RcfProtoController : public RpcController
{
public:

    virtual void Reset();

    virtual bool Failed() const;

    virtual std::string ErrorText() const;

    virtual void StartCancel();

    // Server-side methods ---------------------------------------------

    // These calls may be made from the server side only.  Their results
    // are undefined on the client side (may crash).

    virtual void SetFailed(const std::string& reason);

    virtual bool IsCanceled() const;

    virtual void NotifyOnCancel(Closure* callback);

    RcfProtoController();
    RcfProtoController(RcfProtoSession * context);

    RcfProtoSession * getSession();
    RcfProtoChannel * getChannel();

private:

    friend class RcfProtoChannel;
    friend class RcfProtoServer;

    RcfProtoChannel *            mpRcfChannel;
    RcfProtoSession *            mpRcfContext;
};


//------------------------------------------------------------------------------
// Client side implementation

class I_Pb;
template<typename T> class RcfClient;

class RcfProtoServer;
class RcfProtoSession;

class RCF_EXPORT _SwigCallbackArgs
{
public:

    // *** SWIG BEGIN ***

    std::string mErrorString;

    CertificatePtr mCertificatePtr;

    // *** SWIG END ***

};

class RCF_EXPORT _SwigCallback
{
public:

    // *** SWIG BEGIN ***

    _SwigCallback();
    virtual ~_SwigCallback();

    // Run client-side RPC completion handler.
    virtual void Run();

    // Run server-side RPC server implementation.
    virtual void ProtoRpcBegin(
        _SwigCallbackArgs * args,
        RcfProtoServer * server,
        RcfProtoSession * context, 
        const std::string & serviceName, 
        int methodId);

    // Certificate validation callback.
    virtual bool ValidateCertificate(
        _SwigCallbackArgs * args);

    // *** SWIG END ***

};

class _SwigCallbackCpp : public _SwigCallback
{
public:
    _SwigCallbackCpp(RcfProtoChannel & channel);
    virtual void Run();

private:
    RcfProtoChannel & mChannel;
};

class RCF_EXPORT RcfProtoChannel : public RpcChannel
{
public:

    // For C#.
    void _CallMethodSwig(
        const std::string&          serviceName, 
        int                         methodId, 
        unsigned char *             szBuffer, 
        int                         szBufferLen,
        _SwigCallback *              closure);

    int _GetResponseBufferLength() const;
    void _GetResponseBuffer(unsigned char * szBuffer, int bufferLen) const;

    // For Java.
    void _CallMethodSwig(
        const std::string&          serviceName, 
        int                         methodId, 
        char *                      szBuffer, 
        size_t                      szBufferLen,
        _SwigCallback *              closure);

    void _GetResponseBuffer(char * szBuffer, size_t bufferLen) const;


    // *** SWIG BEGIN ***

    RcfProtoChannel(const RCF::Endpoint & endpoint);

    void _CallMethodSwig_WithCopy(
        const std::string&          serviceName, 
        int                         methodId, 
        const std::string&          strBuffer, 
        _SwigCallback *              closure);

    std::string _GetResponseBuffer_WithCopy() const;

    // Controller interface.

    bool Failed();

    std::string ErrorText();

    void StartCancel();

    // RCF specific functionality.

    void connect();

    void disconnect();

    void setRemoteCallTimeoutMs(unsigned int remoteCallTimeoutMs);

    unsigned int getRemoteCallTimeoutMs() const;

    void setConnectTimeoutMs(unsigned int connectTimeoutMs);

    unsigned int getConnectTimeoutMs() const;

    void setTransportProtocol(RCF::TransportProtocol protocol);

    RCF::TransportProtocol getTransportProtocol();

    void setEnableAsynchronousRpc(bool enable);

    bool getEnableAsynchronousRpc();


    void setPingBackIntervalMs(int pingBackIntervalMs);

    int getPingBackIntervalMs();

    void setHttpProxy(const std::string & httpProxy);

    std::string getHttpProxy();

    void setHttpProxyPort(int httpProxyPort);

    int getHttpProxyPort();

    TransportType getTransportType();

    void setUsername(const tstring & username);

    tstring getUsername();      

    void setPassword(const tstring & password);

    tstring getPassword();      

    void setKerberosSpn(const tstring & kerberosSpn);

    tstring getKerberosSpn();   

    void setEnableCompression(bool enableCompression);

    bool getEnableCompression();

    void setCertificate(CertificatePtr certificatePtr);

    CertificatePtr getCertificate();

    void setCaCertificate(CertificatePtr certificatePtr);

    CertificatePtr getCaCertificate();

    void setOpenSslCipherSuite(const std::string & cipherSuite);

    std::string getOpenSslCipherSuite() const;

    void setEnableSchannelCertificateValidation(const tstring & peerName);

    tstring getEnableSchannelCertificateValidation() const;

    void _setCertificateValidationCallback(_SwigCallback * pcb);

    void setSslImplementation(SslImplementation sslImplementation);

    SslImplementation getSslImplementation() const;


    // *** SWIG END ***

    typedef ClientStub::CertificateValidationCb CertificateValidationCb;
    void setCertificateValidationCallback(CertificateValidationCb certificateValidationCb);

    const CertificateValidationCb & getCertificateValidationCallback() const;


    // Entry point from C++.
    virtual void CallMethod(
        const MethodDescriptor*     method,
        RpcController*              controller,
        const Message*              request,
        Message*                    response,
        google::protobuf::Closure*  done);

    // Common client calling code.
    void CallMethodInternal(
        const std::string &         serviceName, 
        int                         methodId, 
        RCF::ByteBuffer             requestBuffer,
        _SwigCallback *             closure);

private:

    friend  class _SwigCallbackCpp;
    _SwigCallbackCpp                        mSwigCallbackCpp;

    void onCompletionCpp();
    void onCompletion();

    boost::shared_ptr< RcfClient<I_Pb> >    mRcfClientPtr;
    
    const Message *                         mpRequest;
    Message *                               mpResponse;
    Closure *                               mpClosure;

    _SwigCallback *                         mpSwigCallback;

    boost::function<void()>                 mCompletionHandlerSwig;

    RCF::Future<RCF::ByteBuffer>            mFuture;
    RCF::Exception                          mError;
    RCF::ByteBuffer                         mResponseBuffer;

    std::string                             mRequestCopy;

    bool                                    mEnableAsynchronousRpc;
};

//------------------------------------------------------------------------------
// Server side implementation

typedef RCF::RemoteCallContext<
    RCF::ByteBuffer, 
    const std::string &, 
    int, 
    RCF::ByteBuffer> RcfProtoContext;

class RCF_EXPORT RcfProtoSession
{
public:

    RcfProtoSession(RCF::RcfSession & session);

    int _GetRequestBufferLength();

    // For C#.
    void _GetRequestBuffer(unsigned char * szBuffer, int szBufferLen);
    void _SetResponseBuffer(unsigned char * szBuffer, int szBufferLen);
    
    // For Java
    void _GetRequestBuffer(char * szBuffer, size_t szBufferLen);
    void _SetResponseBuffer(char * szBuffer, size_t szBufferLen);

    // *** SWIG BEGIN ***

    void SetFailed(const std::string& reason);

    bool IsCanceled() const;

    void _Commit(const std::string& errorMsg);
    void _Commit();

    std::string _GetRequestBuffer_WithCopy();

    void _SetResponseBuffer_WithCopy(const std::string& buffer);

    tstring getClientUsername();

    TransportProtocol getTransportProtocol();

    TransportType getTransportType();

    bool getEnableCompression();

    std::size_t getConnectionDuration() const;

    std::size_t getRemoteCallCount() const;

    boost::uint64_t getTotalBytesReceived() const;

    boost::uint64_t getTotalBytesSent() const;


    // *** SWIG END ***

    // Returns the timestamp at which the client connected.
    //time_t getConnectedAtTime() const;


    //
    void NotifyOnCancel(Closure* callback);


private:

    friend class RcfProtoServer;

    RcfSession &    mRcfSession;

    RcfProtoContext mServerContext;

    RCF::ByteBuffer mRequestBuffer;
    RCF::ByteBuffer mResponseBuffer;
};

/*
class RCF_EXPORT RcfProtoServer_Vtbl
{
public:
    RcfProtoServer_Vtbl()
    {
    }

    virtual ~RcfProtoServer_Vtbl()
    {
    }

    virtual void ProtoRpcBegin(
        RcfProtoServer * server,
        RcfProtoSession * context, 
        const std::string & serviceName, 
        int methodId)
    {

    }

};
*/

class RCF_EXPORT RcfProtoServer : public RCF::RcfServer
{
public:

    // *** SWIG BEGIN ***

    RcfProtoServer();
    RcfProtoServer(const RCF::Endpoint & endpoint);

    ~RcfProtoServer();
    
    void start();

    void stop();

    void _setCallbackTable(_SwigCallback * pCallback);

    void                    setThreadPool(ThreadPoolPtr threadPoolPtr)      { RcfServer::setThreadPool(threadPoolPtr); }

    ThreadPoolPtr           getThreadPool()                                 { return RcfServer::getThreadPool(); }

    ServerTransport &       addEndpoint(const RCF::Endpoint & endpoint) { return RcfServer::addEndpoint(endpoint); }


    void setSupportedTransportProtocols(
        const std::vector<TransportProtocol> & protocols)                   { RcfServer::setSupportedTransportProtocols(protocols); }

    const std::vector<TransportProtocol> & 
        getSupportedTransportProtocols() const                              { return RcfServer::getSupportedTransportProtocols(); }

    void setSessionTimeoutMs(boost::uint32_t sessionTimeoutMs)              { return RcfServer::setSessionTimeoutMs(sessionTimeoutMs); }

    boost::uint32_t getSessionTimeoutMs()                                   { return RcfServer::getSessionTimeoutMs(); }

    void setSessionHarvestingIntervalMs(boost::uint32_t sessionHarvestingIntervalMs) { RcfServer::setSessionHarvestingIntervalMs(sessionHarvestingIntervalMs); }

    boost::uint32_t getSessionHarvestingIntervalMs()                        { return RcfServer::getSessionHarvestingIntervalMs(); }

    void setCertificate(CertificatePtr certificatePtr)                  { RcfServer::setCertificate(certificatePtr); }

    CertificatePtr getCertificate()                                     { return RcfServer::getCertificate(); }

    void setOpenSslCipherSuite(const std::string & cipherSuite)             { RcfServer::setOpenSslCipherSuite(cipherSuite); }

    std::string getOpenSslCipherSuite() const                               { return RcfServer::getOpenSslCipherSuite(); }

    void setCaCertificate(CertificatePtr certificatePtr)                    { RcfServer::setCaCertificate(certificatePtr); }

    CertificatePtr getCaCertificate()                                   { return RcfServer::getCaCertificate(); }

    void setEnableSchannelCertificateValidation(const tstring & peerName)   { RcfServer::setEnableSchannelCertificateValidation(peerName); }

    tstring getEnableSchannelCertificateValidation() const                  { return RcfServer::getEnableSchannelCertificateValidation(); }

    // Sets the SSL implementation of the server.
    void setSslImplementation(SslImplementation sslImplementation)          { RcfServer::setSslImplementation(sslImplementation); }

    SslImplementation getSslImplementation() const                          { return RcfServer::getSslImplementation(); }

    // *** SWIG END ***

    void setCertificateValidationCallback(CertificateValidationCb certificateValidationCb)  { RcfServer::setCertificateValidationCallback(certificateValidationCb); }

    const CertificateValidationCb & getCertificateValidationCallback() const                { return RcfServer::getCertificateValidationCallback(); }


    void bindService(Service & service);

    RCF::ByteBuffer DoProtoRpc( 
        const std::string &     serviceName,
        int                     methodId,
        RCF::ByteBuffer         requestBuffer);

private:

    void ProtoRpcBeginCpp(RcfProtoSession * context, const std::string & serviceName, int methodId);
    void ProtoRpcEndCpp(Message * pResponse, RcfProtoController * controller);

    typedef std::map<std::string, Service *> ProtobufServices;
    ProtobufServices mProtobufServices; 

    _SwigCallback * mpSwigCallback;
};

class BoostBindClosure : public Closure
{
public:
    BoostBindClosure() :
        mFunc(), 
        mPermanent(true)
    {
    }

    BoostBindClosure(const boost::function<void()> & func, bool permanent = false) : 
        mFunc(func), 
        mPermanent(permanent)
    {
    }

    void assign(const boost::function<void()> & func, bool permanent = true)
    {
        mFunc = func;
        mPermanent = permanent;
    }

    void Run()
    {
        mFunc();
        if (!mPermanent)
        {
            delete this;
        }
    }

    boost::function<void()> mFunc;
    bool mPermanent;
};

} // namespace RCF