S7CommLayer.h

#pragma once
 
#include <memory>
#include "EthLayer.h"
#include "Layer.h"
 
namespace pcpp
{
#pragma pack(push, 1)
    typedef struct
    {
        uint8_t protocolId;
        uint8_t msgType;
        uint16_t reserved;
        uint16_t pduRef;
        uint16_t paramLength;
        uint16_t dataLength;
    } s7commhdr;
#pragma pack(pop)
    static_assert(sizeof(s7commhdr) == 10, "s7commhdr size is not 10 bytes");
 
#pragma pack(push, 1)
    struct s7comm_ack_data_hdr : s7commhdr
    {
        uint8_t errorClass;
        uint8_t errorCode;
    };
#pragma pack(pop)
    static_assert(sizeof(s7comm_ack_data_hdr) == 12, "s7comm_ack_data_hdr size is not 12 bytes");
 
    class S7CommParameter
    {
        friend class S7CommLayer;
 
    public:
        S7CommParameter()
        {}
 
        virtual ~S7CommParameter() = default;
 
        uint8_t* getData() const
        {
            return m_Data;
        }
        size_t getDataLength() const
        {
            return m_DataLen;
        }
 
    private:
        S7CommParameter(uint8_t* data, size_t dataLen) : m_Data(data), m_DataLen(dataLen)
        {}
        uint8_t* m_Data;
        size_t m_DataLen;
    };
    class S7CommLayer : public Layer
    {
    public:
        S7CommLayer(uint8_t msgType, uint16_t pduRef, uint16_t paramLength, uint16_t dataLength, uint8_t errorClass = 0,
                    uint8_t errorCode = 0);
 
        S7CommLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, S7COMM)
        {}
 
        ~S7CommLayer() override = default;
 
        uint8_t getProtocolId() const;
 
        uint8_t getMsgType() const;
 
        uint16_t getPduRef() const;
 
        uint16_t getParamLength() const;
 
        uint16_t getDataLength() const;
 
        uint8_t getErrorCode() const;
 
        uint8_t getErrorClass() const;
 
        const S7CommParameter* getParameter();
 
        void setMsgType(uint8_t msgType) const;
 
        void setPduRef(uint16_t pduRef) const;
 
        void setErrorCode(uint8_t errorCode) const;
        void setErrorClass(uint8_t errorClass) const;
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        void computeCalculateFields() override
        {}
 
        void parseNextLayer() override
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataSize);
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
    private:
        s7commhdr* getS7commHeader() const
        {
            return reinterpret_cast<s7commhdr*>(m_Data);
        }
 
        s7comm_ack_data_hdr* getS7commAckDataHeader() const
        {
            if (getS7commHeader()->msgType == 0x03)
            {
                return reinterpret_cast<s7comm_ack_data_hdr*>(m_Data);
            }
            return nullptr;
        }
 
        size_t getS7commHeaderLength() const;
 
        std::unique_ptr<S7CommParameter> m_Parameter;
    };
 
}  // namespace pcpp