SocketSink.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_PPI_SocketSink_
#define HH_SENF_PPI_SocketSink_ 1

// Custom includes
#include <senf/Packets/Packets.hh>
#include <senf/Socket/ClientSocketHandle.hh>
#include <senf/Socket/Protocols/Raw/PacketSocketHandle.hh>
#include <senf/Socket/SocketPolicy.hh>
#include <senf/Socket/ReadWritePolicy.hh>
#include <senf/Socket/FramingPolicy.hh>
#include <senf/Socket/CommunicationPolicy.hh>
#include <senf/Socket/Protocols/INet/INetAddressing.hh>
#include <senf/Socket/Protocols/Raw/LLAddressing.hh>
#include <senf/Packets/DefaultBundle/EthernetPacket.hh>
#include "Module.hh"
#include "Connectors.hh"
#include "IOEvent.hh"

//#include "SocketSink.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace ppi {

    class ConnectedDgramWriter
    {
    public:
        typedef senf::ClientSocketHandle<
            senf::MakeSocketPolicy< senf::WriteablePolicy,
                                    senf::DatagramFramingPolicy,
                                    senf::ConnectedCommunicationPolicy>::policy > Handle;
        typedef Packet PacketType;

        bool operator()(Handle & handle, Packet const & packet);

    };

    template <class HandleType>
    class TargetDgramWriter
    {
    public:
        typedef HandleType Handle;
        typedef Packet PacketType;

        TargetDgramWriter();            
        TargetDgramWriter(typename Handle::Address const & target);

        typename Handle::Address target() const; 
        void target(typename Handle::Address const & target); 

        bool operator()(Handle & handle, Packet const & packet); 

    private:
        typename Handle::Address target_;
    };

    class IPv4SourceForcingDgramWriter : ConnectedDgramWriter
    {
    public:
        IPv4SourceForcingDgramWriter();
        IPv4SourceForcingDgramWriter(senf::INet4Address sourceAddr, senf::INet4SocketAddress destAddr);
        typedef senf::ClientSocketHandle<
            senf::MakeSocketPolicy< senf::WriteablePolicy,
                                    senf::DatagramFramingPolicy>::policy > Handle;
        typedef Packet PacketType;

        void source(senf::INet4Address & source);
        senf::INet4Address source();
        void destination(senf::INet4SocketAddress & dest);
        senf::INet4SocketAddress destination();

        bool operator()(Handle & handle, Packet const & packet);

    private:
        int sendtoandfrom(int sock, const void *data, size_t dataLen, const in_addr *dst, int port, const in_addr *src);
        senf::INet4Address source_;
        senf::INet4Address destination_;
        unsigned int protocolId_;
    };

    class IPv6SourceForcingDgramWriter : ConnectedDgramWriter
    {
    public:
        IPv6SourceForcingDgramWriter();
        IPv6SourceForcingDgramWriter(senf::INet6Address sourceAddr, senf::INet6SocketAddress destAddr);
        typedef senf::ClientSocketHandle<
            senf::MakeSocketPolicy< senf::WriteablePolicy,
                                    senf::DatagramFramingPolicy>::policy > Handle;
        typedef Packet PacketType;

        void source(senf::INet6Address & source);
        senf::INet6Address source();
        void destination(senf::INet6SocketAddress & dest);
        senf::INet6SocketAddress destination();

        bool operator()(Handle & handle, Packet const & packet);

    private:
        int sendtoandfrom(int sock, const void *data, size_t dataLen, const in6_addr *dst, int port, const in6_addr *src);
        senf::INet6Address source_;
        senf::INet6Address destination_;
        unsigned int protocolId_;
    };


    class LLSocketWriter
    {
    public:
        typedef senf::PacketSocketHandle Handle;
        typedef Packet PacketType;

        void source(Handle &, LLSocketAddress source);

        bool operator()(Handle & handle, Packet const & packet);

    };


    class TargetLLSocketWriter
    {
    public:
        typedef PacketSocketHandle Handle;
        typedef EthernetPacket PacketType;

        TargetLLSocketWriter();

        void target(LLSocketAddress const & target);

        bool operator()(Handle & handle, EthernetPacket const & packet);

    private:
        LLSocketAddress target_;
    };

}}

namespace senf {
namespace ppi {
namespace module {

    template <class Writer=ConnectedDgramWriter>
    class ActiveSocketSink : public Module
    {
        SENF_PPI_MODULE(ActiveSocketSink);

    public:
        typedef typename Writer::Handle Handle; 

        connector::ActiveInput<typename Writer::PacketType> input; 

        ActiveSocketSink();             

        explicit ActiveSocketSink(Writer const & writer);

        explicit ActiveSocketSink(Handle const & handle);

        ActiveSocketSink(Handle const & handle, Writer const & writer);

        Writer & writer();              
        Handle handle();                
        void handle(Handle const & handle);

    private:
        void write();

        Handle handle_;
        IOEvent event_;
        Writer writer_;
    };

    template <class Writer=ConnectedDgramWriter>
    class PassiveSocketSink : public Module
    {
        SENF_PPI_MODULE(PassiveSocketSink);

    public:
        typedef typename Writer::Handle Handle; 

        connector::PassiveInput<typename Writer::PacketType> input; 

        PassiveSocketSink();            

        explicit PassiveSocketSink(Writer const & writer);

        explicit PassiveSocketSink(Handle const & handle);

        PassiveSocketSink(Handle const & handle, Writer const & writer);

        Writer & writer();              
        Handle & handle();              
        void handle(Handle const & handle);

        struct TxStats {
            TxStats () {
                clear();
            }
            void clear() {
                memset(this, 0, sizeof(*this));
            }
            void dump(std::ostream & os) const {
                os << "sent "  << sent << ", "
                   << "error "       << error << ".";
            }

            unsigned sent;
            unsigned error;
        };

        TxStats & txStats() {
            return txStats_;
        }

    private:
        void write();
        void checkThrottle();

        Handle handle_;
        Writer writer_;
        TxStats txStats_;
    };

}}}


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

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