remote.h

 
#ifndef REMOTE_H_
#define REMOTE_H_
 
#ifdef epicsExportSharedSymbols
#   define remoteEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif
 
#include <map>
#include <string>
 
#include <osiSock.h>
 
#include <pv/serialize.h>
#include <pv/pvType.h>
#include <pv/byteBuffer.h>
#include <pv/timer.h>
#include <pv/pvData.h>
#include <pv/sharedPtr.h>
 
#ifdef remoteEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#       undef remoteEpicsExportSharedSymbols
#endif
 
#include <pv/pvaConstants.h>
#include <pv/configuration.h>
#include <pv/fairQueue.h>
#include <pv/pvaDefs.h>
 
#include <pv/pvAccess.h>
 
namespace epics {
namespace pvAccess {
 
class TransportRegistry;
class ClientChannelImpl;
 
enum QoS {
    QOS_DEFAULT = 0x00,
    QOS_REPLY_REQUIRED = 0x01,
    QOS_BESY_EFFORT = 0x02,
    QOS_PROCESS = 0x04,
    QOS_INIT = 0x08,
    QOS_DESTROY = 0x10,
    QOS_SHARE = 0x20,
    QOS_GET = 0x40,
    QOS_GET_PUT = 0x80
};
 
enum ApplicationCommands {
    CMD_BEACON = 0,
    CMD_CONNECTION_VALIDATION = 1,
    CMD_ECHO = 2,
    CMD_SEARCH = 3,
    CMD_SEARCH_RESPONSE = 4,
    CMD_AUTHNZ = 5,
    CMD_ACL_CHANGE = 6,
    CMD_CREATE_CHANNEL = 7,
    CMD_DESTROY_CHANNEL = 8,
    CMD_CONNECTION_VALIDATED = 9,
    CMD_GET = 10,
    CMD_PUT = 11,
    CMD_PUT_GET = 12,
    CMD_MONITOR = 13,
    CMD_ARRAY = 14,
    CMD_DESTROY_REQUEST = 15,
    CMD_PROCESS = 16,
    CMD_GET_FIELD = 17,
    CMD_MESSAGE = 18,
    CMD_MULTIPLE_DATA = 19,
    CMD_RPC = 20,
    CMD_CANCEL_REQUEST = 21,
    CMD_ORIGIN_TAG = 22
};
 
enum ControlCommands {
    CMD_SET_MARKER = 0,
    CMD_ACK_MARKER = 1,
    CMD_SET_ENDIANESS = 2
};
 
void hackAroundRTEMSSocketInterrupt();
 
class epicsShareClass TransportSendControl : public epics::pvData::SerializableControl {
public:
    POINTER_DEFINITIONS(TransportSendControl);
 
    virtual ~TransportSendControl() {}
 
    virtual void startMessage(epics::pvData::int8 command, std::size_t ensureCapacity, epics::pvData::int32 payloadSize = 0) = 0;
    virtual void endMessage() = 0;
 
    virtual void flush(bool lastMessageCompleted) = 0;
 
    virtual void setRecipient(osiSockAddr const & sendTo) = 0;
};
 
class TransportSender : public Lockable, public fair_queue<TransportSender>::entry {
public:
    POINTER_DEFINITIONS(TransportSender);
 
    TransportSender() :bytesTX(0u), bytesRX(0u) {}
    virtual ~TransportSender() {}
 
    virtual void send(epics::pvData::ByteBuffer* buffer, TransportSendControl* control) = 0;
 
    size_t bytesTX;
    size_t bytesRX;
};
 
class ClientChannelImpl;
class SecuritySession;
 
class epicsShareClass Transport : public epics::pvData::DeserializableControl {
public:
    POINTER_DEFINITIONS(Transport);
 
    static size_t num_instances;
 
    Transport();
    virtual ~Transport();
 
    virtual bool acquire(std::tr1::shared_ptr<ClientChannelImpl> const & client) = 0;
 
    virtual void release(pvAccessID clientId) = 0;
 
    virtual std::string getType() const = 0;
 
    virtual const osiSockAddr& getRemoteAddress() const = 0;
 
    virtual const std::string& getRemoteName() const = 0;
 
    // TODO getContext?
 
    virtual std::size_t getReceiveBufferSize() const = 0;
 
    virtual epics::pvData::int16 getPriority() const = 0;
 
    virtual void setRemoteTransportReceiveBufferSize(std::size_t receiveBufferSize) = 0;
 
    virtual void setRemoteTransportSocketReceiveBufferSize(std::size_t socketReceiveBufferSize) = 0;
 
    // TODO enum
    virtual void setByteOrder(int byteOrder) = 0;
 
    virtual void enqueueSendRequest(TransportSender::shared_pointer const & sender) = 0;
 
    virtual void flushSendQueue() = 0;
 
    virtual void verified(epics::pvData::Status const & status) = 0;
 
    virtual bool verify(epics::pvData::int32 timeoutMs) = 0;
 
    virtual void close() = 0;
 
    virtual void waitJoin() {}
 
    virtual bool isClosed() = 0;
 
    virtual void authNZMessage(epics::pvData::PVStructure::shared_pointer const & data) = 0;
 
    size_t _totalBytesSent;
    size_t _totalBytesRecv;
};
 
class Channel;
class SecurityPlugin;
class AuthenticationRegistry;
 
class Context {
public:
    POINTER_DEFINITIONS(Context);
 
    virtual ~Context() {}
 
    virtual epics::pvData::Timer::shared_pointer getTimer() = 0;
 
    virtual TransportRegistry* getTransportRegistry() = 0;
 
 
 
 
    virtual Configuration::const_shared_pointer getConfiguration() = 0;
 
 
    virtual void newServerDetected() = 0;
 
    virtual std::tr1::shared_ptr<Channel> getChannel(pvAccessID id) = 0;
    virtual Transport::shared_pointer getSearchTransport() = 0;
};
 
class ResponseHandler {
public:
    POINTER_DEFINITIONS(ResponseHandler);
 
    static size_t num_instances;
 
    ResponseHandler(Context* context, const std::string& description);
    virtual ~ResponseHandler();
 
    virtual void
    handleResponse(osiSockAddr* responseFrom, Transport::shared_pointer const & transport,
                   epics::pvData::int8 version, epics::pvData::int8 command, std::size_t payloadSize,
                   epics::pvData::ByteBuffer* payloadBuffer);
 
protected:
    std::string _description;
 
    epics::pvData::int32 _debugLevel;
};
 
class ResponseRequest : public TransportSender {
public:
    POINTER_DEFINITIONS(ResponseRequest);
 
    virtual ~ResponseRequest() {}
 
    virtual pvAccessID getIOID() const = 0;
 
    virtual void timeout() = 0;
 
    virtual void cancel() = 0;
 
    virtual void reportStatus(Channel::ConnectionState status) = 0;
 
    virtual std::tr1::shared_ptr<ChannelBaseRequester> getRequester() = 0;
 
    virtual void response(Transport::shared_pointer const & transport, epics::pvData::int8 version, epics::pvData::ByteBuffer* payloadBuffer) = 0;
 
};
 
 
}
}
 
#endif /* REMOTE_H_ */