SomeIpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include <unordered_set>
 
 
namespace pcpp
{
    class SomeIpLayer : public Layer
    {
    public:
        enum class MsgType : uint8_t
        {
            REQUEST = 0x00,
            REQUEST_ACK = 0x40,
            REQUEST_NO_RETURN = 0x01,
            REQUEST_NO_RETURN_ACK = 0x41,
            NOTIFICATION = 0x02,
            NOTIFICATION_ACK = 0x42,
            RESPONSE = 0x80,
            RESPONSE_ACK = 0xC0,
            ERRORS = 0x81,
            ERROR_ACK = 0xC1,
            TP_REQUEST = 0x20,
            TP_REQUEST_NO_RETURN = 0x21,
            TP_NOTIFICATION = 0x22,
            TP_RESPONSE = 0xa0,
            TP_ERROR = 0xa1,
        };
 
#pragma pack(push, 1)
        struct someiphdr
        {
            uint16_t serviceID;
            uint16_t methodID;
            uint32_t length;
            uint16_t clientID;
            uint16_t sessionID;
            uint8_t protocolVersion;
            uint8_t interfaceVersion;
            uint8_t msgType;
            uint8_t returnCode;
        };
#pragma pack(pop)
        static_assert(sizeof(someiphdr) == 16, "someiphdr size is not 16 bytes");
 
        SomeIpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, SomeIP)
        {}
 
        SomeIpLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID,
                    uint8_t interfaceVersion, MsgType type, uint8_t returnCode, const uint8_t* const data = nullptr,
                    size_t dataLen = 0);
 
        ~SomeIpLayer() override = default;
 
        static Layer* parseSomeIpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        someiphdr* getSomeIpHeader() const
        {
            return reinterpret_cast<someiphdr*>(m_Data);
        }
 
        static bool isSomeIpPort(uint16_t port);
 
        static void addSomeIpPort(uint16_t port);
 
        static void removeSomeIpPort(uint16_t port);
 
        static void removeAllSomeIpPorts();
 
        uint32_t getMessageID() const;
 
        void setMessageID(uint32_t messageID);
 
        uint16_t getServiceID() const;
 
        void setServiceID(uint16_t serviceID);
 
        uint16_t getMethodID() const;
 
        void setMethodID(uint16_t methodID);
 
        uint32_t getLengthField() const;
 
        uint32_t getRequestID() const;
 
        void setRequestID(uint32_t requestID);
 
        uint16_t getSessionID() const;
 
        void setSessionID(uint16_t sessionID);
 
        uint16_t getClientID() const;
 
        void setClientID(uint16_t clientID);
 
        uint8_t getProtocolVersion() const;
 
        void setProtocolVersion(uint8_t version);
 
        uint8_t getInterfaceVersion() const;
 
        void setInterfaceVersion(uint8_t version);
 
        uint8_t getMessageTypeAsInt() const;
 
        SomeIpLayer::MsgType getMessageType() const;
 
        void setMessageType(MsgType type);
 
        void setMessageType(uint8_t type);
 
        uint8_t getReturnCode() const;
 
        void setReturnCode(uint8_t returnCode);
 
        void setPayloadLength(uint32_t payloadLength);
 
        uint8_t* getPduPayload() const
        {
            return m_Data + getSomeIpHeaderLen();
        }
 
        size_t getPduPayloadSize() const
        {
            return getHeaderLen() - getSomeIpHeaderLen();
        }
 
        size_t getHeaderLen() const override
        {
            return sizeof(uint32_t) * 2 + getLengthField();
        }
 
        virtual void computeCalculateFields() override
        {}
 
        void parseNextLayer() override;
 
        virtual 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{ ServiceID,   MethodID,        ClientID,
                                                              SessionID,   ProtocolVersion, InterfaceVersion,
                                                              MessageType, MessageTypeName, ReturnCode };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor ServiceID;
 
            static const FieldDescriptor MethodID;
 
            static const FieldDescriptor ClientID;
 
            static const FieldDescriptor SessionID;
 
            static const FieldDescriptor ProtocolVersion;
 
            static const FieldDescriptor InterfaceVersion;
 
            static const FieldDescriptor MessageType;
 
            static const FieldDescriptor MessageTypeName;
 
            static const FieldDescriptor ReturnCode;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 9;
        };
 
    protected:
        SomeIpLayer()
        {}
 
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        static const uint8_t SOMEIP_PROTOCOL_VERSION = 1;
        virtual size_t getSomeIpHeaderLen() const
        {
            return sizeof(someiphdr);
        }
 
        // Using unordered_set since insertion and search should be almost constant time
        static std::unordered_set<uint16_t> m_SomeIpPorts;
    };
 
    class SomeIpTpLayer : public SomeIpLayer
    {
    public:
#pragma pack(push, 1)
        struct someiptphdr : someiphdr
        {
            uint32_t offsetAndFlag;
        };
#pragma pack(pop)
        static_assert(sizeof(someiptphdr) == 20, "someiptphdr size is not 20 bytes");
 
        SomeIpTpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : SomeIpLayer(data, dataLen, prevLayer, packet)
        {}
 
        SomeIpTpLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID,
                      uint8_t interfaceVersion, MsgType type, uint8_t returnCode, uint32_t offset,
                      bool moreSegmentsFlag, const uint8_t* const data = nullptr, size_t dataLen = 0);
 
        ~SomeIpTpLayer() override = default;
 
        someiptphdr* getSomeIpTpHeader() const
        {
            return reinterpret_cast<someiptphdr*>(m_Data);
        }
 
        uint32_t getOffset() const;
 
        void setOffset(uint32_t offset);
 
        bool getMoreSegmentsFlag() const;
 
        void setMoreSegmentsFlag(bool flag);
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        struct SerializedFields : SomeIpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = SomeIpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Offset, MoreSegments };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Offset;
 
            static const FieldDescriptor MoreSegments;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        static const uint32_t SOMEIP_TP_MORE_FLAG_MASK = 0x01;
        static const uint32_t SOMEIP_TP_OFFSET_MASK = 0xFFFFFFF0;
 
        size_t getSomeIpHeaderLen() const override
        {
            return sizeof(someiptphdr);
        }
 
        static uint8_t setTpFlag(uint8_t messageType);
    };
 
}  // namespace pcpp