infiniband soft_RoCE implement

Packet++/CMakeLists.txt

@@ -60,6 +60,7 @@ add_library(
   src/TLVData.cpp
   src/TpktLayer.cpp
   src/UdpLayer.cpp
+  src/InfiniBandLayer.cpp
   src/VlanLayer.cpp
   src/VrrpLayer.cpp
   src/VxlanLayer.cpp

Packet++/header/InfiniBandLayer.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "Layer.h"
+
+/// @file
+
+/**
+ * \namespace pcpp
+ * \brief The main namespace for the PcapPlusPlus lib
+ */
+namespace pcpp
+{
+	/*
+	 * IBA header types and methods
+	 *
+	 * Some of these are for reference and completeness only since
+	 * rxe does not currently support RD transport
+	 * most of this could be moved into Infiniband core. ib_pack.h has
+	 * part of this but is incomplete
+	 *
+	 * Header specific routines to insert/extract values to/from headers
+	 * the routines that are named __hhh_(set_)fff() take a pointer to a
+	 * hhh header and get(set) the fff field. The routines named
+	 * hhh_(set_)fff take a packet info struct and find the
+	 * header and field based on the opcode in the packet.
+	 * Conversion to/from network byte order from cpu order is also done.
+	 */
+
+#define RXE_ICRC_SIZE 4
+#define RXE_MAX_HDR_LENGTH 80
+
+	/* Base Transport Header */
+	struct rxe_bth
+	{
+		uint8_t opcode;
+		uint8_t flags;
+		uint16_t pkey;
+		uint32_t qpn;
+		uint32_t apsn;
+	};
+
+#define BTH_TVER 0x0
+#define BTH_DEF_PKEY 0xffff
+
+#define BTH_SE_MASK 0x80
+#define BTH_MIG_MASK 0x40
+#define BTH_PAD_MASK 0x30
+#define BTH_TVER_MASK 0x0f
+#define BTH_FECN_MASK 0x80000000
+#define BTH_BECN_MASK 0x40000000
+#define BTH_RESV6A_MASK 0x3f000000
+#define BTH_QPN_MASK 0x00ffffff
+#define BTH_ACK_MASK 0x80000000
+#define BTH_RESV7_MASK 0x7f000000
+#define BTH_PSN_MASK 0x00ffffff
+
+	/**
+	 * @class InfiniBandLayer
+	 * Represents an InfiniBand protocol layer
+	 */
+	class InfiniBandLayer : public Layer
+	{
+	public:
+
+		InfiniBandLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
+		    : Layer(data, dataLen, prevLayer, packet, Infiniband)
+		{}
+
+		InfiniBandLayer(uint8_t opcode, int se, int mig, int pad, uint16_t pkey, uint32_t qpn, int ack_req,
+		                uint32_t psn);
+
+		rxe_bth* getBthHeader() const
+		{
+			return reinterpret_cast<rxe_bth*>(m_Data);
+		}
+
+		uint8_t getOpcode() const;
+		void setOpcode(uint8_t opcode) const;
+		uint8_t getSe() const;
+		void setSe(int se) const;
+		uint8_t getMig() const;
+		void setMig(uint8_t mig) const;
+		uint8_t getPad() const;
+		void setPad(uint8_t pad) const;
+		uint8_t getTver() const;
+		void setTver(uint8_t tver) const;
+		uint16_t getPkey() const;
+		void setPkey(uint16_t pkey) const;
+		uint32_t getQpn() const;
+		void setQpn(uint32_t qpn) const;
+		int getFecn() const;
+		void setfecn(int fecn) const;
+		int getBecn() const;
+		void setbecn(int becn) const;
+		uint8_t getResv6a() const;
+		void setResv6a() const;
+		int getAck() const;
+		void setAck(int ack) const;
+		void setResv7() const;
+		uint32_t getPsn() const;
+		void setPsn(uint32_t psn) const;
+
+		void parseNextLayer() override;
+
+		size_t getHeaderLen() const override
+		{
+			return sizeof(rxe_bth);
+		}
+
+		/**
+		 * Calculate @ref udphdr#headerChecksum field
+		 */
+		void computeCalculateFields() override;
+
+		std::string toString() const override;
+
+		OsiModelLayer getOsiModelLayer() const override
+		{
+			return OsiModelTransportLayer;
+		}
+
+		static inline bool isInfiniBandPort(uint16_t port)
+		{
+			return (port == 4791);
+		}
+	};
+
+}  // namespace pcpp

Packet++/header/ProtocolType.h

@@ -352,6 +352,11 @@ namespace pcpp
 	 */
 	const ProtocolType WireGuard = 56;
 
+	/*
+	 * infiniband protocol
+	 */
+	const ProtocolType Infiniband = 57;
+
 	/**
 	 * An enum representing OSI model layers
 	 */

Packet++/src/InfiniBandLayer.cpp

@@ -0,0 +1,201 @@
+#include "InfiniBandLayer.h"
+#include "PayloadLayer.h"
+#include "PacketUtils.h"
+#include "Logger.h"
+#include <string.h>
+#include "EndianPortable.h"
+
+namespace pcpp
+{
+
+	InfiniBandLayer::InfiniBandLayer(uint8_t opcode, int se, int mig, int pad, uint16_t pkey, uint32_t qpn, int ack_req,
+	                                 uint32_t psn)
+	{
+		const size_t headerLen = sizeof(rxe_bth);
+		m_DataLen = headerLen;
+		m_Data = new uint8_t[headerLen];
+		memset(m_Data, 0, headerLen);
+		rxe_bth* bthHdr = reinterpret_cast<rxe_bth*>(m_Data);
+
+		bthHdr->opcode = opcode;
+		bthHdr->flags = (pad << 4) & BTH_PAD_MASK;
+		if (se)
+			bthHdr->flags |= BTH_SE_MASK;
+		if (mig)
+			bthHdr->flags |= BTH_MIG_MASK;
+		bthHdr->pkey = htobe16(pkey);
+		bthHdr->qpn = htobe32(qpn & BTH_QPN_MASK);
+		psn &= BTH_PSN_MASK;
+		if (ack_req)
+			psn |= BTH_ACK_MASK;
+		bthHdr->apsn = htobe32(psn);
+		m_Protocol = Infiniband;
+	}
+
+	void InfiniBandLayer::parseNextLayer()
+	{
+		if (m_DataLen <= sizeof(rxe_bth))
+			return;
+
+		uint8_t* bthData = m_Data + sizeof(rxe_bth);
+		size_t bthDataLen = m_DataLen - sizeof(rxe_bth);
+
+		m_NextLayer = new PayloadLayer(bthData, bthDataLen, this, m_Packet);
+	}
+
+	void InfiniBandLayer::computeCalculateFields()
+	{}
+
+	std::string InfiniBandLayer::toString() const
+	{
+		std::ostringstream ss;
+		ss << "InfiniBand Layer, Opcode: " << getOpcode();
+		return ss.str();
+	}
+
+
+	uint8_t InfiniBandLayer::getOpcode() const
+	{
+		return getBthHeader()->opcode;
+	}
+
+	void InfiniBandLayer::setOpcode(uint8_t opcode) const
+	{
+		getBthHeader()->opcode = opcode;
+	}
+
+	uint8_t InfiniBandLayer::getSe() const
+	{
+		return 0 != (BTH_SE_MASK & getBthHeader()->flags);
+	}
+
+	void InfiniBandLayer::setSe(int se) const
+	{
+		if (se)
+			getBthHeader()->flags |= BTH_SE_MASK;
+		else
+			getBthHeader()->flags &= ~BTH_SE_MASK;
+	}
+
+	uint8_t InfiniBandLayer::getMig() const
+	{
+		return 0 != (BTH_MIG_MASK & getBthHeader()->flags);
+	}
+
+	void InfiniBandLayer::setMig(uint8_t mig) const
+	{
+		if (mig)
+			getBthHeader()->flags |= BTH_MIG_MASK;
+		else
+			getBthHeader()->flags &= ~BTH_MIG_MASK;
+	}
+
+	uint8_t InfiniBandLayer::getPad() const
+	{
+		return (BTH_PAD_MASK & getBthHeader()->flags) >> 4;
+	}
+
+	void InfiniBandLayer::setPad(uint8_t pad) const
+	{
+		getBthHeader()->flags = (BTH_PAD_MASK & (pad << 4)) | (~BTH_PAD_MASK & getBthHeader()->flags);
+	}
+
+	uint8_t InfiniBandLayer::getTver() const
+	{
+		return BTH_TVER_MASK & getBthHeader()->flags;
+	}
+
+	void InfiniBandLayer::setTver(uint8_t tver) const
+	{
+		getBthHeader()->flags = (BTH_TVER_MASK & tver) | (~BTH_TVER_MASK & getBthHeader()->flags);
+	}
+
+	uint16_t InfiniBandLayer::getPkey() const
+	{
+		return be16toh(getBthHeader()->pkey);
+	}
+
+	void InfiniBandLayer::setPkey(uint16_t pkey) const
+	{
+		getBthHeader()->pkey = htobe16(pkey);
+	}
+
+	uint32_t InfiniBandLayer::getQpn() const
+	{
+		return BTH_QPN_MASK & be32toh(getBthHeader()->qpn);
+	}
+
+	void InfiniBandLayer::setQpn(uint32_t qpn) const
+	{
+
+		uint32_t resvqpn = be32toh(getBthHeader()->qpn);
+
+		getBthHeader()->qpn = htobe32((BTH_QPN_MASK & qpn) | (~BTH_QPN_MASK & resvqpn));
+	}
+
+	int InfiniBandLayer::getFecn() const
+	{
+		return 0 != (htobe32(BTH_FECN_MASK) & getBthHeader()->qpn);
+	}
+
+	void InfiniBandLayer::setfecn(int fecn) const
+	{
+		if (fecn)
+			getBthHeader()->qpn |= htobe32(BTH_FECN_MASK);
+		else
+			getBthHeader()->qpn &= ~htobe32(BTH_FECN_MASK);
+	}
+
+	int InfiniBandLayer::getBecn() const
+	{
+		return 0 != (htobe32(BTH_BECN_MASK) & getBthHeader()->qpn);
+	}
+
+	void InfiniBandLayer::setbecn(int becn) const
+	{
+		if (becn)
+			getBthHeader()->qpn |= htobe32(BTH_BECN_MASK);
+		else
+			getBthHeader()->qpn &= ~htobe32(BTH_BECN_MASK);
+	}
+
+	uint8_t InfiniBandLayer::getResv6a() const
+	{
+		return (BTH_RESV6A_MASK & be32toh(getBthHeader()->qpn)) >> 24;
+	}
+
+	void InfiniBandLayer::setResv6a() const
+	{
+		getBthHeader()->qpn = htobe32(~BTH_RESV6A_MASK);
+	}
+
+	int InfiniBandLayer::getAck() const
+	{
+		return 0 != (htobe32(BTH_ACK_MASK) & getBthHeader()->apsn);
+	}
+
+	void InfiniBandLayer::setAck(int ack) const
+	{
+		if (ack)
+			getBthHeader()->apsn |= htobe32(BTH_ACK_MASK);
+		else
+			getBthHeader()->apsn &= ~htobe32(BTH_ACK_MASK);
+	}
+
+	void InfiniBandLayer::setResv7() const
+	{
+		getBthHeader()->apsn &= ~htobe32(BTH_RESV7_MASK);
+	}
+
+	uint32_t InfiniBandLayer::getPsn() const
+	{
+		return BTH_PSN_MASK & be32toh(getBthHeader()->apsn);
+	}
+
+	void InfiniBandLayer::setPsn(uint32_t psn) const
+	{
+		uint32_t apsn = be32toh(getBthHeader()->apsn);
+
+		getBthHeader()->apsn = htobe32((BTH_PSN_MASK & psn) | (~BTH_PSN_MASK & apsn));
+	}
+}  // namespace pcpp

Packet++/src/UdpLayer.cpp

@@ -5,6 +5,7 @@
 #include "PayloadLayer.h"
 #include "IPv4Layer.h"
 #include "IPv6Layer.h"
+#include "InfiniBandLayer.h"
 #include "DnsLayer.h"
 #include "DhcpLayer.h"
 #include "DhcpV6Layer.h"
@@ -142,6 +143,8 @@ namespace pcpp
 			if (!m_NextLayer)
 				m_NextLayer = new PayloadLayer(udpData, udpDataLen, this, m_Packet);
 		}
+		else if (InfiniBandLayer::isInfiniBandPort(portDst))
+			m_NextLayer = new InfiniBandLayer(udpData, udpDataLen, this, m_Packet);
 		else
 			m_NextLayer = new PayloadLayer(udpData, udpDataLen, this, m_Packet);
 	}

Tests/Packet++Test/CMakeLists.txt

@@ -39,6 +39,7 @@ add_executable(
   Tests/TcpTests.cpp
   Tests/TelnetTests.cpp
   Tests/TpktTests.cpp
+  Tests/InfiniBandTests.cpp
   Tests/VlanMplsTests.cpp
   Tests/VrrpTest.cpp
   Tests/WakeOnLanTests.cpp

Tests/Packet++Test/TestDefinition.h

@@ -271,3 +271,6 @@ PTF_TEST_CASE(WireGuardCookieReplyParsingTest);
 PTF_TEST_CASE(WireGuardTransportDataParsingTest);
 PTF_TEST_CASE(WireGuardCreationTest);
 PTF_TEST_CASE(WireGuardEditTest);
+
+// Implemented in InfiniBandTests.cpp
+PTF_TEST_CASE(InfiniBandPacketParsing);