/src/PcapPlusPlus/Packet++/src/BgpLayer.cpp

Source
#define LOG_MODULE PacketLogModuleBgpLayer

#include "Logger.h"
#include "BgpLayer.h"
#include "Packet.h"
#include "EndianPortable.h"
#include "GeneralUtils.h"
#include <algorithm>

namespace pcpp
{
  // ~~~~~~~~
  // BgpLayer
  // ~~~~~~~~

  size_t BgpLayer::getHeaderLen() const
  {
    if (m_DataLen < sizeof(bgp_common_header))
    {
      return m_DataLen;
    }

    uint16_t messageLen = be16toh(getBasicHeader()->length);
    if (m_DataLen < messageLen)
    {
      return m_DataLen;
    }

    return (size_t)messageLen;
  }

  BgpLayer* BgpLayer::parseBgpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
  {
    if (data == nullptr || dataLen < sizeof(bgp_common_header))
      return nullptr;

    auto* bgpHeader = reinterpret_cast<bgp_common_header*>(data);

    // illegal header data - length is too small
    uint16_t messageLen = be16toh(bgpHeader->length);
    if (dataLen < messageLen || messageLen < static_cast<uint16_t>(sizeof(bgp_common_header)))
      return nullptr;

    switch (bgpHeader->messageType)
    {
    case 1:  // OPEN
      return BgpOpenMessageLayer::isDataValid(data, dataLen)
                 ? new BgpOpenMessageLayer(data, dataLen, prevLayer, packet)
                 : nullptr;
    case 2:  // UPDATE
      return BgpUpdateMessageLayer::isDataValid(data, dataLen)
                 ? new BgpUpdateMessageLayer(data, dataLen, prevLayer, packet)
                 : nullptr;
    case 3:  // NOTIFICATION
      return new BgpNotificationMessageLayer(data, dataLen, prevLayer, packet);
    case 4:  // KEEPALIVE
      return new BgpKeepaliveMessageLayer(data, dataLen, prevLayer, packet);
    case 5:  // ROUTE-REFRESH
      return new BgpRouteRefreshMessageLayer(data, dataLen, prevLayer, packet);
    default:
      return nullptr;
    }
  }

  std::string BgpLayer::getMessageTypeAsString() const
  {
    switch (getBgpMessageType())
    {
    case BgpLayer::Open:
      return "OPEN";
    case BgpLayer::Update:
      return "UPDATE";
    case BgpLayer::Notification:
      return "NOTIFICATION";
    case BgpLayer::Keepalive:
      return "KEEPALIVE";
    case BgpLayer::RouteRefresh:
      return "ROUTE-REFRESH";
    default:
      return "Unknown";
    }
  }

  void BgpLayer::parseNextLayer()
  {
    size_t headerLen = getHeaderLen();
    if (m_DataLen <= headerLen || headerLen == 0)
      return;

    uint8_t* payload = m_Data + headerLen;
    size_t payloadLen = m_DataLen - headerLen;

    constructNextLayerFromFactory(BgpLayer::parseBgpLayer, payload, payloadLen);
  }

  std::string BgpLayer::toString() const
  {
    return "BGP Layer, " + getMessageTypeAsString() + " message";
  }

  void BgpLayer::computeCalculateFields()
  {
    bgp_common_header* bgpHeader = getBasicHeader();
    memset(bgpHeader->marker, 0xff, 16 * sizeof(uint8_t));
    bgpHeader->messageType = (uint8_t)getBgpMessageType();
    bgpHeader->length = htobe16(getHeaderLen());
  }

  void BgpLayer::setBgpFields(size_t messageLen)
  {
    bgp_common_header* bgpHdr = getBasicHeader();
    memset(bgpHdr->marker, 0xff, 16 * sizeof(uint8_t));
    bgpHdr->messageType = (uint8_t)getBgpMessageType();
    if (messageLen != 0)
    {
      bgpHdr->length = htobe16((uint16_t)messageLen);
    }
    else
    {
      bgpHdr->length = m_DataLen;
    }
  }

  bool BgpLayer::extendLayer(int offsetInLayer, size_t numOfBytesToExtend)
  {
    if (getAttachedPacket() != nullptr)
    {
      int rawPacketLen = getAttachedPacket()->getRawPacket()->getRawDataLen();
      const uint8_t* rawPacketPtr = getAttachedPacket()->getRawPacket()->getRawData();

      if (m_Data - rawPacketPtr + static_cast<ptrdiff_t>(offsetInLayer) > static_cast<ptrdiff_t>(rawPacketLen))
      {
        PCPP_LOG_ERROR("Requested offset is larger than total packet length");
        return false;
      }

      if (m_NextLayer != nullptr && static_cast<ptrdiff_t>(offsetInLayer) > m_NextLayer->getData() - m_Data)
      {
        PCPP_LOG_ERROR("Requested offset exceeds current layer's boundary");
        return false;
      }
    }

    return Layer::extendLayer(offsetInLayer, numOfBytesToExtend);
  }

