InterfaceAPI.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_InterfaceAPI_
#define HH_SENF_Ext_NetEmu_InterfaceAPI_ 1

// Custom includes
#include <boost/noncopyable.hpp>
#include <senf/PPI/Jack.hh>
#include <senf/Utils/Statistics.hh>
#include <senf/Packets/DefaultBundle/EthernetPacket.hh>
#include "InterfaceDecorator.hh"
#include "InterfaceId.hh"

#include "InterfaceAPI.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace emu {

    class Receiver;
    class Transmitter;

    class Interface
        : public detail::CommfaceAccess<Receiver,Transmitter>,
          private boost::noncopyable
    {
    public:
        typedef InterfaceDecorator Decorator; 

        using detail::CommfaceAccess<Receiver,Transmitter>::receiver;
        using detail::CommfaceAccess<Receiver,Transmitter>::transmitter;

        virtual ~Interface();

        bool canTransmit() const;        
        bool canReceive() const;         

        void enable();                   
        void disable();                  
        bool enabled() const;            

        unsigned index() const;          

        void id(MACAddress const & eui); 
        MACAddress const & id() const;           

        static unsigned nodeId();        

        static void nodeId(unsigned id); 

        void deviceId(InterfaceDeviceId id);
        InterfaceDeviceId deviceId() const;

        std::string const & device() const;
        
        boost::uint8_t linkTypeId() const;
        std::string interfaceTypeName() const;

        console::DirectoryNode & consoleDir() const; 

        //\{
        console::DirectoryNode & statisticsDir() const;

        template <class Stat>
        senf::Statistics & registerStatistics(std::string name, Stat & stat);

        boost::optional<senf::Statistics &> statistic(std::string const & name);

#ifndef DOXYGEN
        boost::signals2::signal<void (ClockService::clock_type)> startStatistics;
#else
        void startStatistics(ClockService::clock_type inverval);

#endif
        //\}

        //\{
        boost::signals2::signal<void (Interface &, MACAddress)> idChangedSignal;
        //\}

    protected:
        Interface();

        void init();                    

#ifndef DOXYGEN
    private:
#else
    protected:
#endif
        virtual void v_enable() = 0;    
        virtual void v_disable() = 0;   
        virtual bool v_enabled() const = 0; 
        virtual void v_id(MACAddress const & id) = 0; 
        virtual MACAddress v_id() const = 0; 
        virtual boost::uint8_t v_linkTypeId() const = 0;
        virtual std::string const & v_device() const = 0;
        
    private:
        typedef boost::ptr_map<std::string, senf::Statistics> Statistics;
        Statistics statistics_;
        console::ScopedDirectory<> consoleDir_;
        unsigned index_;
        mutable MACAddress id_; // id cache (therefore mutable)
        static unsigned nodeId_;
        InterfaceDeviceId deviceId_;
    };


    class Receiver
        : public detail::InterfaceAccess<Interface>
    {
    public:
        virtual ~Receiver();

        ppi::connector::ActiveOutputJack<EthernetPacket> output;

        bool annotationMode() const;    
        void annotationMode(bool a);    
        bool promisc() const;           
        void promisc(bool v);           
        void mcAdd(senf::MACAddress const & address);
        void mcDrop(senf::MACAddress const & address);
        void flushRxQueues();           
        
#ifndef DOXYGEN
    protected:
#else
    private:
#endif
        Receiver(ppi::connector::ActiveOutput<> & output);
        Receiver(ppi::connector::ActiveOutput<EthernetPacket> & output);
        Receiver(ppi::connector::ActiveOutputJack<> & output);
        Receiver(ppi::connector::ActiveOutputJack<EthernetPacket> & output);

        void init();

        virtual bool v_annotationMode() const = 0;
        virtual void v_annotationMode(bool a) = 0;
        virtual bool v_promisc() const = 0;
        virtual void v_promisc(bool v) = 0;

        virtual void v_mcAdd(senf::MACAddress const & address) = 0;
        virtual void v_mcDrop(senf::MACAddress const & address) = 0;

        virtual void v_flushRxQueues() {};   
    };

    class Transmitter
        : public detail::InterfaceAccess<Interface>
    {
    public:
        virtual ~Transmitter();

        ppi::connector::PassiveInputJack<EthernetPacket> input;

        unsigned mtu() const;           
        void mtu(unsigned v);           
        void flushTxQueues();           

#ifndef DOXYGEN
    protected:
#else
    private:
#endif
        Transmitter(ppi::connector::PassiveInput<> & input);
        Transmitter(ppi::connector::PassiveInput<EthernetPacket> & input);
        Transmitter(ppi::connector::PassiveInputJack<> & input);
        Transmitter(ppi::connector::PassiveInputJack<EthernetPacket> & input);

        void init();

        virtual unsigned v_mtu() const = 0; 
        virtual void v_mtu(unsigned v) = 0; 
        virtual void v_flushTxQueues() {} ;
    };

    //-//////////////////////////////////////////////////////////////////////

    class WiredReceiver;
    class WiredTransmitter;

    class WiredInterface
        : public Interface,
          public detail::CommfaceAccess<WiredReceiver,WiredTransmitter>
    {
    public:
        typedef TypedInterfaceDecorator<WiredInterface, Interface::Decorator> Decorator;

        using detail::CommfaceAccess<WiredReceiver,WiredTransmitter>::receiver;
        using detail::CommfaceAccess<WiredReceiver,WiredTransmitter>::transmitter;

    protected:
        void init();
    };


    class WiredReceiver
        : public Receiver,
          public detail::InterfaceAccess<WiredInterface>
    {
    protected:
        WiredReceiver(ppi::connector::ActiveOutput<> & output);
        WiredReceiver(ppi::connector::ActiveOutput<EthernetPacket> & output);
        WiredReceiver(ppi::connector::ActiveOutputJack<> & output);
        WiredReceiver(ppi::connector::ActiveOutputJack<EthernetPacket> & output);

        void init();

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


    class WiredTransmitter
        : public Transmitter,
          public detail::InterfaceAccess<WiredInterface>
    {
    protected:
        WiredTransmitter(ppi::connector::PassiveInput<> & input);
        WiredTransmitter(ppi::connector::PassiveInput<EthernetPacket> & input);
        WiredTransmitter(ppi::connector::PassiveInputJack<> & input);
        WiredTransmitter(ppi::connector::PassiveInputJack<EthernetPacket> & input);

        void init();

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

    //-//////////////////////////////////////////////////////////////////////

    class HardwareInterface
        : public detail::InterfaceAccess<Interface>
    {
    protected:
        void init();
    };

    //-//////////////////////////////////////////////////////////////////////

    console::DirectoryNode & interfaceDir();

    boost::uint16_t perturb(boost::uint16_t value);

    void macIdSeed(boost::uint16_t seed); 

    MACAddress uniqueMAC(boost::uint32_t magic);

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "InterfaceAPI.cci"
#include "InterfaceAPI.ct"
#include "InterfaceAPI.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: