StpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_STP_LAYER
#define PACKETPP_STP_LAYER

#include "Layer.h"
#include "MacAddress.h"


namespace pcpp
{

#pragma pack(push, 1)
    struct stp_tcn_bpdu
    {
        uint16_t protoId;
        uint8_t version;
        uint8_t type;
    };
#pragma pack(pop)

typedef stp_tcn_bpdu stp_header;

#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)

#pragma pack(push, 1)
    struct rstp_conf_bpdu : stp_conf_bpdu
    {
        uint8_t version1Len;
    };
#pragma pack(pop)

#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)

#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)

    class StpLayer : public Layer
    {
      protected:
        StpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : Layer(data, dataLen, prevLayer, packet)
        {
            m_Protocol = STP;
        }

        explicit StpLayer(size_t dataLen)
        {
            m_DataLen = dataLen;
            m_Data = new uint8_t[dataLen];
            memset(m_Data, 0, dataLen);
            m_Protocol = STP;
        }

        static pcpp::MacAddress IDtoMacAddress(uint64_t id);
        static uint64_t macAddressToID(const pcpp::MacAddress &addr);

      public:
        static pcpp::MacAddress StpMulticastDstMAC;
        static pcpp::MacAddress StpUplinkFastMulticastDstMAC;

        stp_header *getStpHeader() const { return (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 { return m_DataLen; }

        void computeCalculateFields() {}

        OsiModelLayer getOsiModelLayer() const { 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 { return sizeof(stp_tcn_bpdu); }

        void parseNextLayer();

        std::string toString() const { return "Spanning Tree Topology Change Notification"; }

        static bool isDataValid(const uint8_t *data, size_t dataLen) { return data && dataLen >= sizeof(stp_tcn_bpdu); }
    };

    class StpConfigurationBPDULayer : public StpTopologyChangeBPDULayer
    {
      protected:
        explicit StpConfigurationBPDULayer(size_t dataLen) : StpTopologyChangeBPDULayer(dataLen) {}

      public:
        StpConfigurationBPDULayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : StpTopologyChangeBPDULayer(data, dataLen, prevLayer, packet)
        {
        }

        StpConfigurationBPDULayer();

        stp_conf_bpdu *getStpConfHeader() const { return (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 { return sizeof(stp_conf_bpdu); }

        void parseNextLayer();

        std::string toString() const { return "Spanning Tree Configuration"; }

        static bool isDataValid(const uint8_t *data, size_t dataLen)
        {
            return data && dataLen >= sizeof(stp_conf_bpdu);
        }
    };

    class RapidStpLayer : public StpConfigurationBPDULayer
    {
      protected:
        explicit RapidStpLayer(size_t dataLen) : StpConfigurationBPDULayer(dataLen) {}

      public:
        RapidStpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : StpConfigurationBPDULayer(data, dataLen, prevLayer, packet)
        {
        }

        RapidStpLayer();

        rstp_conf_bpdu *getRstpConfHeader() const { return (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 { return sizeof(rstp_conf_bpdu); }

        void parseNextLayer();

        std::string toString() const { return "Rapid Spanning Tree"; }

        static bool isDataValid(const uint8_t *data, size_t dataLen)
        {
            return data && dataLen >= sizeof(rstp_conf_bpdu);
        }
    };

    class MultipleStpLayer : public RapidStpLayer
    {
      public:
        MultipleStpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : RapidStpLayer(data, dataLen, prevLayer, packet)
        {
        }

        MultipleStpLayer();

        mstp_conf_bpdu *getMstpHeader() const { return (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() {}

        std::string toString() const { return "Multiple Spanning Tree"; }

        static bool isDataValid(const uint8_t *data, size_t dataLen)
        {
            return data && dataLen >= sizeof(mstp_conf_bpdu);
        }
    };
} // namespace pcpp

#endif /* PACKETPP_STP_LAYER */