  bool BgpLayer::shortenLayer(int offsetInLayer, size_t numOfBytesToShorten)
  {
    if (getAttachedPacket() != nullptr)
    {
      int rawPacketLen = getAttachedPacket()->getRawPacket()->getRawDataLen();
      const uint8_t* rawPacketPtr = getAttachedPacket()->getRawPacket()->getRawData();

      if (m_Data - rawPacketPtr + static_cast<ptrdiff_t>(offsetInLayer) +
              static_cast<ptrdiff_t>(numOfBytesToShorten) >
          static_cast<ptrdiff_t>(rawPacketLen))
      {
        PCPP_LOG_ERROR("Requested number of bytes to shorten is larger than total packet length");
        return false;
      }

      if (m_NextLayer != nullptr &&
          static_cast<ptrdiff_t>(offsetInLayer) + static_cast<ptrdiff_t>(numOfBytesToShorten) >
              m_NextLayer->getData() - m_Data)
      {
        PCPP_LOG_ERROR("Requested number of bytes to shorten exceeds current layer's boundary");
        return false;
      }
    }

    return Layer::shortenLayer(offsetInLayer, numOfBytesToShorten);
  }

  // ~~~~~~~~~~~~~~~~~~~~
  // BgpOpenMessageLayer
  // ~~~~~~~~~~~~~~~~~~~~

  BgpOpenMessageLayer::optional_parameter::optional_parameter(uint8_t typeVal, const std::string& valueAsHexString)
  {
    type = typeVal;
    length = hexStringToByteArray(valueAsHexString, value, 32);
  }

  bool BgpOpenMessageLayer::isDataValid(const uint8_t* data, size_t dataSize)
  {
    if (data == nullptr || dataSize < sizeof(bgp_common_header))
    {
      return false;
    }

    const auto* bgpHeader = reinterpret_cast<const bgp_common_header*>(data);
    uint16_t messageLen = be16toh(bgpHeader->length);
    return messageLen >= sizeof(bgp_open_message) && dataSize >= messageLen;
  }

  BgpOpenMessageLayer::BgpOpenMessageLayer(uint16_t myAutonomousSystem, uint16_t holdTime, const IPv4Address& bgpId,
                                           const std::vector<optional_parameter>& optionalParams)
  {
    uint8_t optionalParamsData[1500];
    size_t optionalParamsDataLen = optionalParamsToByteArray(optionalParams, optionalParamsData, 1500);

    const size_t headerLen = sizeof(bgp_open_message) + optionalParamsDataLen;
    allocData(headerLen);
    setBgpFields(headerLen);

    bgp_open_message* msgHdr = getOpenMsgHeader();
    msgHdr->version = 4;
    msgHdr->myAutonomousSystem = htobe16(myAutonomousSystem);
    msgHdr->holdTime = htobe16(holdTime);
    msgHdr->bgpId = bgpId.toInt();
    msgHdr->optionalParameterLength = optionalParamsDataLen;
    if (optionalParamsDataLen > 0)
    {
      memcpy(m_Data + sizeof(bgp_open_message), optionalParamsData, optionalParamsDataLen);
    }

    m_Protocol = BGP;
  }

  size_t BgpOpenMessageLayer::optionalParamsToByteArray(const std::vector<optional_parameter>& optionalParams,
                                                        uint8_t* resultByteArr, size_t maxByteArrSize)
  {
    if (resultByteArr == nullptr || maxByteArrSize == 0)
    {
      return 0;
    }

    size_t dataLen = 0;

    for (const auto& param : optionalParams)
    {
      if (param.length > 32)
      {
        PCPP_LOG_ERROR("Illegal optional parameter length " << (int)param.length
                                                            << ", must be 32 bytes or less");
        break;  // illegal value
      }

      size_t curDataSize = 2 * sizeof(uint8_t) + (size_t)param.length;

      if (dataLen + curDataSize > maxByteArrSize)
      {
        break;
      }

      resultByteArr[0] = param.type;
      resultByteArr[1] = param.length;
      if (param.length > 0)
      {
        memcpy(resultByteArr + 2 * sizeof(uint8_t), param.value, param.length);
      }

      dataLen += curDataSize;
      resultByteArr += curDataSize;
    }

    return dataLen;
  }

