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