blockingTCP.h

 
#ifndef BLOCKINGTCP_H_
#define BLOCKINGTCP_H_
 
#include <set>
#include <map>
#include <deque>
 
#ifdef epicsExportSharedSymbols
#   define blockingTCPEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif
 
#include <shareLib.h>
#include <osiSock.h>
#include <epicsTime.h>
#include <epicsThread.h>
 
#include <pv/byteBuffer.h>
#include <pv/pvType.h>
#include <pv/lock.h>
#include <pv/timer.h>
#include <pv/event.h>
 
#ifdef blockingTCPEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#       undef blockingTCPEpicsExportSharedSymbols
#endif
 
#include <pv/pvaConstants.h>
#include <pv/remote.h>
#include <pv/transportRegistry.h>
#include <pv/introspectionRegistry.h>
#include <pv/inetAddressUtil.h>
 
namespace epics {
namespace pvAccess {
 
class ClientChannelImpl;

class BlockingTCPConnector {
public:
    POINTER_DEFINITIONS(BlockingTCPConnector);
 
    BlockingTCPConnector(Context::shared_pointer const & context, int receiveBufferSize,
                         float beaconInterval);
 
    Transport::shared_pointer connect(std::tr1::shared_ptr<ClientChannelImpl> const & client,
            ResponseHandler::shared_pointer const & responseHandler, osiSockAddr& address,
            epics::pvData::int8 transportRevision, epics::pvData::int16 priority);
private:
    static const int LOCK_TIMEOUT = 20*1000; // 20s

    Context::weak_pointer _context;

    int _receiveBufferSize;

    float _heartbeatInterval;

    SOCKET tryConnect(osiSockAddr& address, int tries);
 
};

class BlockingTCPAcceptor : public epicsThreadRunable {
public:
    POINTER_DEFINITIONS(BlockingTCPAcceptor);
 
    BlockingTCPAcceptor(Context::shared_pointer const & context,
                        ResponseHandler::shared_pointer const & responseHandler,
                        const osiSockAddr& addr, int receiveBufferSize);
 
    virtual ~BlockingTCPAcceptor();

    const osiSockAddr* getBindAddress() {
        return &_bindAddress;
    }

    void destroy();
 
private:
    virtual void run();

    Context::shared_pointer _context;

    ResponseHandler::shared_pointer _responseHandler;

    osiSockAddr _bindAddress;

    SOCKET _serverSocketChannel;

    int _receiveBufferSize;

    bool _destroyed;
 
    epics::pvData::Mutex _mutex;
 
    epicsThread _thread;

    int initialize();

    bool validateConnection(Transport::shared_pointer const & transport, const char* address);
};
 
}
}
 
#endif /* BLOCKINGTCP_H_ */