BgpLayer.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include "Layer.h"
#include "IpAddress.h"
 
 
namespace pcpp
{
 
    class BgpLayer : public Layer
    {
    public:
        enum BgpMessageType
        {
            Open = 1,
            Update = 2,
            Notification = 3,
            Keepalive = 4,
            RouteRefresh = 5,
        };
 
#pragma pack(push, 1)
        struct bgp_common_header
        {
            uint8_t marker[16];
            uint16_t length;
            uint8_t messageType;
        };
#pragma pack(pop)
        static_assert(sizeof(bgp_common_header) == 19, "bgp_common_header size is not 19 bytes");
 
        virtual BgpMessageType getBgpMessageType() const = 0;
 
        std::string getMessageTypeAsString() const;
 
        static bool isBgpPort(uint16_t portSrc, uint16_t portDst)
        {
            return portSrc == 179 || portDst == 179;
        }
 
        static BgpLayer* parseBgpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        // implement abstract methods
 
        size_t getHeaderLen() const override;
 
        void parseNextLayer() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
        void computeCalculateFields() override;
 
    protected:
        // protected c'tors, this class cannot be instantiated by users
        BgpLayer()
        {}
        BgpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, BGP)
        {}
 
        bgp_common_header* getBasicHeader() const
        {
            return reinterpret_cast<bgp_common_header*>(m_Data);
        }
 