  void BgpOpenMessageLayer::setBgpId(const IPv4Address& newBgpId)
  {
    bgp_open_message* msgHdr = getOpenMsgHeader();
    if (msgHdr == nullptr)
    {
      return;
    }

    msgHdr->bgpId = newBgpId.toInt();
  }

  void BgpOpenMessageLayer::getOptionalParameters(std::vector<optional_parameter>& optionalParameters)
  {
    size_t headerLen = getHeaderLen();
    bgp_open_message* msgHdr = getOpenMsgHeader();

    // Parentheses around std::min avoid clashes with platform min macros (for example on Windows)
    size_t optionalParamsLen =
        (std::min)(static_cast<size_t>(msgHdr->optionalParameterLength), headerLen - sizeof(bgp_open_message));

    uint8_t* dataPtr = m_Data + sizeof(bgp_open_message);
    size_t byteCount = 0;
    while (byteCount < optionalParamsLen)
    {
      size_t remaining = optionalParamsLen - byteCount;
      constexpr size_t optParamHdrSize = sizeof(optional_parameter::type) + sizeof(optional_parameter::length);
      if (remaining < optParamHdrSize)
      {
        PCPP_LOG_ERROR("Truncated optional parameter header");
        break;
      }

      optional_parameter op;
      op.type = dataPtr[0];
      op.length = dataPtr[1];

      size_t totalLen = optParamHdrSize + static_cast<size_t>(op.length);
      if (totalLen > remaining)
      {
        PCPP_LOG_ERROR("Optional parameter length is out of bounds: " << static_cast<int>(op.length));
        break;
      }

      if (op.length > 0)
      {
        memcpy(op.value, dataPtr + optParamHdrSize,
               (std::min)(static_cast<size_t>(op.length), sizeof(op.value)));
      }

      optionalParameters.push_back(op);

      byteCount += totalLen;
      dataPtr += totalLen;
    }
  }

  size_t BgpOpenMessageLayer::getOptionalParametersLength()
  {
    size_t headerLen = getHeaderLen();
    bgp_open_message* msgHdr = getOpenMsgHeader();
    auto optParamLen = static_cast<size_t>(msgHdr->optionalParameterLength);

    constexpr size_t bgpOpenMsgHeaderSize = sizeof(bgp_open_message);
    if (headerLen < optParamLen + bgpOpenMsgHeaderSize)
    {
      PCPP_LOG_WARN("BGP Layer optional param length exceeds total BGP message. "
                    "This packet might be malformed! Trimming to maximum allowed by BGP message length.");
      optParamLen = headerLen >= bgpOpenMsgHeaderSize ? headerLen - bgpOpenMsgHeaderSize : 0;
    }

    return optParamLen;
  }

  bool BgpOpenMessageLayer::setOptionalParameters(const std::vector<optional_parameter>& optionalParameters)
  {
    uint8_t newOptionalParamsData[1500];
    size_t newOptionalParamsDataLen = optionalParamsToByteArray(optionalParameters, newOptionalParamsData, 1500);
    size_t curOptionalParamsDataLen = getOptionalParametersLength();
    constexpr int offsetInLayer = sizeof(bgp_open_message);

    if (newOptionalParamsDataLen > curOptionalParamsDataLen)
    {
      size_t numOfBytesToExtend = newOptionalParamsDataLen - curOptionalParamsDataLen;

      if (!extendLayer(offsetInLayer, numOfBytesToExtend))
      {
        PCPP_LOG_ERROR("Couldn't extend BGP open layer to include the additional optional parameters");
        return false;
      }
    }
    else if (newOptionalParamsDataLen < curOptionalParamsDataLen)
    {
      size_t numOfBytesToShorten = curOptionalParamsDataLen - newOptionalParamsDataLen;

      if (!shortenLayer(offsetInLayer, numOfBytesToShorten))
      {
        PCPP_LOG_ERROR("Couldn't shorten BGP open layer to set the right size of the optional parameters data");
        return false;
      }
    }

    if (newOptionalParamsDataLen > 0)
    {
      memcpy(m_Data + offsetInLayer, newOptionalParamsData, newOptionalParamsDataLen);
    }

    getOpenMsgHeader()->optionalParameterLength = static_cast<uint8_t>(newOptionalParamsDataLen);
    getOpenMsgHeader()->length = htobe16(sizeof(bgp_open_message) + newOptionalParamsDataLen);

    return true;
  }

  bool BgpOpenMessageLayer::clearOptionalParameters()
  {
    return setOptionalParameters(std::vector<optional_parameter>());
  }

  // ~~~~~~~~~~~~~~~~~~~~~
  // BgpUpdateMessageLayer
  // ~~~~~~~~~~~~~~~~~~~~~

