EmulatedInterface.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Ext_NetEmu_EmulatedInterface_
#define HH_SENF_Ext_NetEmu_EmulatedInterface_ 1

// Custom includes
#include <senf/Socket/Protocols/INet/UDPSocketHandle.hh>
#include <senf/PPI/SocketSink.hh>
#include <senf/PPI/SocketSource.hh>
#include "Modules/PacketDelayer.hh"
#include "Modules/PacketDropper.hh"
#include "InterfaceAPI.hh"
#include "config.hh"

//#include "EmulatedInterface.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace emu {

    // Change this to UDPv6ClientSocketHandle to use IPv6
    typedef senf::UDPv4ClientSocketHandle UDPClientHandle;

}}

#include "EmulatedInterface.ih"

namespace senf {
namespace emu {

    class EmulatedReceiver;
    class EmulatedTransmitter;

    //-////////////////////////////////////////////////////////////////////////
    // Interface

    class EmulatedInterface
        : public detail::InterfaceAccess<Interface>,
          public detail::CommfaceAccess<EmulatedReceiver, EmulatedTransmitter>
    {
    public:
        using detail::CommfaceAccess<EmulatedReceiver, EmulatedTransmitter>::receiver;
        using detail::CommfaceAccess<EmulatedReceiver, EmulatedTransmitter>::transmitter;

        virtual ~EmulatedInterface();

        UDPClientHandle emulationSocket() const; 

        UDPClientHandle::Address emulationAddress() const;

        void emulationInterface(std::string const & interface);
        std::string const & emulationInterface() const;

        std::uint32_t const & interfaceIndex() const;

    protected:
        EmulatedInterface();
        void init();

        void emulationAddress(UDPClientHandle::Address const & address);

        void enableEmulatedInterface(); 

        void disableEmulatedInterface(); 

        bool emulatedInterfaceEnabled() const; 

#ifndef DOXYGEN
    private:
#else
    protected:
#endif
        virtual void v_initEmulationInterface() = 0; 
        virtual void v_deinitEmulationInterface() = 0; 

    private:
        void openSocket();
        void closeSocket();

        UDPClientHandle::Address address_;
        UDPClientHandle socket_;
        bool enabled_;
        std::string interface_;
        std::uint32_t interfaceIndex_;
        // this is a static counter, which is increamented in the ctor whenever an interface is created
        // This can be used to uniquely identify an interface across multiple runs of the same emulated scenario (actually: same config a node)
        static std::uint32_t emuInterfaceIndex;
    };


    class EmulatedReceiver
        : public detail::InterfaceAccess<EmulatedInterface>,
          public detail::InterfaceAccess<Interface>
    {
        ppi::module::ActiveSocketSource<ppi::DgramReader<PacketHeader,SENF_EMU_MAXMTU> > source_;
        detail::EmulatedInterfaceReceiveFilter filter_;
        detail::DroppedPacketChecker dropChecker_;
        detail::DelayTimeChecker delayChecker_;
        emu::PacketDropper dropper_;
        detail::AdvancePacket advance_;

    public:
        void startStatistics(ClockService::clock_type pollInterval);

        void maxDelay(ClockService::clock_type maxDelay);
        ClockService::clock_type maxDelay() const;

        unsigned delayedPackets() const; 
        ClockService::clock_type maxPacketDelay() const;
        unsigned droppedPackets() const; 

        double lossRate() const;
        void lossRate(double lossRate);

    protected:
        ppi::connector::ActiveOutputJack<> receiverJack;

        EmulatedReceiver();
        void init();

        void initEmulatedReceiver();    

        void deinitEmulatedReceiver();  

        bool promiscEmulatedReceiver() const; 

        void promiscEmulatedReceiver(bool v); 

        void annotationModeEmulatedReceiver(bool a); 

        bool annotationModeEmulatedReceiver() const; 

        void mcAddEmulatedReceiver(MACAddress const & address);

        void mcDropEmulatedReceiver(MACAddress const & address);

    private:
        typedef detail::InterfaceAccess<EmulatedInterface> emui;
        typedef detail::InterfaceAccess<Interface> basei;

        bool promisc_;
        bool annotationMode_;
        std::set<MACAddress> mcSet_;

        friend class detail::EmulatedInterfaceReceiveFilter;
    };


    class EmulatedTransmitter
        : public detail::InterfaceAccess<EmulatedInterface>,
          public detail::InterfaceAccess<Interface>
    {
    public:
        void delay(ClockService::clock_type delay); 
        ClockService::clock_type delay() const; 

    protected:
        ppi::connector::PassiveInputJack<> transmitterJack;

        EmulatedTransmitter();
        void init();

        void initEmulatedTransmitter(); 

        void deinitEmulatedTransmitter(); 

        unsigned mtuEmulatedTransmitter() const; 

        void mtuEmulatedTransmitter(unsigned v); 

        virtual Packet::size_type v_emulatedPayloadSize(Packet packet); 

    private:
        typedef detail::InterfaceAccess<EmulatedInterface> emui;
        typedef detail::InterfaceAccess<Interface> basei;

        detail::EmulatedInterfaceTransmitFilter filter_;
        PacketDelayer delayer_;
        ppi::module::PassiveSocketSink<ppi::TargetDgramWriter<UDPClientHandle> > sink_;

        friend class detail::EmulatedInterfaceTransmitFilter;
    };


    class EmulatedWiredReceiver;
    class EmulatedWiredTransmitter;

    class EmulatedWiredInterface
        : public EmulatedInterface,
          public detail::InterfaceAccess<WiredInterface>,
          public detail::CommfaceAccess<EmulatedWiredReceiver, EmulatedWiredTransmitter>
    {
    public:
        using detail::InterfaceAccess<WiredInterface>::interface;
        using detail::CommfaceAccess<EmulatedWiredReceiver, EmulatedWiredTransmitter>::receiver;
        using detail::CommfaceAccess<EmulatedWiredReceiver, EmulatedWiredTransmitter>::transmitter;

        using EmulatedInterface::emulationAddress;

    protected:
        void init();
    };


    class EmulatedWiredReceiver
        : public EmulatedReceiver,
          public detail::InterfaceAccess<WiredInterface>
    {
    protected:
        void init();

    private:
        using detail::InterfaceAccess<EmulatedInterface>::interface;
    };

    class EmulatedWiredTransmitter
        : public EmulatedTransmitter,
          public detail::InterfaceAccess<WiredInterface>
    {
    protected:
        void init();

    private:
        using detail::InterfaceAccess<EmulatedInterface>::interface;
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "EmulatedInterface.cci"
//#include "EmulatedInterface.ct"
//#include "EmulatedInterface.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: