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 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_ */