SomeIpSdLayer.h

Go to the documentation of this file.

#pragma once
 
#include "IpAddress.h"
#include "Layer.h"
#include "SomeIpLayer.h"
#include <cstring>
#include <iterator>
#include <unordered_map>
#include <memory>
#include <stdexcept>
#include <vector>
 
 
namespace pcpp
{
    enum SomeIpSdProtocolType : uint8_t
    {
        SD_TCP = 0x06,
        SD_UDP = 0x11
    };
 
    class SomeIpSdLayer;
 
    class SomeIpSdOption
    {
    public:
        friend class SomeIpSdLayer;
 
        enum class OptionType : uint8_t
        {
            Unknown = 0x00,
            ConfigurationString = 0x01,
            LoadBalancing = 0x02,
            IPv4Endpoint = 0x04,
            IPv6Endpoint = 0x06,
            IPv4Multicast = 0x14,
            IPv6Multicast = 0x16,
            IPv4SdEndpoint = 0x24,
            IPv6SdEndpoint = 0x26
        };
 
#pragma pack(push, 1)
        struct someipsdhdroptionsbase
        {
            uint16_t length;
            uint8_t type;
            uint8_t reserved;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdroptionsbase) == 4, "someipsdhdroptionsbase size is not 4 bytes");
 
        virtual ~SomeIpSdOption();
 
        OptionType getType() const;
 
        size_t getLength() const
        {
            return m_DataLen;
        }
 
        uint8_t* getDataPtr() const;
 
        someipsdhdroptionsbase* getSomeIpSdOptionHeader() const;
 
    protected:
        const IDataContainer* m_DataContainer;
        size_t m_Offset;
        uint8_t* m_ShadowData;
        size_t m_DataLen;
 
        SomeIpSdOption() : m_DataContainer(nullptr), m_Offset(0), m_ShadowData(nullptr), m_DataLen(0)
        {}
 
        SomeIpSdOption(const IDataContainer* dataContainer, size_t offset)
            : m_DataContainer(dataContainer), m_Offset(offset), m_ShadowData(nullptr), m_DataLen(0)
        {}
 
        void initStdFields(OptionType type);
 
