StpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "MacAddress.h"
#include <cstring>
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct stp_tcn_bpdu
    {
        uint16_t protoId;
        uint8_t version;
        uint8_t type;
    };
#pragma pack(pop)
    static_assert(sizeof(stp_tcn_bpdu) == 4, "stp_tcn_bpdu size is not 4 bytes");
 
    typedef stp_tcn_bpdu stp_header;
    static_assert(sizeof(stp_header) == 4, "stp_header size is not 4 bytes");
 
#pragma pack(push, 1)
    struct stp_conf_bpdu : stp_tcn_bpdu
    {
        uint8_t flag;
        uint64_t rootId;
        uint32_t pathCost;
        uint64_t bridgeId;
        uint16_t portId;
        uint16_t msgAge;
        uint16_t maxAge;
        uint16_t helloTime;
        uint16_t forwardDelay;
    };
#pragma pack(pop)
    static_assert(sizeof(stp_conf_bpdu) == 35, "stp_conf_bpdu size is not 35 bytes");
 
#pragma pack(push, 1)
    struct rstp_conf_bpdu : stp_conf_bpdu
    {
        uint8_t version1Len;
    };
#pragma pack(pop)
    static_assert(sizeof(rstp_conf_bpdu) == 36, "rstp_conf_bpdu size is not 36 bytes");
 
#pragma pack(push, 1)
    struct mstp_conf_bpdu : rstp_conf_bpdu
    {
        uint16_t version3Len;
        uint8_t mstConfigFormatSelector;
        uint8_t mstConfigName[32];
        uint16_t mstConfigRevision;
        uint8_t mstConfigDigest[16];
        uint32_t irpc;
        uint64_t cistBridgeId;
        uint8_t remainId;
    };
#pragma pack(pop)
    static_assert(sizeof(mstp_conf_bpdu) == 102, "mstp_conf_bpdu size is not 102 bytes");
 
#pragma pack(push, 1)
    struct msti_conf_msg
    {
        uint8_t flags;
        uint64_t regionalRootId;
        uint32_t pathCost;
        uint8_t bridgePriority;
        uint8_t portPriority;
        uint8_t remainingHops;
    };