  BgpUpdateMessageLayer::path_attribute::path_attribute(uint8_t flagsVal, uint8_t typeVal,
                                                        const std::string& dataAsHexString)
  {
    flags = flagsVal;
    type = typeVal;
    length = hexStringToByteArray(dataAsHexString, data, 32);
  }

  BgpUpdateMessageLayer::BgpUpdateMessageLayer(const std::vector<prefix_and_ip>& withdrawnRoutes,
                                               const std::vector<path_attribute>& pathAttributes,
                                               const std::vector<prefix_and_ip>& nlri)
  {
    uint8_t withdrawnRoutesData[1500];
    uint8_t pathAttributesData[1500];
    uint8_t nlriData[1500];
    size_t withdrawnRoutesDataLen = prefixAndIPDataToByteArray(withdrawnRoutes, withdrawnRoutesData, 1500);
    size_t pathAttributesDataLen = pathAttributesToByteArray(pathAttributes, pathAttributesData, 1500);
    size_t nlriDataLen = prefixAndIPDataToByteArray(nlri, nlriData, 1500);

    size_t headerLen = sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + withdrawnRoutesDataLen +
                       pathAttributesDataLen + nlriDataLen;
    allocData(headerLen);
    setBgpFields(headerLen);

    uint8_t* dataPtr = m_Data + sizeof(bgp_common_header);

    // copy withdrawn routes data
    uint16_t withdrawnRoutesDataLenBE = htobe16(withdrawnRoutesDataLen);
    memcpy(dataPtr, &withdrawnRoutesDataLenBE, sizeof(uint16_t));
    dataPtr += sizeof(uint16_t);
    if (withdrawnRoutesDataLen > 0)
    {
      memcpy(dataPtr, withdrawnRoutesData, withdrawnRoutesDataLen);
      dataPtr += withdrawnRoutesDataLen;
    }

    // copy path attributes data
    uint16_t pathAttributesDataLenBE = htobe16(pathAttributesDataLen);
    memcpy(dataPtr, &pathAttributesDataLenBE, sizeof(uint16_t));
    dataPtr += sizeof(uint16_t);
    if (pathAttributesDataLen > 0)
    {
      memcpy(dataPtr, pathAttributesData, pathAttributesDataLen);
      dataPtr += pathAttributesDataLen;
    }

    // copy nlri data
    if (nlriDataLen > 0)
    {
      memcpy(dataPtr, nlriData, nlriDataLen);
    }

    m_Protocol = BGP;
  }

  void BgpUpdateMessageLayer::parsePrefixAndIPData(uint8_t* dataPtr, size_t dataLen,
                                                   std::vector<prefix_and_ip>& result)
  {
    size_t byteCount = 0;
    while (byteCount < dataLen)
    {
      prefix_and_ip wr;
      wr.prefix = dataPtr[0];
      size_t curByteCount = 1;
      if (wr.prefix == 32)
      {
        uint8_t octets[4] = { dataPtr[1], dataPtr[2], dataPtr[3], dataPtr[4] };
        wr.ipAddr = IPv4Address(octets);
        curByteCount += 4;
      }
      else if (wr.prefix == 24)
      {
        uint8_t octets[4] = { dataPtr[1], dataPtr[2], dataPtr[3], 0 };
        wr.ipAddr = IPv4Address(octets);
        curByteCount += 3;
      }
      else if (wr.prefix == 16)
      {
        uint8_t octets[4] = { dataPtr[1], dataPtr[2], 0, 0 };
        wr.ipAddr = IPv4Address(octets);
        curByteCount += 2;
      }
      else if (wr.prefix == 8)
      {
        uint8_t octets[4] = { dataPtr[1], 0, 0, 0 };
        wr.ipAddr = IPv4Address(octets);
        curByteCount += 1;
      }
      else
      {
        PCPP_LOG_DEBUG("Illegal prefix value " << (int)wr.prefix);
        break;  // illegal value
      }

      result.push_back(wr);
      dataPtr += curByteCount;
      byteCount += curByteCount;
    }
  }

