QueueReadWritePolicy.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_Socket_QueueReadWritePolicy_
#define HH_SENF_Socket_QueueReadWritePolicy_ 1

// Custom includes
#include <linux/if_packet.h>
#include <boost/optional.hpp>
#include "Protocols/Raw/LLAddressing.hh"
#include "SocketPolicy.hh"
#include "FileHandle.hh"

//#include "QueueReadWritePolicy.mpp"
#include "QueueReadWritePolicy.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    struct QueueReadPolicy;
    struct QueueWritePolicy;

    class SocketQueueBuffer
    {
    public:
        typedef unsigned char * iterator;
        typedef unsigned char const * const_iterator;
        typedef std::size_t size_type;

        SocketQueueBuffer();

        iterator begin();
        iterator end();
        const_iterator begin() const;
        const_iterator end() const;
        size_type size() const;
        bool empty() const;

        iterator frameBegin();
        iterator frameEnd();
        const_iterator frameBegin() const;
        const_iterator frameEnd() const;
        size_type frameSize() const;

        unsigned dataOffset() const;

        senf::ClockService::clock_type timestamp() const;
        std::uint32_t const * timestampPtr() const;
        senf::LLSocketAddress address() const;
        boost::optional<unsigned> vlan() const;
        unsigned tpid() const;

        void resize(size_type sz
#ifdef SENF_ENABLE_TPACKET_OFFSET
                    , int offset=-1
#endif
            );      

    private:
        SocketQueueBuffer(unsigned char * b, unsigned char * e, unsigned hdrlen);

        struct ::tpacket2_hdr & hdr();
        struct ::tpacket2_hdr const & hdr() const;

        unsigned char * b_;
        unsigned char * e_;
        unsigned hdrlen_;

        friend struct QueueReadPolicy;
        friend struct QueueWritePolicy;
    };

    //\{

    struct QueueReadPolicy
        : public ReadPolicyBase,
          private detail::QueuePolicyBase
    {
        typedef SocketQueueBuffer Buffer;
        typedef SocketQueueBuffer::size_type size_type;

        static boost::optional<Buffer> dequeue(FileHandle & handle);
        static void release(FileHandle & handle);

        // classic read API
        static unsigned read(FileHandle & handle, char * buffer, unsigned size);
    };

    struct QueueWritePolicy
        : public WritePolicyBase,
          private detail::QueuePolicyBase
    {
        typedef SocketQueueBuffer Buffer;
        typedef SocketQueueBuffer::size_type size_type;

        static boost::optional<Buffer> enqueue(FileHandle & handle);
        static bool send(FileHandle & handle);
        static void flush(FileHandle & handle);

        // classic write API
        static unsigned write(FileHandle & handle, char const * buffer, unsigned size);
    };

    //\}
}

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