TcpTransport.h

Go to the documentation of this file.

 
#include "RobotRaconteur/RobotRaconteurNode.h"
#include <boost/shared_array.hpp>
 
#pragma once
 
namespace RobotRaconteur
{
enum IPNodeDiscoveryFlags
{
    IPNodeDiscoveryFlags_NODE_LOCAL = 0x1,
    IPNodeDiscoveryFlags_LINK_LOCAL = 0x2,
    IPNodeDiscoveryFlags_SITE_LOCAL = 0x4,
    IPNodeDiscoveryFlags_IPV4_BROADCAST = 0x8
};
 
class TcpTransportConnection;
namespace detail
{
class TcpConnector;
class TcpWebSocketConnector;
class TcpWSSWebSocketConnector;
class TcpSocketAcceptor;
} // namespace detail

class ROBOTRACONTEUR_CORE_API TcpTransport : public Transport, public RR_ENABLE_SHARED_FROM_THIS<TcpTransport>
{
    friend class TcpTransportConnection;
    friend class detail::TcpConnector;
    friend class detail::TcpWebSocketConnector;
    friend class detail::TcpWSSWebSocketConnector;
 
  private:
    int32_t m_Port;
 
  public:
    RR_UNORDERED_MAP<uint32_t, RR_SHARED_PTR<ITransportConnection> > TransportConnections;
    boost::mutex TransportConnections_lock;
 
    std::list<RR_WEAK_PTR<ITransportConnection> > closing_TransportConnections;
    std::list<RR_WEAK_PTR<ITransportConnection> > incoming_TransportConnections;

    TcpTransport(const RR_SHARED_PTR<RobotRaconteurNode>& node = RobotRaconteurNode::sp());
 
    RR_OVIRTUAL ~TcpTransport() RR_OVERRIDE;
 
    RR_OVIRTUAL bool IsServer() const RR_OVERRIDE;
    RR_OVIRTUAL bool IsClient() const RR_OVERRIDE;

    virtual int32_t GetDefaultReceiveTimeout();

    virtual void SetDefaultReceiveTimeout(int32_t milliseconds);

    virtual int32_t GetDefaultConnectTimeout();

    virtual void SetDefaultConnectTimeout(int32_t milliseconds);
 
    RR_OVIRTUAL std::string GetUrlSchemeString() const RR_OVERRIDE;
 
    virtual int32_t GetListenPort();
 
    RR_OVIRTUAL void SendMessage(const RR_INTRUSIVE_PTR<Message>& m) RR_OVERRIDE;
 
    RR_OVIRTUAL void AsyncSendMessage(
        const RR_INTRUSIVE_PTR<Message>& m,
        const boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>& handler) RR_OVERRIDE;
 
    RR_OVIRTUAL void AsyncCreateTransportConnection(
        boost::string_ref url, const RR_SHARED_PTR<Endpoint>& e,
        boost::function<void(const RR_SHARED_PTR<ITransportConnection>&,
                             const RR_SHARED_PTR<RobotRaconteurException>&)>& callback) RR_OVERRIDE;
 
    RR_OVIRTUAL RR_SHARED_PTR<ITransportConnection> CreateTransportConnection(
        boost::string_ref url, const RR_SHARED_PTR<Endpoint>& e) RR_OVERRIDE;
 
    RR_OVIRTUAL void CloseTransportConnection(const RR_SHARED_PTR<Endpoint>& e) RR_OVERRIDE;
 
  protected:
    virtual void CloseTransportConnection_timed(const boost::system::error_code& err, const RR_SHARED_PTR<Endpoint>& e,
                                                const RR_SHARED_PTR<void>& timer);
 
  public:
    virtual void StartServer(int32_t porte, bool localhost_only = false,
                             boost::function<bool(const boost::asio::ip::tcp::endpoint&)> accept_filter = 0);

    virtual void StartServerUsingPortSharer();

    virtual bool IsPortSharerRunning();

    virtual void StartServer(const std::vector<boost::asio::ip::tcp::endpoint>& listen_endpoints,
                             boost::function<bool(const boost::asio::ip::tcp::endpoint&)> accept_filter = 0);

    virtual std::vector<boost::asio::ip::tcp::endpoint> GetListenEndpoints();

    virtual std::vector<boost::asio::ip::tcp::endpoint> GetResolvedListenEndpoints();

    RR_OVIRTUAL std::vector<std::string> GetServerListenUrls() RR_OVERRIDE;
 
    RR_OVIRTUAL bool CanConnectService(boost::string_ref url) RR_OVERRIDE;
 
    RR_OVIRTUAL void Close() RR_OVERRIDE;
 
    RR_OVIRTUAL void CheckConnection(uint32_t endpoint) RR_OVERRIDE;

    void EnableNodeDiscoveryListening(uint32_t flags = (IPNodeDiscoveryFlags_LINK_LOCAL));

    void DisableNodeDiscoveryListening();

    void EnableNodeAnnounce(uint32_t flags = (IPNodeDiscoveryFlags_LINK_LOCAL));

    void DisableNodeAnnounce();

    int32_t GetNodeAnnouncePeriod();

    void SetNodeAnnouncePeriod(int32_t millis);
 
    void SendDiscoveryRequest();
 