  size_t BgpUpdateMessageLayer::prefixAndIPDataToByteArray(const std::vector<prefix_and_ip>& prefixAndIpData,
                                                           uint8_t* resultByteArr, size_t maxByteArrSize)
  {
    if (resultByteArr == nullptr || maxByteArrSize == 0)
    {
      return 0;
    }

    size_t dataLen = 0;

    for (const auto& prefixAndIp : prefixAndIpData)
    {
      uint8_t curData[5];
      curData[0] = prefixAndIp.prefix;
      size_t curDataSize = 1;
      const uint8_t* octets = prefixAndIp.ipAddr.toBytes();
      if (prefixAndIp.prefix == 32)
      {
        curDataSize += 4;
        curData[1] = octets[0];
        curData[2] = octets[1];
        curData[3] = octets[2];
        curData[4] = octets[3];
      }
      else if (prefixAndIp.prefix == 24)
      {
        curDataSize += 3;
        curData[1] = octets[0];
        curData[2] = octets[1];
        curData[3] = octets[2];
      }
      else if (prefixAndIp.prefix == 16)
      {
        curDataSize += 2;
        curData[1] = octets[0];
        curData[2] = octets[1];
      }
      else if (prefixAndIp.prefix == 8)
      {
        curDataSize += 1;
        curData[1] = octets[0];
      }
      else
      {
        PCPP_LOG_ERROR("Illegal prefix value " << (int)prefixAndIp.prefix);
        break;  // illegal value
      }

      if (dataLen + curDataSize > maxByteArrSize)
      {
        break;
      }

      dataLen += curDataSize;

      memcpy(resultByteArr, curData, curDataSize);
      resultByteArr += curDataSize;
    }

    return dataLen;
  }

  size_t BgpUpdateMessageLayer::pathAttributesToByteArray(const std::vector<path_attribute>& pathAttributes,
                                                          uint8_t* resultByteArr, size_t maxByteArrSize)
  {
    if (resultByteArr == nullptr || maxByteArrSize == 0)
    {
      return 0;
    }

    size_t dataLen = 0;

    for (const auto& attribute : pathAttributes)
    {
      if (attribute.length > 32)
      {
        PCPP_LOG_ERROR("Illegal path attribute length " << (int)attribute.length);
        break;  // illegal value
      }

      size_t curDataSize = 3 * sizeof(uint8_t) + (size_t)attribute.length;

      if (dataLen + curDataSize > maxByteArrSize)
      {
        break;
      }

      resultByteArr[0] = attribute.flags;
      resultByteArr[1] = attribute.type;
      resultByteArr[2] = attribute.length;
      if (attribute.length > 0)
      {
        memcpy(resultByteArr + 3 * sizeof(uint8_t), attribute.data, attribute.length);
      }

      dataLen += curDataSize;
      resultByteArr += curDataSize;
    }

    return dataLen;
  }

  size_t BgpUpdateMessageLayer::getWithdrawnRoutesLength() const
  {
    size_t headerLen = getHeaderLen();
    size_t minLen = sizeof(bgp_common_header) + sizeof(uint16_t);
    if (headerLen >= minLen)
    {
      uint16_t res = be16toh(*(uint16_t*)(m_Data + sizeof(bgp_common_header)));
      if ((size_t)res > headerLen - minLen)
      {
        return headerLen - minLen;
      }

      return (size_t)res;
    }

    return 0;
  }

  void BgpUpdateMessageLayer::getWithdrawnRoutes(std::vector<prefix_and_ip>& withdrawnRoutes)
  {
    size_t withdrawnRouteLen = getWithdrawnRoutesLength();
    if (withdrawnRouteLen == 0)
    {
      return;
    }

    uint8_t* dataPtr = m_Data + sizeof(bgp_common_header) + sizeof(uint16_t);
    parsePrefixAndIPData(dataPtr, withdrawnRouteLen, withdrawnRoutes);
  }

  size_t BgpUpdateMessageLayer::getPathAttributesLength() const
  {
    size_t headerLen = getHeaderLen();
    size_t minLen = sizeof(bgp_common_header) + 2 * sizeof(uint16_t);
    if (headerLen >= minLen)
    {
      size_t withdrawnRouteLen = getWithdrawnRoutesLength();
      // Ensure the memory access is within bounds
      if (sizeof(bgp_common_header) + sizeof(uint16_t) + withdrawnRouteLen + sizeof(uint16_t) > headerLen)
      {
        return 0;  // Invalid access, return 0
      }
      uint16_t res =
          be16toh(*(uint16_t*)(m_Data + sizeof(bgp_common_header) + sizeof(uint16_t) + withdrawnRouteLen));
      if ((size_t)res > headerLen - minLen - withdrawnRouteLen)
      {
        return headerLen - minLen - withdrawnRouteLen;
      }

      return (size_t)res;
    }

    return 0;
  }

