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