IgmpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IpAddress.h"
#include <vector>
 
 
namespace pcpp
{
    struct igmp_header
    {
        uint8_t type;
        uint8_t maxResponseTime;
        uint16_t checksum;
        uint32_t groupAddress;
    };
    static_assert(sizeof(igmp_header) == 8, "igmp_header size is not 8 bytes");
 
    struct igmpv3_query_header
    {
        uint8_t type;
        uint8_t maxResponseTime;
        uint16_t checksum;
        uint32_t groupAddress;
        uint8_t s_qrv;
        uint8_t qqic;
        uint16_t numOfSources;
    };
    static_assert(sizeof(igmpv3_query_header) == 12, "igmpv3_query_header size is not 12 bytes");
 
    struct igmpv3_report_header
    {
        uint8_t type;
        uint8_t reserved1;
        uint16_t checksum;
        uint16_t reserved2;
        uint16_t numOfGroupRecords;
    };
    static_assert(sizeof(igmpv3_report_header) == 8, "igmpv3_report_header size is not 8 bytes");
 
    struct igmpv3_group_record
    {
        uint8_t recordType;
        uint8_t auxDataLen;
        uint16_t numOfSources;
        uint32_t multicastAddress;
        uint8_t sourceAddresses[];
 
        IPv4Address getMulticastAddress() const
        {
            return multicastAddress;
        }
 
        uint16_t getSourceAddressCount() const;
 
        IPv4Address getSourceAddressAtIndex(int index) const;
 
        size_t getRecordLen() const;
    };
 
    enum IgmpType
    {
        IgmpType_Unknown = 0,
        IgmpType_MembershipQuery = 0x11,
        IgmpType_MembershipReportV1 = 0x12,
        IgmpType_DVMRP = 0x13,
        IgmpType_P1Mv1 = 0x14,
        IgmpType_CiscoTrace = 0x15,
        IgmpType_MembershipReportV2 = 0x16,
        IgmpType_LeaveGroup = 0x17,
        IgmpType_MulticastTracerouteResponse = 0x1e,
        IgmpType_MulticastTraceroute = 0x1f,
        IgmpType_MembershipReportV3 = 0x22,
        IgmpType_MulticastRouterAdvertisement = 0x30,
        IgmpType_MulticastRouterSolicitation = 0x31,
        IgmpType_MulticastRouterTermination = 0x32,
    };
 
    class IgmpLayer : public Layer
    {
    protected:
        IgmpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType igmpVer)
            : Layer(data, dataLen, prevLayer, packet, igmpVer)
        {}
 
        IgmpLayer(IgmpType type, const IPv4Address& groupAddr, uint8_t maxResponseTime, ProtocolType igmpVer);
 
        uint16_t calculateChecksum();
 
        size_t getHeaderSizeByVerAndType(ProtocolType igmpVer, IgmpType igmpType) const;
 
    public:
        ~IgmpLayer() override = default;
 
        igmp_header* getIgmpHeader() const
        {
            return reinterpret_cast<igmp_header*>(m_Data);
        }
 
        IPv4Address getGroupAddress() const
        {
            return getIgmpHeader()->groupAddress;
        }
 
        void setGroupAddress(const IPv4Address& groupAddr);
 
        IgmpType getType() const;
 
        void setType(IgmpType type);
 
        static ProtocolType getIGMPVerFromData(uint8_t* data, size_t dataLen, bool& isQuery);
 
        // implement abstract methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return sizeof(igmp_header);
        }
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
    };
 
    class IgmpV1Layer : public IgmpLayer
    {
    public:
        IgmpV1Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : IgmpLayer(data, dataLen, prevLayer, packet, IGMPv1)
        {}
 
        explicit IgmpV1Layer(IgmpType type, const IPv4Address& groupAddr = IPv4Address())
            : IgmpLayer(type, groupAddr, 0, IGMPv1)
        {}
 
        ~IgmpV1Layer() override = default;
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<igmp_header>(data, dataLen);
        }
    };
 
    class IgmpV2Layer : public IgmpLayer
    {
    public:
        IgmpV2Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : IgmpLayer(data, dataLen, prevLayer, packet, IGMPv2)
        {}
 
        explicit IgmpV2Layer(IgmpType type, const IPv4Address& groupAddr = IPv4Address(), uint8_t maxResponseTime = 0)
            : IgmpLayer(type, groupAddr, maxResponseTime, IGMPv2)
        {}
 
        ~IgmpV2Layer() override = default;
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<igmp_header>(data, dataLen);
        }
    };
 
    class IgmpV3QueryLayer : public IgmpLayer
    {
    public:
        IgmpV3QueryLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit IgmpV3QueryLayer(const IPv4Address& multicastAddr = IPv4Address(), uint8_t maxResponseTime = 0,
                                  uint8_t s_qrv = 0);
 
        igmpv3_query_header* getIgmpV3QueryHeader() const
        {
            return reinterpret_cast<igmpv3_query_header*>(m_Data);
        }
 
        uint16_t getSourceAddressCount() const;
 
        IPv4Address getSourceAddressAtIndex(int index) const;
 
        bool addSourceAddress(const IPv4Address& addr);
 
        bool addSourceAddressAtIndex(const IPv4Address& addr, int index);
 
        bool removeSourceAddressAtIndex(int index);
 
        bool removeAllSourceAddresses();
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        size_t getHeaderLen() const override;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<igmpv3_query_header>(data, dataLen);
        }
    };
 
    class IgmpV3ReportLayer : public IgmpLayer
    {
    private:
        igmpv3_group_record* addGroupRecordAt(uint8_t recordType, const IPv4Address& multicastAddress,
                                              const std::vector<IPv4Address>& sourceAddresses, int offset);
 
    public:
        IgmpV3ReportLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : IgmpLayer(data, dataLen, prevLayer, packet, IGMPv3)
        {}
 
        IgmpV3ReportLayer() : IgmpLayer(IgmpType_MembershipReportV3, IPv4Address(), 0, IGMPv3)
        {}
 
        igmpv3_report_header* getReportHeader() const
        {
            return reinterpret_cast<igmpv3_report_header*>(m_Data);
        }
 
        uint16_t getGroupRecordCount() const;
 
        igmpv3_group_record* getFirstGroupRecord() const;
 
        igmpv3_group_record* getNextGroupRecord(igmpv3_group_record* groupRecord) const;
 
        igmpv3_group_record* addGroupRecord(uint8_t recordType, const IPv4Address& multicastAddress,
                                            const std::vector<IPv4Address>& sourceAddresses);
 
        igmpv3_group_record* addGroupRecordAtIndex(uint8_t recordType, const IPv4Address& multicastAddress,
                                                   const std::vector<IPv4Address>& sourceAddresses, int index);
 
        bool removeGroupRecordAtIndex(int index);
 
        bool removeAllGroupRecords();
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<igmpv3_report_header>(data, dataLen);
        }
    };
 
}  // namespace pcpp