Packets.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_Packets_
#define HH_SENF_Ext_NetEmu_Packets_ 1

// Custom includes
#include <senf/Packets/Packets.hh>

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

namespace senf {
namespace emu {

     struct PacketHeaderParser : public PacketParserBase
     {
#       include SENF_FIXED_PARSER()

         SENF_PARSER_FIELD( interfaceType,   UInt32Parser );
         SENF_PARSER_FIELD( sequenceNumber,  UInt32Parser );
         SENF_PARSER_FIELD( timestamp,       Int64Parser  );
         SENF_PARSER_FIELD( nodeId,          UInt32Parser );
         SENF_PARSER_FIELD( interfaceIndex,  UInt32Parser );

         SENF_PARSER_FINALIZE(PacketHeaderParser);
     };

     struct InterfaceTypes
     {
         typedef boost::uint32_t key_t;
     };

     struct PacketHeaderType
         : public PacketTypeBase,
           public PacketTypeMixin<PacketHeaderType, InterfaceTypes>
     {
         typedef PacketTypeMixin<PacketHeaderType, InterfaceTypes> mixin;
         typedef ConcretePacket<PacketHeaderType> packet; 
         typedef PacketHeaderParser parser;               

         using mixin::nextPacketRange;
         using mixin::nextPacketType;
         using mixin::initSize;
         using mixin::init;

         static key_t nextPacketKey(packet p);
         static void dump(packet p, std::ostream & os);
         static void finalize(packet p);
     };

     typedef ConcretePacket<PacketHeaderType> PacketHeader;


     struct dumpPacketInfo
     {
         dumpPacketInfo(senf::Packet const & p) : packet (p) {}
         Packet packet;
     };

     std::ostream & operator<<(std::ostream & os, dumpPacketInfo const & info);


    struct WLANPacketHeaderParser : public PacketParserBase
    {
#       include SENF_PARSER()
        SENF_PARSER_BITFIELD( mgt, 1,  bool         );
        SENF_PARSER_FINALIZE( WLANPacketHeaderParser);
        SENF_PARSER_INIT() {
            mgt() = false;
        }
    };

    struct WLANPacketHeaderType
        : public PacketTypeBase,
          public PacketTypeMixin<WLANPacketHeaderType>
    {
        typedef PacketTypeMixin<WLANPacketHeaderType> mixin;
        typedef ConcretePacket<WLANPacketHeaderType> packet;
        typedef WLANPacketHeaderParser parser;

        using mixin::nextPacketRange;
        using mixin::initSize;
        using mixin::init;

        static factory_t nextPacketType(packet p);
        static void dump(packet p, std::ostream & os);
        static void finalize(packet p);
    };

    typedef ConcretePacket<WLANPacketHeaderType> WLANPacketHeader;


    struct EmulatedWirelessPacketHeaderParser : public PacketParserBase
    {
#       include SENF_FIXED_PARSER()

        SENF_PARSER_FIELD( interfaceType,   UInt32Parser );
        SENF_PARSER_FIELD( txPower,         Int16Parser  );
        SENF_PARSER_FIELD( frequency,       UInt32Parser );
        SENF_PARSER_FIELD( bandwidth,       UInt16Parser );
        SENF_PARSER_FIELD( modulationId,    UInt32Parser );

        SENF_PARSER_FINALIZE(EmulatedWirelessPacketHeaderParser);
    };

    struct EmulatedWirelessPacketHeaderType
        : public PacketTypeBase,
          public PacketTypeMixin<EmulatedWirelessPacketHeaderType, InterfaceTypes>
    {
        typedef PacketTypeMixin<EmulatedWirelessPacketHeaderType, InterfaceTypes> mixin;
        typedef ConcretePacket<EmulatedWirelessPacketHeaderType> packet;
        typedef EmulatedWirelessPacketHeaderParser parser;

        using mixin::nextPacketRange;
        using mixin::nextPacketType;
        using mixin::initSize;
        using mixin::init;

        static key_t nextPacketKey(packet p);
        static void dump(packet p, std::ostream & os);
        static void finalize(packet p);
    };

    typedef ConcretePacket<EmulatedWirelessPacketHeaderType> EmulatedWirelessPacketHeader;


    struct DVBPacketHeaderParser : public PacketParserBase
    {
#       include SENF_FIXED_PARSER()

        SENF_PARSER_FINALIZE(DVBPacketHeaderParser);
    };

    struct DVBPacketHeaderType
        : public PacketTypeBase,
          public PacketTypeMixin<DVBPacketHeaderType>
    {
        typedef PacketTypeMixin<DVBPacketHeaderType> mixin;
        typedef ConcretePacket<DVBPacketHeaderType> packet;
        typedef DVBPacketHeaderParser parser;

        using mixin::nextPacketRange;
        using mixin::initSize;
        using mixin::init;

        static factory_t nextPacketType(packet p);
        static void dump(packet p, std::ostream & os);
    };

    typedef ConcretePacket<DVBPacketHeaderType> DVBPacketHeader;


    struct EthernetPacketHeaderParser : public PacketParserBase
    {
#       include SENF_FIXED_PARSER()

        SENF_PARSER_FINALIZE(EthernetPacketHeaderParser );
    };

    struct EthernetPacketHeaderType
        : public PacketTypeBase,
          public PacketTypeMixin<EthernetPacketHeaderType>
    {
        typedef PacketTypeMixin<EthernetPacketHeaderType> mixin;
        typedef ConcretePacket<EthernetPacketHeaderType> packet;
        typedef EthernetPacketHeaderParser parser;

        using mixin::nextPacketRange;
        using mixin::initSize;
        using mixin::init;

        static factory_t nextPacketType(packet p);
        static void dump(packet p, std::ostream & os);
    };

    typedef ConcretePacket<EthernetPacketHeaderType> EthernetPacketHeader;
}};

SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION( senf::emu::PacketHeader                 );
SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION( senf::emu::WLANPacketHeader             );
SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION( senf::emu::EmulatedWirelessPacketHeader );
SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION( senf::emu::DVBPacketHeader              );
SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION( senf::emu::EthernetPacketHeader         );


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