EmulatedInterface.cci

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


/** \file
    \brief EmulatedInterface inline non-template implementation */

#include "EmulatedInterface.ih"

// Custom includes

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::EmulatedInterfaceReceiveFilter

prefix_ senf::emu::detail::EmulatedInterfaceReceiveFilter::
EmulatedInterfaceReceiveFilter(EmulatedReceiver & receiver)
    : receiver_ (receiver)
{
    route(input, output);
    input.onRequest(&EmulatedInterfaceReceiveFilter::request);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::EmulatedInterfaceTransmitFilter::

prefix_ senf::emu::detail::EmulatedInterfaceTransmitFilter::
EmulatedInterfaceTransmitFilter(EmulatedTransmitter & transmitter)
    : transmitter_ (transmitter), mtu_ (0u)
{
    route(input, output);
    input.onRequest(&EmulatedInterfaceTransmitFilter::request);
}

prefix_ unsigned senf::emu::detail::EmulatedInterfaceTransmitFilter::mtu()
    const
{
    return mtu_;
}

prefix_ void senf::emu::detail::EmulatedInterfaceTransmitFilter::mtu(unsigned v)
{
    if (v > SENF_EMU_MAXMTU)
        throw senf::SystemException( "mtu too large: ", EINVAL)
            << v << ", max. emulated mtu is " << SENF_EMU_MAXMTU;
    mtu_ = v;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::DroppedPacketChecker

prefix_ unsigned senf::emu::detail::DroppedPacketChecker::droppedPackets()
    const
{
    return droppedPackets_;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::DelayTimeChecker

prefix_ void senf::emu::detail::DelayTimeChecker::maxDelay(ClockService::clock_type maxDelay)
{
    maxDelay_ = maxDelay;
}

prefix_ senf::ClockService::clock_type senf::emu::detail::DelayTimeChecker::maxDelay()
    const
{
    return maxDelay_;
}

prefix_ unsigned senf::emu::detail::DelayTimeChecker::delayedPackets()
    const
{
    return delayedPackets_;
}

prefix_ senf::ClockService::clock_type senf::emu::detail::DelayTimeChecker::maxPacketDelay()
    const
{
    return maxPacketDelay_;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::AdvancePacket

prefix_ senf::emu::detail::AdvancePacket::AdvancePacket()
{
    route(input, output);
    input.onRequest(&AdvancePacket::request);
}

prefix_ void senf::emu::detail::AdvancePacket::request()
{
    output(input().next(senf::nothrow));
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedInterface

prefix_ senf::emu::EmulatedInterface::EmulatedInterface()
    : socket_ (senf::noinit), enabled_ (false), interfaceIndex_(emuInterfaceIndex++)
{}

prefix_ senf::emu::EmulatedInterface::~EmulatedInterface()
{}

prefix_ std::uint32_t const & senf::emu::EmulatedInterface::interfaceIndex()
    const
{
    return interfaceIndex_;
}

prefix_ bool senf::emu::EmulatedInterface::emulatedInterfaceEnabled()
    const
{
    return enabled_;
}

prefix_ senf::emu::UDPClientHandle senf::emu::EmulatedInterface::emulationSocket()
    const
{
    return socket_;
}

prefix_ senf::emu::UDPClientHandle::Address senf::emu::EmulatedInterface::emulationAddress()
    const
{
    return address_;
}

prefix_ void senf::emu::EmulatedInterface::emulationInterface(std::string const & interface)
{
    interface_ = interface;
    emulationAddress(address_);
}

prefix_ std::string const & senf::emu::EmulatedInterface::emulationInterface()
    const
{
    return interface_;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedReceiver

prefix_ void
senf::emu::EmulatedReceiver::startStatistics(ClockService::clock_type interval)
{
    dropChecker_.startStatistics(interval);
    delayChecker_.startStatistics(interval);
}

prefix_ void senf::emu::EmulatedReceiver::maxDelay(ClockService::clock_type maxDelay)
{
    delayChecker_.maxDelay(maxDelay);
}

prefix_ senf::ClockService::clock_type senf::emu::EmulatedReceiver::maxDelay()
    const
{
    return delayChecker_.maxDelay();
}

prefix_ unsigned senf::emu::EmulatedReceiver::delayedPackets()
    const
{
    return delayChecker_.delayedPackets();
}

prefix_ senf::ClockService::clock_type senf::emu::EmulatedReceiver::maxPacketDelay()
    const
{
    return delayChecker_.maxPacketDelay();
}

prefix_ unsigned senf::emu::EmulatedReceiver::droppedPackets()
    const
{
    return dropChecker_.droppedPackets();
}

prefix_ void senf::emu::EmulatedReceiver::deinitEmulatedReceiver()
{
    source_.handle(UDPClientHandle(senf::noinit));
}

prefix_ bool senf::emu::EmulatedReceiver::promiscEmulatedReceiver()
    const
{
    return promisc_;
}

prefix_ void senf::emu::EmulatedReceiver::promiscEmulatedReceiver(bool v)
{
    promisc_ = v;
}

prefix_ bool senf::emu::EmulatedReceiver::annotationModeEmulatedReceiver()
    const
{
    return annotationMode_;
}

prefix_ void senf::emu::EmulatedReceiver::annotationModeEmulatedReceiver(bool a)
{
    annotationMode_ = a;
}

prefix_ void senf::emu::EmulatedReceiver::mcAddEmulatedReceiver(MACAddress const & address)
{
    mcSet_.insert(address);
}

prefix_ void senf::emu::EmulatedReceiver::mcDropEmulatedReceiver(MACAddress const & address)
{
    mcSet_.erase(address);
}

prefix_ double senf::emu::EmulatedReceiver::lossRate()
    const
{
    return dropper_.lossRate();
}

prefix_ void senf::emu::EmulatedReceiver::lossRate(double lossRate)
{
    dropper_.lossRate(lossRate);
}
//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedTransmitter

prefix_ void senf::emu::EmulatedTransmitter::delay(ClockService::clock_type delay)
{
    delayer_.delay(delay);
}

prefix_ senf::ClockService::clock_type senf::emu::EmulatedTransmitter::delay()
    const
{
    return delayer_.delay();
}

prefix_ void senf::emu::EmulatedTransmitter::deinitEmulatedTransmitter()
{
    sink_.handle(UDPClientHandle(senf::noinit));
}

prefix_ unsigned senf::emu::EmulatedTransmitter::mtuEmulatedTransmitter()
    const
{
    return filter_.mtu();
}

prefix_ void senf::emu::EmulatedTransmitter::mtuEmulatedTransmitter(unsigned v)
{
    filter_.mtu(v);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// 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: