TransportInterface.hpp

// Copyright 2019 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FASTDDS_RTPS_TRANSPORT__TRANSPORTINTERFACE_HPP
#define FASTDDS_RTPS_TRANSPORT__TRANSPORTINTERFACE_HPP
 
#include <memory>
#include <vector>
 
#include <fastdds/rtps/attributes/PropertyPolicy.hpp>
#include <fastdds/rtps/common/Locator.hpp>
#include <fastdds/rtps/common/LocatorList.hpp>
#include <fastdds/rtps/common/LocatorSelector.hpp>
#include <fastdds/rtps/common/LocatorSelectorEntry.hpp>
#include <fastdds/rtps/common/LocatorWithMask.hpp>
#include <fastdds/rtps/common/PortParameters.hpp>
#include <fastdds/rtps/transport/network/AllowedNetworkInterface.hpp>
#include <fastdds/rtps/transport/network/NetmaskFilterKind.hpp>
#include <fastdds/rtps/transport/SenderResource.hpp>
#include <fastdds/rtps/transport/TransportDescriptorInterface.hpp>
#include <fastdds/rtps/transport/TransportReceiverInterface.hpp>
 
namespace eprosima {
namespace fastdds {
namespace rtps {
 
constexpr uint32_t s_maximumMessageSize = 65500;
constexpr uint32_t s_maximumInitialPeersRange = 4;
static const std::string s_IPv4AddressAny = "0.0.0.0";
static const std::string s_IPv6AddressAny = "::";
 
using SendResourceList = std::vector<std::unique_ptr<fastdds::rtps::SenderResource>>;
using NetmaskFilterInfo = std::pair<NetmaskFilterKind, std::vector<AllowedNetworkInterface>>;
using TransportNetmaskFilterInfo = std::pair<int32_t, NetmaskFilterInfo>;
 
class FASTDDS_EXPORTED_API TransportInterface
{
public:
 
    virtual ~TransportInterface() = default;
 
    TransportInterface(
            const TransportInterface& t) = delete;
 
    TransportInterface& operator =(
            const TransportInterface& t) = delete;
 
    TransportInterface(
            TransportInterface&& t) = delete;
 
    TransportInterface& operator =(
            TransportInterface&& t) = delete;
 
    virtual bool init(
            const fastdds::rtps::PropertyPolicy* properties = nullptr,
            const uint32_t& max_msg_size_no_frag = 0) = 0;
 
    virtual bool IsInputChannelOpen(
            const Locator&) const = 0;
 
    virtual bool IsLocatorSupported(
            const Locator&) const = 0;
 
    virtual bool is_locator_allowed(
            const Locator&) const = 0;
 
    virtual bool is_locator_reachable(
            const Locator_t& locator) = 0;
 
 
    virtual Locator RemoteToMainLocal(
            const Locator& remote) const = 0;
 
    virtual bool transform_remote_locator(
            const Locator& remote_locator,
            Locator& result_locator) const
    {
        (void)remote_locator;
        (void)result_locator;
        return false;
    }
 
    virtual bool OpenOutputChannel(
            SendResourceList& sender_resource_list,
            const Locator&) = 0;
 
    virtual bool OpenOutputChannels(
            SendResourceList& sender_resource_list,
            const fastdds::rtps::LocatorSelectorEntry& locator_selector_entry);
 
    virtual void CloseOutputChannels(
            SendResourceList& sender_resource_list,
            const fastdds::rtps::LocatorSelectorEntry& locator_selector_entry);
 
    virtual bool OpenInputChannel(
            const Locator&,
            TransportReceiverInterface*,
            uint32_t) = 0;
 
    virtual bool CloseInputChannel(
            const Locator&) = 0;
 
    virtual bool DoInputLocatorsMatch(
            const Locator&,
            const Locator&) const = 0;
 
    virtual LocatorList NormalizeLocator(
            const Locator& locator) = 0;
 
    virtual void select_locators(
            fastdds::rtps::LocatorSelector& selector) const = 0;
 
    virtual bool is_local_locator(
            const Locator& locator) const = 0;
 
    virtual TransportDescriptorInterface* get_configuration() = 0;
 
    virtual void AddDefaultOutputLocator(
            LocatorList& defaultList) = 0;
 
    virtual bool getDefaultMetatrafficMulticastLocators(
            LocatorList& locators,
            uint32_t metatraffic_multicast_port) const = 0;
 
    virtual bool getDefaultMetatrafficUnicastLocators(
            LocatorList& locators,
            uint32_t metatraffic_unicast_port) const = 0;
 
    virtual bool getDefaultUnicastLocators(
            LocatorList& locators,
            uint32_t unicast_port) const = 0;
 
    virtual bool fillMetatrafficMulticastLocator(
            Locator& locator,
            uint32_t metatraffic_multicast_port) const = 0;
 
    virtual bool fillMetatrafficUnicastLocator(
            Locator& locator,
            uint32_t metatraffic_unicast_port) const = 0;
 
    virtual bool configureInitialPeerLocator(
            Locator& locator,
            const fastdds::rtps::PortParameters& port_params,
            uint32_t domainId,
            LocatorList& list) const = 0;
 
    virtual bool fillUnicastLocator(
            Locator& locator,
            uint32_t well_known_port) const = 0;
 
    virtual uint32_t max_recv_buffer_size() const = 0;
 
    virtual void shutdown()
    {
    }
 
    virtual void update_network_interfaces()
    {
    }
 
    int32_t kind() const
    {
        return transport_kind_;
    }
 
    virtual bool transform_remote_locator(
            const Locator& remote_locator,
            Locator& result_locator,
            bool allowed_remote_localhost,
            bool allowed_local_localhost) const
    {
        static_cast<void>(allowed_remote_localhost);
        static_cast<void>(allowed_local_localhost);
        return transform_remote_locator(remote_locator, result_locator);
    }
 
    virtual bool is_localhost_allowed() const
    {
        return false;
    }
 
    virtual NetmaskFilterInfo netmask_filter_info() const
    {
        return {NetmaskFilterKind::AUTO, {}};
    }
 
protected:
 
    TransportInterface(
            int32_t transport_kind)
        : transport_kind_(transport_kind)
    {
    }
 
    int32_t transport_kind_;
};
 
} // namespace rtps
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_RTPS_TRANSPORT__TRANSPORTINTERFACE_HPP