ModbusLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
 
 
namespace pcpp
{
 
#pragma pack(push, 1)
    struct modbus_header
    {
        uint16_t transactionId;
        uint16_t protocolId;
        uint16_t length;
        uint8_t unitId;
        uint8_t functionCode;
    };
#pragma pack(pop)
    static_assert(sizeof(modbus_header) == 8, "modbus_header size is not 8 bytes");
 
    class ModbusLayer : public Layer
    {
    public:
        enum class ModbusFunctionCode : uint8_t
        {
            ReadCoils = 1,
 
            ReadDiscreteInputs = 2,
 
            ReadHoldingRegisters = 3,
 
            ReadInputRegisters = 4,
 
            WriteSingleCoil = 5,
 
            WriteSingleHoldingRegister = 6,
 
            WriteMultipleCoils = 15,
 
            WriteMultipleHoldingRegisters = 16,
 
            ReadSlaveId = 17,
 
            UnknownFunction = 0xFF
        };
 
        struct ModbusReadInputRegisters
        {
            uint16_t startingAddress;  
            uint16_t quantity;         
        };
 
        ModbusLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, Modbus)
        {}
 
        ModbusLayer(uint16_t transactionId, uint8_t unitId);
 
        static bool isModbusPort(uint16_t port)
        {
            return port == 502;
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataSize)
        {
            return data != nullptr && dataSize >= sizeof(modbus_header);
        }
 
        uint16_t getTransactionId() const;
 
        uint16_t getProtocolId() const;
 
        uint16_t getLength() const;
 
        uint8_t getUnitId() const;
 
        ModbusFunctionCode getFunctionCode() const;
 
        void setTransactionId(uint16_t transactionId);
 
        void setUnitId(uint8_t unitId);
 
        void setFunctionCode(ModbusFunctionCode functionCode);
 
        // Overridden methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return sizeof(modbus_header);
        }
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ TransactionID, ProtocolID, UnitID, FunctionCode };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor TransactionID;
 
            static const FieldDescriptor ProtocolID;
 
            static const FieldDescriptor UnitID;
 
            static const FieldDescriptor FunctionCode;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        modbus_header* getModbusHeader() const;
    };
 
}  // namespace pcpp