  bool BgpUpdateMessageLayer::setWithdrawnRoutes(const std::vector<prefix_and_ip>& withdrawnRoutes)
  {
    uint8_t newWithdrawnRoutesData[1500];
    size_t newWithdrawnRoutesDataLen = prefixAndIPDataToByteArray(withdrawnRoutes, newWithdrawnRoutesData, 1500);
    size_t curWithdrawnRoutesDataLen = getWithdrawnRoutesLength();
    int offsetInLayer = sizeof(bgp_common_header) + sizeof(uint16_t);

    if (newWithdrawnRoutesDataLen > curWithdrawnRoutesDataLen)
    {
      size_t numOfBytesToExtend = newWithdrawnRoutesDataLen - curWithdrawnRoutesDataLen;

      if (!extendLayer(offsetInLayer, numOfBytesToExtend))
      {
        PCPP_LOG_ERROR("Couldn't extend BGP update layer to include the additional withdrawn routes");
        return false;
      }
    }
    else if (newWithdrawnRoutesDataLen < curWithdrawnRoutesDataLen)
    {
      size_t numOfBytesToShorten = curWithdrawnRoutesDataLen - newWithdrawnRoutesDataLen;

      if (!shortenLayer(offsetInLayer, numOfBytesToShorten))
      {
        PCPP_LOG_ERROR("Couldn't shorten BGP update layer to set the right size of the withdrawn routes data");
        return false;
      }
    }

    if (newWithdrawnRoutesDataLen > 0)
    {
      memcpy(m_Data + offsetInLayer, newWithdrawnRoutesData, newWithdrawnRoutesDataLen);
    }

    getBasicHeader()->length =
        htobe16(be16toh(getBasicHeader()->length) + newWithdrawnRoutesDataLen - curWithdrawnRoutesDataLen);

    uint16_t newWithdrawnRoutesDataLenBE = htobe16(newWithdrawnRoutesDataLen);
    memcpy(m_Data + sizeof(bgp_common_header), &newWithdrawnRoutesDataLenBE, sizeof(uint16_t));

    return true;
  }

  bool BgpUpdateMessageLayer::clearWithdrawnRoutes()
  {
    return setWithdrawnRoutes(std::vector<prefix_and_ip>());
  }

  void BgpUpdateMessageLayer::getPathAttributes(std::vector<path_attribute>& pathAttributes)
  {
    size_t pathAttrLen = getPathAttributesLength();
    if (pathAttrLen == 0)
    {
      return;
    }

    uint8_t* dataPtr = m_Data + sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + getWithdrawnRoutesLength();
    size_t byteCount = 0;
    while (byteCount < pathAttrLen)
    {
      path_attribute pa;
      pa.flags = dataPtr[0];
      pa.type = dataPtr[1];
      pa.length = dataPtr[2];
      size_t curByteCount = 3 + pa.length;
      if (pa.length > 0)
      {
        size_t dataLenToCopy = (pa.length <= 32 ? pa.length : 32);
        memcpy(pa.data, dataPtr + 3, dataLenToCopy);
      }

      pathAttributes.push_back(pa);
      dataPtr += curByteCount;
      byteCount += curByteCount;
    }
  }

  bool BgpUpdateMessageLayer::setPathAttributes(const std::vector<path_attribute>& pathAttributes)
  {
    uint8_t newPathAttributesData[1500];
    size_t newPathAttributesDataLen = pathAttributesToByteArray(pathAttributes, newPathAttributesData, 1500);
    size_t curPathAttributesDataLen = getPathAttributesLength();
    size_t curWithdrawnRoutesDataLen = getWithdrawnRoutesLength();
    int offsetInLayer = sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + curWithdrawnRoutesDataLen;

    if (newPathAttributesDataLen > curPathAttributesDataLen)
    {
      size_t numOfBytesToExtend = newPathAttributesDataLen - curPathAttributesDataLen;

      if (!extendLayer(offsetInLayer, numOfBytesToExtend))
      {
        PCPP_LOG_ERROR("Couldn't extend BGP update layer to include the additional path attributes");
        return false;
      }
    }
    else if (newPathAttributesDataLen < curPathAttributesDataLen)
    {
      size_t numOfBytesToShorten = curPathAttributesDataLen - newPathAttributesDataLen;

      if (!shortenLayer(offsetInLayer, numOfBytesToShorten))
      {
        PCPP_LOG_ERROR("Couldn't shorten BGP update layer to set the right size of the path attributes data");
        return false;
      }
    }

    if (newPathAttributesDataLen > 0)
    {
      memcpy(m_Data + offsetInLayer, newPathAttributesData, newPathAttributesDataLen);
    }

    getBasicHeader()->length =
        htobe16(be16toh(getBasicHeader()->length) + newPathAttributesDataLen - curPathAttributesDataLen);

    uint16_t newWithdrawnRoutesDataLenBE = htobe16(newPathAttributesDataLen);
    memcpy(m_Data + sizeof(bgp_common_header) + sizeof(uint16_t) + curWithdrawnRoutesDataLen,
           &newWithdrawnRoutesDataLenBE, sizeof(uint16_t));

    return true;
  }