        SomeIpSdOption(const SomeIpSdOption&) = delete;
        SomeIpSdOption& operator=(const SomeIpSdOption&) = delete;
    };
 
    class SomeIpSdIPv4Option : public SomeIpSdOption
    {
    public:
        friend class SomeIpSdLayer;
 
        enum IPv4OptionType
        {
            IPv4Endpoint,
            IPv4Multicast,
            IPv4SdEndpoint,
        };
 
        SomeIpSdIPv4Option(IPv4OptionType type, IPv4Address ipAddress, uint16_t port, SomeIpSdProtocolType l4Protocol);
 
        SomeIpSdIPv4Option(const IDataContainer* dataContainer, size_t offset);
 
        IPv4Address getIpAddress() const;
 
        uint16_t getPort() const;
 
        SomeIpSdProtocolType getProtocol() const;
 
        static bool isDataValid(const IDataContainer* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(someipsdhdroptionsipv4);
        }
 
    private:
#pragma pack(push, 1)
        struct someipsdhdroptionsipv4 : someipsdhdroptionsbase
        {
            uint32_t ipv4Address;
            // cppcheck-suppress duplInheritedMember
            uint8_t reserved;
            SomeIpSdProtocolType l4Protocol;
            uint16_t portNumber;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdroptionsipv4) == 12, "someipsdhdroptionsipv4 size is not 12 bytes");
    };
 
    class SomeIpSdIPv6Option : public SomeIpSdOption
    {
    public:
        friend class SomeIpSdLayer;
 
        enum IPv6OptionType
        {
            IPv6Endpoint,
            IPv6Multicast,
            IPv6SdEndpoint,
        };
 
        SomeIpSdIPv6Option(IPv6OptionType type, IPv6Address ipAddress, uint16_t port, SomeIpSdProtocolType l4Protocol);
 
        SomeIpSdIPv6Option(const IDataContainer* dataContainer, size_t offset);
 
        IPv6Address getIpAddress() const;
 
        uint16_t getPort() const;
 
        SomeIpSdProtocolType getProtocol() const;
 
        static bool isDataValid(const IDataContainer* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(someipsdhdroptionsipv6);
        }
 
    private:
#pragma pack(push, 1)
        struct someipsdhdroptionsipv6 : someipsdhdroptionsbase
        {
            uint8_t ipv6Address[16];
            // cppcheck-suppress duplInheritedMember
            uint8_t reserved;
            SomeIpSdProtocolType l4Protocol;
            uint16_t portNumber;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdroptionsipv6) == 24, "someipsdhdroptionsipv6 size is not 24 bytes");
    };
 
    class SomeIpSdConfigurationOption : public SomeIpSdOption
    {
    public:
        friend class SomeIpSdLayer;
 
        explicit SomeIpSdConfigurationOption(const std::string& configurationString);
 
        SomeIpSdConfigurationOption(const IDataContainer* dataContainer, size_t offset);
 
        std::string getConfigurationString() const;
 
        static bool isDataValid(const IDataContainer* data, size_t dataLen)
        {
            return data && dataLen >= (sizeof(someipsdhdroptionsbase) - 1);
        }
    };
 
    class SomeIpSdLoadBalancingOption : public SomeIpSdOption
    {
    public:
        friend class SomeIpSdLayer;
 
        SomeIpSdLoadBalancingOption(uint16_t priority, uint16_t weight);
 
        SomeIpSdLoadBalancingOption(const IDataContainer* dataContainer, size_t offset);
 
        uint16_t getPriority() const;
 
        uint16_t getWeight() const;
 
        static bool isDataValid(const IDataContainer* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(someipsdhdroptionsload);
        }
 
    private:
#pragma pack(push, 1)
        struct someipsdhdroptionsload : someipsdhdroptionsbase
        {
            uint16_t priority;
            uint16_t weight;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdroptionsload) == 8, "someipsdhdroptionsload size is not 8 bytes");
    };
 
    class SomeIpSdEntry
    {
    public:
        friend class SomeIpSdLayer;
 
        enum class EntryType : uint8_t
        {
            FindService,
            OfferService,
            StopOfferService,
            SubscribeEventgroup,
            StopSubscribeEventgroup,
            SubscribeEventgroupAck,
            SubscribeEventgroupNack,
            UnknownEntryType
        };
 
#pragma pack(push, 1)
        struct someipsdhdrentry
        {
            uint8_t type;
            uint8_t indexFirstOption;
            uint8_t indexSecondOption;
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t
                nrOpt2 : 4,
                nrOpt1 : 4;
#else
            uint8_t
                nrOpt1 : 4,
                nrOpt2 : 4;
#endif
            uint16_t serviceID;
            uint16_t instanceID;
            uint32_t majorVersion_ttl;
            uint32_t data;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdrentry) == 16, "someipsdhdrentry size is not 16 bytes");
 
        SomeIpSdEntry(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL,
                      uint32_t minorVersion);
 
        SomeIpSdEntry(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL,
                      uint8_t counter, uint16_t eventGroupID);
 
        SomeIpSdEntry(const SomeIpSdLayer* pSomeIpSdLayer, size_t offset);
 
        ~SomeIpSdEntry();
 
        uint8_t* getDataPtr() const;
 
        someipsdhdrentry* getSomeIpSdEntryHeader() const;
 
        EntryType getType() const
        {
            return m_EntryType;
        }
 
        size_t getLength() const
        {
            return sizeof(someipsdhdrentry);
        }
 
        uint32_t getNumOptions() const;
 
        uint16_t getServiceId() const;
 
        void setServiceId(uint16_t serviceId);
 
        uint16_t getInstanceId() const;
 
        void setInstanceId(uint16_t instanceId);
 
        uint8_t getMajorVersion() const;
 
        void setMajorVersion(uint8_t majorVersion);
 
        uint32_t getTtl() const;
 
        void setTtl(uint32_t ttl);
 
        uint32_t getMinorVersion() const;
 
        void setMinorVersion(uint32_t minorVersion);
 
        uint8_t getCounter() const;
 
        void setCounter(uint8_t counter);
 
        uint16_t getEventgroupId() const;
 
        void setEventgroupId(uint16_t eventgroupID);
 
    private:
        enum class TypeInternal : uint8_t
        {
            FindService_Internal = 0x00,
            OfferService_Internal = 0x01,
            SubscribeEventgroup_Internal = 0x06,
            SubscribeEventgroupAck_Internal = 0x07,
        };
 
        EntryType m_EntryType;
        const SomeIpSdLayer* m_Layer;
        size_t m_Offset;
        uint8_t* m_ShadowData;
 
        void initStdFields(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL);
 
        SomeIpSdEntry(const SomeIpSdEntry&) = delete;
        SomeIpSdEntry& operator=(const SomeIpSdEntry&) = delete;
 
        static const uint32_t SOMEIPSD_HDR_ENTRY_MASK_TTL = 0x00FFFFFF;
    };
 
    class SomeIpSdLayer : public SomeIpLayer
    {
    public:
        friend class SomeIpSdEntry;
 
        using EntryPtr = SomeIpSdEntry*;
        using EntriesVec = std::vector<EntryPtr>;
        using OptionPtr = SomeIpSdOption*;
        using OptionsVec = std::vector<OptionPtr>;
 
        SomeIpSdLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        SomeIpSdLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID,
                      uint8_t interfaceVersion, MsgType type, uint8_t returnCode, uint8_t flags);
 
        ~SomeIpSdLayer() override = default;
 
        static bool isSomeIpSdPort(uint16_t port)
        {
            return port == 30490;
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        uint8_t getFlags() const;
 
        void setFlags(uint8_t flags);
 
        uint32_t getNumEntries() const;
 
        uint32_t getNumOptions() const;
 
        const EntriesVec getEntries() const;
 
        const OptionsVec getOptions() const;
 
        const OptionsVec getOptionsFromEntry(uint32_t index) const;
 
        uint32_t addEntry(const SomeIpSdEntry& entry);
 
        bool addOptionTo(uint32_t indexEntry, const SomeIpSdOption& option);
 
        void computeCalculateFields() override {};
 
        std::string toString() const override;
 
    private:
#pragma pack(push, 1)
        struct someipsdhdr : someiphdr
        {
            uint8_t flags;
            uint8_t reserved1;
            uint8_t reserved2;
            uint8_t reserved3;
        };
#pragma pack(pop)
        static_assert(sizeof(someipsdhdr) == 20, "someipsdhdr size is not 20 bytes");
 
        uint32_t m_NumOptions;
 
        static bool countOptions(uint32_t& count, const uint8_t* data);
        uint32_t findOption(const SomeIpSdOption& option);
        void addOption(const SomeIpSdOption& option);
        bool addOptionIndex(uint32_t indexEntry, uint32_t indexOffset);
        OptionPtr parseOption(SomeIpSdOption::OptionType type, size_t offset, size_t remainingLength) const;
 
        static size_t getLenEntries(const uint8_t* data);
        size_t getLenEntries() const;
        static size_t getLenOptions(const uint8_t* data);
        size_t getLenOptions() const;
        void setLenEntries(uint32_t length);
        void setLenOptions(uint32_t length);
    };
}  // namespace pcpp