ModbusLayer.h

#pragma once

#include "Layer.h"

/// @file
/// This file contains classes for parsing, creating and editing Modbus packets.

/// @namespace pcpp
/// @brief The main namespace for the PcapPlusPlus lib
namespace pcpp
{

#pragma pack(push, 1)
	/// @struct modbus_header
	/// MODBUS Application Protocol header
	struct modbus_header
	{
		/// For synchronization between messages of server and client
		uint16_t transactionId;
		/// 0 for Modbus/TCP
		uint16_t protocolId;
		/// Number of remaining bytes in this frame starting from the unit id
		uint16_t length;
		/// Unit identifier
		uint8_t unitId;
		/// Function code
		uint8_t functionCode;
	};
#pragma pack(pop)
	static_assert(sizeof(modbus_header) == 8, "modbus_header size is not 8 bytes");

	/// @class ModbusLayer
	/// Represents the MODBUS Application Protocol layer
	class ModbusLayer : public Layer
	{
	public:
		/// @brief Enum class representing Modbus function codes.
		/// This enumeration defines the standard Modbus function codes used in request and response PDUs.
		/// Each value corresponds to a specific operation defined by the Modbus protocol.
		enum class ModbusFunctionCode : uint8_t
		{
			/// Read coil status (0x01)
			ReadCoils = 1,

			/// Read discrete input status (0x02)
			ReadDiscreteInputs = 2,

			/// Read holding registers (0x03)
			ReadHoldingRegisters = 3,

			/// Read input registers (0x04)
			ReadInputRegisters = 4,

			/// Write a single coil (0x05)
			WriteSingleCoil = 5,

			/// Write a single holding register (0x06)
			WriteSingleHoldingRegister = 6,

			/// Write multiple coils (0x0F)
			WriteMultipleCoils = 15,

			/// Write multiple holding registers (0x10)
			WriteMultipleHoldingRegisters = 16,

			/// Report slave ID (0x11)
			ReadSlaveId = 17,

			/// Unknown or unsupported function code (0xFF)
			UnknownFunction = 0xFF
		};

		/// @struct ModbusReadInputRegisters
		/// Represents a Modbus request to read input registers.
		struct ModbusReadInputRegisters
		{
			uint16_t startingAddress;  ///< Starting address of the input registers to read
			uint16_t quantity;         ///< Number of input registers to read
		};

		/// A constructor that creates the layer from an existing packet raw data
		/// @param[in] data A pointer to the raw data
		/// @param[in] dataLen Size of the data in bytes
		/// @param[in] prevLayer A pointer to the previous layer
		/// @param[in] packet A pointer to the Packet instance where layer will be stored in
		ModbusLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
		    : Layer(data, dataLen, prevLayer, packet, Modbus)
		{}

		/// A constructor that creates the layer from user inputs
		/// @param[in] transactionId Transaction ID
		/// @param[in] unitId Unit ID
		ModbusLayer(uint16_t transactionId, uint8_t unitId);

		/// @brief  Check if a port is a valid MODBUS port
		/// @param port Port number to check
		/// @note MODBUS uses port 502, so this function checks if the port is equal to 502
		/// @return true if the port is valid, false otherwise
		static bool isModbusPort(uint16_t port)
		{
			return port == 502;
		}

		/// @return MODBUS message type
		uint16_t getTransactionId() const;

		/// @return MODBUS protocol id
		uint16_t getProtocolId() const;

		/// @return MODBUS remaining bytes in frame starting from the unit id
		/// @note This is the length of the MODBUS payload + unit_id, not the entire packet
		uint16_t getLength() const;

		/// @return MODBUS unit id
		uint8_t getUnitId() const;

		/// @return MODBUS function code
		ModbusFunctionCode getFunctionCode() const;

		/// @brief set the MODBUS transaction id
		/// @param transactionId transaction id
		void setTransactionId(uint16_t transactionId);

		/// @brief set the MODBUS header unit id
		/// @param unitId unit id
		void setUnitId(uint8_t unitId);

		/// @brief set the MODBUS header function code
		/// @param functionCode function code
		void setFunctionCode(ModbusFunctionCode functionCode);

		// Overridden methods

		/// Does nothing for this layer (ModbusLayer is always last)
		void parseNextLayer() override
		{}

		/// @brief Get the length of the MODBUS header
		/// @return Length of the MODBUS header in bytes
		size_t getHeaderLen() const override
		{
			return sizeof(modbus_header);
		}

		/// Does nothing for this layer
		void computeCalculateFields() override
		{}

		/// @return A string representation of the layer most important data (should look like the layer description in
		/// Wireshark)
		std::string toString() const override;

		/// @return The OSI Model layer this protocol belongs to
		OsiModelLayer getOsiModelLayer() const override
		{
			return OsiModelApplicationLayer;
		}

	private:
		/// @return A pointer to the MODBUS header
		modbus_header* getModbusHeader() const;
	};

}  // namespace pcpp