  bool BgpUpdateMessageLayer::clearPathAttributes()
  {
    return setPathAttributes(std::vector<path_attribute>());
  }

  size_t BgpUpdateMessageLayer::getNetworkLayerReachabilityInfoLength() const
  {
    size_t headerLen = getHeaderLen();
    size_t minLen = sizeof(bgp_common_header) + 2 * sizeof(uint16_t);
    if (headerLen >= minLen)
    {
      size_t withdrawnRouteLen = getWithdrawnRoutesLength();
      size_t pathAttrLen = getPathAttributesLength();
      int nlriSize = headerLen - minLen - withdrawnRouteLen - pathAttrLen;
      if (nlriSize >= 0)
      {
        return (size_t)nlriSize;
      }

      return 0;
    }

    return 0;
  }

  void BgpUpdateMessageLayer::getNetworkLayerReachabilityInfo(std::vector<prefix_and_ip>& nlri)
  {
    size_t nlriSize = getNetworkLayerReachabilityInfoLength();
    if (nlriSize == 0)
    {
      return;
    }

    uint8_t* dataPtr = m_Data + sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + getWithdrawnRoutesLength() +
                       getPathAttributesLength();
    parsePrefixAndIPData(dataPtr, nlriSize, nlri);
  }

  bool BgpUpdateMessageLayer::isDataValid(const uint8_t* data, size_t dataSize)
  {
    if (dataSize < sizeof(bgp_common_header) + 2 * sizeof(uint16_t))
      return false;

    uint16_t withdrLen = be16toh(*(uint16_t*)(data + sizeof(bgp_common_header)));
    if (dataSize < sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + withdrLen)
      return false;

    uint16_t attrLen = be16toh(*(uint16_t*)(data + sizeof(bgp_common_header) + sizeof(uint16_t) + withdrLen));
    if (dataSize < sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + withdrLen + attrLen)
      return false;

    return true;
  }

  bool BgpUpdateMessageLayer::setNetworkLayerReachabilityInfo(const std::vector<prefix_and_ip>& nlri)
  {
    uint8_t newNlriData[1500];
    size_t newNlriDataLen = prefixAndIPDataToByteArray(nlri, newNlriData, 1500);
    size_t curNlriDataLen = getNetworkLayerReachabilityInfoLength();
    size_t curPathAttributesDataLen = getPathAttributesLength();
    size_t curWithdrawnRoutesDataLen = getWithdrawnRoutesLength();
    int offsetInLayer =
        sizeof(bgp_common_header) + 2 * sizeof(uint16_t) + curWithdrawnRoutesDataLen + curPathAttributesDataLen;

    if (newNlriDataLen > curNlriDataLen)
    {
      size_t numOfBytesToExtend = newNlriDataLen - curNlriDataLen;

      if (!extendLayer(offsetInLayer, numOfBytesToExtend))
      {
        PCPP_LOG_ERROR("Couldn't extend BGP update layer to include the additional NLRI data");
        return false;
      }
    }
    else if (newNlriDataLen < curNlriDataLen)
    {
      size_t numOfBytesToShorten = curNlriDataLen - newNlriDataLen;

      if (!shortenLayer(offsetInLayer, numOfBytesToShorten))
      {
        PCPP_LOG_ERROR("Couldn't shorten BGP update layer to set the right size of the NLRI data");
        return false;
      }
    }

    if (newNlriDataLen > 0)
    {
      memcpy(m_Data + offsetInLayer, newNlriData, newNlriDataLen);
    }

    getBasicHeader()->length = htobe16(be16toh(getBasicHeader()->length) + newNlriDataLen - curNlriDataLen);

    return true;
  }

  bool BgpUpdateMessageLayer::clearNetworkLayerReachabilityInfo()
  {
    return setNetworkLayerReachabilityInfo(std::vector<prefix_and_ip>());
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  // BgpNotificationMessageLayer
  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~

  BgpNotificationMessageLayer::BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode)
  {
    initMessageData(errorCode, errorSubCode, nullptr, 0);
  }