#pragma pack(pop)
    static_assert(sizeof(msti_conf_msg) == 16, "msti_conf_msg size is not 16 bytes");
 
    class StpLayer : public Layer
    {
    protected:
        StpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, STP)
        {}
 
        explicit StpLayer(size_t dataLen)
        {
            allocData(dataLen);
            m_Protocol = STP;
        }
 
        static pcpp::MacAddress IDtoMacAddress(uint64_t id);
        static uint64_t macAddressToID(const pcpp::MacAddress& addr);
 
        void serializeLayer(ObjectScope& serializer) const override;
 
    public:
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ ProtoId, Version, Type };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor ProtoId;
 
            static const FieldDescriptor Version;
 
            static const FieldDescriptor Type;
 
            static constexpr uint16_t MaxStpFieldID = Layer::SerializedFields::MaxID + 3;
        };
 
        static pcpp::MacAddress StpMulticastDstMAC;
        static pcpp::MacAddress StpUplinkFastMulticastDstMAC;
 
        stp_header* getStpHeader() const
        {
            return reinterpret_cast<stp_header*>(m_Data);
        }
 
        uint16_t getProtoId() const
        {
            return getStpHeader()->protoId;
        }
 
 
        void setProtoId(uint16_t value)
        {
            getStpHeader()->protoId = value;
        }
 
        uint8_t getVersion() const
        {
            return getStpHeader()->version;
        }
 
        void setVersion(uint8_t value)
        {
            getStpHeader()->version = value;
        }
 
        uint8_t getType() const
        {
            return getStpHeader()->type;
        }
 
        void setType(uint8_t value)
        {
            getStpHeader()->type = value;
        }
 
        // overridden methods
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        void computeCalculateFields() override
        {}
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelDataLinkLayer;
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        static StpLayer* parseStpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
    };
 
    class StpTopologyChangeBPDULayer : public StpLayer
    {
    protected:
        explicit StpTopologyChangeBPDULayer(size_t dataLen) : StpLayer(dataLen)
        {}
 
    public:
        StpTopologyChangeBPDULayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : StpLayer(data, dataLen, prevLayer, packet)
        {}
 
        StpTopologyChangeBPDULayer();
 
        stp_tcn_bpdu* getStpTcnHeader()
        {
            return getStpHeader();
        }
 
        // overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(stp_tcn_bpdu);
        }
 
        void parseNextLayer() override;
 
        std::string toString() const override
        {
            return "Spanning Tree Topology Change Notification";
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return canReinterpretAs<stp_tcn_bpdu>(data, dataLen);
        }
    };
 
    class StpConfigurationBPDULayer : public StpTopologyChangeBPDULayer
    {
    protected:
        explicit StpConfigurationBPDULayer(size_t dataLen) : StpTopologyChangeBPDULayer(dataLen)
        {}
 
        void serializeLayer(ObjectScope& serializer) const override;
 
    public:
        StpConfigurationBPDULayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : StpTopologyChangeBPDULayer(data, dataLen, prevLayer, packet)
        {}
 
        struct BridgeIdSerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                return { Priority, SystemIdExtension, SystemId };
            }
 
            static const FieldDescriptor Priority;
 
            static const FieldDescriptor SystemIdExtension;
 
            static const FieldDescriptor SystemId;
        };
 
        struct SerializedFields : StpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = StpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Flags,       RootId,     PathCost,   BridgeId,
                                                              PortId,      MessageAge, MaximumAge, TransmissionInterval,
                                                              ForwardDelay };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Flags;
 
            static const ObjectFieldDescriptor<BridgeIdSerializedFields> RootId;
 
            static const FieldDescriptor PathCost;
 
            static const ObjectFieldDescriptor<BridgeIdSerializedFields> BridgeId;
 
            static const FieldDescriptor PortId;
 
            static const FieldDescriptor MessageAge;
 
            static const FieldDescriptor MaximumAge;
 
            static const FieldDescriptor TransmissionInterval;
 
            static const FieldDescriptor ForwardDelay;
 
            static constexpr uint16_t MaxConfigurationFieldID = StpLayer::SerializedFields::MaxStpFieldID + 9;
        };
 
        StpConfigurationBPDULayer();
 
        stp_conf_bpdu* getStpConfHeader() const
        {
            return reinterpret_cast<stp_conf_bpdu*>(m_Data);
        }
 
        uint8_t getFlag() const
        {
            return getStpConfHeader()->flag;
        }
 
        void setFlag(uint8_t value)
        {
            getStpConfHeader()->flag = value;
        }
 
        uint64_t getRootId() const;
 
        void setRootId(uint64_t value);
 
        uint16_t getRootPriority() const;
 
        void setRootPriority(uint16_t value);
 
        uint16_t getRootSystemIDExtension() const;
 
        void setRootSystemIDExtension(uint16_t value);
 
        pcpp::MacAddress getRootSystemID() const
        {
            return IDtoMacAddress(getRootId());
        }
 
        void setRootSystemID(const pcpp::MacAddress& value);
 
        uint32_t getPathCost() const;
 
        void setPathCost(uint32_t value);
 
        uint64_t getBridgeId() const;
 
        void setBridgeId(uint64_t value);
 
        uint16_t getBridgePriority() const;
 
        void setBridgePriority(uint16_t value);
 
        uint16_t getBridgeSystemIDExtension() const;
 
        void setBridgeSystemIDExtension(uint16_t value);
 
        pcpp::MacAddress getBridgeSystemID() const
        {
            return IDtoMacAddress(getBridgeId());
        }
 
        void setBridgeSystemID(const pcpp::MacAddress& value);
 
        uint16_t getPortId() const;
 
        void setPortId(uint16_t value);
 
        double getMessageAge() const;
 
        void setMessageAge(double value);
 
        double getMaximumAge() const;
 
        void setMaximumAge(double value);
 
        double getTransmissionInterval() const;
 
        void setTransmissionInterval(double value);
 
        double getForwardDelay() const;
 
        void setForwardDelay(double value);
 
        // overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(stp_conf_bpdu);
        }
 
        void parseNextLayer() override;
 
        std::string toString() const override
        {
            return "Spanning Tree Configuration";
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return canReinterpretAs<stp_conf_bpdu>(data, dataLen);
        }
    };
 
    class RapidStpLayer : public StpConfigurationBPDULayer
    {
    protected:
        explicit RapidStpLayer(size_t dataLen) : StpConfigurationBPDULayer(dataLen)
        {}
 
        void serializeLayer(ObjectScope& serializer) const override;
 
    public:
        RapidStpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : StpConfigurationBPDULayer(data, dataLen, prevLayer, packet)
        {}
 
        struct SerializedFields : StpConfigurationBPDULayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = StpConfigurationBPDULayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Version1Length };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Version1Length;
 
            static constexpr uint16_t MaxRapidFieldID =
                StpConfigurationBPDULayer::SerializedFields::MaxConfigurationFieldID + 1;
        };
 
        RapidStpLayer();
 
        rstp_conf_bpdu* getRstpConfHeader() const
        {
            return reinterpret_cast<rstp_conf_bpdu*>(m_Data);
        }
 
        uint8_t getVersion1Len() const
        {
            return getRstpConfHeader()->version1Len;
        }
 
        void setVersion1Len(uint8_t value)
        {
            getRstpConfHeader()->version1Len = value;
        }
 
        // overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(rstp_conf_bpdu);
        }
 
        void parseNextLayer() override;
 
        std::string toString() const override
        {
            return "Rapid Spanning Tree";
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return canReinterpretAs<rstp_conf_bpdu>(data, dataLen);
        }
    };
 
    class MultipleStpLayer : public RapidStpLayer
    {
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    public:
        MultipleStpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : RapidStpLayer(data, dataLen, prevLayer, packet)
        {}
 
        struct SerializedFields : RapidStpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = RapidStpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Version3Length, ConfigFormatSelector,
                                                              ConfigName,     ConfigRevision,
                                                              ConfigDigest,   CistInternalRootPathCost,
                                                              CistBridgeId,   RemainingHopCount };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Version3Length;
 
            static const FieldDescriptor ConfigFormatSelector;
 
            static const FieldDescriptor ConfigName;
 
            static const FieldDescriptor ConfigRevision;
 
            static const FieldDescriptor ConfigDigest;
 
            static const FieldDescriptor CistInternalRootPathCost;
 
            static const ObjectFieldDescriptor<BridgeIdSerializedFields> CistBridgeId;
 
            static const FieldDescriptor RemainingHopCount;
 
            static constexpr uint16_t MaxMultipleFieldID = RapidStpLayer::SerializedFields::MaxRapidFieldID + 8;
        };
 
        MultipleStpLayer();
 
        mstp_conf_bpdu* getMstpHeader() const
        {
            return reinterpret_cast<mstp_conf_bpdu*>(m_Data);
        }
 
        uint16_t getVersion3Len() const;
 
        void setVersion3Len(uint16_t value);
 
        uint8_t getMstConfigurationFormatSelector() const
        {
            return getMstpHeader()->mstConfigFormatSelector;
        }
 
        void setMstConfigurationFormatSelector(uint8_t value)
        {
            getMstpHeader()->mstConfigFormatSelector = value;
        }
 
        std::string getMstConfigurationName() const;
 
        void setMstConfigurationName(const std::string& value);
 
        uint16_t getMstConfigRevision() const;
 
        void setMstConfigRevision(uint16_t value);
 
        uint8_t* getMstConfigDigest() const
        {
            return getMstpHeader()->mstConfigDigest;
        }
 
        void setMstConfigDigest(const uint8_t* value, uint8_t len);
 
        uint32_t getCISTIrpc() const;
 
        void setCISTIrpc(uint32_t value);
 
        uint64_t getCISTBridgeId() const;
 
        void setCISTBridgeId(uint64_t value);
 
        uint16_t getCISTBridgePriority() const;
 
        void setCISTBridgePriority(uint16_t value);
 
        uint16_t getCISTBridgeSystemIDExtension() const;
 
        void setCISTBridgeSystemIDExtension(uint16_t value);
 
        pcpp::MacAddress getCISTBridgeSystemID() const
        {
            return IDtoMacAddress(getCISTBridgeId());
        }
 
        void setCISTBridgeSystemID(const pcpp::MacAddress& value);
 
        uint8_t getRemainingHopCount() const
        {
            return getMstpHeader()->remainId;
        }
 
        void setRemainingHopCount(uint8_t value)
        {
            getMstpHeader()->remainId = value;
        }
 
        uint8_t getNumberOfMSTIConfMessages() const
        {
            return (getVersion3Len() - (sizeof(mstp_conf_bpdu) - sizeof(rstp_conf_bpdu) - sizeof(uint16_t))) /
                   sizeof(msti_conf_msg);
        }
 
        msti_conf_msg* getMstiConfMessages() const;
 
        // overridden methods
 
        void parseNextLayer() override
        {}
 
        std::string toString() const override
        {
            return "Multiple Spanning Tree";
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return canReinterpretAs<mstp_conf_bpdu>(data, dataLen);
        }
    };
}  // namespace pcpp