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;
        }

        static pcpp::MacAddress IDtoMacAddress(uint64_t id);

      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; }

        uint8_t getVersion() const { return getStpHeader()->version; }

        uint8_t getType() const { return getStpHeader()->type; }

        // overridden methods

        size_t getHeaderLen() const { return m_DataLen; }

        void parseNextLayer() {}

        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
    {
      public:
        StpTopologyChangeBPDULayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : StpLayer(data, dataLen, prevLayer, packet)
        {
        }

        stp_tcn_bpdu* getStpTcnHeader() { return getStpHeader(); }

        // overridden methods

        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
    {
      public:
        StpConfigurationBPDULayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : StpTopologyChangeBPDULayer(data, dataLen, prevLayer, packet)
        {
        }

        stp_conf_bpdu *getStpConfHeader() const { return (stp_conf_bpdu *)(m_Data); }

        uint8_t getFlag() const { return getStpConfHeader()->flag; }

        uint64_t getRootId() const;

        uint16_t getRootPriority() const;

        uint16_t getRootSystemIDExtension() const;

        pcpp::MacAddress getRootSystemID() const { return IDtoMacAddress(getRootId()); }

        uint32_t getPathCost() const;

        uint64_t getBridgeId() const;

        uint16_t getBridgePriority() const;

        uint16_t getBridgeSystemIDExtension() const;

        pcpp::MacAddress getBridgeSystemID() const { return IDtoMacAddress(getBridgeId()); }

        uint16_t getPortId() const;

        double getMessageAge() const;

        double getMaximumAge() const;

        double getTransmissionInterval() const;

        double getForwardDelay() const;

        // overridden methods

        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
    {
      public:
        RapidStpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
            : StpConfigurationBPDULayer(data, dataLen, prevLayer, packet)
        {
        }

        rstp_conf_bpdu *getRstpConfHeader() const { return (rstp_conf_bpdu *)(m_Data); }

        uint8_t getVersion1Len() const { return getRstpConfHeader()->version1Len; }

        // overridden methods

        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)
        {
        }

        mstp_conf_bpdu *getMstpHeader() const { return (mstp_conf_bpdu *)(m_Data); }

        uint16_t getVersion3Len() const;

        uint8_t getMstConfigurationFormatSelector() const { return getMstpHeader()->mstConfigFormatSelector; }

        std::string getMstConfigurationName() const;

        uint16_t getMstConfigRevision() const { return getMstpHeader()->mstConfigRevision; }

        uint8_t *getMstConfigDigest() const { return getMstpHeader()->mstConfigDigest; }

        uint32_t getCISTIrpc() const;

        uint64_t getCISTBridgeId() const;

        uint16_t getCISTBridgePriority() const;

        uint16_t getCISTBridgeSystemIDExtension() const;

        pcpp::MacAddress getCISTBridgeSystemID() const { return IDtoMacAddress(getCISTBridgeId()); }

        uint8_t getRemainingHopCount() const { return getMstpHeader()->remainId; }

        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

        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 */