  BgpNotificationMessageLayer::BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode,
                                                           const uint8_t* notificationData,
                                                           size_t notificationDataLen)
  {
    initMessageData(errorCode, errorSubCode, notificationData, notificationDataLen);
  }

  BgpNotificationMessageLayer::BgpNotificationMessageLayer(uint8_t errorCode, uint8_t errorSubCode,
                                                           const std::string& notificationData)
  {
    uint8_t notificationDataByteArr[1500];
    size_t notificationDataLen = hexStringToByteArray(notificationData, notificationDataByteArr, 1500);
    initMessageData(errorCode, errorSubCode, notificationDataByteArr, notificationDataLen);
  }

  void BgpNotificationMessageLayer::initMessageData(uint8_t errorCode, uint8_t errorSubCode,
                                                    const uint8_t* notificationData, size_t notificationDataLen)
  {
    size_t headerLen = sizeof(bgp_notification_message);
    if (notificationData != nullptr && notificationDataLen > 0)
    {
      headerLen += notificationDataLen;
    }
    allocData(headerLen);
    setBgpFields(headerLen);
    bgp_notification_message* msgHdr = getNotificationMsgHeader();
    msgHdr->errorCode = errorCode;
    msgHdr->errorSubCode = errorSubCode;
    memcpy(m_Data + sizeof(bgp_notification_message), notificationData, notificationDataLen);
    m_Protocol = BGP;
  }

  size_t BgpNotificationMessageLayer::getNotificationDataLen() const
  {
    size_t headerLen = getHeaderLen();
    if (headerLen > sizeof(bgp_notification_message))
    {
      return headerLen - sizeof(bgp_notification_message);
    }

    return 0;
  }

  uint8_t* BgpNotificationMessageLayer::getNotificationData() const
  {
    if (getNotificationDataLen() > 0)
    {
      return m_Data + sizeof(bgp_notification_message);
    }

    return nullptr;
  }

  std::string BgpNotificationMessageLayer::getNotificationDataAsHexString() const
  {
    uint8_t* notificationData = getNotificationData();
    if (notificationData == nullptr)
    {
      return "";
    }

    return byteArrayToHexString(notificationData, getNotificationDataLen());
  }

  bool BgpNotificationMessageLayer::setNotificationData(const uint8_t* newNotificationData,
                                                        size_t newNotificationDataLen)
  {
    if (newNotificationData == nullptr)
    {
      newNotificationDataLen = 0;
    }

    size_t curNotificationDataLen = getNotificationDataLen();
    int offsetInLayer = sizeof(bgp_notification_message);

    if (newNotificationDataLen > curNotificationDataLen)
    {
      size_t numOfBytesToExtend = newNotificationDataLen - curNotificationDataLen;

      if (!extendLayer(offsetInLayer, numOfBytesToExtend))
      {
        PCPP_LOG_ERROR("Couldn't extend BGP notification layer to include the additional notification data");
        return false;
      }
    }
    else if (newNotificationDataLen < curNotificationDataLen)
    {
      size_t numOfBytesToShorten = curNotificationDataLen - newNotificationDataLen;

      if (!shortenLayer(offsetInLayer, numOfBytesToShorten))
      {
        PCPP_LOG_ERROR(
            "Couldn't shorten BGP notification layer to set the right size of the notification data");
        return false;
      }
    }

    if (newNotificationDataLen > 0)
    {
      memcpy(m_Data + offsetInLayer, newNotificationData, newNotificationDataLen);
    }

    getNotificationMsgHeader()->length = htobe16(sizeof(bgp_notification_message) + newNotificationDataLen);

    return true;
  }

  bool BgpNotificationMessageLayer::setNotificationData(const std::string& newNotificationDataAsHexString)
  {
    if (newNotificationDataAsHexString.empty())
    {
      return setNotificationData(nullptr, 0);
    }

    uint8_t newNotificationData[1500];
    size_t newNotificationDataLen = hexStringToByteArray(newNotificationDataAsHexString, newNotificationData, 1500);

    if (newNotificationDataLen == 0)
    {
      PCPP_LOG_ERROR("newNotificationDataAsHexString is not a valid hex string");
      return false;
    }

    return setNotificationData(newNotificationData, newNotificationDataLen);
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~
  // BgpKeepaliveMessageLayer
  // ~~~~~~~~~~~~~~~~~~~~~~~~

  BgpKeepaliveMessageLayer::BgpKeepaliveMessageLayer() : BgpLayer()
  {
    const size_t headerLen = sizeof(bgp_common_header);
    allocData(headerLen);
    setBgpFields(headerLen);
    m_Protocol = BGP;
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  // BgpRouteRefreshMessageLayer
  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~

  BgpRouteRefreshMessageLayer::BgpRouteRefreshMessageLayer(uint16_t afi, uint8_t safi)
  {
    const size_t headerLen = sizeof(bgp_route_refresh_message);
    allocData(headerLen);
    setBgpFields(headerLen);
    bgp_route_refresh_message* msgHdr = getRouteRefreshHeader();
    msgHdr->afi = htobe16(afi);
    msgHdr->safi = safi;
    m_Protocol = BGP;
  }

}  // namespace pcpp

Coverage Report

Created: 2026-09-01 08:15