    RR_OVIRTUAL void PeriodicCleanupTask() RR_OVERRIDE;
 
    RR_OVIRTUAL uint32_t TransportCapability(boost::string_ref name) RR_OVERRIDE;
 
    static void GetLocalAdapterIPAddresses(std::vector<boost::asio::ip::address>& addresses);
 
    RR_OVIRTUAL void MessageReceived(const RR_INTRUSIVE_PTR<Message>& m) RR_OVERRIDE;

    virtual int32_t GetDefaultHeartbeatPeriod();
    virtual void SetDefaultHeartbeatPeriod(int32_t milliseconds);

    virtual int32_t GetMaxMessageSize();

    virtual void SetMaxMessageSize(int32_t size);

    virtual int32_t GetMaxConnectionCount();
    virtual void SetMaxConnectionCount(int32_t count);

    virtual bool GetRequireTls();

    virtual void SetRequireTls(bool require_tls);

    virtual void LoadTlsNodeCertificate();

    virtual bool IsTlsNodeCertificateLoaded();

    virtual bool IsTransportConnectionSecure(uint32_t endpoint);

    virtual bool IsTransportConnectionSecure(const RR_SHARED_PTR<Endpoint>& endpoint);

    virtual bool IsTransportConnectionSecure(const RR_SHARED_PTR<RRObject>& obj);

    virtual bool IsTransportConnectionSecure(const RR_SHARED_PTR<ITransportConnection>& transport);

    virtual bool IsSecurePeerIdentityVerified(uint32_t endpoint);

    virtual bool IsSecurePeerIdentityVerified(const RR_SHARED_PTR<Endpoint>& endpoint);
    virtual bool IsSecurePeerIdentityVerified(const RR_SHARED_PTR<RRObject>& obj);
    virtual bool IsSecurePeerIdentityVerified(const RR_SHARED_PTR<ITransportConnection>& transport);

    virtual std::string GetSecurePeerIdentity(uint32_t endpoint);

    virtual std::string GetSecurePeerIdentity(const RR_SHARED_PTR<Endpoint>& endpoint);
    virtual std::string GetSecurePeerIdentity(const RR_SHARED_PTR<RRObject>& obj);
    virtual std::string GetSecurePeerIdentity(const RR_SHARED_PTR<ITransportConnection>& transport);

    virtual bool GetAcceptWebSockets();

    virtual void SetAcceptWebSockets(bool value);

    virtual std::vector<std::string> GetWebSocketAllowedOrigins();

    virtual void AddWebSocketAllowedOrigin(boost::string_ref origin);

    virtual void RemoveWebSocketAllowedOrigin(boost::string_ref origin);

    virtual bool GetDisableMessage4();

    virtual void SetDisableMessage4(bool d);

    virtual bool GetDisableStringTable();

    virtual void SetDisableStringTable(bool d);

    virtual bool GetDisableAsyncMessageIO();

    virtual void SetDisableAsyncMessageIO(bool d);
 
    template <typename T, typename F>
    boost::signals2::connection AddCloseListener(const RR_SHARED_PTR<T>& t, const F& f)
    {
        boost::mutex::scoped_lock lock(closed_lock);
        if (closed)
        {
            lock.unlock();
            boost::bind(f, t)();
            return boost::signals2::connection();
        }
 
        return close_signal.connect(boost::signals2::signal<void()>::slot_type(boost::bind(f, t.get())).track(t));
    }
 
  protected:
    RR_OVIRTUAL void LocalNodeServicesChanged() RR_OVERRIDE;
 
    boost::mutex node_discovery_lock;
    RR_SHARED_PTR<void> node_discovery;
 
    std::vector<RR_SHARED_PTR<detail::TcpSocketAcceptor> > acceptors;
    boost::mutex acceptor_lock;
 
    static void handle_accept(const RR_SHARED_PTR<TcpTransport>& parent,
                              const RR_SHARED_PTR<detail::TcpSocketAcceptor>& acceptor,
                              const RR_SHARED_PTR<boost::asio::ip::tcp::socket>& socket,
                              const boost::system::error_code& error);
 
    virtual void register_transport(const RR_SHARED_PTR<ITransportConnection>& connection);
    virtual void erase_transport(const RR_SHARED_PTR<ITransportConnection>& connection);
    virtual void incoming_transport(const RR_SHARED_PTR<ITransportConnection>& connection);
 
    boost::mutex parameter_lock;
    int32_t heartbeat_period;
    int32_t default_connect_timeout;
    int32_t default_receive_timeout;
    int32_t max_message_size;
    int32_t max_connection_count;
    bool disable_message4;
    bool disable_string_table;
    bool disable_async_message_io;
 
    boost::shared_ptr<void> GetTlsContext();
 
    boost::shared_ptr<void> tls_context;
    boost::mutex tls_context_lock;
    bool require_tls;
 
    RR_SHARED_PTR<void> port_sharer_client;
    boost::mutex port_sharer_client_lock;
 
    bool accept_websockets;
 
    std::vector<std::string> allowed_websocket_origins;
 
    bool closed;
    boost::signals2::signal<void()> close_signal;
    boost::mutex closed_lock;
};
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using TcpTransportPtr = RR_SHARED_PTR<TcpTransport>;
#endif
 
} // namespace RobotRaconteur