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 instanciated 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_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_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_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