BgpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_BGP_LAYER
#define PACKETPP_BGP_LAYER

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

    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;

    void parseNextLayer();

    std::string toString() const;

    OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }

    void computeCalculateFields();

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) { m_Protocol = BGP; }

    bgp_common_header* getBasicHeader() const { return (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];

        optional_parameter() {}

        optional_parameter(uint8_t typeVal, 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 (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 { 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];

        path_attribute() {}

        path_attribute(uint8_t flagsVal, uint8_t typeVal, std::string dataAsHexString);
    };

    BgpUpdateMessageLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : BgpLayer(data, dataLen, prevLayer, packet) {}

    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 (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 { 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 (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 { 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 (bgp_keepalive_message*)getBasicHeader(); }

    // implement abstract methods

    BgpMessageType getBgpMessageType() const { 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 (bgp_route_refresh_message*)getBasicHeader(); }

    // implement abstract methods

    BgpMessageType getBgpMessageType() const { return BgpLayer::RouteRefresh; }

};

}

#endif //PACKETPP_BGP_LAYER