        void setBgpFields(size_t messageLen = 0);
    };
 
    class BgpOpenMessageLayer : public BgpLayer
    {
    public:
#pragma pack(push, 1)
        typedef struct bgp_open_message : bgp_common_header
        {
            uint8_t version;
            uint16_t myAutonomousSystem;
            uint16_t holdTime;
            uint32_t bgpId;
            uint8_t optionalParameterLength;
        } bgp_open_message;
#pragma pack(pop)
 
        struct optional_parameter
        {
            uint8_t type;
            uint8_t length;
            uint8_t value[32];
 
            // FIXME: This does not actually zero the data.
            optional_parameter()
            {}
 
            optional_parameter(uint8_t typeVal, const std::string& valueAsHexString);
        };
 
        BgpOpenMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : BgpLayer(data, dataLen, prevLayer, packet)
        {}
 
        BgpOpenMessageLayer(uint16_t myAutonomousSystem, uint16_t holdTime, const IPv4Address& bgpId,
                            const std::vector<optional_parameter>& optionalParams = std::vector<optional_parameter>());
 
        bgp_open_message* getOpenMsgHeader() const
        {
            return reinterpret_cast<bgp_open_message*>(m_Data);
        }
 
        IPv4Address getBgpId() const
        {
            return IPv4Address(getOpenMsgHeader()->bgpId);
        }
 
        void setBgpId(const IPv4Address& newBgpId);
 
        void getOptionalParameters(std::vector<optional_parameter>& optionalParameters);
 
        size_t getOptionalParametersLength();
 
        bool setOptionalParameters(const std::vector<optional_parameter>& optionalParameters);
 
        bool clearOptionalParameters();
 
        // implement abstract methods
 
        BgpMessageType getBgpMessageType() const override
        {
            return BgpLayer::Open;
        }
 
    private:
        size_t optionalParamsToByteArray(const std::vector<optional_parameter>& optionalParams, uint8_t* resultByteArr,
                                         size_t maxByteArrSize);
    };
 
    class BgpUpdateMessageLayer : public BgpLayer
    {
    public:
        struct prefix_and_ip
        {
            uint8_t prefix;
            IPv4Address ipAddr;
 
            prefix_and_ip() : prefix(0), ipAddr(IPv4Address::Zero)
            {}
 
            prefix_and_ip(uint8_t prefixVal, const std::string& ipAddrVal) : prefix(prefixVal), ipAddr(ipAddrVal)
            {}
        };
 
        struct path_attribute
        {
            uint8_t flags;
            uint8_t type;
            uint8_t length;
            uint8_t data[32];
 
            // FIXME: This does not actually zero the data.
            path_attribute()
            {}
 
            path_attribute(uint8_t flagsVal, uint8_t typeVal, const std::string& dataAsHexString);
        };
 
        BgpUpdateMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : BgpLayer(data, dataLen, prevLayer, packet)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataSize);
 
        explicit BgpUpdateMessageLayer(
            const std::vector<prefix_and_ip>& withdrawnRoutes = std::vector<prefix_and_ip>(),
            const std::vector<path_attribute>& pathAttributes = std::vector<path_attribute>(),
            const std::vector<prefix_and_ip>& nlri = std::vector<prefix_and_ip>());
 
        bgp_common_header* getBasicMsgHeader() const
        {
            return reinterpret_cast<bgp_common_header*>(m_Data);
        }
 
        size_t getWithdrawnRoutesLength() const;
 
        void getWithdrawnRoutes(std::vector<prefix_and_ip>& withdrawnRoutes);
 
        bool setWithdrawnRoutes(const std::vector<prefix_and_ip>& withdrawnRoutes);
 
        bool clearWithdrawnRoutes();
 
        size_t getPathAttributesLength() const;
 
        void getPathAttributes(std::vector<path_attribute>& pathAttributes);
 
        bool setPathAttributes(const std::vector<path_attribute>& pathAttributes);
 
        bool clearPathAttributes();
 
        size_t getNetworkLayerReachabilityInfoLength() const;
 
        void getNetworkLayerReachabilityInfo(std::vector<prefix_and_ip>& nlri);
 
        bool setNetworkLayerReachabilityInfo(const std::vector<prefix_and_ip>& nlri);
 
        bool clearNetworkLayerReachabilityInfo();
 
        // implement abstract methods
 
        BgpMessageType getBgpMessageType() const override
        {
            return BgpLayer::Update;
        }
 
    private:
        void parsePrefixAndIPData(uint8_t* dataPtr, size_t dataLen, std::vector<prefix_and_ip>& result);
 
        size_t prefixAndIPDataToByteArray(const std::vector<prefix_and_ip>& prefixAndIpData, uint8_t* resultByteArr,
                                          size_t maxByteArrSize);
 
        size_t pathAttributesToByteArray(const std::vector<path_attribute>& pathAttributes, uint8_t* resultByteArr,
                                         size_t maxByteArrSize);
    };
 
    class BgpNotificationMessageLayer : public BgpLayer
    {
    public:
#pragma pack(push, 1)
        typedef struct bgp_notification_message : bgp_common_header
        {
            uint8_t errorCode;
            uint8_t errorSubCode;
        } bgp_notification_message;
#pragma pack(pop)
 
        BgpNotificationMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : BgpLayer(data, dataLen, prevLayer, packet)
        {}
 
        BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode);
 
        BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode, const uint8_t* notificationData,
                                    size_t notificationDataLen);
 
        BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode, const std::string& notificationData);
 
        bgp_notification_message* getNotificationMsgHeader() const
        {
            return reinterpret_cast<bgp_notification_message*>(m_Data);
        }
 
        size_t getNotificationDataLen() const;
 
        uint8_t* getNotificationData() const;
 
        std::string getNotificationDataAsHexString() const;
 
        bool setNotificationData(const uint8_t* newNotificationData, size_t newNotificationDataLen);
 
        bool setNotificationData(const std::string& newNotificationDataAsHexString);
 
        // implement abstract methods
 
        BgpMessageType getBgpMessageType() const override
        {
            return BgpLayer::Notification;
        }
 
    private:
        void initMessageData(uint8_t errorCode, uint8_t errorSubCode, const uint8_t* notificationData,
                             size_t notificationDataLen);
    };
 
    class BgpKeepaliveMessageLayer : public BgpLayer
    {
    public:
        typedef bgp_common_header bgp_keepalive_message;
 
        BgpKeepaliveMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : BgpLayer(data, dataLen, prevLayer, packet)
        {}
 
        BgpKeepaliveMessageLayer();
 
        bgp_keepalive_message* getKeepaliveHeader() const
        {
            return reinterpret_cast<bgp_keepalive_message*>(getBasicHeader());
        }
 
        // implement abstract methods
 
        BgpMessageType getBgpMessageType() const override
        {
            return BgpLayer::Keepalive;
        }
    };
 
    class BgpRouteRefreshMessageLayer : public BgpLayer
    {
    public:
#pragma pack(push, 1)
        typedef struct bgp_route_refresh_message : bgp_common_header
        {
            uint16_t afi;
            uint8_t reserved;
            uint8_t safi;
        } bgp_route_refresh_message;
#pragma pack(pop)
 
        BgpRouteRefreshMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : BgpLayer(data, dataLen, prevLayer, packet)
        {}
 
        BgpRouteRefreshMessageLayer(uint16_t afi, uint8_t safi);
 
        bgp_route_refresh_message* getRouteRefreshHeader() const
        {
            return reinterpret_cast<bgp_route_refresh_message*>(getBasicHeader());
        }
 
        // implement abstract methods
 
        BgpMessageType getBgpMessageType() const override
        {
            return BgpLayer::RouteRefresh;
        }
    };
 
}  // namespace pcpp